345 files changed, 166786 insertions, 3660 deletions

diff --git a/vendor/github.com/bytedance/sonic/.gitignore b/vendor/github.com/bytedance/sonic/.gitignore
new file mode 100644
index 000000000..0d8844705
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/.gitignore
@@ -0,0 +1,52 @@
+*.o
+*.swp
+*.swm
+*.swn
+*.a
+*.so
+_obj
+_test
+*.[568vq]
+[568vq].out
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+_testmain.go
+*.exe
+*.exe~
+*.test
+*.prof
+*.rar
+*.zip
+*.gz
+*.psd
+*.bmd
+*.cfg
+*.pptx
+*.log
+*nohup.out
+*settings.pyc
+*.sublime-project
+*.sublime-workspace
+.DS_Store
+/.idea/
+/.vscode/
+/output/
+/vendor/
+/Gopkg.lock
+/Gopkg.toml
+coverage.html
+coverage.out
+coverage.xml
+junit.xml
+*.profile
+*.svg
+*.out
+ast/test.out
+ast/bench.sh
+
+!testdata/*.json.gz
+fuzz/testdata
+*__debug_bin
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/.gitmodules b/vendor/github.com/bytedance/sonic/.gitmodules
new file mode 100644
index 000000000..b8d11c921
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "tools/asm2asm"]
+	path = tools/asm2asm
+	url = https://github.com/chenzhuoyu/asm2asm
diff --git a/vendor/github.com/bytedance/sonic/.licenserc.yaml b/vendor/github.com/bytedance/sonic/.licenserc.yaml
new file mode 100644
index 000000000..1cb993e39
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/.licenserc.yaml
@@ -0,0 +1,24 @@
+header:
+  license:
+    spdx-id: Apache-2.0
+    copyright-owner: ByteDance Inc.
+
+  paths:
+    - '**/*.go'
+    - '**/*.s'
+
+  paths-ignore:
+    - 'ast/asm.s'                                   # empty file
+    - 'decoder/asm.s'                               # empty file
+    - 'encoder/asm.s'                               # empty file
+    - 'internal/caching/asm.s'                      # empty file
+    - 'internal/jit/asm.s'                          # empty file
+    - 'internal/native/avx/native_amd64.s'          # auto-generated by asm2asm
+    - 'internal/native/avx/native_subr_amd64.go'    # auto-generated by asm2asm
+    - 'internal/native/avx2/native_amd64.s'         # auto-generated by asm2asm
+    - 'internal/native/avx2/native_subr_amd64.go'   # auto-generated by asm2asm
+    - 'internal/resolver/asm.s'                     # empty file
+    - 'internal/rt/asm.s'                           # empty file
+    - 'internal/loader/asm.s'                       # empty file
+
+  comment: on-failure
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/CODE_OF_CONDUCT.md b/vendor/github.com/bytedance/sonic/CODE_OF_CONDUCT.md
new file mode 100644
index 000000000..8505feb1c
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/CODE_OF_CONDUCT.md
@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+wudi.daniel@bytedance.com.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.
diff --git a/vendor/github.com/bytedance/sonic/CONTRIBUTING.md b/vendor/github.com/bytedance/sonic/CONTRIBUTING.md
new file mode 100644
index 000000000..7f63c661a
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/CONTRIBUTING.md
@@ -0,0 +1,63 @@
+# How to Contribute
+
+## Your First Pull Request
+We use GitHub for our codebase. You can start by reading [How To Pull Request](https://docs.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests).
+
+## Without Semantic Versioning
+We keep the stable code in branch `main` like `golang.org/x`. Development base on branch `develop`. We promise the **Forward Compatibility** by adding new package directory with suffix `v2/v3` when code has break changes.
+
+## Branch Organization
+We use [git-flow](https://nvie.com/posts/a-successful-git-branching-model/) as our branch organization, as known as [FDD](https://en.wikipedia.org/wiki/Feature-driven_development)
+
+
+## Bugs
+### 1. How to Find Known Issues
+We are using [Github Issues](https://github.com/bytedance/sonic/issues) for our public bugs. We keep a close eye on this and try to make it clear when we have an internal fix in progress. Before filing a new task, try to make sure your problem doesn’t already exist.
+
+### 2. Reporting New Issues
+Providing a reduced test code is a recommended way for reporting issues. Then can be placed in:
+- Just in issues
+- [Golang Playground](https://play.golang.org/)
+
+### 3. Security Bugs
+Please do not report the safe disclosure of bugs to public issues. Contact us by [Support Email](mailto:sonic@bytedance.com)
+
+## How to Get in Touch
+- [Email](mailto:wudi.daniel@bytedance.com)
+
+## Submit a Pull Request
+Before you submit your Pull Request (PR) consider the following guidelines:
+1. Search [GitHub](https://github.com/bytedance/sonic/pulls) for an open or closed PR that relates to your submission. You don't want to duplicate existing efforts.
+2. Be sure that an issue describes the problem you're fixing, or documents the design for the feature you'd like to add. Discussing the design upfront helps to ensure that we're ready to accept your work.
+3. [Fork](https://docs.github.com/en/github/getting-started-with-github/fork-a-repo) the bytedance/sonic repo.
+4. In your forked repository, make your changes in a new git branch:
+    ```
+    git checkout -b bugfix/security_bug develop
+    ```
+5. Create your patch, including appropriate test cases.
+6. Follow our [Style Guides](#code-style-guides).
+7. Commit your changes using a descriptive commit message that follows [AngularJS Git Commit Message Conventions](https://docs.google.com/document/d/1QrDFcIiPjSLDn3EL15IJygNPiHORgU1_OOAqWjiDU5Y/edit).
+   Adherence to these conventions is necessary because release notes will be automatically generated from these messages.
+8. Push your branch to GitHub:
+    ```
+    git push origin bugfix/security_bug
+    ```
+9. In GitHub, send a pull request to `sonic:main`
+
+Note: you must use one of `optimize/feature/bugfix/doc/ci/test/refactor` following a slash(`/`) as the branch prefix.
+
+Your pr title and commit message should follow https://www.conventionalcommits.org/.
+
+## Contribution Prerequisites
+- Our development environment keeps up with [Go Official](https://golang.org/project/).
+- You need fully checking with lint tools before submit your pull request. [gofmt](https://golang.org/pkg/cmd/gofmt/) & [golangci-lint](https://github.com/golangci/golangci-lint)
+- You are familiar with [Github](https://github.com) 
+- Maybe you need familiar with [Actions](https://github.com/features/actions)(our default workflow tool).
+
+## Code Style Guides
+See [Go Code Review Comments](https://github.com/golang/go/wiki/CodeReviewComments).
+
+Good resources:
+- [Effective Go](https://golang.org/doc/effective_go)
+- [Pingcap General advice](https://pingcap.github.io/style-guide/general.html)
+- [Uber Go Style Guide](https://github.com/uber-go/guide/blob/master/style.md)
diff --git a/vendor/github.com/bytedance/sonic/CREDITS b/vendor/github.com/bytedance/sonic/CREDITS
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/CREDITS
diff --git a/vendor/github.com/bytedance/sonic/INTRODUCTION.md b/vendor/github.com/bytedance/sonic/INTRODUCTION.md
new file mode 100644
index 000000000..6b42118a7
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/INTRODUCTION.md
@@ -0,0 +1,48 @@
+# 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:
+![Scalability](introduction-1.png) 
+
+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**.
+![design](introduction-2.png)
+
+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/LICENSE b/vendor/github.com/bytedance/sonic/LICENSE
new file mode 100644
index 000000000..261eeb9e9
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
diff --git a/vendor/github.com/bytedance/sonic/Makefile b/vendor/github.com/bytedance/sonic/Makefile
new file mode 100644
index 000000000..8cc0acf15
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/Makefile
@@ -0,0 +1,112 @@
+#
+# 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.
+#
+
+ARCH			:= avx avx2 sse
+TMP_DIR			:= output
+OUT_DIR			:= internal/native
+SRC_FILE		:= native/native.c
+
+CPU_avx			:= amd64
+CPU_avx2		:= amd64
+CPU_sse  		:= amd64
+
+TMPL_avx		:= fastint_amd64_test fastfloat_amd64_test native_amd64_test native_export_amd64
+TMPL_avx2		:= fastint_amd64_test fastfloat_amd64_test native_amd64_test native_export_amd64
+TMPL_sse 		:= fastint_amd64_test fastfloat_amd64_test native_amd64_test native_export_amd64
+
+CFLAGS_avx		:= -msse -mno-sse4 -mavx -mpclmul -mno-avx2 -DUSE_AVX=1 -DUSE_AVX2=0
+CFLAGS_avx2		:= -msse -mno-sse4 -mavx -mpclmul -mavx2    -DUSE_AVX=1 -DUSE_AVX2=1 
+CFLAGS_sse		:= -msse -mno-sse4 -mno-avx -mno-avx2 -mpclmul
+
+CC_amd64		:= clang
+ASM2ASM_amd64	:= tools/asm2asm/asm2asm.py
+
+CFLAGS			:= -mno-red-zone
+CFLAGS			+= -target x86_64-apple-macos11
+CFLAGS			+= -fno-asynchronous-unwind-tables
+CFLAGS			+= -fno-builtin
+CFLAGS			+= -fno-exceptions
+CFLAGS			+= -fno-rtti
+CFLAGS			+= -fno-stack-protector
+CFLAGS			+= -nostdlib
+CFLAGS			+= -O3
+CFLAGS			+= -Wall -Werror
+
+NATIVE_SRC		:= $(wildcard native/*.h)
+NATIVE_SRC		+= $(wildcard native/*.c)
+
+.PHONY: all clean ${ARCH}
+
+define build_tmpl
+	$(eval @arch := $(1))
+	$(eval @tmpl := $(2))
+	$(eval @dest := $(3))
+
+${@dest}: ${@tmpl}
+	mkdir -p $(dir ${@dest})
+	echo '// Code generated by Makefile, DO NOT EDIT.' > ${@dest}
+	echo >> ${@dest}
+	sed -e 's/{{PACKAGE}}/${@arch}/g' ${@tmpl} >> ${@dest}
+endef
+
+define build_arch
+	$(eval @cpu		:= $(value CPU_$(1)))
+	$(eval @deps	:= $(foreach tmpl,$(value TMPL_$(1)),${OUT_DIR}/$(1)/${tmpl}.go))
+	$(eval @asmin	:= ${TMP_DIR}/$(1)/native.s)
+	$(eval @asmout	:= ${OUT_DIR}/$(1)/native_${@cpu}.s)
+	$(eval @stubin	:= ${OUT_DIR}/native_${@cpu}.tmpl)
+	$(eval @stubout	:= ${OUT_DIR}/$(1)/native_${@cpu}.go)
+
+$(1): ${@asmout} ${@deps}
+
+${@asmout}: ${@stubout} ${NATIVE_SRC}
+	mkdir -p ${TMP_DIR}/$(1)
+	$${CC_${@cpu}} $${CFLAGS} $${CFLAGS_$(1)} -S -o ${TMP_DIR}/$(1)/native.s ${SRC_FILE}
+	python3 $${ASM2ASM_${@cpu}} ${@asmout} ${TMP_DIR}/$(1)/native.s
+	asmfmt -w ${@asmout}
+
+$(eval $(call 	\
+	build_tmpl,	\
+	$(1),		\
+	${@stubin},	\
+	${@stubout}	\
+))
+
+$(foreach 							\
+	tmpl,							\
+	$(value TMPL_$(1)),				\
+	$(eval $(call 					\
+		build_tmpl,					\
+		$(1),						\
+		${OUT_DIR}/${tmpl}.tmpl,	\
+		${OUT_DIR}/$(1)/${tmpl}.go	\
+	))								\
+)
+endef
+
+all: ${ARCH}
+
+clean:
+	for arch in ${ARCH}; do \
+		rm -vfr ${TMP_DIR}/$${arch}; \
+		rm -vfr ${OUT_DIR}/$${arch}; \
+	done
+
+$(foreach 								\
+	arch,								\
+	${ARCH},							\
+	$(eval $(call build_arch,${arch}))	\
+)
diff --git a/vendor/github.com/bytedance/sonic/README.md b/vendor/github.com/bytedance/sonic/README.md
new file mode 100644
index 000000000..9cc42c462
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/README.md
@@ -0,0 +1,359 @@
+# Sonic
+
+A blazingly fast JSON serializing & deserializing library, accelerated by JIT (just-in-time compiling) and SIMD (single-instruction-multiple-data).
+
+## Requirement
+- Go 1.15~1.20
+- Linux/MacOS/Windows
+- Amd64 ARCH
+
+## Features
+- Runtime object binding without code generation
+- Complete APIs for JSON value manipulation
+- Fast, fast, fast!
+
+## Benchmarks
+For **all sizes** of json and **all scenarios** of usage, **Sonic performs best**.
+- [Medium](https://github.com/bytedance/sonic/blob/main/decoder/testdata_test.go#L19) (13KB, 300+ key, 6 layers)
+```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
+```
+- [Small](https://github.com/bytedance/sonic/blob/main/testdata/small.go) (400B, 11 keys, 3 layers)
+![small benchmarks](bench-small.png)
+- [Large](https://github.com/bytedance/sonic/blob/main/testdata/twitter.json) (635KB, 10000+ key, 6 layers)
+![large benchmarks](bench-large.png)
+
+See [bench.sh](https://github.com/bytedance/sonic/blob/main/bench.sh) for benchmark codes.
+
+## How it works
+See [INTRODUCTION.md](INTRODUCTION.md).
+
+## Usage
+
+### Marshal/Unmarshal
+
+Default behaviors are mostly consistent with `encoding/json`, except HTML escaping form (see [Escape HTML](https://github.com/bytedance/sonic/blob/main/README.md#escape-html)) and `SortKeys` feature (optional support see [Sort Keys](https://github.com/bytedance/sonic/blob/main/README.md#sort-keys)) that is **NOT** in conformity to [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)
+ ```
+
+### Streaming IO
+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)
+enc.Encode(o1)
+enc.Encode(o2)
+println(w.String()) // "{"a":"b"}\n1"
+```
+- 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)
+dec.Decode(&o)
+dec.Decode(&o)
+fmt.Printf("%+v", o) // map[1:2 a:b]
+```
+
+### Use Number/Use 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
+ ```
+
+### Sort Keys
+On account of the performance loss from sorting (roughly 10%), sonic doesn't enable this feature by default. If your component depends on it to work (like [zstd](https://github.com/facebook/zstd)), Use it like this:
+```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()
+```
+### Escape HTML
+On account of the performance loss (roughly 15%), sonic doesn't enable this feature by default. You can use `encoder.EscapeHTML` option to open this feature (align with `encoding/json.HTMLEscape`).
+```go
+import "github.com/bytedance/sonic"
+
+v := map[string]string{"&&":"<>"}
+ret, err := Encode(v, EscapeHTML) // ret == `{"\u0026\u0026":{"X":"\u003c\u003e"}}`
+```
+### Compact Format
+Sonic encodes primitive objects (struct/map...) as compact-format JSON by default, except marshaling `json.RawMessage` or `json.Marshaler`: sonic ensures validating their output JSON but **DONOT** compacting them for performance concerns. We provide the option `encoder.CompactMarshaler` to add compacting process.
+
+### Print Error
+If there invalid syntax in input JSON, sonic will return `decoder.SyntaxError`, which supports pretty-printing of error position
+```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())
+    }
+}
+```
+
+#### Mismatched Types [Sonic v1.6.0]
+If there a **mismatch-typed** value for a given key, sonic will report `decoder.MismatchTypeError` (if there are many, report the last one), but still skip wrong the value and keep decoding next 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 is a completely self-contained AST for JSON. It implements serialization and deserialization both and provides robust APIs for obtaining and modification of generic data.
+#### Get/Index
+Search partial JSON by given paths, which must be non-negative integer or string, or 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
+```
+**Tip**: since `Index()` uses offset to locate data, which is much faster than scanning like `Get()`, we suggest you use it as much as possible. And sonic also provides another API `IndexOrGet()` to underlying use offset as well as ensure the key is matched.
+
+#### Set/Unset
+Modify the json content by Set()/Unset()
+```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"
+```
+
+#### Serialize
+To encode `ast.Node` as json, use `MarshalJson()` or `json.Marshal()` (MUST pass the node's pointer)
+```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
+- validation: `Check()`, `Error()`, `Valid()`, `Exist()`
+- searching: `Index()`, `Get()`, `IndexPair()`, `IndexOrGet()`, `GetByPath()`
+- go-type casting: `Int64()`, `Float64()`, `String()`, `Number()`, `Bool()`, `Map[UseNumber|UseNode]()`, `Array[UseNumber|UseNode]()`, `Interface[UseNumber|UseNode]()`
+- go-type packing: `NewRaw()`, `NewNumber()`, `NewNull()`, `NewBool()`, `NewString()`, `NewObject()`, `NewArray()`
+- iteration: `Values()`, `Properties()`, `ForEach()`, `SortKeys()`
+- modification: `Set()`, `SetByIndex()`, `Add()`
+
+## Compatibility
+Sonic **DOES NOT** ensure to support all environments, due to the difficulty of developing high-performance codes. For developers who use sonic to build their applications in different environments, we have the following suggestions:
+
+- Developing on **Mac M1**: Make sure you have Rosetta 2 installed on your machine, and set `GOARCH=amd64` when building your application. Rosetta 2 can automatically translate x86 binaries to arm64 binaries and run x86 applications on Mac M1.
+- Developing on **Linux arm64**: You can install qemu and use the `qemu-x86_64 -cpu max` command to convert x86 binaries to amr64 binaries for applications built with sonic. The qemu can achieve a similar transfer effect to Rosetta 2 on Mac M1.
+
+For developers who want to use sonic on Linux arm64 without qemu, or those who want to handle JSON strictly consistent with `encoding/json`, we provide some compatible APIs as `sonic.API`
+- `ConfigDefault`: the sonic's default config (`EscapeHTML=false`,`SortKeys=false`...) to run on sonic-supporting environment. It will fall back to `encoding/json` with the corresponding config, and some options like `SortKeys=false` will be invalid.
+- `ConfigStd`: the std-compatible config (`EscapeHTML=true`,`SortKeys=true`...) to run on sonic-supporting environment. It will fall back to `encoding/json`.
+- `ConfigFastest`: the fastest config (`NoQuoteTextMarshaler=true`) to run on sonic-supporting environment. It will fall back to `encoding/json` with the corresponding config, and some options will be invalid.
+
+## Tips
+
+### Pretouch
+Since Sonic uses [golang-asm](https://github.com/twitchyliquid64/golang-asm) as a JIT assembler, which is NOT very suitable for runtime compiling, first-hit running of a huge schema may cause request-timeout or even process-OOM. For better stability, we advise **using `Pretouch()` for huge-schema or compact-memory applications** before `Marshal()/Unmarshal()`.
+```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),
+    )
+}
+```
+
+### Copy string
+When decoding **string values without any escaped characters**, sonic references them from the origin JSON buffer instead of mallocing a new buffer to copy. This helps a lot for CPU performance but may leave the whole JSON buffer in memory as long as the decoded objects are being used. In practice, we found the extra memory introduced by referring JSON buffer is usually 20% ~ 80% of decoded objects. Once an application holds these objects for a long time (for example, cache the decoded objects for reusing), its in-use memory on the server may go up. We provide the option `decoder.CopyString()` for users to choose not to reference the JSON buffer, which may cause a decline in CPU performance to some degree.
+
+### Pass string or []byte?
+For alignment to `encoding/json`, we provide API to pass `[]byte` as an argument, but the string-to-bytes copy is conducted at the same time considering safety, which may lose performance when the origin JSON is huge. Therefore, you can use `UnmarshalString()` and `GetFromString()` to pass a string, as long as your origin data is a string or **nocopy-cast** is safe for your []byte. We also provide API `MarshalString()` for convenient **nocopy-cast** of encoded JSON []byte, which is safe since sonic's output bytes is always duplicated and unique.
+
+### Accelerate `encoding.TextMarshaler`
+To ensure data security, sonic.Encoder quotes and escapes string values from `encoding.TextMarshaler` interfaces by default, which may degrade performance much if most of your data is in form of them. We provide `encoder.NoQuoteTextMarshaler` to skip these operations, which means you **MUST** ensure their output string escaped and quoted following [RFC8259](https://datatracker.ietf.org/doc/html/rfc8259).
+
+
+### Better performance for generic data
+In **fully-parsed** scenario, `Unmarshal()` performs better than `Get()`+`Node.Interface()`. But if you only have a part of the schema for specific json, you can combine `Get()` and `Unmarshal()` together:
+```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)
+```
+Even if you don't have any schema, use `ast.Node` as the container of generic values instead of `map` or `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)
+```
+Why? Because `ast.Node` stores its children using `array`:
+- `Array`'s performance is **much better** than `Map` when Inserting (Deserialize) and Scanning (Serialize) data;
+- **Hashing** (`map[x]`) is not as efficient as **Indexing** (`array[x]`), which `ast.Node` can conduct on **both array and object**;
+- Using `Interface()`/`Map()` means Sonic must parse all the underlying values, while `ast.Node` can parse them **on demand**.
+
+**CAUTION:** `ast.Node` **DOESN'T** ensure concurrent security directly, due to its **lazy-load** design. However, you can call `Node.Load()`/`Node.LoadAll()` to achieve that, which may bring performance reduction while it still works faster than converting to `map` or `interface{}`
+
+## Community
+Sonic is a subproject of [CloudWeGo](https://www.cloudwego.io/). We are committed to building a cloud native ecosystem.
diff --git a/vendor/github.com/bytedance/sonic/api.go b/vendor/github.com/bytedance/sonic/api.go
new file mode 100644
index 000000000..a2bc67eaa
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/api.go
@@ -0,0 +1,185 @@
+/*
+ * 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 sonic
+
+import (
+    `io`
+
+    `github.com/bytedance/sonic/ast`
+)
+
+// Config is a combination of sonic/encoder.Options and sonic/decoder.Options
+type Config struct {
+    // 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                    bool
+
+    // SortMapKeys indicates encoder that the keys of a map needs to be sorted 
+    // before serializing into JSON.
+    // WARNING: This hurts performance A LOT, USE WITH CARE.
+    SortMapKeys                   bool
+
+    // CompactMarshaler indicates encoder that the output JSON from json.Marshaler 
+    // is always compact and needs no validation 
+    CompactMarshaler              bool
+
+    // NoQuoteTextMarshaler indicates encoder that the output text from encoding.TextMarshaler 
+    // is always escaped string and needs no quoting
+    NoQuoteTextMarshaler          bool
+
+    // NoNullSliceOrMap indicates encoder that all empty Array or Object are encoded as '[]' or '{}',
+    // instead of 'null'
+    NoNullSliceOrMap              bool
+
+    // UseInt64 indicates decoder to unmarshal an integer into an interface{} as an
+    // int64 instead of as a float64.
+    UseInt64                      bool
+
+    // UseNumber indicates decoder to unmarshal a number into an interface{} as a
+    // json.Number instead of as a float64.
+    UseNumber                     bool
+
+    // UseUnicodeErrors indicates decoder to return an error when encounter invalid
+    // UTF-8 escape sequences.
+    UseUnicodeErrors              bool
+
+    // DisallowUnknownFields indicates 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.
+    DisallowUnknownFields         bool
+
+    // CopyString indicates decoder to decode string values by copying instead of referring.
+    CopyString                    bool
+
+    // ValidateString indicates decoder and encoder to valid string values: decoder will return errors 
+    // when unescaped control chars(\u0000-\u001f) in the string value of JSON.
+    ValidateString                    bool
+}
+ 
+var (
+    // ConfigDefault is the default config of APIs, aiming at efficiency and safty.
+    ConfigDefault = Config{}.Froze()
+ 
+    // ConfigStd is the standard config of APIs, aiming at being compatible with encoding/json.
+    ConfigStd = Config{
+        EscapeHTML : true,
+        SortMapKeys: true,
+        CompactMarshaler: true,
+        CopyString : true,
+        ValidateString : true,
+    }.Froze()
+ 
+    // ConfigFastest is the fastest config of APIs, aiming at speed.
+    ConfigFastest = Config{
+        NoQuoteTextMarshaler: true,
+    }.Froze()
+)
+ 
+ 
+// API is a binding of specific config.
+// This interface is inspired by github.com/json-iterator/go,
+// and has same behaviors under equavilent config.
+type API interface {
+    // MarshalToString returns the JSON encoding string of v
+    MarshalToString(v interface{}) (string, error)
+    // Marshal returns the JSON encoding bytes of v.
+    Marshal(v interface{}) ([]byte, error)
+    // MarshalIndent returns the JSON encoding bytes with indent and prefix.
+    MarshalIndent(v interface{}, prefix, indent string) ([]byte, error)
+    // UnmarshalFromString parses the JSON-encoded bytes and stores the result in the value pointed to by v.
+    UnmarshalFromString(str string, v interface{}) error
+    // Unmarshal parses the JSON-encoded string and stores the result in the value pointed to by v.
+    Unmarshal(data []byte, v interface{}) error
+    // NewEncoder create a Encoder holding writer
+    NewEncoder(writer io.Writer) Encoder
+    // NewDecoder create a Decoder holding reader
+    NewDecoder(reader io.Reader) Decoder
+    // Valid validates the JSON-encoded bytes and reportes if it is valid
+    Valid(data []byte) bool
+}
+
+// Encoder encodes JSON into io.Writer
+type Encoder interface {
+    // Encode writes the JSON encoding of v to the stream, followed by a newline character.
+    Encode(val interface{}) error
+    // SetEscapeHTML specifies whether problematic HTML characters 
+    // should be escaped inside JSON quoted strings. 
+    // The default behavior NOT ESCAPE 
+    SetEscapeHTML(on bool)
+    // SetIndent instructs the encoder to format each subsequent encoded value 
+    // as if indented by the package-level function Indent(dst, src, prefix, indent).
+    // Calling SetIndent("", "") disables indentation
+    SetIndent(prefix, indent string)
+}
+
+// Decoder decodes JSON from io.Read
+type Decoder interface {
+    // Decode reads the next JSON-encoded value from its input and stores it in the value pointed to by v.
+    Decode(val interface{}) error
+    // Buffered returns a reader of the data remaining in the Decoder's buffer.
+    // The reader is valid until the next call to Decode.
+    Buffered() io.Reader
+    // DisallowUnknownFields causes 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.
+    DisallowUnknownFields()
+    // More reports whether there is another element in the current array or object being parsed.
+    More() bool
+    // UseNumber causes the Decoder to unmarshal a number into an interface{} as a Number instead of as a float64.
+    UseNumber()
+}
+
+// Marshal returns the JSON encoding bytes of v.
+func Marshal(val interface{}) ([]byte, error) {
+    return ConfigDefault.Marshal(val)
+}
+
+// MarshalString returns the JSON encoding string of v.
+func MarshalString(val interface{}) (string, error) {
+    return ConfigDefault.MarshalToString(val)
+}
+
+// Unmarshal parses the JSON-encoded data and stores the result in the value pointed to by v.
+// NOTICE: This API copies given buffer by default,
+// if you want to pass JSON more efficiently, use UnmarshalString instead.
+func Unmarshal(buf []byte, val interface{}) error {
+    return ConfigDefault.Unmarshal(buf, val)
+}
+
+// UnmarshalString is like Unmarshal, except buf is a string.
+func UnmarshalString(buf string, val interface{}) error {
+    return ConfigDefault.UnmarshalFromString(buf, val)
+}
+
+// Get searches the given path from json,
+// 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
+//
+// 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) {
+    return GetFromString(string(src), path...)
+}
+
+// GetFromString is same with Get except src is string,
+// which can reduce unnecessary memory copy.
+func GetFromString(src string, path ...interface{}) (ast.Node, error) {
+    return ast.NewSearcher(src).GetByPath(path...)
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/ast/api_amd64.go b/vendor/github.com/bytedance/sonic/ast/api_amd64.go
new file mode 100644
index 000000000..6b3458aee
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/ast/api_amd64.go
@@ -0,0 +1,126 @@
+// +build amd64,go1.15,!go1.21
+
+
+package ast
+
+import (
+    `runtime`
+    `unsafe`
+
+    `github.com/bytedance/sonic/encoder`
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+    uq `github.com/bytedance/sonic/unquote`
+    `github.com/chenzhuoyu/base64x`
+)
+
+var typeByte = rt.UnpackEface(byte(0)).Type
+
+func quote(buf *[]byte, val string) {
+    *buf = append(*buf, '"')
+    if len(val) == 0 {
+        *buf = append(*buf, '"')
+    }
+
+    sp := rt.IndexChar(val, 0)
+    nb := len(val)
+    b := (*rt.GoSlice)(unsafe.Pointer(buf))
+
+    // input buffer
+    for nb > 0 {
+        // output buffer
+        dp := unsafe.Pointer(uintptr(b.Ptr) + uintptr(b.Len))
+        dn := b.Cap - b.Len
+        // call native.Quote, dn is byte count it outputs
+        ret := native.Quote(sp, nb, dp, &dn, 0)
+        // update *buf length
+        b.Len += dn
+
+        // no need more output
+        if ret >= 0 {
+            break
+        }
+
+        // double buf size
+        *b = growslice(typeByte, *b, b.Cap*2)
+        // ret is the complement of consumed input
+        ret = ^ret
+        // update input buffer
+        nb -= ret
+        sp = unsafe.Pointer(uintptr(sp) + uintptr(ret))
+    }
+
+    runtime.KeepAlive(buf)
+    runtime.KeepAlive(sp)
+    *buf = append(*buf, '"')
+}
+
+func unquote(src string) (string, types.ParsingError) {
+    return uq.String(src)
+}
+
+func decodeBase64(src string) ([]byte, error) {
+    return base64x.StdEncoding.DecodeString(src)
+}
+
+func encodeBase64(src []byte) string {
+    return base64x.StdEncoding.EncodeToString(src)
+}
+
+func (self *Parser) decodeValue() (val types.JsonState) {
+    sv := (*rt.GoString)(unsafe.Pointer(&self.s))
+    self.p = native.Value(sv.Ptr, sv.Len, self.p, &val, 0)
+    return
+}
+
+func (self *Parser) skip() (int, types.ParsingError) {
+    fsm := types.NewStateMachine()
+    start := native.SkipOne(&self.s, &self.p, fsm, 0)
+    types.FreeStateMachine(fsm)
+
+    if start < 0 {
+        return self.p, types.ParsingError(-start)
+    }
+    return start, 0
+}
+
+func (self *Node) encodeInterface(buf *[]byte) error {
+    //WARN: NOT compatible with json.Encoder
+    return encoder.EncodeInto(buf, self.packAny(), 0)
+}
+
+func (self *Parser) skipFast() (int, types.ParsingError) {
+    start := native.SkipOneFast(&self.s, &self.p)
+    if start < 0 {
+        return self.p, types.ParsingError(-start)
+    }
+    return start, 0
+}
+
+func (self *Parser) getByPath(path ...interface{}) (int, types.ParsingError) {
+    start := native.GetByPath(&self.s, &self.p, &path)
+    runtime.KeepAlive(path)
+    if start < 0 {
+        return self.p, types.ParsingError(-start)
+    }
+    return start, 0
+}
+
+
+func (self *Searcher) GetByPath(path ...interface{}) (Node, error) {
+    var err types.ParsingError
+    var start int
+
+    self.parser.p = 0
+    start, err = self.parser.getByPath(path...)
+    if err != 0 {
+        return Node{}, self.parser.syntaxError(err)
+    }
+
+    t := switchRawType(self.parser.s[start])
+    if t == _V_NONE {
+        return Node{}, self.parser.ExportError(err)
+    }
+    return newRawNode(self.parser.s[start:self.parser.p], t), nil
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/ast/api_compat.go b/vendor/github.com/bytedance/sonic/ast/api_compat.go
new file mode 100644
index 000000000..642330c51
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/ast/api_compat.go
@@ -0,0 +1,102 @@
+// +build !amd64 go1.21
+
+package ast
+
+import (
+    `encoding/base64`
+    `encoding/json`
+    `fmt`
+
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+func quote(buf *[]byte, val string) {
+    quoteString(buf, val)
+}
+
+func unquote(src string) (string, types.ParsingError) {
+    sp := rt.IndexChar(src, -1)
+    out, ok := unquoteBytes(rt.BytesFrom(sp, len(src)+2, len(src)+2))
+    if !ok {
+        return "", types.ERR_INVALID_ESCAPE
+    }
+    return rt.Mem2Str(out), 0
+}
+
+
+
+func decodeBase64(src string) ([]byte, error) {
+    return base64.StdEncoding.DecodeString(src)
+}
+
+func encodeBase64(src []byte) string {
+    return base64.StdEncoding.EncodeToString(src)
+}
+
+func (self *Parser) decodeValue() (val types.JsonState) {
+    e, v := decodeValue(self.s, self.p)
+    if e < 0 {
+        return v
+    }
+    self.p = e
+    return v
+}
+
+func (self *Parser) skip() (int, types.ParsingError) {
+    e, s := skipValue(self.s, self.p)
+    if e < 0 {
+        return self.p, types.ParsingError(-e)
+    }
+    self.p = e
+    return s, 0
+}
+
+func (self *Parser) skipFast() (int, types.ParsingError) {
+    return self.skip()
+}
+
+func (self *Node) encodeInterface(buf *[]byte) error {
+    out, err := json.Marshal(self.packAny())
+    if err != nil {
+        return err
+    }
+    *buf = append(*buf, out...)
+    return nil
+}
+
+func (self *Searcher) GetByPath(path ...interface{}) (Node, error) {
+    self.parser.p = 0
+
+    var err types.ParsingError
+    for _, p := range path {
+        switch p := p.(type) {
+        case int:
+            if err = self.parser.searchIndex(p); err != 0 {
+                return Node{}, self.parser.ExportError(err)
+            }
+        case string:
+            if err = self.parser.searchKey(p); err != 0 {
+                return Node{}, self.parser.ExportError(err)
+            }
+        default:
+            panic("path must be either int or string")
+        }
+    }
+
+    var start = self.parser.p
+    if start, err = self.parser.skip(); err != 0 {
+        return Node{}, self.parser.ExportError(err)
+    }
+    ns := len(self.parser.s)
+    if self.parser.p > ns || start >= ns || start>=self.parser.p {
+        return Node{}, fmt.Errorf("skip %d char out of json boundary", start)
+    }
+
+    t := switchRawType(self.parser.s[start])
+    if t == _V_NONE {
+        return Node{}, self.parser.ExportError(err)
+    }
+
+    return newRawNode(self.parser.s[start:self.parser.p], t), nil
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/ast/asm.s b/vendor/github.com/bytedance/sonic/ast/asm.s
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/ast/asm.s
diff --git a/vendor/github.com/bytedance/sonic/ast/decode.go b/vendor/github.com/bytedance/sonic/ast/decode.go
new file mode 100644
index 000000000..d54e98318
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/ast/decode.go
@@ -0,0 +1,430 @@
+package ast
+
+import (
+    `encoding/base64`
+    `runtime`
+    `strconv`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+const _blankCharsMask = (1 << ' ') | (1 << '\t') | (1 << '\r') | (1 << '\n')
+
+const (
+    bytesNull   = "null"
+    bytesTrue   = "true"
+    bytesFalse  = "false"
+    bytesObject = "{}"
+    bytesArray  = "[]"
+)
+
+func isSpace(c byte) bool {
+    return (int(1<<c) & _blankCharsMask) != 0
+}
+
+func skipBlank(src string, pos int) int {
+    se := uintptr(rt.IndexChar(src, len(src)))
+    sp := uintptr(rt.IndexChar(src, pos))
+
+    for sp < se {
+        if !isSpace(*(*byte)(unsafe.Pointer(sp))) {
+            break
+        }
+        sp += 1
+    }
+    if sp >= se {
+        return -int(types.ERR_EOF)
+    }
+    runtime.KeepAlive(src)
+    return int(sp - uintptr(rt.IndexChar(src, 0)))
+}
+
+func decodeNull(src string, pos int) (ret int) {
+    ret = pos + 4
+    if ret > len(src) {
+        return -int(types.ERR_EOF)
+    }
+    if src[pos:ret] == bytesNull {
+        return ret
+    } else {
+        return -int(types.ERR_INVALID_CHAR)
+    }
+}
+
+func decodeTrue(src string, pos int) (ret int) {
+    ret = pos + 4
+    if ret > len(src) {
+        return -int(types.ERR_EOF)
+    }
+    if src[pos:ret] == bytesTrue {
+        return ret
+    } else {
+        return -int(types.ERR_INVALID_CHAR)
+    }
+
+}
+
+func decodeFalse(src string, pos int) (ret int) {
+    ret = pos + 5
+    if ret > len(src) {
+        return -int(types.ERR_EOF)
+    }
+    if src[pos:ret] == bytesFalse {
+        return ret
+    }
+    return -int(types.ERR_INVALID_CHAR)
+}
+
+func decodeString(src string, pos int) (ret int, v string) {
+    ret, ep := skipString(src, pos)
+    if ep == -1 {
+        (*rt.GoString)(unsafe.Pointer(&v)).Ptr = rt.IndexChar(src, pos+1)
+        (*rt.GoString)(unsafe.Pointer(&v)).Len = ret - pos - 2
+        return ret, v
+    }
+
+    vv, ok := unquoteBytes(rt.Str2Mem(src[pos:ret]))
+    if !ok {
+        return -int(types.ERR_INVALID_CHAR), ""
+    }
+
+    runtime.KeepAlive(src)
+    return ret, rt.Mem2Str(vv)
+}
+
+func decodeBinary(src string, pos int) (ret int, v []byte) {
+    var vv string
+    ret, vv = decodeString(src, pos)
+    if ret < 0 {
+        return ret, nil
+    }
+    var err error
+    v, err = base64.StdEncoding.DecodeString(vv)
+    if err != nil {
+        return -int(types.ERR_INVALID_CHAR), nil
+    }
+    return ret, v
+}
+
+func isDigit(c byte) bool {
+    return c >= '0' && c <= '9'
+}
+
+func decodeInt64(src string, pos int) (ret int, v int64, err error) {
+    sp := uintptr(rt.IndexChar(src, pos))
+    ss := uintptr(sp)
+    se := uintptr(rt.IndexChar(src, len(src)))
+    if uintptr(sp) >= se {
+        return -int(types.ERR_EOF), 0, nil
+    }
+
+    if c := *(*byte)(unsafe.Pointer(sp)); c == '-' {
+        sp += 1
+    }
+    if sp == se {
+        return -int(types.ERR_EOF), 0, nil
+    }
+
+    for ; sp < se; sp += uintptr(1) {
+        if !isDigit(*(*byte)(unsafe.Pointer(sp))) {
+            break
+        }
+    }
+
+    if sp < se {
+        if c := *(*byte)(unsafe.Pointer(sp)); c == '.' || c == 'e' || c == 'E' {
+            return -int(types.ERR_INVALID_NUMBER_FMT), 0, nil
+        }
+    }
+
+    var vv string
+    ret = int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
+    (*rt.GoString)(unsafe.Pointer(&vv)).Ptr = unsafe.Pointer(ss)
+    (*rt.GoString)(unsafe.Pointer(&vv)).Len = ret - pos
+
+    v, err = strconv.ParseInt(vv, 10, 64)
+    if err != nil {
+        //NOTICE: allow overflow here
+        if err.(*strconv.NumError).Err == strconv.ErrRange {
+            return ret, 0, err
+        }
+        return -int(types.ERR_INVALID_CHAR), 0, err
+    }
+
+    runtime.KeepAlive(src)
+    return ret, v, nil
+}
+
+func isNumberChars(c byte) bool {
+    return (c >= '0' && c <= '9') || c == '+' || c == '-' || c == 'e' || c == 'E' || c == '.'
+}
+
+func decodeFloat64(src string, pos int) (ret int, v float64, err error) {
+    sp := uintptr(rt.IndexChar(src, pos))
+    ss := uintptr(sp)
+    se := uintptr(rt.IndexChar(src, len(src)))
+    if uintptr(sp) >= se {
+        return -int(types.ERR_EOF), 0, nil
+    }
+
+    if c := *(*byte)(unsafe.Pointer(sp)); c == '-' {
+        sp += 1
+    }
+    if sp == se {
+        return -int(types.ERR_EOF), 0, nil
+    }
+
+    for ; sp < se; sp += uintptr(1) {
+        if !isNumberChars(*(*byte)(unsafe.Pointer(sp))) {
+            break
+        }
+    }
+
+    var vv string
+    ret = int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
+    (*rt.GoString)(unsafe.Pointer(&vv)).Ptr = unsafe.Pointer(ss)
+    (*rt.GoString)(unsafe.Pointer(&vv)).Len = ret - pos
+
+    v, err = strconv.ParseFloat(vv, 64)
+    if err != nil {
+        //NOTICE: allow overflow here
+        if err.(*strconv.NumError).Err == strconv.ErrRange {
+            return ret, 0, err
+        }
+        return -int(types.ERR_INVALID_CHAR), 0, err
+    }
+
+    runtime.KeepAlive(src)
+    return ret, v, nil
+}
+
+func decodeValue(src string, pos int) (ret int, v types.JsonState) {
+    pos = skipBlank(src, pos)
+    if pos < 0 {
+        return pos, types.JsonState{Vt: types.ValueType(pos)}
+    }
+    switch c := src[pos]; c {
+    case 'n':
+        ret = decodeNull(src, pos)
+        if ret < 0 {
+            return ret, types.JsonState{Vt: types.ValueType(ret)}
+        }
+        return ret, types.JsonState{Vt: types.V_NULL}
+    case '"':
+        var ep int
+        ret, ep = skipString(src, pos)
+        if ret < 0 {
+            return ret, types.JsonState{Vt: types.ValueType(ret)}
+        }
+        return ret, types.JsonState{Vt: types.V_STRING, Iv: int64(pos + 1), Ep: ep}
+    case '{':
+        return pos + 1, types.JsonState{Vt: types.V_OBJECT}
+    case '[':
+        return pos + 1, types.JsonState{Vt: types.V_ARRAY}
+    case 't':
+        ret = decodeTrue(src, pos)
+        if ret < 0 {
+            return ret, types.JsonState{Vt: types.ValueType(ret)}
+        }
+        return ret, types.JsonState{Vt: types.V_TRUE}
+    case 'f':
+        ret = decodeFalse(src, pos)
+        if ret < 0 {
+            return ret, types.JsonState{Vt: types.ValueType(ret)}
+        }
+        return ret, types.JsonState{Vt: types.V_FALSE}
+    case '-', '+', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+        var iv int64
+        ret, iv, _ = decodeInt64(src, pos)
+        if ret >= 0 {
+            return ret, types.JsonState{Vt: types.V_INTEGER, Iv: iv, Ep: pos}
+        } else if ret != -int(types.ERR_INVALID_NUMBER_FMT) {
+            return ret, types.JsonState{Vt: types.ValueType(ret)}
+        }
+        var fv float64
+        ret, fv, _ = decodeFloat64(src, pos)
+        if ret >= 0 {
+            return ret, types.JsonState{Vt: types.V_DOUBLE, Dv: fv, Ep: pos}
+        } else {
+            return ret, types.JsonState{Vt: types.ValueType(ret)}
+        }
+    default:
+        return -int(types.ERR_INVALID_CHAR), types.JsonState{Vt:-types.ValueType(types.ERR_INVALID_CHAR)}
+    }
+}
+
+func skipNumber(src string, pos int) (ret int) {
+    sp := uintptr(rt.IndexChar(src, pos))
+    se := uintptr(rt.IndexChar(src, len(src)))
+    if uintptr(sp) >= se {
+        return -int(types.ERR_EOF)
+    }
+
+    if c := *(*byte)(unsafe.Pointer(sp)); c == '-' {
+        sp += 1
+    }
+    ss := sp
+
+    var pointer bool
+    var exponent bool
+    var lastIsDigit bool
+    var nextNeedDigit = true
+
+    for ; sp < se; sp += uintptr(1) {
+        c := *(*byte)(unsafe.Pointer(sp))
+        if isDigit(c) {
+            lastIsDigit = true
+            nextNeedDigit = false
+            continue
+        } else if nextNeedDigit {
+            return -int(types.ERR_INVALID_CHAR)
+        } else if c == '.' {
+            if !lastIsDigit || pointer || sp == ss {
+                return -int(types.ERR_INVALID_CHAR)
+            }
+            pointer = true
+            lastIsDigit = false
+            nextNeedDigit = true
+            continue
+        } else if c == 'e' || c == 'E' {
+            if !lastIsDigit || exponent {
+                return -int(types.ERR_INVALID_CHAR)
+            }
+            if sp == se-1 {
+                return -int(types.ERR_EOF)
+            }
+            exponent = true
+            lastIsDigit = false
+            nextNeedDigit = false
+            continue
+        } else if c == '-' || c == '+' {
+            if prev := *(*byte)(unsafe.Pointer(sp - 1)); prev != 'e' && prev != 'E' {
+                return -int(types.ERR_INVALID_CHAR)
+            }
+            lastIsDigit = false
+            nextNeedDigit = true
+            continue
+        } else {
+            break
+        }
+    }
+
+    if nextNeedDigit {
+        return -int(types.ERR_EOF)
+    }
+
+    runtime.KeepAlive(src)
+    return int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
+}
+
+func skipString(src string, pos int) (ret int, ep int) {
+    if pos+1 >= len(src) {
+        return -int(types.ERR_EOF), -1
+    }
+
+    sp := uintptr(rt.IndexChar(src, pos))
+    se := uintptr(rt.IndexChar(src, len(src)))
+
+    if *(*byte)(unsafe.Pointer(sp)) != '"' {
+        return -int(types.ERR_INVALID_CHAR), -1
+    }
+    sp += 1
+
+    ep = -1
+    for sp < se {
+        c := *(*byte)(unsafe.Pointer(sp))
+        if c == '\\' {
+            if ep == -1 {
+                ep = int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
+            }
+            sp += 2
+            continue
+        }
+        sp += 1
+        if c == '"' {
+            break
+        }
+    }
+
+    if sp > se {
+        return -int(types.ERR_EOF), -1
+    }
+
+    runtime.KeepAlive(src)
+    return int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr)), ep
+}
+
+func skipPair(src string, pos int, lchar byte, rchar byte) (ret int) {
+    if pos+1 >= len(src) {
+        return -int(types.ERR_EOF)
+    }
+
+    sp := uintptr(rt.IndexChar(src, pos))
+    se := uintptr(rt.IndexChar(src, len(src)))
+
+    if *(*byte)(unsafe.Pointer(sp)) != lchar {
+        return -int(types.ERR_INVALID_CHAR)
+    }
+
+    sp += 1
+    nbrace := 1
+    inquote := false
+
+    for sp < se {
+        c := *(*byte)(unsafe.Pointer(sp))
+        if c == '\\' {
+            sp += 2
+            continue
+        } else if c == '"' {
+            inquote = !inquote
+        } else if c == lchar {
+            if !inquote {
+                nbrace += 1
+            }
+        } else if c == rchar {
+            if !inquote {
+                nbrace -= 1
+                if nbrace == 0 {
+                    sp += 1
+                    break
+                }
+            }
+        }
+        sp += 1
+    }
+
+    if nbrace != 0 {
+        return -int(types.ERR_INVALID_CHAR)
+    }
+
+    runtime.KeepAlive(src)
+    return int(uintptr(sp) - uintptr((*rt.GoString)(unsafe.Pointer(&src)).Ptr))
+}
+
+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 = skipPair(src, pos, '{', '}')
+    case '[':
+        ret = skipPair(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
+}
diff --git a/vendor/github.com/bytedance/sonic/ast/encode.go b/vendor/github.com/bytedance/sonic/ast/encode.go
new file mode 100644
index 000000000..1187e30c2
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/ast/encode.go
@@ -0,0 +1,259 @@
+/*
+ * 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 ast
+
+import (
+    `sync`
+    `unicode/utf8`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+const (
+    _MaxBuffer = 1024    // 1KB buffer size
+)
+
+func quoteString(e *[]byte, s string) {
+    *e = append(*e, '"')
+    start := 0
+    for i := 0; i < len(s); {
+        if b := s[i]; b < utf8.RuneSelf {
+            if safeSet[b] {
+                i++
+                continue
+            }
+            if start < i {
+                *e = append(*e, s[start:i]...)
+            }
+            *e = append(*e, '\\')
+            switch b {
+            case '\\', '"':
+                *e = append(*e, b)
+            case '\n':
+                *e = append(*e, 'n')
+            case '\r':
+                *e = append(*e, 'r')
+            case '\t':
+                *e = append(*e, 't')
+            default:
+                // This encodes bytes < 0x20 except for \t, \n and \r.
+                // If escapeHTML is set, it also escapes <, >, and &
+                // because they can lead to security holes when
+                // user-controlled strings are rendered into JSON
+                // and served to some browsers.
+                *e = append(*e, `u00`...)
+                *e = append(*e, hex[b>>4])
+                *e = append(*e, hex[b&0xF])
+            }
+            i++
+            start = i
+            continue
+        }
+        c, size := utf8.DecodeRuneInString(s[i:])
+        // if c == utf8.RuneError && size == 1 {
+        //     if start < i {
+        //         e.Write(s[start:i])
+        //     }
+        //     e.WriteString(`\ufffd`)
+        //     i += size
+        //     start = i
+        //     continue
+        // }
+        if c == '\u2028' || c == '\u2029' {
+            if start < i {
+                *e = append(*e, s[start:i]...)
+            }
+            *e = append(*e, `\u202`...)
+            *e = append(*e, hex[c&0xF])
+            i += size
+            start = i
+            continue
+        }
+        i += size
+    }
+    if start < len(s) {
+        *e = append(*e, s[start:]...)
+    }
+    *e = append(*e, '"')
+}
+
+var bytesPool   = sync.Pool{}
+
+func (self *Node) MarshalJSON() ([]byte, error) {
+    buf := newBuffer()
+    err := self.encode(buf)
+    if err != nil {
+        freeBuffer(buf)
+        return nil, err
+    }
+
+    ret := make([]byte, len(*buf))
+    copy(ret, *buf)
+    freeBuffer(buf)
+    return ret, err
+}
+
+func newBuffer() *[]byte {
+    if ret := bytesPool.Get(); ret != nil {
+        return ret.(*[]byte)
+    } else {
+        buf := make([]byte, 0, _MaxBuffer)
+        return &buf
+    }
+}
+
+func freeBuffer(buf *[]byte) {
+    *buf = (*buf)[:0]
+    bytesPool.Put(buf)
+}
+
+func (self *Node) encode(buf *[]byte) error {
+    if self.IsRaw() {
+        return self.encodeRaw(buf)
+    }
+    switch self.Type() {
+        case V_NONE  : return ErrNotExist
+        case V_ERROR : return self.Check()
+        case V_NULL  : return self.encodeNull(buf)
+        case V_TRUE  : return self.encodeTrue(buf)
+        case V_FALSE : return self.encodeFalse(buf)
+        case V_ARRAY : return self.encodeArray(buf)
+        case V_OBJECT: return self.encodeObject(buf)
+        case V_STRING: return self.encodeString(buf)
+        case V_NUMBER: return self.encodeNumber(buf)
+        case V_ANY   : return self.encodeInterface(buf)
+        default      : return ErrUnsupportType 
+    }
+}
+
+func (self *Node) encodeRaw(buf *[]byte) error {
+    raw, err := self.Raw()
+    if err != nil {
+        return err
+    }
+    *buf = append(*buf, raw...)
+    return nil
+}
+
+func (self *Node) encodeNull(buf *[]byte) error {
+    *buf = append(*buf, bytesNull...)
+    return nil
+}
+
+func (self *Node) encodeTrue(buf *[]byte) error {
+    *buf = append(*buf, bytesTrue...)
+    return nil
+}
+
+func (self *Node) encodeFalse(buf *[]byte) error {
+    *buf = append(*buf, bytesFalse...)
+    return nil
+}
+
+func (self *Node) encodeNumber(buf *[]byte) error {
+    str := rt.StrFrom(self.p, self.v)
+    *buf = append(*buf, str...)
+    return nil
+}
+
+func (self *Node) encodeString(buf *[]byte) error {
+    if self.v == 0 {
+        *buf = append(*buf, '"', '"')
+        return nil
+    }
+
+    quote(buf, rt.StrFrom(self.p, self.v))
+    return nil
+}
+
+func (self *Node) encodeArray(buf *[]byte) error {
+    if self.isLazy() {
+        if err := self.skipAllIndex(); err != nil {
+            return err
+        }
+    }
+
+    nb := self.len()
+    if nb == 0 {
+        *buf = append(*buf, bytesArray...)
+        return nil
+    }
+    
+    *buf = append(*buf, '[')
+
+    var p = (*Node)(self.p)
+    err := p.encode(buf)
+    if err != nil {
+        return err
+    }
+    for i := 1; i < nb; i++ {
+        *buf = append(*buf, ',')
+        p = p.unsafe_next()
+        err := p.encode(buf)
+        if err != nil {
+            return err
+        }
+    }
+
+    *buf = append(*buf, ']')
+    return nil
+}
+
+func (self *Pair) encode(buf *[]byte) error {
+    if len(*buf) == 0 {
+        *buf = append(*buf, '"', '"', ':')
+        return self.Value.encode(buf)
+    }
+
+    quote(buf, self.Key)
+    *buf = append(*buf, ':')
+
+    return self.Value.encode(buf)
+}
+
+func (self *Node) encodeObject(buf *[]byte) error {
+    if self.isLazy() {
+        if err := self.skipAllKey(); err != nil {
+            return err
+        }
+    }
+    
+    nb := self.len()
+    if nb == 0 {
+        *buf = append(*buf, bytesObject...)
+        return nil
+    }
+    
+    *buf = append(*buf, '{')
+
+    var p = (*Pair)(self.p)
+    err := p.encode(buf)
+    if err != nil {
+        return err
+    }
+    for i := 1; i < nb; i++ {
+        *buf = append(*buf, ',')
+        p = p.unsafe_next()
+        err := p.encode(buf)
+        if err != nil {
+            return err
+        }
+    }
+
+    *buf = append(*buf, '}')
+    return nil
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/ast/error.go b/vendor/github.com/bytedance/sonic/ast/error.go
new file mode 100644
index 000000000..f4c441ae6
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/ast/error.go
@@ -0,0 +1,98 @@
+package ast
+
+import (
+    `fmt`
+    `strings`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native/types`
+)
+
+func (self *Parser) syntaxError(err types.ParsingError) SyntaxError {
+    return SyntaxError{
+        Pos : self.p,
+        Src : self.s,
+        Code: err,
+    }
+}
+
+func newSyntaxError(err SyntaxError) *Node {
+    msg := err.Description()
+    return &Node{
+        t: V_ERROR,
+        v: int64(err.Code),
+        p: unsafe.Pointer(&msg),
+    }
+}
+
+type SyntaxError struct {
+    Pos  int
+    Src  string
+    Code types.ParsingError
+    Msg  string
+}
+
+func (self SyntaxError) Error() string {
+    return fmt.Sprintf("%q", self.Description())
+}
+
+func (self SyntaxError) Description() string {
+    return "Syntax error " + self.description()
+}
+
+func (self SyntaxError) description() string {
+    i := 16
+    p := self.Pos - i
+    q := self.Pos + i
+
+    /* check for empty source */
+    if self.Src == "" {
+        return fmt.Sprintf("no sources available: %#v", self)
+    }
+
+    /* prevent slicing before the beginning */
+    if p < 0 {
+        p, q, i = 0, q - p, i + p
+    }
+
+    /* prevent slicing beyond the end */
+    if n := len(self.Src); q > n {
+        n = q - n
+        q = len(self.Src)
+
+        /* move the left bound if possible */
+        if p > n {
+            i += n
+            p -= n
+        }
+    }
+
+    /* left and right length */
+    x := clamp_zero(i)
+    y := clamp_zero(q - p - i - 1)
+
+    /* compose the error description */
+    return fmt.Sprintf(
+        "at index %d: %s\n\n\t%s\n\t%s^%s\n",
+        self.Pos,
+        self.Message(),
+        self.Src[p:q],
+        strings.Repeat(".", x),
+        strings.Repeat(".", y),
+    )
+}
+
+func (self SyntaxError) Message() string {
+    if self.Msg == "" {
+        return self.Code.Message()
+    }
+    return self.Msg
+}
+
+func clamp_zero(v int) int {
+    if v < 0 {
+        return 0
+    } else {
+        return v
+    }
+}
diff --git a/vendor/github.com/bytedance/sonic/ast/iterator.go b/vendor/github.com/bytedance/sonic/ast/iterator.go
new file mode 100644
index 000000000..03a25b4e9
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/ast/iterator.go
@@ -0,0 +1,164 @@
+/*
+ * 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 ast
+
+import (
+    `fmt`
+
+    `github.com/bytedance/sonic/internal/native/types`
+)
+
+type Pair struct {
+    Key   string
+    Value Node
+}
+
+// Values returns iterator for array's children traversal
+func (self *Node) Values() (ListIterator, error) {
+    if err := self.should(types.V_ARRAY, "an array"); err != nil {
+        return ListIterator{}, err
+    }
+    return ListIterator{Iterator{p: self}}, nil
+}
+
+// Properties returns iterator for object's children traversal
+func (self *Node) Properties() (ObjectIterator, error) {
+    if err := self.should(types.V_OBJECT, "an object"); err != nil {
+        return ObjectIterator{}, err
+    }
+    return ObjectIterator{Iterator{p: self}}, nil
+}
+
+type Iterator struct {
+    i int
+    p *Node
+}
+
+func (self *Iterator) Pos() int {
+    return self.i
+}
+
+func (self *Iterator) Len() int {
+    return self.p.len()
+}
+
+// HasNext reports if it is the end of iteration or has error.
+func (self *Iterator) HasNext() bool {
+    if !self.p.isLazy() {
+        return self.p.Valid() && self.i < self.p.len()
+    } else if self.p.t == _V_ARRAY_LAZY {
+        return self.p.skipNextNode().Valid()
+    } else if self.p.t == _V_OBJECT_LAZY {
+        pair := self.p.skipNextPair()
+        if pair == nil {
+            return false
+        }
+        return pair.Value.Valid()
+    }
+    return false
+}
+
+// ListIterator is specialized iterator for V_ARRAY
+type ListIterator struct {
+    Iterator
+}
+
+// ObjectIterator is specialized iterator for V_ARRAY
+type ObjectIterator struct {
+    Iterator
+}
+
+// Next scans through children of underlying V_ARRAY, 
+// copies each child to v, and returns .HasNext().
+func (self *ListIterator) Next(v *Node) bool {
+    if !self.HasNext() {
+        return false
+    } else {
+        *v, self.i = *self.p.nodeAt(self.i), self.i + 1
+        return true
+    }
+}
+
+// Next scans through children of underlying V_OBJECT, 
+// copies each child to v, and returns .HasNext().
+func (self *ObjectIterator) Next(p *Pair) bool {
+    if !self.HasNext() {
+        return false
+    } else {
+        *p, self.i = *self.p.pairAt(self.i), self.i + 1
+        return true
+    }
+}
+
+// Sequence represents scanning path of single-layer nodes.
+// Index indicates the value's order in both V_ARRAY and V_OBJECT json.
+// Key is the value's key (for V_OBJECT json only, otherwise it will be nil).
+type Sequence struct {
+    Index int 
+    Key *string
+    // Level int
+}
+
+// String is string representation of one Sequence
+func (s Sequence) String() string {
+    k := ""
+    if s.Key != nil {
+        k = *s.Key
+    }
+    return fmt.Sprintf("Sequence(%d, %q)", s.Index, k)
+}
+
+type Scanner func(path Sequence, node *Node) bool
+
+// ForEach scans one V_OBJECT node's children from JSON head to tail, 
+// and pass the Sequence and Node of corresponding JSON value.
+//
+// Especailly, if the node is not V_ARRAY or V_OBJECT, 
+// the node itself will be returned and Sequence.Index == -1.
+func (self *Node) ForEach(sc Scanner) error {
+    switch self.itype() {
+    case types.V_ARRAY:
+        ns, err := self.UnsafeArray()
+        if err != nil {
+            return err
+        }
+        for i := range ns {
+            if !sc(Sequence{i, nil}, &ns[i]) {
+                return err
+            }
+        }
+    case types.V_OBJECT:
+        ns, err := self.UnsafeMap()
+        if err != nil {
+            return err
+        }
+        for i := range ns {
+            if !sc(Sequence{i, &ns[i].Key}, &ns[i].Value) {
+                return err
+            }
+        }
+    default:
+        sc(Sequence{-1, nil}, self)
+    }
+    return self.Check()
+}
+
+type PairSlice []Pair
+
+func (self PairSlice) Sort() {
+    radixQsort(self, 0, maxDepth(len(self)))
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/ast/node.go b/vendor/github.com/bytedance/sonic/ast/node.go
new file mode 100644
index 000000000..0d37baf12
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/ast/node.go
@@ -0,0 +1,1802 @@
+/*
+ * 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 ast
+
+import (
+    `encoding/json`
+    `fmt`
+    `strconv`
+    `unsafe`
+    `reflect`
+    
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+const (
+    _CAP_BITS          = 32
+    _LEN_MASK          = 1 << _CAP_BITS - 1
+
+    _NODE_SIZE = unsafe.Sizeof(Node{})
+    _PAIR_SIZE = unsafe.Sizeof(Pair{})
+)
+
+const (
+    _V_NONE         types.ValueType = 0
+    _V_NODE_BASE    types.ValueType = 1 << 5
+    _V_LAZY         types.ValueType = 1 << 7
+    _V_RAW          types.ValueType = 1 << 8
+    _V_NUMBER                       = _V_NODE_BASE + 1
+    _V_ANY                          = _V_NODE_BASE + 2
+    _V_ARRAY_LAZY                   = _V_LAZY | types.V_ARRAY
+    _V_OBJECT_LAZY                  = _V_LAZY | types.V_OBJECT
+    _MASK_LAZY                      = _V_LAZY - 1
+    _MASK_RAW                       = _V_RAW - 1
+)
+
+const (
+    V_NONE   = 0
+    V_ERROR  = 1
+    V_NULL   = 2
+    V_TRUE   = 3
+    V_FALSE  = 4
+    V_ARRAY  = 5
+    V_OBJECT = 6
+    V_STRING = 7
+    V_NUMBER = int(_V_NUMBER)
+    V_ANY    = int(_V_ANY)
+)
+
+var (
+    byteType = rt.UnpackType(reflect.TypeOf(byte(0)))
+)
+
+type Node struct {
+    v int64
+    t types.ValueType
+    p unsafe.Pointer
+}
+
+// UnmarshalJSON is just an adapter to json.Unmarshaler.
+// If you want better performance, use Searcher.GetByPath() directly
+func (self *Node) UnmarshalJSON(data []byte) (err error) {
+    *self, err = NewSearcher(string(data)).GetByPath()
+    return 
+}
+
+/** Node Type Accessor **/
+
+// Type returns json type represented by the node
+// It will be one of belows:
+//    V_NONE   = 0 (empty node)
+//    V_ERROR  = 1 (error node)
+//    V_NULL   = 2 (json value `null`)
+//    V_TRUE   = 3 (json value `true`)
+//    V_FALSE  = 4 (json value `false`)
+//    V_ARRAY  = 5 (json value array)
+//    V_OBJECT = 6 (json value object)
+//    V_STRING = 7 (json value string)
+//    V_NUMBER = 33 (json value number )
+//    V_ANY    = 34 (golang interface{})
+func (self Node) Type() int {
+    return int(self.t & _MASK_LAZY & _MASK_RAW)
+}
+
+func (self Node) itype() types.ValueType {
+    return self.t & _MASK_LAZY & _MASK_RAW
+}
+
+// Exists returns false only if the self is nil or empty node V_NONE
+func (self *Node) Exists() bool {
+    return self != nil && self.t != _V_NONE
+}
+
+// Valid reports if self is NOT V_ERROR or nil
+func (self *Node) Valid() bool {
+    if self == nil {
+        return false
+    }
+    return self.t != V_ERROR
+}
+
+// Check checks if the node itself is valid, and return:
+//   - ErrNotFound If the node is nil
+//   - Its underlying error If the node is V_ERROR
+func (self *Node)  Check() error {
+    if self == nil {
+        return ErrNotExist
+    } else if self.t != V_ERROR {
+        return nil
+    } else {
+        return self
+    }
+}
+
+// Error returns error message if the node is invalid
+func (self Node) Error() string {
+    if self.t != V_ERROR {
+        return ""
+    } else {
+        return *(*string)(self.p)
+    } 
+}
+
+// IsRaw returns true if node's underlying value is raw json
+func (self Node) IsRaw() bool {
+    return self.t&_V_RAW != 0
+}
+
+func (self *Node) isLazy() bool {
+    return self != nil && self.t&_V_LAZY != 0
+}
+
+func (self *Node) isAny() bool {
+    return self != nil && self.t == _V_ANY
+}
+
+/** Simple Value Methods **/
+
+// Raw returns json representation of the node,
+func (self *Node) Raw() (string, error) {
+    if !self.IsRaw() {
+        buf, err := self.MarshalJSON()
+        return rt.Mem2Str(buf), err
+    }
+    return rt.StrFrom(self.p, self.v), nil
+}
+
+func (self *Node) checkRaw() error {
+    if err := self.Check(); err != nil {
+        return err
+    }
+    if self.IsRaw() {
+        self.parseRaw(false)
+    }
+    return nil
+}
+
+// Bool returns bool value represented by this node, 
+// including types.V_TRUE|V_FALSE|V_NUMBER|V_STRING|V_ANY|V_NULL, 
+// V_NONE will return error
+func (self *Node) Bool() (bool, error) {
+    if err := self.checkRaw(); err != nil {
+        return false, err
+    }
+    switch self.t {
+        case types.V_TRUE  : return true , nil
+        case types.V_FALSE : return false, nil
+        case types.V_NULL  : return false, nil
+        case _V_NUMBER     : 
+            if i, err := numberToInt64(self); err == nil {
+                return i != 0, nil
+            } else if f, err := numberToFloat64(self); err == nil {
+                return f != 0, nil
+            } else {
+                return false, err
+            }
+        case types.V_STRING: return strconv.ParseBool(rt.StrFrom(self.p, self.v))
+        case _V_ANY        :   
+            any := self.packAny()     
+            switch v := any.(type) {
+                case bool   : return v, nil
+                case int    : return v != 0, nil
+                case int8   : return v != 0, nil
+                case int16  : return v != 0, nil
+                case int32  : return v != 0, nil
+                case int64  : return v != 0, nil
+                case uint   : return v != 0, nil
+                case uint8  : return v != 0, nil
+                case uint16 : return v != 0, nil
+                case uint32 : return v != 0, nil
+                case uint64 : return v != 0, nil
+                case float32: return v != 0, nil
+                case float64: return v != 0, nil
+                case string : return strconv.ParseBool(v)
+                case json.Number: 
+                    if i, err := v.Int64(); err == nil {
+                        return i != 0, nil
+                    } else if f, err := v.Float64(); err == nil {
+                        return f != 0, nil
+                    } else {
+                        return false, err
+                    }
+                default: return false, ErrUnsupportType
+            }
+        default            : return false, ErrUnsupportType
+    }
+}
+
+// Int64 casts the node to int64 value, 
+// including V_NUMBER|V_TRUE|V_FALSE|V_ANY|V_STRING
+// V_NONE it will return error
+func (self *Node) Int64() (int64, error) {
+    if err := self.checkRaw(); err != nil {
+        return 0, err
+    }
+    switch self.t {
+        case _V_NUMBER, types.V_STRING :
+            if i, err := numberToInt64(self); err == nil {
+                return i, nil
+            } else if f, err := numberToFloat64(self); err == nil {
+                return int64(f), nil
+            } else {
+                return 0, err
+            }
+        case types.V_TRUE     : return 1, nil
+        case types.V_FALSE    : return 0, nil
+        case types.V_NULL     : return 0, nil
+        case _V_ANY           :  
+            any := self.packAny()
+            switch v := any.(type) {
+                case bool   : if v { return 1, nil } else { return 0, nil }
+                case int    : return int64(v), nil
+                case int8   : return int64(v), nil
+                case int16  : return int64(v), nil
+                case int32  : return int64(v), nil
+                case int64  : return int64(v), nil
+                case uint   : return int64(v), nil
+                case uint8  : return int64(v), nil
+                case uint16 : return int64(v), nil
+                case uint32 : return int64(v), nil
+                case uint64 : return int64(v), nil
+                case float32: return int64(v), nil
+                case float64: return int64(v), nil
+                case string : 
+                    if i, err := strconv.ParseInt(v, 10, 64); err == nil {
+                        return i, nil
+                    } else if f, err := strconv.ParseFloat(v, 64); err == nil {
+                        return int64(f), nil
+                    } else {
+                        return 0, err
+                    }
+                case json.Number: 
+                    if i, err := v.Int64(); err == nil {
+                        return i, nil
+                    } else if f, err := v.Float64(); err == nil {
+                        return int64(f), nil
+                    } else {
+                        return 0, err
+                    }
+                default: return 0, ErrUnsupportType
+            }
+        default               : return 0, ErrUnsupportType
+    }
+}
+
+// StrictInt64 exports underlying int64 value, including V_NUMBER, V_ANY
+func (self *Node) StrictInt64() (int64, error) {
+    if err := self.checkRaw(); err != nil {
+        return 0, err
+    }
+    switch self.t {
+        case _V_NUMBER        : return numberToInt64(self)
+        case _V_ANY           :  
+            any := self.packAny()
+            switch v := any.(type) {
+                case int   : return int64(v), nil
+                case int8  : return int64(v), nil
+                case int16 : return int64(v), nil
+                case int32 : return int64(v), nil
+                case int64 : return int64(v), nil
+                case uint  : return int64(v), nil
+                case uint8 : return int64(v), nil
+                case uint16: return int64(v), nil
+                case uint32: return int64(v), nil
+                case uint64: return int64(v), nil
+                case json.Number: 
+                    if i, err := v.Int64(); err == nil {
+                        return i, nil
+                    } else {
+                        return 0, err
+                    }
+                default: return 0, ErrUnsupportType
+            }
+        default               : return 0, ErrUnsupportType
+    }
+}
+
+func castNumber(v bool) json.Number {
+    if v {
+        return json.Number("1")
+    } else {
+        return json.Number("0")
+    }
+}
+
+// Number casts node to float64, 
+// including V_NUMBER|V_TRUE|V_FALSE|V_ANY|V_STRING|V_NULL,
+// V_NONE it will return error
+func (self *Node) Number() (json.Number, error) {
+    if err := self.checkRaw(); err != nil {
+        return json.Number(""), err
+    }
+    switch self.t {
+        case _V_NUMBER        : return toNumber(self)  , nil
+        case types.V_STRING : 
+            if _, err := numberToInt64(self); err == nil {
+                return toNumber(self), nil
+            } else if _, err := numberToFloat64(self); err == nil {
+                return toNumber(self), nil
+            } else {
+                return json.Number(""), err
+            }
+        case types.V_TRUE     : return json.Number("1"), nil
+        case types.V_FALSE    : return json.Number("0"), nil
+        case types.V_NULL     : return json.Number("0"), nil
+        case _V_ANY           :        
+            any := self.packAny()
+            switch v := any.(type) {
+                case bool   : return castNumber(v), nil
+                case int    : return castNumber(v != 0), nil
+                case int8   : return castNumber(v != 0), nil
+                case int16  : return castNumber(v != 0), nil
+                case int32  : return castNumber(v != 0), nil
+                case int64  : return castNumber(v != 0), nil
+                case uint   : return castNumber(v != 0), nil
+                case uint8  : return castNumber(v != 0), nil
+                case uint16 : return castNumber(v != 0), nil
+                case uint32 : return castNumber(v != 0), nil
+                case uint64 : return castNumber(v != 0), nil
+                case float32: return castNumber(v != 0), nil
+                case float64: return castNumber(v != 0), nil
+                case string : 
+                    if _, err := strconv.ParseFloat(v, 64); err == nil {
+                        return json.Number(v), nil
+                    } else {
+                        return json.Number(""), err
+                    }
+                case json.Number: return v, nil
+                default: return json.Number(""), ErrUnsupportType
+            }
+        default               : return json.Number(""), ErrUnsupportType
+    }
+}
+
+// Number exports underlying float64 value, including V_NUMBER, V_ANY of json.Number
+func (self *Node) StrictNumber() (json.Number, error) {
+    if err := self.checkRaw(); err != nil {
+        return json.Number(""), err
+    }
+    switch self.t {
+        case _V_NUMBER        : return toNumber(self)  , nil
+        case _V_ANY        :        
+            if v, ok := self.packAny().(json.Number); ok {
+                return v, nil
+            } else {
+                return json.Number(""), ErrUnsupportType
+            }
+        default               : return json.Number(""), ErrUnsupportType
+    }
+}
+
+// String cast node to string, 
+// including V_NUMBER|V_TRUE|V_FALSE|V_ANY|V_STRING|V_NULL,
+// V_NONE it will return error
+func (self *Node) String() (string, error) {
+    if err := self.checkRaw(); err != nil {
+        return "", err
+    }
+    switch self.t {
+        case types.V_NULL    : return "" , nil
+        case types.V_TRUE    : return "true" , nil
+        case types.V_FALSE   : return "false", nil
+        case types.V_STRING, _V_NUMBER  : return rt.StrFrom(self.p, self.v), nil
+        case _V_ANY          :        
+        any := self.packAny()
+        switch v := any.(type) {
+            case bool   : return strconv.FormatBool(v), nil
+            case int    : return strconv.Itoa(v), nil
+            case int8   : return strconv.Itoa(int(v)), nil
+            case int16  : return strconv.Itoa(int(v)), nil
+            case int32  : return strconv.Itoa(int(v)), nil
+            case int64  : return strconv.Itoa(int(v)), nil
+            case uint   : return strconv.Itoa(int(v)), nil
+            case uint8  : return strconv.Itoa(int(v)), nil
+            case uint16 : return strconv.Itoa(int(v)), nil
+            case uint32 : return strconv.Itoa(int(v)), nil
+            case uint64 : return strconv.Itoa(int(v)), nil
+            case float32: return strconv.FormatFloat(float64(v), 'g', -1, 64), nil
+            case float64: return strconv.FormatFloat(float64(v), 'g', -1, 64), nil
+            case string : return v, nil 
+            case json.Number: return v.String(), nil
+            default: return "", ErrUnsupportType
+        }
+        default              : return ""     , ErrUnsupportType
+    }
+}
+
+// StrictString returns string value (unescaped), includeing V_STRING, V_ANY of string.
+// In other cases, it will return empty string.
+func (self *Node) StrictString() (string, error) {
+    if err := self.checkRaw(); err != nil {
+        return "", err
+    }
+    switch self.t {
+        case types.V_STRING  : return rt.StrFrom(self.p, self.v), nil
+        case _V_ANY          :        
+            if v, ok := self.packAny().(string); ok {
+                return v, nil
+            } else {
+                return "", ErrUnsupportType
+            }
+        default              : return "", ErrUnsupportType
+    }
+}
+
+// Float64 cast node to float64, 
+// including V_NUMBER|V_TRUE|V_FALSE|V_ANY|V_STRING|V_NULL,
+// V_NONE it will return error
+func (self *Node) Float64() (float64, error) {
+    if err := self.checkRaw(); err != nil {
+        return 0.0, err
+    }
+    switch self.t {
+        case _V_NUMBER, types.V_STRING : return numberToFloat64(self)
+        case types.V_TRUE    : return 1.0, nil
+        case types.V_FALSE   : return 0.0, nil
+        case types.V_NULL    : return 0.0, nil
+        case _V_ANY          :        
+            any := self.packAny()
+            switch v := any.(type) {
+                case bool    : 
+                    if v {
+                        return 1.0, nil
+                    } else {
+                        return 0.0, nil
+                    }
+                case int    : return float64(v), nil
+                case int8   : return float64(v), nil
+                case int16  : return float64(v), nil
+                case int32  : return float64(v), nil
+                case int64  : return float64(v), nil
+                case uint   : return float64(v), nil
+                case uint8  : return float64(v), nil
+                case uint16 : return float64(v), nil
+                case uint32 : return float64(v), nil
+                case uint64 : return float64(v), nil
+                case float32: return float64(v), nil
+                case float64: return float64(v), nil
+                case string : 
+                    if f, err := strconv.ParseFloat(v, 64); err == nil {
+                        return float64(f), nil
+                    } else {
+                        return 0, err
+                    }
+                case json.Number: 
+                    if f, err := v.Float64(); err == nil {
+                        return float64(f), nil
+                    } else {
+                        return 0, err
+                    }
+                default     : return 0, ErrUnsupportType
+            }
+        default             : return 0.0, ErrUnsupportType
+    }
+}
+
+// Float64 exports underlying float64 value, includeing V_NUMBER, V_ANY 
+func (self *Node) StrictFloat64() (float64, error) {
+    if err := self.checkRaw(); err != nil {
+        return 0.0, err
+    }
+    switch self.t {
+        case _V_NUMBER       : return numberToFloat64(self)
+        case _V_ANY        :        
+            any := self.packAny()
+            switch v := any.(type) {
+                case float32 : return float64(v), nil
+                case float64 : return float64(v), nil
+                default      : return 0, ErrUnsupportType
+            }
+        default              : return 0.0, ErrUnsupportType
+    }
+}
+
+/** Sequencial Value Methods **/
+
+// Len returns children count of a array|object|string node
+// For partially loaded node, it also works but only counts the parsed children
+func (self *Node) Len() (int, error) {
+    if err := self.checkRaw(); err != nil {
+        return 0, err
+    }
+    if self.t == types.V_ARRAY || self.t == types.V_OBJECT || self.t == _V_ARRAY_LAZY || self.t == _V_OBJECT_LAZY {
+        return int(self.v & _LEN_MASK), nil
+    } else if self.t == types.V_STRING {
+        return int(self.v), nil
+    } else if self.t == _V_NONE || self.t == types.V_NULL {
+        return 0, nil
+    } else {
+        return 0, ErrUnsupportType
+    }
+}
+
+func (self Node) len() int {
+    return int(self.v & _LEN_MASK)
+}
+
+// Cap returns malloc capacity of a array|object node for children
+func (self *Node) Cap() (int, error) {
+    if err := self.checkRaw(); err != nil {
+        return 0, err
+    }
+    if self.t == types.V_ARRAY || self.t == types.V_OBJECT || self.t == _V_ARRAY_LAZY || self.t == _V_OBJECT_LAZY {
+        return int(self.v >> _CAP_BITS), nil
+    } else if self.t == _V_NONE || self.t == types.V_NULL {
+        return 0, nil
+    } else {
+        return 0, ErrUnsupportType
+    }
+}
+
+func (self Node) cap() int {
+    return int(self.v >> _CAP_BITS)
+}
+
+// Set sets the node of given key under self, and reports if the key has existed.
+//
+// If self is V_NONE or V_NULL, it becomes V_OBJECT and sets the node at the key.
+func (self *Node) Set(key string, node Node) (bool, error) {
+    if self != nil && (self.t == _V_NONE || self.t == types.V_NULL) {
+        *self = NewObject([]Pair{{key, node}})
+        return false, nil
+    }
+
+    if err := node.Check(); err != nil {
+        return false, err 
+    }
+
+    p := self.Get(key)
+    if !p.Exists() {
+        l := self.len()
+        c := self.cap()
+        if l == c {
+            // TODO: maybe change append size in future
+            c += _DEFAULT_NODE_CAP
+            mem := unsafe_NewArray(_PAIR_TYPE, c)
+            memmove(mem, self.p, _PAIR_SIZE * uintptr(l))
+            self.p = mem
+        }
+        v := self.pairAt(l)
+        v.Key = key
+        v.Value = node
+        self.setCapAndLen(c, l+1)
+        return false, nil
+
+    } else if err := p.Check(); err != nil {
+        return false, err
+    } 
+
+    *p = node
+    return true, nil
+}
+
+// SetAny wraps val with V_ANY node, and Set() the node.
+func (self *Node) SetAny(key string, val interface{}) (bool, error) {
+    return self.Set(key, NewAny(val))
+}
+
+// Unset remove the node of given key under object parent, and reports if the key has existed.
+func (self *Node) Unset(key string) (bool, error) {
+    self.must(types.V_OBJECT, "an object")
+    p, i := self.skipKey(key)
+    if !p.Exists() {
+        return false, nil
+    } else if err := p.Check(); err != nil {
+        return false, err
+    }
+    
+    self.removePair(i)
+    return true, nil
+}
+
+// SetByIndex sets the node of given index, and reports if the key has existed.
+//
+// The index must be within self's children.
+func (self *Node) SetByIndex(index int, node Node) (bool, error) {
+    if err := node.Check(); err != nil {
+        return false, err 
+    }
+
+    p := self.Index(index)
+    if !p.Exists() {
+        return false, ErrNotExist
+    } else if err := p.Check(); err != nil {
+        return false, err
+    }
+
+    *p = node
+    return true, nil
+}
+
+// SetAny wraps val with V_ANY node, and SetByIndex() the node.
+func (self *Node) SetAnyByIndex(index int, val interface{}) (bool, error) {
+    return self.SetByIndex(index, NewAny(val))
+}
+
+// UnsetByIndex remove the node of given index
+func (self *Node) UnsetByIndex(index int) (bool, error) {
+    var p *Node
+    it := self.itype()
+    if it == types.V_ARRAY {
+        p = self.Index(index)
+    }else if it == types.V_OBJECT {
+        pr := self.skipIndexPair(index)
+        if pr == nil {
+           return false, ErrNotExist
+        }
+        p = &pr.Value
+    } else {
+        return false, ErrUnsupportType
+    }
+
+    if !p.Exists() {
+        return false, ErrNotExist
+    }
+
+    if it == types.V_ARRAY {
+        self.removeNode(index)
+    }else if it == types.V_OBJECT {
+        self.removePair(index)
+    }
+    return true, nil
+}
+
+// Add appends the given node under self.
+//
+// If self is V_NONE or V_NULL, it becomes V_ARRAY and sets the node at index 0.
+func (self *Node) Add(node Node) error {
+    if self != nil && (self.t == _V_NONE || self.t == types.V_NULL) {
+        *self = NewArray([]Node{node})
+        return nil
+    }
+
+    if err := self.should(types.V_ARRAY, "an array"); err != nil {
+        return err
+    }
+    if err := self.skipAllIndex(); err != nil {
+        return err
+    }
+
+    var p rt.GoSlice
+    p.Cap = self.cap()
+    p.Len = self.len()
+    p.Ptr = self.p
+
+    s := *(*[]Node)(unsafe.Pointer(&p))
+    s = append(s, node)
+
+    self.p = unsafe.Pointer(&s[0])
+    self.setCapAndLen(cap(s), len(s))
+    return nil
+}
+
+// SetAny wraps val with V_ANY node, and Add() the node.
+func (self *Node) AddAny(val interface{}) error {
+    return self.Add(NewAny(val))
+}
+
+// GetByPath load given path on demands,
+// which only ensure nodes before this path got parsed.
+//
+// Note, the api expects the json is well-formed at least,
+// otherwise it may return unexpected result.
+func (self *Node) GetByPath(path ...interface{}) *Node {
+    if !self.Valid() {
+        return self
+    }
+    var s = self
+    for _, p := range path {
+        switch p := p.(type) {
+        case int:
+            s = s.Index(p)
+            if !s.Valid() {
+                return s
+            }
+        case string:
+            s = s.Get(p)
+            if !s.Valid() {
+                return s
+            }
+        default:
+            panic("path must be either int or string")
+        }
+    }
+    return s
+}
+
+// Get loads given key of an object node on demands
+func (self *Node) Get(key string) *Node {
+    if err := self.should(types.V_OBJECT, "an object"); err != nil {
+        return unwrapError(err)
+    }
+    n, _ := self.skipKey(key)
+    return n
+}
+
+// Index indexies node at given idx,
+// node type CAN be either V_OBJECT or V_ARRAY
+func (self *Node) Index(idx int) *Node {
+    if err := self.checkRaw(); err != nil {
+        return unwrapError(err)
+    }
+
+    it := self.itype()
+    if it == types.V_ARRAY {
+        return self.skipIndex(idx)
+
+    }else if it == types.V_OBJECT {
+        pr := self.skipIndexPair(idx)
+        if pr == nil {
+           return newError(_ERR_NOT_FOUND, "value not exists")
+        }
+        return &pr.Value
+
+    } else {
+        return newError(_ERR_UNSUPPORT_TYPE, fmt.Sprintf("unsupported type: %v", self.itype()))
+    }
+}
+
+// IndexPair indexies pair at given idx,
+// node type MUST be either V_OBJECT
+func (self *Node) IndexPair(idx int) *Pair {
+    if err := self.should(types.V_OBJECT, "an object"); err != nil {
+        return nil
+    }
+    return self.skipIndexPair(idx)
+}
+
+// IndexOrGet firstly use idx to index a value and check if its key matches
+// If not, then use the key to search value
+func (self *Node) IndexOrGet(idx int, key string) *Node {
+    if err := self.should(types.V_OBJECT, "an object"); err != nil {
+        return unwrapError(err)
+    }
+
+    pr := self.skipIndexPair(idx)
+    if pr != nil && pr.Key == key {
+        return &pr.Value
+    }
+    n, _ := self.skipKey(key)
+    return n
+}
+
+/** Generic Value Converters **/
+
+// Map loads all keys of an object node
+func (self *Node) Map() (map[string]interface{}, error) {
+    if self.isAny() {
+        any := self.packAny()
+        if v, ok := any.(map[string]interface{}); ok {
+            return v, nil
+        } else {
+            return nil, ErrUnsupportType
+        }
+    }
+    if err := self.should(types.V_OBJECT, "an object"); err != nil {
+        return nil, err
+    }
+    if err := self.loadAllKey(); err != nil {
+        return nil, err
+    }
+    return self.toGenericObject()
+}
+
+// MapUseNumber loads all keys of an object node, with numeric nodes casted to json.Number
+func (self *Node) MapUseNumber() (map[string]interface{}, error) {
+    if self.isAny() {
+        any := self.packAny()
+        if v, ok := any.(map[string]interface{}); ok {
+            return v, nil
+        } else {
+            return nil, ErrUnsupportType
+        }
+    }
+    if err := self.should(types.V_OBJECT, "an object"); err != nil {
+        return nil, err
+    }
+    if err := self.loadAllKey(); err != nil {
+        return nil, err
+    }
+    return self.toGenericObjectUseNumber()
+}
+
+// MapUseNode scans both parsed and non-parsed chidren nodes, 
+// and map them by their keys
+func (self *Node) MapUseNode() (map[string]Node, error) {
+    if self.isAny() {
+        any := self.packAny()
+        if v, ok := any.(map[string]Node); ok {
+            return v, nil
+        } else {
+            return nil, ErrUnsupportType
+        }
+    }
+    if err := self.should(types.V_OBJECT, "an object"); err != nil {
+        return nil, err
+    }
+    if err := self.skipAllKey(); err != nil {
+        return nil, err
+    }
+    return self.toGenericObjectUseNode()
+}
+
+// MapUnsafe exports the underlying pointer to its children map
+// WARN: don't use it unless you know what you are doing
+func (self *Node) UnsafeMap() ([]Pair, error) {
+    if err := self.should(types.V_OBJECT, "an object"); err != nil {
+        return nil, err
+    }
+    if err := self.skipAllKey(); err != nil {
+        return nil, err
+    }
+    s := rt.Ptr2SlicePtr(self.p, int(self.len()), self.cap())
+    return *(*[]Pair)(s), nil
+}
+
+// SortKeys sorts children of a V_OBJECT node in ascending key-order.
+// If recurse is true, it recursively sorts children's children as long as a V_OBJECT node is found.
+func (self *Node) SortKeys(recurse bool) (err error) {
+    ps, err := self.UnsafeMap()
+    if err != nil {
+        return err
+    }
+    PairSlice(ps).Sort()
+    if recurse {
+        var sc Scanner
+        sc = func(path Sequence, node *Node) bool {
+            if node.itype() == types.V_OBJECT {
+                if err := node.SortKeys(recurse); err != nil {
+                    return false
+                }
+            }
+            if node.itype() == types.V_ARRAY {
+                if err := node.ForEach(sc); err != nil {
+                    return false
+                }
+            }
+            return true
+        }
+        self.ForEach(sc)
+    }
+    return nil
+}
+
+// Array loads all indexes of an array node
+func (self *Node) Array() ([]interface{}, error) {
+    if self.isAny() {
+        any := self.packAny()
+        if v, ok := any.([]interface{}); ok {
+            return v, nil
+        } else {
+            return nil, ErrUnsupportType
+        }
+    }
+    if err := self.should(types.V_ARRAY, "an array"); err != nil {
+        return nil, err
+    }
+    if err := self.loadAllIndex(); err != nil {
+        return nil, err
+    }
+    return self.toGenericArray()
+}
+
+// ArrayUseNumber loads all indexes of an array node, with numeric nodes casted to json.Number
+func (self *Node) ArrayUseNumber() ([]interface{}, error) {
+    if self.isAny() {
+        any := self.packAny()
+        if v, ok := any.([]interface{}); ok {
+            return v, nil
+        } else {
+            return nil, ErrUnsupportType
+        }
+    }
+    if err := self.should(types.V_ARRAY, "an array"); err != nil {
+        return nil, err
+    }
+    if err := self.loadAllIndex(); err != nil {
+        return nil, err
+    }
+    return self.toGenericArrayUseNumber()
+}
+
+// ArrayUseNode copys both parsed and non-parsed chidren nodes, 
+// and indexes them by original order
+func (self *Node) ArrayUseNode() ([]Node, error) {
+    if self.isAny() {
+        any := self.packAny()
+        if v, ok := any.([]Node); ok {
+            return v, nil
+        } else {
+            return nil, ErrUnsupportType
+        }
+    }
+    if err := self.should(types.V_ARRAY, "an array"); err != nil {
+        return nil, err
+    }
+    if err := self.skipAllIndex(); err != nil {
+        return nil, err
+    }
+    return self.toGenericArrayUseNode()
+}
+
+// ArrayUnsafe exports the underlying pointer to its children array
+// WARN: don't use it unless you know what you are doing
+func (self *Node) UnsafeArray() ([]Node, error) {
+    if err := self.should(types.V_ARRAY, "an array"); err != nil {
+        return nil, err
+    }
+    if err := self.skipAllIndex(); err != nil {
+        return nil, err
+    }
+    s := rt.Ptr2SlicePtr(self.p, self.len(), self.cap())
+    return *(*[]Node)(s), nil
+}
+
+// Interface loads all children under all pathes from this node,
+// and converts itself as generic type.
+// WARN: all numberic nodes are casted to float64
+func (self *Node) Interface() (interface{}, error) {
+    if err := self.checkRaw(); err != nil {
+        return nil, err
+    }
+    switch self.t {
+        case V_ERROR         : return nil, self.Check()
+        case types.V_NULL    : return nil, nil
+        case types.V_TRUE    : return true, nil
+        case types.V_FALSE   : return false, nil
+        case types.V_ARRAY   : return self.toGenericArray()
+        case types.V_OBJECT  : return self.toGenericObject()
+        case types.V_STRING  : return rt.StrFrom(self.p, self.v), nil
+        case _V_NUMBER       : 
+            v, err := numberToFloat64(self)
+            if err != nil {
+                return nil, err
+            }
+            return v, nil
+        case _V_ARRAY_LAZY   :
+            if err := self.loadAllIndex(); err != nil {
+                return nil, err
+            }
+            return self.toGenericArray()
+        case _V_OBJECT_LAZY  :
+            if err := self.loadAllKey(); err != nil {
+                return nil, err
+            }
+            return self.toGenericObject()
+        case _V_ANY:
+            switch v := self.packAny().(type) {
+                case Node : return v.Interface()
+                case *Node: return v.Interface()
+                default   : return v, nil
+            }
+        default              : return nil,  ErrUnsupportType
+    }
+}
+
+func (self *Node) packAny() interface{} {
+    return *(*interface{})(self.p)
+}
+
+// InterfaceUseNumber works same with Interface()
+// except numberic nodes  are casted to json.Number
+func (self *Node) InterfaceUseNumber() (interface{}, error) {
+    if err := self.checkRaw(); err != nil {
+        return nil, err
+    }
+    switch self.t {
+        case V_ERROR         : return nil, self.Check()
+        case types.V_NULL    : return nil, nil
+        case types.V_TRUE    : return true, nil
+        case types.V_FALSE   : return false, nil
+        case types.V_ARRAY   : return self.toGenericArrayUseNumber()
+        case types.V_OBJECT  : return self.toGenericObjectUseNumber()
+        case types.V_STRING  : return rt.StrFrom(self.p, self.v), nil
+        case _V_NUMBER       : return toNumber(self), nil
+        case _V_ARRAY_LAZY   :
+            if err := self.loadAllIndex(); err != nil {
+                return nil, err
+            }
+            return self.toGenericArrayUseNumber()
+        case _V_OBJECT_LAZY  :
+            if err := self.loadAllKey(); err != nil {
+                return nil, err
+            }
+            return self.toGenericObjectUseNumber()
+        case _V_ANY          : return self.packAny(), nil
+        default              : return nil, ErrUnsupportType
+    }
+}
+
+// InterfaceUseNode clone itself as a new node, 
+// or its children as map[string]Node (or []Node)
+func (self *Node) InterfaceUseNode() (interface{}, error) {
+    if err := self.checkRaw(); err != nil {
+        return nil, err
+    }
+    switch self.t {
+        case types.V_ARRAY   : return self.toGenericArrayUseNode()
+        case types.V_OBJECT  : return self.toGenericObjectUseNode()
+        case _V_ARRAY_LAZY   :
+            if err := self.skipAllIndex(); err != nil {
+                return nil, err
+            }
+            return self.toGenericArrayUseNode()
+        case _V_OBJECT_LAZY  :
+            if err := self.skipAllKey(); err != nil {
+                return nil, err
+            }
+            return self.toGenericObjectUseNode()
+        default              : return *self, self.Check()
+    }
+}
+
+// LoadAll loads all the node's children and children's children as parsed.
+// After calling it, the node can be safely used on concurrency
+func (self *Node) LoadAll() error {
+    if self.IsRaw() {
+        self.parseRaw(true)
+        return self.Check()
+    }
+
+    switch self.itype() {
+    case types.V_ARRAY:
+        e := self.len()
+        if err := self.loadAllIndex(); err != nil {
+            return err
+        }
+        for i := 0; i < e; i++ {
+            n := self.nodeAt(i)
+            if n.IsRaw() {
+                n.parseRaw(true)
+            }
+            if err := n.Check(); err != nil {
+                return err
+            }
+        }
+        return nil
+    case types.V_OBJECT:
+        e := self.len()
+        if err := self.loadAllKey(); err != nil {
+            return err
+        }
+        for i := 0; i < e; i++ {
+            n := self.pairAt(i)
+            if n.Value.IsRaw() {
+                n.Value.parseRaw(true)
+            }
+            if err := n.Value.Check(); err != nil {
+                return err
+            }
+        }
+        return nil
+    default:
+        return self.Check()
+    }
+}
+
+// Load loads the node's children as parsed.
+// After calling it, only the node itself can be used on concurrency (not include its children)
+func (self *Node) Load() error {
+    if self.IsRaw() {
+        self.parseRaw(false)
+        return self.Load()
+    }
+
+    switch self.t {
+    case _V_ARRAY_LAZY:
+        return self.skipAllIndex()
+    case _V_OBJECT_LAZY:
+        return self.skipAllKey()
+    default:
+        return self.Check()
+    }
+}
+
+/**---------------------------------- Internal Helper Methods ----------------------------------**/
+
+var (
+    _NODE_TYPE = rt.UnpackEface(Node{}).Type
+    _PAIR_TYPE = rt.UnpackEface(Pair{}).Type
+)
+
+func (self *Node) setCapAndLen(cap int, len int) {
+    if self.t == types.V_ARRAY || self.t == types.V_OBJECT || self.t == _V_ARRAY_LAZY || self.t == _V_OBJECT_LAZY {
+        self.v = int64(len&_LEN_MASK | cap<<_CAP_BITS)
+    } else {
+        panic("value does not have a length")
+    }
+}
+
+func (self *Node) unsafe_next() *Node {
+    return (*Node)(unsafe.Pointer(uintptr(unsafe.Pointer(self)) + _NODE_SIZE))
+}
+
+func (self *Pair) unsafe_next() *Pair {
+    return (*Pair)(unsafe.Pointer(uintptr(unsafe.Pointer(self)) + _PAIR_SIZE))
+}
+
+func (self *Node) must(t types.ValueType, s string) {
+    if err := self.checkRaw(); err != nil {
+        panic(err)
+    }
+    if err := self.Check(); err != nil {
+        panic(err)
+    }
+    if  self.itype() != t {
+        panic("value cannot be represented as " + s)
+    }
+}
+
+func (self *Node) should(t types.ValueType, s string) error {
+    if err := self.checkRaw(); err != nil {
+        return err
+    }
+    if  self.itype() != t {
+        return ErrUnsupportType
+    }
+    return nil
+}
+
+func (self *Node) nodeAt(i int) *Node {
+    var p = self.p
+    if self.isLazy() {
+        _, stack := self.getParserAndArrayStack()
+        p = *(*unsafe.Pointer)(unsafe.Pointer(&stack.v))
+    }
+    return (*Node)(unsafe.Pointer(uintptr(p) + uintptr(i)*_NODE_SIZE))
+}
+
+func (self *Node) pairAt(i int) *Pair {
+    var p = self.p
+    if self.isLazy() {
+        _, stack := self.getParserAndObjectStack()
+        p = *(*unsafe.Pointer)(unsafe.Pointer(&stack.v))
+    }
+    return (*Pair)(unsafe.Pointer(uintptr(p) + uintptr(i)*_PAIR_SIZE))
+}
+
+func (self *Node) getParserAndArrayStack() (*Parser, *parseArrayStack) {
+    stack := (*parseArrayStack)(self.p)
+    ret := (*rt.GoSlice)(unsafe.Pointer(&stack.v))
+    ret.Len = self.len()
+    ret.Cap = self.cap()
+    return &stack.parser, stack
+}
+
+func (self *Node) getParserAndObjectStack() (*Parser, *parseObjectStack) {
+    stack := (*parseObjectStack)(self.p)
+    ret := (*rt.GoSlice)(unsafe.Pointer(&stack.v))
+    ret.Len = self.len()
+    ret.Cap = self.cap()
+    return &stack.parser, stack
+}
+
+func (self *Node) skipAllIndex() error {
+    if !self.isLazy() {
+        return nil
+    }
+    var err types.ParsingError
+    parser, stack := self.getParserAndArrayStack()
+    parser.skipValue = true
+    parser.noLazy = true
+    *self, err = parser.decodeArray(stack.v)
+    if err != 0 {
+        return parser.ExportError(err)
+    }
+    return nil
+}
+
+func (self *Node) skipAllKey() error {
+    if !self.isLazy() {
+        return nil
+    }
+    var err types.ParsingError
+    parser, stack := self.getParserAndObjectStack()
+    parser.skipValue = true
+    parser.noLazy = true
+    *self, err = parser.decodeObject(stack.v)
+    if err != 0 {
+        return parser.ExportError(err)
+    }
+    return nil
+}
+
+func (self *Node) skipKey(key string) (*Node, int) {
+    nb := self.len()
+    lazy := self.isLazy()
+
+    if nb > 0 {
+        /* linear search */
+        var p *Pair
+        if lazy {
+            s := (*parseObjectStack)(self.p)
+            p = &s.v[0]
+        } else {
+            p = (*Pair)(self.p)
+        }
+
+        if p.Key == key {
+            return &p.Value, 0
+        }
+        for i := 1; i < nb; i++ {
+            p = p.unsafe_next()
+            if p.Key == key {
+                return &p.Value, i
+            }
+        }
+    }
+
+    /* not found */
+    if !lazy {
+        return nil, -1
+    }
+
+    // lazy load
+    for last, i := self.skipNextPair(), nb; last != nil; last, i = self.skipNextPair(), i+1 {
+        if last.Value.Check() != nil {
+            return &last.Value, -1
+        }
+        if last.Key == key {
+            return &last.Value, i
+        }
+    }
+
+    return nil, -1
+}
+
+func (self *Node) skipIndex(index int) *Node {
+    nb := self.len()
+    if nb > index {
+        v := self.nodeAt(index)
+        return v
+    }
+    if !self.isLazy() {
+        return nil
+    }
+
+    // lazy load
+    for last := self.skipNextNode(); last != nil; last = self.skipNextNode(){
+        if last.Check() != nil {
+            return last
+        }
+        if self.len() > index {
+            return last
+        }
+    }
+
+    return nil
+}
+
+func (self *Node) skipIndexPair(index int) *Pair {
+    nb := self.len()
+    if nb > index {
+        return self.pairAt(index)
+    }
+    if !self.isLazy() {
+        return nil
+    }
+
+    // lazy load
+    for last := self.skipNextPair(); last != nil; last = self.skipNextPair(){
+        if last.Value.Check() != nil {
+            return last
+        }
+        if self.len() > index {
+            return last
+        }
+    }
+
+    return nil
+}
+
+func (self *Node) loadAllIndex() error {
+    if !self.isLazy() {
+        return nil
+    }
+    var err types.ParsingError
+    parser, stack := self.getParserAndArrayStack()
+    parser.noLazy = true
+    *self, err = parser.decodeArray(stack.v)
+    if err != 0 {
+        return parser.ExportError(err)
+    }
+    return nil
+}
+
+func (self *Node) loadAllKey() error {
+    if !self.isLazy() {
+        return nil
+    }
+    var err types.ParsingError
+    parser, stack := self.getParserAndObjectStack()
+    parser.noLazy = true
+    *self, err = parser.decodeObject(stack.v)
+    if err != 0 {
+        return parser.ExportError(err)
+    }
+    return nil
+}
+
+func (self *Node) removeNode(i int) {
+    nb := self.len() - 1
+    node := self.nodeAt(i)
+    if i == nb {
+        self.setCapAndLen(self.cap(), nb)
+        *node = Node{}
+        return
+    }
+
+    from := self.nodeAt(i + 1)
+    memmove(unsafe.Pointer(node), unsafe.Pointer(from), _NODE_SIZE * uintptr(nb - i))
+
+    last := self.nodeAt(nb)
+    *last = Node{}
+    
+    self.setCapAndLen(self.cap(), nb)
+}
+
+func (self *Node) removePair(i int) {
+    nb := self.len() - 1
+    node := self.pairAt(i)
+    if i == nb {
+        self.setCapAndLen(self.cap(), nb)
+        *node = Pair{}
+        return
+    }
+
+    from := self.pairAt(i + 1)
+    memmove(unsafe.Pointer(node), unsafe.Pointer(from), _PAIR_SIZE * uintptr(nb - i))
+
+    last := self.pairAt(nb)
+    *last = Pair{}
+    
+    self.setCapAndLen(self.cap(), nb)
+}
+
+func (self *Node) toGenericArray() ([]interface{}, error) {
+    nb := self.len()
+    ret := make([]interface{}, nb)
+    if nb == 0 {
+        return ret, nil
+    }
+
+    /* convert each item */
+    var p = (*Node)(self.p)
+    x, err := p.Interface()
+    if err != nil {
+        return nil, err
+    }
+    ret[0] = x
+
+    for i := 1; i < nb; i++ {
+        p = p.unsafe_next()
+        x, err := p.Interface()
+        if err != nil {
+            return nil, err
+        }
+        ret[i] = x
+    }
+
+    /* all done */
+    return ret, nil
+}
+
+func (self *Node) toGenericArrayUseNumber() ([]interface{}, error) {
+    nb := self.len()
+    ret := make([]interface{}, nb)
+    if nb == 0 {
+        return ret, nil
+    }
+
+    /* convert each item */
+    var p = (*Node)(self.p)
+    x, err := p.InterfaceUseNumber()
+    if err != nil {
+        return nil, err
+    }
+    ret[0] = x
+
+    for i := 1; i < nb; i++ {
+        p = p.unsafe_next()
+        x, err := p.InterfaceUseNumber()
+        if err != nil {
+            return nil, err
+        }
+        ret[i] = x
+    }
+
+    /* all done */
+    return ret, nil
+}
+
+func (self *Node) toGenericArrayUseNode() ([]Node, error) {
+    var nb = self.len()
+    var out = make([]Node, nb)
+    if nb == 0 {
+        return out, nil
+    }
+
+    var p = (*Node)(self.p)
+    out[0] = *p
+    if err := p.Check(); err != nil {
+        return nil, err
+    }
+
+    for i := 1; i < nb; i++ {
+        p = p.unsafe_next()
+        if err := p.Check(); err != nil {
+            return nil, err
+        }
+        out[i] = *p
+    }
+
+    return out, nil
+}
+
+func (self *Node) toGenericObject() (map[string]interface{}, error) {
+    nb := self.len()
+    ret := make(map[string]interface{}, nb)
+    if nb == 0 {
+        return ret, nil
+    }
+
+    /* convert each item */
+    var p = (*Pair)(self.p)
+    x, err := p.Value.Interface()
+    if err != nil {
+        return nil, err
+    }
+    ret[p.Key] = x
+
+    for i := 1; i < nb; i++ {
+        p = p.unsafe_next()
+        x, err := p.Value.Interface()
+        if err != nil {
+            return nil, err
+        }
+        ret[p.Key] = x
+    }
+
+    /* all done */
+    return ret, nil
+}
+
+
+func (self *Node) toGenericObjectUseNumber() (map[string]interface{}, error) {
+    nb := self.len()
+    ret := make(map[string]interface{}, nb)
+    if nb == 0 {
+        return ret, nil
+    }
+
+    /* convert each item */
+    var p = (*Pair)(self.p)
+    x, err := p.Value.InterfaceUseNumber()
+    if err != nil {
+        return nil, err
+    }
+    ret[p.Key] = x
+
+    for i := 1; i < nb; i++ {
+        p = p.unsafe_next()
+        x, err := p.Value.InterfaceUseNumber()
+        if err != nil {
+            return nil, err
+        }
+        ret[p.Key] = x
+    }
+
+    /* all done */
+    return ret, nil
+}
+
+func (self *Node) toGenericObjectUseNode() (map[string]Node, error) {
+    var nb = self.len()
+    var out = make(map[string]Node, nb)
+    if nb == 0 {
+        return out, nil
+    }
+
+    var p = (*Pair)(self.p)
+    out[p.Key] = p.Value
+    if err := p.Value.Check(); err != nil {
+        return nil, err
+    }
+
+    for i := 1; i < nb; i++ {
+        p = p.unsafe_next()
+        if err := p.Value.Check(); err != nil {
+            return nil, err
+        }
+        out[p.Key] = p.Value
+    }
+
+    /* all done */
+    return out, nil
+}
+
+/**------------------------------------ Factory Methods ------------------------------------**/
+
+var (
+    nullNode  = Node{t: types.V_NULL}
+    trueNode  = Node{t: types.V_TRUE}
+    falseNode = Node{t: types.V_FALSE}
+
+    emptyArrayNode  = Node{t: types.V_ARRAY}
+    emptyObjectNode = Node{t: types.V_OBJECT}
+)
+
+// NewRaw creates a node of raw json, and decides its type by first char.
+func NewRaw(json string) Node {
+    if json == "" {
+        panic("empty json string")
+    }
+    it := switchRawType(json[0])
+    return newRawNode(json, it)
+}
+
+// NewAny creates a node of type V_ANY if any's type isn't Node or *Node, 
+// which stores interface{} and can be only used for `.Interface()`\`.MarshalJSON()`.
+func NewAny(any interface{}) Node {
+    switch n := any.(type) {
+    case Node:
+        return n
+    case *Node:
+        return *n
+    default:
+        return Node{
+            t: _V_ANY,
+            v: 0,
+            p: unsafe.Pointer(&any),
+        }
+    }
+}
+
+// NewBytes encodes given src with Base64 (RFC 4648), and creates a node of type V_STRING.
+func NewBytes(src []byte) Node {
+    if len(src) == 0 {
+        panic("empty src bytes")
+    }
+    out := encodeBase64(src)
+    return NewString(out)
+}
+
+// NewNull creates a node of type V_NULL
+func NewNull() Node {
+    return Node{
+        v: 0,
+        p: nil,
+        t: types.V_NULL,
+    }
+}
+
+// NewBool creates a node of type bool:
+//  If v is true, returns V_TRUE node
+//  If v is false, returns V_FALSE node
+func NewBool(v bool) Node {
+    var t = types.V_FALSE
+    if v {
+        t = types.V_TRUE
+    }
+    return Node{
+        v: 0,
+        p: nil,
+        t: t,
+    }
+}
+
+// NewNumber creates a json.Number node
+// v must be a decimal string complying with RFC8259
+func NewNumber(v string) Node {
+    return Node{
+        v: int64(len(v) & _LEN_MASK),
+        p: rt.StrPtr(v),
+        t: _V_NUMBER,
+    }
+}
+
+func toNumber(node *Node) json.Number {
+    return json.Number(rt.StrFrom(node.p, node.v))
+}
+
+func numberToFloat64(node *Node) (float64, error) {
+    ret,err := toNumber(node).Float64()
+    if err != nil {
+        return 0, err
+    }
+    return ret, nil
+}
+
+func numberToInt64(node *Node) (int64, error) {
+    ret,err := toNumber(node).Int64()
+    if err != nil {
+        return 0, err
+    }
+    return ret, nil
+}
+
+func newBytes(v []byte) Node {
+    return Node{
+        t: types.V_STRING,
+        p: mem2ptr(v),
+        v: int64(len(v) & _LEN_MASK),
+    }
+}
+
+// NewString creates a node of type V_STRING. 
+// v is considered to be a valid UTF-8 string,
+// which means it won't be validated and unescaped.
+// when the node is encoded to json, v will be escaped.
+func NewString(v string) Node {
+    return Node{
+        t: types.V_STRING,
+        p: rt.StrPtr(v),
+        v: int64(len(v) & _LEN_MASK),
+    }
+}
+
+// NewArray creates a node of type V_ARRAY,
+// using v as its underlying children
+func NewArray(v []Node) Node {
+    return Node{
+        t: types.V_ARRAY,
+        v: int64(len(v)&_LEN_MASK | cap(v)<<_CAP_BITS),
+        p: *(*unsafe.Pointer)(unsafe.Pointer(&v)),
+    }
+}
+
+func (self *Node) setArray(v []Node) {
+    self.t = types.V_ARRAY
+    self.setCapAndLen(cap(v), len(v))
+    self.p = *(*unsafe.Pointer)(unsafe.Pointer(&v))
+}
+
+// NewObject creates a node of type V_OBJECT,
+// using v as its underlying children
+func NewObject(v []Pair) Node {
+    return Node{
+        t: types.V_OBJECT,
+        v: int64(len(v)&_LEN_MASK | cap(v)<<_CAP_BITS),
+        p: *(*unsafe.Pointer)(unsafe.Pointer(&v)),
+    }
+}
+
+func (self *Node) setObject(v []Pair) {
+    self.t = types.V_OBJECT
+    self.setCapAndLen(cap(v), len(v))
+    self.p = *(*unsafe.Pointer)(unsafe.Pointer(&v))
+}
+
+type parseObjectStack struct {
+    parser Parser
+    v      []Pair
+}
+
+type parseArrayStack struct {
+    parser Parser
+    v      []Node
+}
+
+func newLazyArray(p *Parser, v []Node) Node {
+    s := new(parseArrayStack)
+    s.parser = *p
+    s.v = v
+    return Node{
+        t: _V_ARRAY_LAZY,
+        v: int64(len(v)&_LEN_MASK | cap(v)<<_CAP_BITS),
+        p: unsafe.Pointer(s),
+    }
+}
+
+func (self *Node) setLazyArray(p *Parser, v []Node) {
+    s := new(parseArrayStack)
+    s.parser = *p
+    s.v = v
+    self.t = _V_ARRAY_LAZY
+    self.setCapAndLen(cap(v), len(v))
+    self.p = (unsafe.Pointer)(s)
+}
+
+func newLazyObject(p *Parser, v []Pair) Node {
+    s := new(parseObjectStack)
+    s.parser = *p
+    s.v = v
+    return Node{
+        t: _V_OBJECT_LAZY,
+        v: int64(len(v)&_LEN_MASK | cap(v)<<_CAP_BITS),
+        p: unsafe.Pointer(s),
+    }
+}
+
+func (self *Node) setLazyObject(p *Parser, v []Pair) {
+    s := new(parseObjectStack)
+    s.parser = *p
+    s.v = v
+    self.t = _V_OBJECT_LAZY
+    self.setCapAndLen(cap(v), len(v))
+    self.p = (unsafe.Pointer)(s)
+}
+
+func newRawNode(str string, typ types.ValueType) Node {
+    return Node{
+        t: _V_RAW | typ,
+        p: rt.StrPtr(str),
+        v: int64(len(str) & _LEN_MASK),
+    }
+}
+
+func (self *Node) parseRaw(full bool) {
+    raw := rt.StrFrom(self.p, self.v)
+    parser := NewParser(raw)
+    if full {
+        parser.noLazy = true
+        parser.skipValue = false
+    }
+    var e types.ParsingError
+    *self, e = parser.Parse()
+    if e != 0 {
+        *self = *newSyntaxError(parser.syntaxError(e))
+    }
+}
+
+func newError(err types.ParsingError, msg string) *Node {
+    return &Node{
+        t: V_ERROR,
+        v: int64(err),
+        p: unsafe.Pointer(&msg),
+    }
+}
+
+var typeJumpTable = [256]types.ValueType{
+    '"' : types.V_STRING,
+    '-' : _V_NUMBER,
+    '0' : _V_NUMBER,
+    '1' : _V_NUMBER,
+    '2' : _V_NUMBER,
+    '3' : _V_NUMBER,
+    '4' : _V_NUMBER,
+    '5' : _V_NUMBER,
+    '6' : _V_NUMBER,
+    '7' : _V_NUMBER,
+    '8' : _V_NUMBER,
+    '9' : _V_NUMBER,
+    '[' : types.V_ARRAY,
+    'f' : types.V_FALSE,
+    'n' : types.V_NULL,
+    't' : types.V_TRUE,
+    '{' : types.V_OBJECT,
+}
+
+func switchRawType(c byte) types.ValueType {
+    return typeJumpTable[c]
+}
+
+func unwrapError(err error) *Node {
+    if se, ok := err.(*Node); ok {
+        return se
+    }else if sse, ok := err.(Node); ok {
+        return &sse
+    } else {
+        msg := err.Error()
+        return &Node{
+            t: V_ERROR,
+            v: 0,
+            p: unsafe.Pointer(&msg),
+        }
+    }
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/ast/parser.go b/vendor/github.com/bytedance/sonic/ast/parser.go
new file mode 100644
index 000000000..ebb7bb097
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/ast/parser.go
@@ -0,0 +1,618 @@
+/*
+ * 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 ast
+
+import (
+    `fmt`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+const _DEFAULT_NODE_CAP int = 16
+
+const (
+    _ERR_NOT_FOUND      types.ParsingError = 33
+    _ERR_UNSUPPORT_TYPE types.ParsingError = 34
+)
+
+var (
+    ErrNotExist error = newError(_ERR_NOT_FOUND, "value not exists")
+    ErrUnsupportType error = newError(_ERR_UNSUPPORT_TYPE, "unsupported type")
+)
+
+type Parser struct {
+    p           int
+    s           string
+    noLazy      bool
+    skipValue   bool
+}
+
+/** Parser Private Methods **/
+
+func (self *Parser) delim() types.ParsingError {
+    n := len(self.s)
+    p := self.lspace(self.p)
+
+    /* check for EOF */
+    if p >= n {
+        return types.ERR_EOF
+    }
+
+    /* check for the delimtier */
+    if self.s[p] != ':' {
+        return types.ERR_INVALID_CHAR
+    }
+
+    /* update the read pointer */
+    self.p = p + 1
+    return 0
+}
+
+func (self *Parser) object() types.ParsingError {
+    n := len(self.s)
+    p := self.lspace(self.p)
+
+    /* check for EOF */
+    if p >= n {
+        return types.ERR_EOF
+    }
+
+    /* check for the delimtier */
+    if self.s[p] != '{' {
+        return types.ERR_INVALID_CHAR
+    }
+
+    /* update the read pointer */
+    self.p = p + 1
+    return 0
+}
+
+func (self *Parser) array() types.ParsingError {
+    n := len(self.s)
+    p := self.lspace(self.p)
+
+    /* check for EOF */
+    if p >= n {
+        return types.ERR_EOF
+    }
+
+    /* check for the delimtier */
+    if self.s[p] != '[' {
+        return types.ERR_INVALID_CHAR
+    }
+
+    /* update the read pointer */
+    self.p = p + 1
+    return 0
+}
+
+func (self *Parser) lspace(sp int) int {
+    ns := len(self.s)
+    for ; sp<ns && isSpace(self.s[sp]); sp+=1 {}
+
+    return sp
+}
+
+func (self *Parser) decodeArray(ret []Node) (Node, types.ParsingError) {
+    sp := self.p
+    ns := len(self.s)
+
+    /* check for EOF */
+    if self.p = self.lspace(sp); self.p >= ns {
+        return Node{}, types.ERR_EOF
+    }
+
+    /* check for empty array */
+    if self.s[self.p] == ']' {
+        self.p++
+        return emptyArrayNode, 0
+    }
+
+    /* allocate array space and parse every element */
+    for {
+        var val Node
+        var err types.ParsingError
+
+        if self.skipValue {
+            /* skip the value */
+            var start int
+            if start, err = self.skipFast(); err != 0 {
+                return Node{}, err
+            }
+            if self.p > ns {
+                return Node{}, types.ERR_EOF
+            }
+            t := switchRawType(self.s[start])
+            if t == _V_NONE {
+                return Node{}, types.ERR_INVALID_CHAR
+            }
+            val = newRawNode(self.s[start:self.p], t)
+        }else{
+            /* decode the value */
+            if val, err = self.Parse(); err != 0 {
+                return Node{}, err
+            }
+        }
+
+        /* add the value to result */
+        ret = append(ret, val)
+        self.p = self.lspace(self.p)
+
+        /* check for EOF */
+        if self.p >= ns {
+            return Node{}, types.ERR_EOF
+        }
+
+        /* check for the next character */
+        switch self.s[self.p] {
+            case ',' : self.p++
+            case ']' : self.p++; return NewArray(ret), 0
+        default:
+            if val.isLazy() {
+                return newLazyArray(self, ret), 0
+            }
+            return Node{}, types.ERR_INVALID_CHAR
+        }
+    }
+}
+
+func (self *Parser) decodeObject(ret []Pair) (Node, types.ParsingError) {
+    sp := self.p
+    ns := len(self.s)
+
+    /* check for EOF */
+    if self.p = self.lspace(sp); self.p >= ns {
+        return Node{}, types.ERR_EOF
+    }
+
+    /* check for empty object */
+    if self.s[self.p] == '}' {
+        self.p++
+        return emptyObjectNode, 0
+    }
+
+    /* decode each pair */
+    for {
+        var val Node
+        var njs types.JsonState
+        var err types.ParsingError
+
+        /* decode the key */
+        if njs = self.decodeValue(); njs.Vt != types.V_STRING {
+            return Node{}, types.ERR_INVALID_CHAR
+        }
+
+        /* extract the key */
+        idx := self.p - 1
+        key := self.s[njs.Iv:idx]
+
+        /* check for escape sequence */
+        if njs.Ep != -1 {
+            if key, err = unquote(key); err != 0 {
+                return Node{}, err
+            }
+        }
+
+        /* expect a ':' delimiter */
+        if err = self.delim(); err != 0 {
+            return Node{}, err
+        }
+
+        
+        if self.skipValue {
+            /* skip the value */
+            var start int
+            if start, err = self.skipFast(); err != 0 {
+                return Node{}, err
+            }
+            if self.p > ns {
+                return Node{}, types.ERR_EOF
+            }
+            t := switchRawType(self.s[start])
+            if t == _V_NONE {
+                return Node{}, types.ERR_INVALID_CHAR
+            }
+            val = newRawNode(self.s[start:self.p], t)
+        } else {
+            /* decode the value */
+            if val, err = self.Parse(); err != 0 {
+                return Node{}, err
+            }
+        }
+
+        /* add the value to result */
+        ret = append(ret, Pair{Key: key, Value: val})
+        self.p = self.lspace(self.p)
+
+        /* check for EOF */
+        if self.p >= ns {
+            return Node{}, types.ERR_EOF
+        }
+
+        /* check for the next character */
+        switch self.s[self.p] {
+            case ',' : self.p++
+            case '}' : self.p++; return NewObject(ret), 0
+        default:
+            if val.isLazy() {
+                return newLazyObject(self, ret), 0
+            }
+            return Node{}, types.ERR_INVALID_CHAR
+        }
+    }
+}
+
+func (self *Parser) decodeString(iv int64, ep int) (Node, types.ParsingError) {
+    p := self.p - 1
+    s := self.s[iv:p]
+
+    /* fast path: no escape sequence */
+    if ep == -1 {
+        return NewString(s), 0
+    }
+
+    /* unquote the string */
+    out, err := unquote(s)
+
+    /* check for errors */
+    if err != 0 {
+        return Node{}, err
+    } else {
+        return newBytes(rt.Str2Mem(out)), 0
+    }
+}
+
+/** Parser Interface **/
+
+func (self *Parser) Pos() int {
+    return self.p
+}
+
+func (self *Parser) Parse() (Node, types.ParsingError) {
+    switch val := self.decodeValue(); val.Vt {
+        case types.V_EOF     : return Node{}, types.ERR_EOF
+        case types.V_NULL    : return nullNode, 0
+        case types.V_TRUE    : return trueNode, 0
+        case types.V_FALSE   : return falseNode, 0
+        case types.V_STRING  : return self.decodeString(val.Iv, val.Ep)
+        case types.V_ARRAY:
+            if self.noLazy {
+                return self.decodeArray(make([]Node, 0, _DEFAULT_NODE_CAP))
+            }
+            return newLazyArray(self, make([]Node, 0, _DEFAULT_NODE_CAP)), 0
+        case types.V_OBJECT:
+            if self.noLazy {
+                return self.decodeObject(make([]Pair, 0, _DEFAULT_NODE_CAP))
+            }
+            return newLazyObject(self, make([]Pair, 0, _DEFAULT_NODE_CAP)), 0
+        case types.V_DOUBLE  : return NewNumber(self.s[val.Ep:self.p]), 0
+        case types.V_INTEGER : return NewNumber(self.s[val.Ep:self.p]), 0
+        default              : return Node{}, types.ParsingError(-val.Vt)
+    }
+}
+
+func (self *Parser) searchKey(match string) types.ParsingError {
+    ns := len(self.s)
+    if err := self.object(); err != 0 {
+        return err
+    }
+
+    /* check for EOF */
+    if self.p = self.lspace(self.p); self.p >= ns {
+        return types.ERR_EOF
+    }
+
+    /* check for empty object */
+    if self.s[self.p] == '}' {
+        self.p++
+        return _ERR_NOT_FOUND
+    }
+
+    var njs types.JsonState
+    var err types.ParsingError
+    /* decode each pair */
+    for {
+
+        /* decode the key */
+        if njs = self.decodeValue(); njs.Vt != types.V_STRING {
+            return types.ERR_INVALID_CHAR
+        }
+
+        /* extract the key */
+        idx := self.p - 1
+        key := self.s[njs.Iv:idx]
+
+        /* check for escape sequence */
+        if njs.Ep != -1 {
+            if key, err = unquote(key); err != 0 {
+                return err
+            }
+        }
+
+        /* expect a ':' delimiter */
+        if err = self.delim(); err != 0 {
+            return err
+        }
+
+        /* skip value */
+        if key != match {
+            if _, err = self.skip(); err != 0 {
+                return err
+            }
+        } else {
+            return 0
+        }
+
+        /* check for EOF */
+        self.p = self.lspace(self.p)
+        if self.p >= ns {
+            return types.ERR_EOF
+        }
+
+        /* check for the next character */
+        switch self.s[self.p] {
+        case ',':
+            self.p++
+        case '}':
+            self.p++
+            return _ERR_NOT_FOUND
+        default:
+            return types.ERR_INVALID_CHAR
+        }
+    }
+}
+
+func (self *Parser) searchIndex(idx int) types.ParsingError {
+    ns := len(self.s)
+    if err := self.array(); err != 0 {
+        return err
+    }
+
+    /* check for EOF */
+    if self.p = self.lspace(self.p); self.p >= ns {
+        return types.ERR_EOF
+    }
+
+    /* check for empty array */
+    if self.s[self.p] == ']' {
+        self.p++
+        return _ERR_NOT_FOUND
+    }
+
+    var err types.ParsingError
+    /* allocate array space and parse every element */
+    for i := 0; i < idx; i++ {
+
+        /* decode the value */
+        if _, err = self.skip(); err != 0 {
+            return err
+        }
+
+        /* check for EOF */
+        self.p = self.lspace(self.p)
+        if self.p >= ns {
+            return types.ERR_EOF
+        }
+
+        /* check for the next character */
+        switch self.s[self.p] {
+        case ',':
+            self.p++
+        case ']':
+            self.p++
+            return _ERR_NOT_FOUND
+        default:
+            return types.ERR_INVALID_CHAR
+        }
+    }
+
+    return 0
+}
+
+func (self *Node) skipNextNode() *Node {
+    if !self.isLazy() {
+        return nil
+    }
+
+    parser, stack := self.getParserAndArrayStack()
+    ret := stack.v
+    sp := parser.p
+    ns := len(parser.s)
+
+    /* check for EOF */
+    if parser.p = parser.lspace(sp); parser.p >= ns {
+        return newSyntaxError(parser.syntaxError(types.ERR_EOF))
+    }
+
+    /* check for empty array */
+    if parser.s[parser.p] == ']' {
+        parser.p++
+        self.setArray(ret)
+        return nil
+    }
+
+    var val Node
+    /* skip the value */
+    if start, err := parser.skipFast(); err != 0 {
+        return newSyntaxError(parser.syntaxError(err))
+    } else {
+        t := switchRawType(parser.s[start])
+        if t == _V_NONE {
+            return newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))
+        }
+        val = newRawNode(parser.s[start:parser.p], t)
+    }
+
+    /* add the value to result */
+    ret = append(ret, val)
+    parser.p = parser.lspace(parser.p)
+
+    /* check for EOF */
+    if parser.p >= ns {
+        return newSyntaxError(parser.syntaxError(types.ERR_EOF))
+    }
+
+    /* check for the next character */
+    switch parser.s[parser.p] {
+    case ',':
+        parser.p++
+        self.setLazyArray(parser, ret)
+        return &ret[len(ret)-1]
+    case ']':
+        parser.p++
+        self.setArray(ret)
+        return &ret[len(ret)-1]
+    default:
+        return newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))
+    }
+}
+
+func (self *Node) skipNextPair() (*Pair) {
+    if !self.isLazy() {
+        return nil
+    }
+
+    parser, stack := self.getParserAndObjectStack()
+    ret := stack.v
+    sp := parser.p
+    ns := len(parser.s)
+
+    /* check for EOF */
+    if parser.p = parser.lspace(sp); parser.p >= ns {
+        return &Pair{"", *newSyntaxError(parser.syntaxError(types.ERR_EOF))}
+    }
+
+    /* check for empty object */
+    if parser.s[parser.p] == '}' {
+        parser.p++
+        self.setObject(ret)
+        return nil
+    }
+
+    /* decode one pair */
+    var val Node
+    var njs types.JsonState
+    var err types.ParsingError
+
+    /* decode the key */
+    if njs = parser.decodeValue(); njs.Vt != types.V_STRING {
+        return &Pair{"", *newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))}
+    }
+
+    /* extract the key */
+    idx := parser.p - 1
+    key := parser.s[njs.Iv:idx]
+
+    /* check for escape sequence */
+    if njs.Ep != -1 {
+        if key, err = unquote(key); err != 0 {
+            return &Pair{key, *newSyntaxError(parser.syntaxError(err))}
+        }
+    }
+
+    /* expect a ':' delimiter */
+    if err = parser.delim(); err != 0 {
+        return &Pair{key, *newSyntaxError(parser.syntaxError(err))}
+    }
+
+    /* skip the value */
+    if start, err := parser.skipFast(); err != 0 {
+        return &Pair{key, *newSyntaxError(parser.syntaxError(err))}
+    } else {
+        t := switchRawType(parser.s[start])
+        if t == _V_NONE {
+            return &Pair{key, *newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))}
+        }
+        val = newRawNode(parser.s[start:parser.p], t)
+    }
+
+    /* add the value to result */
+    ret = append(ret, Pair{Key: key, Value: val})
+    parser.p = parser.lspace(parser.p)
+
+    /* check for EOF */
+    if parser.p >= ns {
+        return &Pair{key, *newSyntaxError(parser.syntaxError(types.ERR_EOF))}
+    }
+
+    /* check for the next character */
+    switch parser.s[parser.p] {
+    case ',':
+        parser.p++
+        self.setLazyObject(parser, ret)
+        return &ret[len(ret)-1]
+    case '}':
+        parser.p++
+        self.setObject(ret)
+        return &ret[len(ret)-1]
+    default:
+        return &Pair{key, *newSyntaxError(parser.syntaxError(types.ERR_INVALID_CHAR))}
+    }
+}
+
+
+/** Parser Factory **/
+
+// Loads parse all json into interface{}
+func Loads(src string) (int, interface{}, error) {
+    ps := &Parser{s: src}
+    np, err := ps.Parse()
+
+    /* check for errors */
+    if err != 0 {
+        return 0, nil, ps.ExportError(err)
+    } else {
+        x, err := np.Interface()
+        if err != nil {
+            return 0, nil, err
+        }
+        return ps.Pos(), x, nil
+    }
+}
+
+// LoadsUseNumber parse all json into interface{}, with numeric nodes casted to json.Number
+func LoadsUseNumber(src string) (int, interface{}, error) {
+    ps := &Parser{s: src}
+    np, err := ps.Parse()
+
+    /* check for errors */
+    if err != 0 {
+        return 0, nil, err
+    } else {
+        x, err := np.InterfaceUseNumber()
+        if err != nil {
+            return 0, nil, err
+        }
+        return ps.Pos(), x, nil
+    }
+}
+
+func NewParser(src string) *Parser {
+    return &Parser{s: src}
+}
+
+// ExportError converts types.ParsingError to std Error
+func (self *Parser) ExportError(err types.ParsingError) error {
+    if err == _ERR_NOT_FOUND {
+        return ErrNotExist
+    }
+    return fmt.Errorf("%q", SyntaxError{
+        Pos : self.p,
+        Src : self.s,
+        Code: err,
+    }.Description())
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/ast/search.go b/vendor/github.com/bytedance/sonic/ast/search.go
new file mode 100644
index 000000000..bb6fceaa7
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/ast/search.go
@@ -0,0 +1,30 @@
+/*
+ * 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 ast
+
+type Searcher struct {
+    parser Parser
+}
+
+func NewSearcher(str string) *Searcher {
+    return &Searcher{
+        parser: Parser{
+            s:      str,
+            noLazy: false,
+        },
+    }
+}
diff --git a/vendor/github.com/bytedance/sonic/ast/sort.go b/vendor/github.com/bytedance/sonic/ast/sort.go
new file mode 100644
index 000000000..0a9f14559
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/ast/sort.go
@@ -0,0 +1,206 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ast
+
+// Algorithm 3-way Radix Quicksort, d means the radix.
+// Reference: https://algs4.cs.princeton.edu/51radix/Quick3string.java.html
+func radixQsort(kvs PairSlice, d, maxDepth int) {
+    for len(kvs) > 11 {
+        // To avoid the worst case of quickSort (time: O(n^2)), use introsort here.
+        // Reference: https://en.wikipedia.org/wiki/Introsort and
+        // https://github.com/golang/go/issues/467
+        if maxDepth == 0 {
+            heapSort(kvs, 0, len(kvs))
+            return
+        }
+        maxDepth--
+
+        p := pivot(kvs, d)
+        lt, i, gt := 0, 0, len(kvs)
+        for i < gt {
+            c := byteAt(kvs[i].Key, d)
+            if c < p {
+                swap(kvs, lt, i)
+                i++
+                lt++
+            } else if c > p {
+                gt--
+                swap(kvs, i, gt)
+            } else {
+                i++
+            }
+        }
+
+        // kvs[0:lt] < v = kvs[lt:gt] < kvs[gt:len(kvs)]
+        // Native implemention:
+        //     radixQsort(kvs[:lt], d, maxDepth)
+        //     if p > -1 {
+        //         radixQsort(kvs[lt:gt], d+1, maxDepth)
+        //     }
+        //     radixQsort(kvs[gt:], d, maxDepth)
+        // Optimize as follows: make recursive calls only for the smaller parts.
+        // Reference: https://www.geeksforgeeks.org/quicksort-tail-call-optimization-reducing-worst-case-space-log-n/
+        if p == -1 {
+            if lt > len(kvs) - gt {
+                radixQsort(kvs[gt:], d, maxDepth)
+                kvs = kvs[:lt]
+            } else {
+                radixQsort(kvs[:lt], d, maxDepth)
+                kvs = kvs[gt:]
+            }
+        } else {
+            ml := maxThree(lt, gt-lt, len(kvs)-gt)
+            if ml == lt {
+                radixQsort(kvs[lt:gt], d+1, maxDepth)
+                radixQsort(kvs[gt:], d, maxDepth)
+                kvs = kvs[:lt]
+            } else if ml == gt-lt {
+                radixQsort(kvs[:lt], d, maxDepth)
+                radixQsort(kvs[gt:], d, maxDepth)
+                kvs = kvs[lt:gt]
+                d += 1
+            } else {
+                radixQsort(kvs[:lt], d, maxDepth)
+                radixQsort(kvs[lt:gt], d+1, maxDepth)
+                kvs = kvs[gt:] 
+            }
+        }
+    }
+    insertRadixSort(kvs, d)
+}
+
+func insertRadixSort(kvs PairSlice, d int) {
+    for i := 1; i < len(kvs); i++ {
+        for j := i; j > 0 && lessFrom(kvs[j].Key, kvs[j-1].Key, d); j-- {
+            swap(kvs, j, j-1)
+        }
+    }
+}
+
+func pivot(kvs PairSlice, d int) int {
+    m := len(kvs) >> 1
+    if len(kvs) > 40 {
+        // Tukey's ``Ninther,'' median of three mediankvs of three.
+        t := len(kvs) / 8
+        return medianThree(
+            medianThree(byteAt(kvs[0].Key, d), byteAt(kvs[t].Key, d), byteAt(kvs[2*t].Key, d)),
+            medianThree(byteAt(kvs[m].Key, d), byteAt(kvs[m-t].Key, d), byteAt(kvs[m+t].Key, d)),
+            medianThree(byteAt(kvs[len(kvs)-1].Key, d),
+                byteAt(kvs[len(kvs)-1-t].Key, d),
+                byteAt(kvs[len(kvs)-1-2*t].Key, d)))
+    }
+    return medianThree(byteAt(kvs[0].Key, d), byteAt(kvs[m].Key, d), byteAt(kvs[len(kvs)-1].Key, d))
+}
+
+func medianThree(i, j, k int) int {
+    if i > j {
+        i, j = j, i
+    } // i < j
+    if k < i {
+        return i
+    }
+    if k > j {
+        return j
+    }
+    return k
+}
+
+func maxThree(i, j, k int) int {
+    max := i
+    if max < j {
+        max = j
+    }
+    if max < k {
+        max = k
+    }
+    return max
+}
+
+// maxDepth returns a threshold at which quicksort should switch
+// to heapsort. It returnkvs 2*ceil(lg(n+1)).
+func maxDepth(n int) int {
+    var depth int
+    for i := n; i > 0; i >>= 1 {
+        depth++
+    }
+    return depth * 2
+}
+
+// siftDown implements the heap property on kvs[lo:hi].
+// first is an offset into the array where the root of the heap lies.
+func siftDown(kvs PairSlice, lo, hi, first int) {
+    root := lo
+    for {
+        child := 2*root + 1
+        if child >= hi {
+            break
+        }
+        if child+1 < hi && kvs[first+child].Key < kvs[first+child+1].Key {
+            child++
+        }
+        if kvs[first+root].Key >= kvs[first+child].Key {
+            return
+        }
+        swap(kvs, first+root, first+child)
+        root = child
+    }
+}
+
+func heapSort(kvs PairSlice, a, b int) {
+    first := a
+    lo := 0
+    hi := b - a
+
+    // Build heap with the greatest element at top.
+    for i := (hi - 1) / 2; i >= 0; i-- {
+        siftDown(kvs, i, hi, first)
+    }
+
+    // Pop elements, the largest first, into end of kvs.
+    for i := hi - 1; i >= 0; i-- {
+        swap(kvs, first, first+i)
+        siftDown(kvs, lo, i, first)
+    }
+}
+
+// Note that Pair.Key is NOT pointed to Pair.m when map key is integer after swap
+func swap(kvs PairSlice, a, b int) {
+    kvs[a].Key, kvs[b].Key = kvs[b].Key, kvs[a].Key
+    kvs[a].Value, kvs[b].Value = kvs[b].Value, kvs[a].Value
+}
+
+// Compare two strings from the pos d.
+func lessFrom(a, b string, d int) bool {
+    l := len(a)
+    if l > len(b) {
+        l = len(b)
+    }
+    for i := d; i < l; i++ {
+        if a[i] == b[i] {
+            continue
+        }
+        return a[i] < b[i]
+    }
+    return len(a) < len(b)
+}
+
+func byteAt(b string, p int) int {
+    if p < len(b) {
+        return int(b[p])
+    }
+    return -1
+}
diff --git a/vendor/github.com/bytedance/sonic/ast/stubs_go115.go b/vendor/github.com/bytedance/sonic/ast/stubs_go115.go
new file mode 100644
index 000000000..37b9451f0
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/ast/stubs_go115.go
@@ -0,0 +1,55 @@
+// +build !go1.20
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ast
+
+import (
+    `unsafe`
+    `unicode/utf8`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+//go:noescape
+//go:linkname memmove runtime.memmove
+//goland:noinspection GoUnusedParameter
+func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
+
+//go:linkname unsafe_NewArray reflect.unsafe_NewArray
+//goland:noinspection GoUnusedParameter
+func unsafe_NewArray(typ *rt.GoType, n int) unsafe.Pointer
+
+//go:linkname growslice runtime.growslice
+//goland:noinspection GoUnusedParameter
+func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
+
+//go:nosplit
+func mem2ptr(s []byte) unsafe.Pointer {
+    return (*rt.GoSlice)(unsafe.Pointer(&s)).Ptr
+}
+
+var (
+    //go:linkname safeSet encoding/json.safeSet
+    safeSet [utf8.RuneSelf]bool
+
+    //go:linkname hex encoding/json.hex
+    hex string
+)
+
+//go:linkname unquoteBytes encoding/json.unquoteBytes
+func unquoteBytes(s []byte) (t []byte, ok bool)
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/ast/stubs_go120.go b/vendor/github.com/bytedance/sonic/ast/stubs_go120.go
new file mode 100644
index 000000000..bd6fff680
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/ast/stubs_go120.go
@@ -0,0 +1,55 @@
+// +build go1.20
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ast
+
+import (
+    `unsafe`
+    `unicode/utf8`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+//go:noescape
+//go:linkname memmove runtime.memmove
+//goland:noinspection GoUnusedParameter
+func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
+
+//go:linkname unsafe_NewArray reflect.unsafe_NewArray
+//goland:noinspection GoUnusedParameter
+func unsafe_NewArray(typ *rt.GoType, n int) unsafe.Pointer
+
+//go:linkname growslice reflect.growslice
+//goland:noinspection GoUnusedParameter
+func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
+
+//go:nosplit
+func mem2ptr(s []byte) unsafe.Pointer {
+    return (*rt.GoSlice)(unsafe.Pointer(&s)).Ptr
+}
+
+var (
+    //go:linkname safeSet encoding/json.safeSet
+    safeSet [utf8.RuneSelf]bool
+
+    //go:linkname hex encoding/json.hex
+    hex string
+)
+
+//go:linkname unquoteBytes encoding/json.unquoteBytes
+func unquoteBytes(s []byte) (t []byte, ok bool)
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/bench-arm.sh b/vendor/github.com/bytedance/sonic/bench-arm.sh
new file mode 100644
index 000000000..b47d6278a
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/bench-arm.sh
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+
+pwd=$(pwd)
+export SONIC_NO_ASYNC_GC=1
+
+cd $pwd/ast
+go test -benchmem -run=^$ -benchtime=1000000x -bench "^(BenchmarkGet.*|BenchmarkSet.*)$"
+
+go test -benchmem -run=^$ -benchtime=10000x -bench "^(BenchmarkParser_.*|BenchmarkEncode.*)$"
+
+go test -benchmem -run=^$ -benchtime=10000000x -bench "^(BenchmarkNodeGetByPath|BenchmarkStructGetByPath|BenchmarkNodeIndex|BenchmarkStructIndex|BenchmarkSliceIndex|BenchmarkMapIndex|BenchmarkNodeGet|BenchmarkSliceGet|BenchmarkMapGet|BenchmarkNodeSet|BenchmarkMapSet|BenchmarkNodeSetByIndex|BenchmarkSliceSetByIndex|BenchmarkStructSetByIndex|BenchmarkNodeUnset|BenchmarkMapUnset|BenchmarkNodUnsetByIndex|BenchmarkSliceUnsetByIndex|BenchmarkNodeAdd|BenchmarkSliceAdd|BenchmarkMapAdd)$"
+
+unset SONIC_NO_ASYNC_GC
+cd $pwd
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/bench-large.png b/vendor/github.com/bytedance/sonic/bench-large.png
new file mode 100644
index 000000000..8a8785ec9
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/bench-large.png
diff --git a/vendor/github.com/bytedance/sonic/bench-small.png b/vendor/github.com/bytedance/sonic/bench-small.png
new file mode 100644
index 000000000..7bdab77ca
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/bench-small.png
diff --git a/vendor/github.com/bytedance/sonic/bench.py b/vendor/github.com/bytedance/sonic/bench.py
new file mode 100644
index 000000000..1d4c35739
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/bench.py
@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+
+# 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.
+
+import tempfile
+import os
+import subprocess
+import argparse
+
+gbench_prefix = "SONIC_NO_ASYNC_GC=1 go test -benchmem -run=none "
+
+def run(cmd):
+    print(cmd)
+    if os.system(cmd):
+        print ("Failed to run cmd: %s"%(cmd))
+        exit(1)
+
+def run_s(cmd):
+    print (cmd)
+    try:
+        res = os.popen(cmd)
+    except subprocess.CalledProcessError as e:
+        if e.returncode:
+            print (e.output)
+            exit(1)
+    return res.read()
+
+def run_r(cmd):
+    print (cmd)
+    try:
+        cmds = cmd.split(' ')
+        data = subprocess.check_output(cmds, stderr=subprocess.STDOUT)
+    except subprocess.CalledProcessError as e:
+        if e.returncode:
+            print (e.output)
+            exit(1)
+    return data.decode("utf-8") 
+
+def compare(args):
+    # detech current branch.
+    # result = run_r("git branch")
+    current_branch = run_s("git status | head -n1 | sed 's/On branch //'")
+    # for br in result.split('\n'):
+    #     if br.startswith("* "):
+    #         current_branch = br.lstrip('* ')
+    #         break
+
+    if not current_branch:
+        print ("Failed to detech current branch")
+        return None
+    
+    # get the current diff
+    (fd, diff) = tempfile.mkstemp()
+    run("git diff > %s"%diff)
+
+    # early return if currrent is main branch.
+    print ("Current branch: %s"%(current_branch))
+    if current_branch == "main":
+        print ("Cannot compare at the main branch.Please build a new branch")
+        return None
+
+    # benchmark current branch    
+    (fd, target) = tempfile.mkstemp(".target.txt")
+    run("%s %s ./... 2>&1 | tee %s" %(gbench_prefix, args, target))
+
+    # trying to switch to the latest main branch
+    run("git checkout -- .")
+    if current_branch != "main":
+        run("git checkout main")
+    run("git pull --allow-unrelated-histories origin main")
+
+    # benchmark main branch
+    (fd, main) = tempfile.mkstemp(".main.txt")
+    run("%s %s ./... 2>&1 | tee %s" %(gbench_prefix, args, main))
+
+    # diff the result
+    # benchstat = "go get golang.org/x/perf/cmd/benchstat && go install golang.org/x/perf/cmd/benchstat"
+    run( "benchstat -sort=delta %s %s"%(main, target))
+    run("git checkout -- .")
+
+    # restore branch
+    if current_branch != "main":
+        run("git checkout %s"%(current_branch))
+    run("patch -p1 < %s" % (diff))
+    return target
+
+def main():
+    argparser = argparse.ArgumentParser(description='Tools to test the performance. Example: ./bench.py -b Decoder_Generic_Sonic -c')
+    argparser.add_argument('-b', '--bench', dest='filter', required=False,
+        help='Specify the filter for golang benchmark')
+    argparser.add_argument('-c', '--compare', dest='compare', action='store_true', required=False,
+        help='Compare with the main benchmarking')
+    argparser.add_argument('-t', '--times', dest='times', required=False,
+        help='benchmark the times')
+    argparser.add_argument('-r', '--repeat_times', dest='count', required=False,
+        help='benchmark the count')
+    args = argparser.parse_args()
+    
+    if args.filter:
+        gbench_args = "-bench=%s"%(args.filter)
+    else:
+        gbench_args = "-bench=."
+        
+    if args.times:
+        gbench_args += " -benchtime=%s"%(args.times)
+        
+    if args.count:
+        gbench_args += " -count=%s"%(args.count)
+    else:
+        gbench_args += " -count=10"
+
+    if args.compare:
+        target = compare(gbench_args)
+    else:
+        target = None
+
+    if not target:
+        (fd, target) = tempfile.mkstemp(".target.txt")
+        run("%s %s ./... 2>&1 | tee %s" %(gbench_prefix, gbench_args, target))
+
+if __name__ == "__main__":
+    main()
diff --git a/vendor/github.com/bytedance/sonic/bench.sh b/vendor/github.com/bytedance/sonic/bench.sh
new file mode 100644
index 000000000..701986b58
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/bench.sh
@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+
+pwd=$(pwd)
+export SONIC_NO_ASYNC_GC=1
+
+cd $pwd/encoder
+go test -benchmem -run=^$ -benchtime=100000x -bench "^(BenchmarkEncoder_.*)$"
+
+cd $pwd/decoder
+go test -benchmem -run=^$ -benchtime=100000x -bench "^(BenchmarkDecoder_.*)$"
+
+cd $pwd/ast
+go test -benchmem -run=^$ -benchtime=1000000x -bench "^(BenchmarkGet.*|BenchmarkSet.*)$"
+
+go test -benchmem -run=^$ -benchtime=10000x -bench "^(BenchmarkParser_.*|BenchmarkEncode.*)$"
+
+go test -benchmem -run=^$ -benchtime=10000000x -bench "^(BenchmarkNodeGetByPath|BenchmarkStructGetByPath|BenchmarkNodeIndex|BenchmarkStructIndex|BenchmarkSliceIndex|BenchmarkMapIndex|BenchmarkNodeGet|BenchmarkSliceGet|BenchmarkMapGet|BenchmarkNodeSet|BenchmarkMapSet|BenchmarkNodeSetByIndex|BenchmarkSliceSetByIndex|BenchmarkStructSetByIndex|BenchmarkNodeUnset|BenchmarkMapUnset|BenchmarkNodUnsetByIndex|BenchmarkSliceUnsetByIndex|BenchmarkNodeAdd|BenchmarkSliceAdd|BenchmarkMapAdd)$"
+
+cd $pwd/external_jsonlib_test/benchmark_test
+go test -benchmem -run=^$ -benchtime=100000x -bench "^(BenchmarkEncoder_.*|BenchmarkDecoder_.*)$"
+
+go test -benchmem -run=^$ -benchtime=1000000x -bench "^(BenchmarkGet.*|BenchmarkSet.*)$"
+
+go test -benchmem -run=^$ -benchtime=10000x -bench "^(BenchmarkParser_.*)$"
+
+unset SONIC_NO_ASYNC_GC
+cd $pwd
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/check_branch_name.sh b/vendor/github.com/bytedance/sonic/check_branch_name.sh
new file mode 100644
index 000000000..d1905dab1
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/check_branch_name.sh
@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+current=$(git status | head -n1 | sed 's/On branch //')
+name=${1:-$current}
+if [[ ! $name =~ ^(((opt(imize)?|feat(ure)?|doc|(bug|hot)?fix|test|refact(or)?|ci)/.+)|(main|develop)|(release/.+)|(release-v[0-9]+\.[0-9]+)|(release/v[0-9]+\.[0-9]+\.[0-9]+(-[a-z0-9.]+(\+[a-z0-9.]+)?)?)|revert-[a-z0-9]+)$ ]]; then
+    echo "branch name '$name' is invalid"
+    exit 1
+else
+    echo "branch name '$name' is valid"
+fi
diff --git a/vendor/github.com/bytedance/sonic/compat.go b/vendor/github.com/bytedance/sonic/compat.go
new file mode 100644
index 000000000..015aa62bf
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/compat.go
@@ -0,0 +1,131 @@
+// +build !amd64 go1.21
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sonic
+
+import (
+    `bytes`
+    `encoding/json`
+    `io`
+    `reflect`
+
+    `github.com/bytedance/sonic/option`
+)
+
+type frozenConfig struct {
+    Config
+}
+
+// Froze convert the Config to API
+func (cfg Config) Froze() API {
+    api := &frozenConfig{Config: cfg}
+    return api
+}
+
+func (cfg frozenConfig) marshalOptions(val interface{}, prefix, indent string) ([]byte, error) {
+    w := bytes.NewBuffer([]byte{})
+    enc := json.NewEncoder(w)
+    enc.SetEscapeHTML(cfg.EscapeHTML)
+    enc.SetIndent(prefix, indent)
+    err := enc.Encode(val)
+	out := w.Bytes()
+
+	// json.Encoder always appends '\n' after encoding,
+	// which is not same with json.Marshal()
+	if len(out) > 0 && out[len(out)-1] == '\n' {
+		out = out[:len(out)-1]
+	}
+	return out, err
+}
+
+// Marshal is implemented by sonic
+func (cfg frozenConfig) Marshal(val interface{}) ([]byte, error) {
+    if !cfg.EscapeHTML {
+        return cfg.marshalOptions(val, "", "")
+    }
+    return json.Marshal(val)
+}
+
+// MarshalToString is implemented by sonic
+func (cfg frozenConfig) MarshalToString(val interface{}) (string, error) {
+    out, err := cfg.Marshal(val)
+    return string(out), err
+}
+
+// MarshalIndent is implemented by sonic
+func (cfg frozenConfig) MarshalIndent(val interface{}, prefix, indent string) ([]byte, error) {
+    if !cfg.EscapeHTML {
+        return cfg.marshalOptions(val, prefix, indent)
+    }
+    return json.MarshalIndent(val, prefix, indent)
+}
+
+// UnmarshalFromString is implemented by sonic
+func (cfg frozenConfig) UnmarshalFromString(buf string, val interface{}) error {
+    r := bytes.NewBufferString(buf)
+    dec := json.NewDecoder(r)
+    if cfg.UseNumber {
+        dec.UseNumber()
+    }
+    if cfg.DisallowUnknownFields {
+        dec.DisallowUnknownFields()
+    }
+    return dec.Decode(val)
+}
+
+// Unmarshal is implemented by sonic
+func (cfg frozenConfig) Unmarshal(buf []byte, val interface{}) error {
+    return cfg.UnmarshalFromString(string(buf), val)
+}
+
+// NewEncoder is implemented by sonic
+func (cfg frozenConfig) NewEncoder(writer io.Writer) Encoder {
+    enc := json.NewEncoder(writer)
+    if !cfg.EscapeHTML {
+        enc.SetEscapeHTML(cfg.EscapeHTML)
+    }
+    return enc
+}
+
+// NewDecoder is implemented by sonic
+func (cfg frozenConfig) NewDecoder(reader io.Reader) Decoder {
+    dec := json.NewDecoder(reader)
+    if cfg.UseNumber {
+        dec.UseNumber()
+    }
+    if cfg.DisallowUnknownFields {
+        dec.DisallowUnknownFields()
+    }
+    return dec
+}
+
+// Valid is implemented by sonic
+func (cfg frozenConfig) Valid(data []byte) bool {
+    return json.Valid(data)
+}
+
+// Pretouch compiles vt ahead-of-time to avoid JIT compilation on-the-fly, in
+// order to reduce the first-hit latency at **amd64** Arch.
+// 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.
+// * This is the none implement for !amd64.
+// It will be useful for someone who develop with !amd64 arch,like Mac M1.
+func Pretouch(vt reflect.Type, opts ...option.CompileOption) error {
+    return nil
+}
+
diff --git a/vendor/github.com/bytedance/sonic/decoder/asm.s b/vendor/github.com/bytedance/sonic/decoder/asm.s
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/asm.s
diff --git a/vendor/github.com/bytedance/sonic/decoder/assembler_amd64_go116.go b/vendor/github.com/bytedance/sonic/decoder/assembler_amd64_go116.go
new file mode 100644
index 000000000..9ff1ad248
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/assembler_amd64_go116.go
@@ -0,0 +1,1943 @@
+// +build go1.15,!go1.17
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `encoding/json`
+    `fmt`
+    `math`
+    `reflect`
+    `strconv`
+    `unsafe`
+    
+    `github.com/bytedance/sonic/internal/caching`
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/twitchyliquid64/golang-asm/obj`
+    `github.com/twitchyliquid64/golang-asm/obj/x86`
+)
+
+/** Register Allocations
+ *
+ *  State Registers:
+ *
+ *      %rbx : stack base
+ *      %r12 : input pointer
+ *      %r13 : input length
+ *      %r14 : input cursor
+ *      %r15 : value pointer
+ *
+ *  Error Registers:
+ *
+ *      %r10 : error type register
+ *      %r11 : error pointer register
+ */
+
+/** Function Prototype & Stack Map
+ *
+ *  func (s string, ic int, vp unsafe.Pointer, sb *_Stack, fv uint64, sv string) (rc int, err error)
+ *
+ *  s.buf  :   (FP)
+ *  s.len  :  8(FP)
+ *  ic     : 16(FP)
+ *  vp     : 24(FP)
+ *  sb     : 32(FP)
+ *  fv     : 40(FP)
+ *  sv     : 56(FP)
+ *  err.vt : 72(FP)
+ *  err.vp : 80(FP)
+ */
+
+const (
+    _FP_args   = 96     // 96 bytes to pass arguments and return values for this function
+    _FP_fargs  = 80     // 80 bytes for passing arguments to other Go functions
+    _FP_saves  = 40     // 40 bytes for saving the registers before CALL instructions
+    _FP_locals = 144    // 144 bytes for local variables
+)
+
+const (
+    _FP_offs = _FP_fargs + _FP_saves + _FP_locals
+    _FP_size = _FP_offs + 8     // 8 bytes for the parent frame pointer
+    _FP_base = _FP_size + 8     // 8 bytes for the return address
+)
+
+const (
+    _IM_null = 0x6c6c756e   // 'null'
+    _IM_true = 0x65757274   // 'true'
+    _IM_alse = 0x65736c61   // 'alse' ('false' without the 'f')
+)
+
+const (
+    _BM_space = (1 << ' ') | (1 << '\t') | (1 << '\r') | (1 << '\n')
+)
+
+const (
+    _MODE_JSON = 1 << 3 // base64 mode
+)
+
+const (
+    _LB_error           = "_error"
+    _LB_im_error        = "_im_error"
+    _LB_eof_error       = "_eof_error"
+    _LB_type_error      = "_type_error"
+    _LB_field_error     = "_field_error"
+    _LB_range_error     = "_range_error"
+    _LB_stack_error     = "_stack_error"
+    _LB_base64_error    = "_base64_error"
+    _LB_unquote_error   = "_unquote_error"
+    _LB_parsing_error   = "_parsing_error"
+    _LB_parsing_error_v = "_parsing_error_v"
+    _LB_mismatch_error   = "_mismatch_error"
+)
+
+const (
+    _LB_char_0_error  = "_char_0_error"
+    _LB_char_1_error  = "_char_1_error"
+    _LB_char_2_error  = "_char_2_error"
+    _LB_char_3_error  = "_char_3_error"
+    _LB_char_4_error  = "_char_4_error"
+    _LB_char_m2_error = "_char_m2_error"
+    _LB_char_m3_error = "_char_m3_error"
+)
+
+const (
+    _LB_skip_one = "_skip_one"
+    _LB_skip_key_value = "_skip_key_value"
+)
+
+var (
+    _AX = jit.Reg("AX")
+    _CX = jit.Reg("CX")
+    _DX = jit.Reg("DX")
+    _DI = jit.Reg("DI")
+    _SI = jit.Reg("SI")
+    _BP = jit.Reg("BP")
+    _SP = jit.Reg("SP")
+    _R8 = jit.Reg("R8")
+    _R9 = jit.Reg("R9")
+    _X0 = jit.Reg("X0")
+    _X1 = jit.Reg("X1")
+)
+
+var (
+    _ST = jit.Reg("BX")
+    _IP = jit.Reg("R12")
+    _IL = jit.Reg("R13")
+    _IC = jit.Reg("R14")
+    _VP = jit.Reg("R15")
+)
+
+var (
+    _R10 = jit.Reg("R10")    // used for gcWriteBarrier
+    _DF  = jit.Reg("R10")    // reuse R10 in generic decoder for flags
+    _ET  = jit.Reg("R10")
+    _EP  = jit.Reg("R11")
+)
+
+var (
+    _ARG_s  = _ARG_sp
+    _ARG_sp = jit.Ptr(_SP, _FP_base)
+    _ARG_sl = jit.Ptr(_SP, _FP_base + 8)
+    _ARG_ic = jit.Ptr(_SP, _FP_base + 16)
+    _ARG_vp = jit.Ptr(_SP, _FP_base + 24)
+    _ARG_sb = jit.Ptr(_SP, _FP_base + 32)
+    _ARG_fv = jit.Ptr(_SP, _FP_base + 40)
+)
+
+var (
+    _VAR_sv = _VAR_sv_p
+    _VAR_sv_p = jit.Ptr(_SP, _FP_base + 48)
+    _VAR_sv_n = jit.Ptr(_SP, _FP_base + 56)
+    _VAR_vk   = jit.Ptr(_SP, _FP_base + 64)
+)
+
+var (
+    _RET_rc = jit.Ptr(_SP, _FP_base + 72)
+    _RET_et = jit.Ptr(_SP, _FP_base + 80)
+    _RET_ep = jit.Ptr(_SP, _FP_base + 88)
+)
+
+var (
+    _VAR_st = _VAR_st_Vt
+    _VAR_sr = jit.Ptr(_SP, _FP_fargs + _FP_saves)
+)
+
+
+var (
+    _VAR_st_Vt = jit.Ptr(_SP, _FP_fargs + _FP_saves + 0)
+    _VAR_st_Dv = jit.Ptr(_SP, _FP_fargs + _FP_saves + 8)
+    _VAR_st_Iv = jit.Ptr(_SP, _FP_fargs + _FP_saves + 16)
+    _VAR_st_Ep = jit.Ptr(_SP, _FP_fargs + _FP_saves + 24)
+    _VAR_st_Db = jit.Ptr(_SP, _FP_fargs + _FP_saves + 32)
+    _VAR_st_Dc = jit.Ptr(_SP, _FP_fargs + _FP_saves + 40)
+)
+
+var (
+    _VAR_ss_AX = jit.Ptr(_SP, _FP_fargs + _FP_saves + 48)
+    _VAR_ss_CX = jit.Ptr(_SP, _FP_fargs + _FP_saves + 56)
+    _VAR_ss_SI = jit.Ptr(_SP, _FP_fargs + _FP_saves + 64)
+    _VAR_ss_R8 = jit.Ptr(_SP, _FP_fargs + _FP_saves + 72)
+    _VAR_ss_R9 = jit.Ptr(_SP, _FP_fargs + _FP_saves + 80)
+)
+
+var (
+    _VAR_bs_p = jit.Ptr(_SP, _FP_fargs + _FP_saves + 88)
+    _VAR_bs_n = jit.Ptr(_SP, _FP_fargs + _FP_saves + 96)
+    _VAR_bs_LR = jit.Ptr(_SP, _FP_fargs + _FP_saves + 104)
+)
+
+var _VAR_fl = jit.Ptr(_SP, _FP_fargs + _FP_saves + 112)
+
+var (
+    _VAR_et = jit.Ptr(_SP, _FP_fargs + _FP_saves + 120) // save dismatched type
+    _VAR_ic = jit.Ptr(_SP, _FP_fargs + _FP_saves + 128) // save dismatched position
+    _VAR_pc = jit.Ptr(_SP, _FP_fargs + _FP_saves + 136) // save skip return pc
+)
+
+type _Assembler struct {
+    jit.BaseAssembler
+    p _Program
+    name string
+}
+
+func newAssembler(p _Program) *_Assembler {
+    return new(_Assembler).Init(p)
+}
+
+/** Assembler Interface **/
+
+func (self *_Assembler) Load() _Decoder {
+    return ptodec(self.BaseAssembler.Load("decode_"+self.name, _FP_size, _FP_args, argPtrs, localPtrs))
+}
+
+func (self *_Assembler) Init(p _Program) *_Assembler {
+    self.p = p
+    self.BaseAssembler.Init(self.compile)
+    return self
+}
+
+func (self *_Assembler) compile() {
+    self.prologue()
+    self.instrs()
+    self.epilogue()
+    self.copy_string()
+    self.escape_string()
+    self.escape_string_twice()
+    self.skip_one()
+    self.skip_key_value()
+    self.mismatch_error()
+    self.type_error()
+    self.field_error()
+    self.range_error()
+    self.stack_error()
+    self.base64_error()
+    self.parsing_error()
+}
+
+/** Assembler Stages **/
+
+var _OpFuncTab = [256]func(*_Assembler, *_Instr) {
+    _OP_any              : (*_Assembler)._asm_OP_any,
+    _OP_dyn              : (*_Assembler)._asm_OP_dyn,
+    _OP_str              : (*_Assembler)._asm_OP_str,
+    _OP_bin              : (*_Assembler)._asm_OP_bin,
+    _OP_bool             : (*_Assembler)._asm_OP_bool,
+    _OP_num              : (*_Assembler)._asm_OP_num,
+    _OP_i8               : (*_Assembler)._asm_OP_i8,
+    _OP_i16              : (*_Assembler)._asm_OP_i16,
+    _OP_i32              : (*_Assembler)._asm_OP_i32,
+    _OP_i64              : (*_Assembler)._asm_OP_i64,
+    _OP_u8               : (*_Assembler)._asm_OP_u8,
+    _OP_u16              : (*_Assembler)._asm_OP_u16,
+    _OP_u32              : (*_Assembler)._asm_OP_u32,
+    _OP_u64              : (*_Assembler)._asm_OP_u64,
+    _OP_f32              : (*_Assembler)._asm_OP_f32,
+    _OP_f64              : (*_Assembler)._asm_OP_f64,
+    _OP_unquote          : (*_Assembler)._asm_OP_unquote,
+    _OP_nil_1            : (*_Assembler)._asm_OP_nil_1,
+    _OP_nil_2            : (*_Assembler)._asm_OP_nil_2,
+    _OP_nil_3            : (*_Assembler)._asm_OP_nil_3,
+    _OP_deref            : (*_Assembler)._asm_OP_deref,
+    _OP_index            : (*_Assembler)._asm_OP_index,
+    _OP_is_null          : (*_Assembler)._asm_OP_is_null,
+    _OP_is_null_quote    : (*_Assembler)._asm_OP_is_null_quote,
+    _OP_map_init         : (*_Assembler)._asm_OP_map_init,
+    _OP_map_key_i8       : (*_Assembler)._asm_OP_map_key_i8,
+    _OP_map_key_i16      : (*_Assembler)._asm_OP_map_key_i16,
+    _OP_map_key_i32      : (*_Assembler)._asm_OP_map_key_i32,
+    _OP_map_key_i64      : (*_Assembler)._asm_OP_map_key_i64,
+    _OP_map_key_u8       : (*_Assembler)._asm_OP_map_key_u8,
+    _OP_map_key_u16      : (*_Assembler)._asm_OP_map_key_u16,
+    _OP_map_key_u32      : (*_Assembler)._asm_OP_map_key_u32,
+    _OP_map_key_u64      : (*_Assembler)._asm_OP_map_key_u64,
+    _OP_map_key_f32      : (*_Assembler)._asm_OP_map_key_f32,
+    _OP_map_key_f64      : (*_Assembler)._asm_OP_map_key_f64,
+    _OP_map_key_str      : (*_Assembler)._asm_OP_map_key_str,
+    _OP_map_key_utext    : (*_Assembler)._asm_OP_map_key_utext,
+    _OP_map_key_utext_p  : (*_Assembler)._asm_OP_map_key_utext_p,
+    _OP_array_skip       : (*_Assembler)._asm_OP_array_skip,
+    _OP_array_clear      : (*_Assembler)._asm_OP_array_clear,
+    _OP_array_clear_p    : (*_Assembler)._asm_OP_array_clear_p,
+    _OP_slice_init       : (*_Assembler)._asm_OP_slice_init,
+    _OP_slice_append     : (*_Assembler)._asm_OP_slice_append,
+    _OP_object_skip      : (*_Assembler)._asm_OP_object_skip,
+    _OP_object_next      : (*_Assembler)._asm_OP_object_next,
+    _OP_struct_field     : (*_Assembler)._asm_OP_struct_field,
+    _OP_unmarshal        : (*_Assembler)._asm_OP_unmarshal,
+    _OP_unmarshal_p      : (*_Assembler)._asm_OP_unmarshal_p,
+    _OP_unmarshal_text   : (*_Assembler)._asm_OP_unmarshal_text,
+    _OP_unmarshal_text_p : (*_Assembler)._asm_OP_unmarshal_text_p,
+    _OP_lspace           : (*_Assembler)._asm_OP_lspace,
+    _OP_match_char       : (*_Assembler)._asm_OP_match_char,
+    _OP_check_char       : (*_Assembler)._asm_OP_check_char,
+    _OP_load             : (*_Assembler)._asm_OP_load,
+    _OP_save             : (*_Assembler)._asm_OP_save,
+    _OP_drop             : (*_Assembler)._asm_OP_drop,
+    _OP_drop_2           : (*_Assembler)._asm_OP_drop_2,
+    _OP_recurse          : (*_Assembler)._asm_OP_recurse,
+    _OP_goto             : (*_Assembler)._asm_OP_goto,
+    _OP_switch           : (*_Assembler)._asm_OP_switch,
+    _OP_check_char_0     : (*_Assembler)._asm_OP_check_char_0,
+    _OP_dismatch_err     : (*_Assembler)._asm_OP_dismatch_err,
+    _OP_go_skip          : (*_Assembler)._asm_OP_go_skip,
+    _OP_add              : (*_Assembler)._asm_OP_add,
+}
+
+func (self *_Assembler) instr(v *_Instr) {
+    if fn := _OpFuncTab[v.op()]; fn != nil {
+        fn(self, v)
+    } else {
+        panic(fmt.Sprintf("invalid opcode: %d", v.op()))
+    }
+}
+
+func (self *_Assembler) instrs() {
+    for i, v := range self.p {
+        self.Mark(i)
+        self.instr(&v)
+        self.debug_instr(i, &v)
+    }
+}
+
+func (self *_Assembler) epilogue() {
+    self.Mark(len(self.p))
+    self.Emit("XORL", _EP, _EP)                     // XORL EP, EP
+    self.Emit("MOVQ", _VAR_et, _ET)                 // MOVQ VAR_et, ET
+    self.Emit("TESTQ", _ET, _ET)                    // TESTQ ET, ET
+    self.Sjmp("JNZ", _LB_mismatch_error)            // JNZ _LB_mismatch_error
+    self.Link(_LB_error)                            // _error:
+    self.Emit("MOVQ", _IC, _RET_rc)                 // MOVQ IC, rc<>+40(FP)
+    self.Emit("MOVQ", _ET, _RET_et)                 // MOVQ ET, et<>+48(FP)
+    self.Emit("MOVQ", _EP, _RET_ep)                 // MOVQ EP, ep<>+56(FP)
+    self.Emit("MOVQ", jit.Ptr(_SP, _FP_offs), _BP)  // MOVQ _FP_offs(SP), BP
+    self.Emit("ADDQ", jit.Imm(_FP_size), _SP)       // ADDQ $_FP_size, SP
+    self.Emit("RET")                                // RET
+}
+
+func (self *_Assembler) prologue() {
+    self.Emit("SUBQ", jit.Imm(_FP_size), _SP)       // SUBQ $_FP_size, SP
+    self.Emit("MOVQ", _BP, jit.Ptr(_SP, _FP_offs))  // MOVQ BP, _FP_offs(SP)
+    self.Emit("LEAQ", jit.Ptr(_SP, _FP_offs), _BP)  // LEAQ _FP_offs(SP), BP
+    self.Emit("MOVQ", _ARG_sp, _IP)                 // MOVQ s.p<>+0(FP), IP
+    self.Emit("MOVQ", _ARG_sl, _IL)                 // MOVQ s.l<>+8(FP), IL
+    self.Emit("MOVQ", _ARG_ic, _IC)                 // MOVQ ic<>+16(FP), IC
+    self.Emit("MOVQ", _ARG_vp, _VP)                 // MOVQ vp<>+24(FP), VP
+    self.Emit("MOVQ", _ARG_sb, _ST)                 // MOVQ vp<>+32(FP), ST
+    // initialize digital buffer first
+    self.Emit("MOVQ", jit.Imm(_MaxDigitNums), _VAR_st_Dc)    // MOVQ $_MaxDigitNums, ss.Dcap
+    self.Emit("LEAQ", jit.Ptr(_ST, _DbufOffset), _AX)           // LEAQ _DbufOffset(ST), AX
+    self.Emit("MOVQ", _AX, _VAR_st_Db)                          // MOVQ AX, ss.Dbuf
+    self.Emit("XORL", _AX, _AX)                                 // XORL AX, AX
+    self.Emit("MOVQ", _AX, _VAR_et)                          // MOVQ AX, ss.Dp
+}
+
+/** Function Calling Helpers **/
+
+var _REG_go = []obj.Addr {
+    _ST,
+    _VP,
+    _IP,
+    _IL,
+    _IC,
+}
+
+func (self *_Assembler) save(r ...obj.Addr) {
+    for i, v := range r {
+        if i > _FP_saves / 8 - 1 {
+            panic("too many registers to save")
+        } else {
+            self.Emit("MOVQ", v, jit.Ptr(_SP, _FP_fargs + int64(i) * 8))
+        }
+    }
+}
+
+func (self *_Assembler) load(r ...obj.Addr) {
+    for i, v := range r {
+        if i > _FP_saves / 8 - 1 {
+            panic("too many registers to load")
+        } else {
+            self.Emit("MOVQ", jit.Ptr(_SP, _FP_fargs + int64(i) * 8), v)
+        }
+    }
+}
+
+func (self *_Assembler) call(fn obj.Addr) {
+    self.Emit("MOVQ", fn, _AX)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _AX)      // CALL AX
+}
+
+func (self *_Assembler) call_go(fn obj.Addr) {
+    self.save(_REG_go...)   // SAVE $REG_go
+    self.call(fn)           // CALL ${fn}
+    self.load(_REG_go...)   // LOAD $REG_go
+}
+
+func (self *_Assembler) call_sf(fn obj.Addr) {
+    self.Emit("LEAQ", _ARG_s, _DI)                      // LEAQ s<>+0(FP), DI
+    self.Emit("MOVQ", _IC, _ARG_ic)                     // MOVQ IC, ic<>+16(FP)
+    self.Emit("LEAQ", _ARG_ic, _SI)                     // LEAQ ic<>+16(FP), SI
+    self.Emit("LEAQ", jit.Ptr(_ST, _FsmOffset), _DX)    // LEAQ _FsmOffset(ST), DX
+    self.Emit("MOVQ", _ARG_fv, _CX)
+    self.call(fn)                                       // CALL ${fn}
+    self.Emit("MOVQ", _ARG_ic, _IC)                     // MOVQ ic<>+16(FP), IC
+}
+
+func (self *_Assembler) call_vf(fn obj.Addr) {
+    self.Emit("LEAQ", _ARG_s, _DI)      // LEAQ s<>+0(FP), DI
+    self.Emit("MOVQ", _IC, _ARG_ic)     // MOVQ IC, ic<>+16(FP)
+    self.Emit("LEAQ", _ARG_ic, _SI)     // LEAQ ic<>+16(FP), SI
+    self.Emit("LEAQ", _VAR_st, _DX)     // LEAQ st, DX
+    self.call(fn)                       // CALL ${fn}
+    self.Emit("MOVQ", _ARG_ic, _IC)     // MOVQ ic<>+16(FP), IC
+}
+
+/** Assembler Error Handlers **/
+
+var (
+    _F_convT64        = jit.Func(convT64)
+    _F_error_wrap     = jit.Func(error_wrap)
+    _F_error_type     = jit.Func(error_type)
+    _F_error_field    = jit.Func(error_field)
+    _F_error_value    = jit.Func(error_value)
+    _F_error_mismatch = jit.Func(error_mismatch)
+)
+
+var (
+    _I_int8    , _T_int8    = rtype(reflect.TypeOf(int8(0)))
+    _I_int16   , _T_int16   = rtype(reflect.TypeOf(int16(0)))
+    _I_int32   , _T_int32   = rtype(reflect.TypeOf(int32(0)))
+    _I_uint8   , _T_uint8   = rtype(reflect.TypeOf(uint8(0)))
+    _I_uint16  , _T_uint16  = rtype(reflect.TypeOf(uint16(0)))
+    _I_uint32  , _T_uint32  = rtype(reflect.TypeOf(uint32(0)))
+    _I_float32 , _T_float32 = rtype(reflect.TypeOf(float32(0)))
+)
+
+var (
+    _T_error                    = rt.UnpackType(errorType)
+    _I_base64_CorruptInputError = jit.Itab(_T_error, base64CorruptInputError)
+)
+
+var (
+    _V_stackOverflow              = jit.Imm(int64(uintptr(unsafe.Pointer(&stackOverflow))))
+    _I_json_UnsupportedValueError = jit.Itab(_T_error, reflect.TypeOf(new(json.UnsupportedValueError)))
+)
+
+func (self *_Assembler) type_error() {
+    self.Link(_LB_type_error)                   // _type_error:
+    self.Emit("MOVQ", _ET, jit.Ptr(_SP, 0))     // MOVQ    ET, (SP)
+    self.call_go(_F_error_type)                 // CALL_GO error_type
+    self.Emit("MOVQ", jit.Ptr(_SP, 8), _ET)     // MOVQ    8(SP), ET
+    self.Emit("MOVQ", jit.Ptr(_SP, 16), _EP)    // MOVQ    16(SP), EP
+    self.Sjmp("JMP" , _LB_error)                // JMP     _error
+}
+
+
+func (self *_Assembler) mismatch_error() {
+    self.Link(_LB_mismatch_error)               // _type_error:
+    self.Emit("MOVQ", _ARG_sp, _AX)
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))     // MOVQ    AX, (SP)
+    self.Emit("MOVQ", _ARG_sl, _CX)
+    self.Emit("MOVQ", _CX, jit.Ptr(_SP, 8))     // MOVQ    CX, 8(SP)
+    self.Emit("MOVQ", _VAR_ic, _AX)
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 16))    // MOVQ    AX, 16(SP)
+    self.Emit("MOVQ", _VAR_et, _CX)
+    self.Emit("MOVQ", _CX, jit.Ptr(_SP, 24))    // MOVQ    CX, 24(SP)
+    self.call_go(_F_error_mismatch)             // CALL_GO error_type
+    self.Emit("MOVQ", jit.Ptr(_SP, 32), _ET)    // MOVQ    32(SP), ET
+    self.Emit("MOVQ", jit.Ptr(_SP, 40), _EP)    // MOVQ    40(SP), EP
+    self.Sjmp("JMP" , _LB_error)                // JMP     _error
+}
+
+func (self *_Assembler) _asm_OP_dismatch_err(p *_Instr) {
+    self.Emit("MOVQ", _IC, _VAR_ic)  
+    self.Emit("MOVQ", jit.Type(p.vt()), _ET)       
+    self.Emit("MOVQ", _ET, _VAR_et)
+}
+
+func (self *_Assembler) _asm_OP_go_skip(p *_Instr) {
+    self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ (PC), R9
+    self.Xref(p.vi(), 4)
+    self.Emit("MOVQ", _R9, _VAR_pc)
+    self.Sjmp("JMP"  , _LB_skip_one)            // JMP     _skip_one
+}
+
+func (self *_Assembler) skip_one() {
+    self.Link(_LB_skip_one)                     // _skip:
+    self.Emit("MOVQ", _VAR_ic, _IC)             // MOVQ    _VAR_ic, IC
+    self.call_sf(_F_skip_one)                   // CALL_SF skip_one
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
+    self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
+    self.Emit("MOVQ" , _VAR_pc, _R9)            // MOVQ    pc, R9
+    self.Rjmp("JMP"  , _R9)                     // JMP     (R9)
+}
+
+
+func (self *_Assembler) skip_key_value() {
+    self.Link(_LB_skip_key_value)               // _skip:
+    // skip the key
+    self.Emit("MOVQ", _VAR_ic, _IC)             // MOVQ    _VAR_ic, IC
+    self.call_sf(_F_skip_one)                   // CALL_SF skip_one
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
+    self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
+    // match char ':'
+    self.lspace("_global_1")
+    self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(':'))
+    self.Sjmp("JNE"  , _LB_parsing_error_v)     // JNE     _parse_error_v
+    self.Emit("ADDQ", jit.Imm(1), _IC)          // ADDQ    $1, IC
+    self.lspace("_global_2")
+    // skip the value
+    self.call_sf(_F_skip_one)                   // CALL_SF skip_one
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
+    self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
+    // jump back to specified address
+    self.Emit("MOVQ" , _VAR_pc, _R9)            // MOVQ    pc, R9
+    self.Rjmp("JMP"  , _R9)                     // JMP     (R9)
+}
+
+func (self *_Assembler) field_error() {
+    self.Link(_LB_field_error)                  // _field_error:
+    self.Emit("MOVOU", _VAR_sv, _X0)            // MOVOU   sv, X0
+    self.Emit("MOVOU", _X0, jit.Ptr(_SP, 0))    // MOVOU   X0, (SP)
+    self.call_go(_F_error_field)                // CALL_GO error_field
+    self.Emit("MOVQ" , jit.Ptr(_SP, 16), _ET)   // MOVQ    16(SP), ET
+    self.Emit("MOVQ" , jit.Ptr(_SP, 24), _EP)   // MOVQ    24(SP), EP
+    self.Sjmp("JMP"  , _LB_error)               // JMP     _error
+}
+
+func (self *_Assembler) range_error() {
+    self.Link(_LB_range_error)                  // _range_error:
+    self.slice_from(_VAR_st_Ep, 0)              // SLICE   st.Ep, $0
+    self.Emit("MOVQ", _DI, jit.Ptr(_SP, 0))     // MOVQ    DI, (SP)
+    self.Emit("MOVQ", _SI, jit.Ptr(_SP, 8))     // MOVQ    SI, 8(SP)
+    self.Emit("MOVQ", _ET, jit.Ptr(_SP, 16))    // MOVQ    ET, 16(SP)
+    self.Emit("MOVQ", _EP, jit.Ptr(_SP, 24))    // MOVQ    EP, 24(SP)
+    self.call_go(_F_error_value)                // CALL_GO error_value
+    self.Emit("MOVQ", jit.Ptr(_SP, 32), _ET)    // MOVQ    32(SP), ET
+    self.Emit("MOVQ", jit.Ptr(_SP, 40), _EP)    // MOVQ    40(SP), EP
+    self.Sjmp("JMP" , _LB_error)                // JMP     _error
+}
+
+func (self *_Assembler) stack_error() {
+    self.Link(_LB_stack_error)                              // _stack_error:
+    self.Emit("MOVQ", _V_stackOverflow, _EP)                // MOVQ ${_V_stackOverflow}, EP
+    self.Emit("MOVQ", _I_json_UnsupportedValueError, _ET)   // MOVQ ${_I_json_UnsupportedValueError}, ET
+    self.Sjmp("JMP" , _LB_error)                            // JMP  _error
+}
+
+func (self *_Assembler) base64_error() {
+    self.Link(_LB_base64_error)
+    self.Emit("NEGQ", _AX)                                  // NEGQ    AX
+    self.Emit("SUBQ", jit.Imm(1), _AX)                      // SUBQ    $1, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))                 // MOVQ    AX, (SP)
+    self.call_go(_F_convT64)                                // CALL_GO convT64
+    self.Emit("MOVQ", jit.Ptr(_SP, 8), _EP)                 // MOVQ    8(SP), EP
+    self.Emit("MOVQ", _I_base64_CorruptInputError, _ET)     // MOVQ    ${itab(base64.CorruptInputError)}, ET
+    self.Sjmp("JMP" , _LB_error)                            // JMP     _error
+}
+
+func (self *_Assembler) parsing_error() {
+    self.Link(_LB_eof_error)                                            // _eof_error:
+    self.Emit("MOVQ" , _IL, _IC)                                        // MOVQ    IL, IC
+    self.Emit("MOVL" , jit.Imm(int64(types.ERR_EOF)), _EP)              // MOVL    ${types.ERR_EOF}, EP
+    self.Sjmp("JMP"  , _LB_parsing_error)                               // JMP     _parsing_error
+    self.Link(_LB_unquote_error)                                        // _unquote_error:
+    self.Emit("SUBQ" , _VAR_sr, _SI)                                    // SUBQ    sr, SI
+    self.Emit("SUBQ" , _SI, _IC)                                        // SUBQ    IL, IC
+    self.Link(_LB_parsing_error_v)                                      // _parsing_error_v:
+    self.Emit("MOVQ" , _AX, _EP)                                        // MOVQ    AX, EP
+    self.Emit("NEGQ" , _EP)                                             // NEGQ    EP
+    self.Sjmp("JMP"  , _LB_parsing_error)                               // JMP     _parsing_error
+    self.Link(_LB_char_m3_error)                                        // _char_m3_error:
+    self.Emit("SUBQ" , jit.Imm(1), _IC)                                 // SUBQ    $1, IC
+    self.Link(_LB_char_m2_error)                                        // _char_m2_error:
+    self.Emit("SUBQ" , jit.Imm(2), _IC)                                 // SUBQ    $2, IC
+    self.Sjmp("JMP"  , _LB_char_0_error)                                // JMP     _char_0_error
+    self.Link(_LB_im_error)                                             // _im_error:
+    self.Emit("CMPB" , _CX, jit.Sib(_IP, _IC, 1, 0))                    // CMPB    CX, (IP)(IC)
+    self.Sjmp("JNE"  , _LB_char_0_error)                                // JNE     _char_0_error
+    self.Emit("SHRL" , jit.Imm(8), _CX)                                 // SHRL    $8, CX
+    self.Emit("CMPB" , _CX, jit.Sib(_IP, _IC, 1, 1))                    // CMPB    CX, 1(IP)(IC)
+    self.Sjmp("JNE"  , _LB_char_1_error)                                // JNE     _char_1_error
+    self.Emit("SHRL" , jit.Imm(8), _CX)                                 // SHRL    $8, CX
+    self.Emit("CMPB" , _CX, jit.Sib(_IP, _IC, 1, 2))                    // CMPB    CX, 2(IP)(IC)
+    self.Sjmp("JNE"  , _LB_char_2_error)                                // JNE     _char_2_error
+    self.Sjmp("JMP"  , _LB_char_3_error)                                // JNE     _char_3_error
+    self.Link(_LB_char_4_error)                                         // _char_4_error:
+    self.Emit("ADDQ" , jit.Imm(1), _IC)                                 // ADDQ    $1, IC
+    self.Link(_LB_char_3_error)                                         // _char_3_error:
+    self.Emit("ADDQ" , jit.Imm(1), _IC)                                 // ADDQ    $1, IC
+    self.Link(_LB_char_2_error)                                         // _char_2_error:
+    self.Emit("ADDQ" , jit.Imm(1), _IC)                                 // ADDQ    $1, IC
+    self.Link(_LB_char_1_error)                                         // _char_1_error:
+    self.Emit("ADDQ" , jit.Imm(1), _IC)                                 // ADDQ    $1, IC
+    self.Link(_LB_char_0_error)                                         // _char_0_error:
+    self.Emit("MOVL" , jit.Imm(int64(types.ERR_INVALID_CHAR)), _EP)     // MOVL    ${types.ERR_INVALID_CHAR}, EP
+    self.Link(_LB_parsing_error)                                        // _parsing_error:
+    self.Emit("MOVOU", _ARG_s, _X0)                                     // MOVOU   s, X0
+    self.Emit("MOVOU", _X0, jit.Ptr(_SP, 0))                            // MOVOU   X0, (SP)
+    self.Emit("MOVQ" , _IC, jit.Ptr(_SP, 16))                           // MOVQ    IC, 16(SP)
+    self.Emit("MOVQ" , _EP, jit.Ptr(_SP, 24))                           // MOVQ    EP, 24(SP)
+    self.call_go(_F_error_wrap)                                         // CALL_GO error_wrap
+    self.Emit("MOVQ" , jit.Ptr(_SP, 32), _ET)                           // MOVQ    32(SP), ET
+    self.Emit("MOVQ" , jit.Ptr(_SP, 40), _EP)                           // MOVQ    40(SP), EP
+    self.Sjmp("JMP"  , _LB_error)                                       // JMP     _error
+}
+
+/** Memory Management Routines **/
+
+var (
+    _T_byte     = jit.Type(byteType)
+    _F_mallocgc = jit.Func(mallocgc)
+)
+
+func (self *_Assembler) malloc(nb obj.Addr, ret obj.Addr) {
+    self.Emit("XORL", _AX, _AX)                 // XORL    AX, AX
+    self.Emit("MOVQ", _T_byte, _CX)             // MOVQ    ${type(byte)}, CX
+    self.Emit("MOVQ", nb, jit.Ptr(_SP, 0))      // MOVQ    ${nb}, (SP)
+    self.Emit("MOVQ", _CX, jit.Ptr(_SP, 8))     // MOVQ    CX, 8(SP)
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 16))    // MOVQ    AX, 16(SP)
+    self.call_go(_F_mallocgc)                   // CALL_GO mallocgc
+    self.Emit("MOVQ", jit.Ptr(_SP, 24), ret)    // MOVQ    24(SP), ${ret}
+}
+
+func (self *_Assembler) valloc(vt reflect.Type, ret obj.Addr) {
+    self.Emit("MOVQ", jit.Imm(int64(vt.Size())), _AX)   // MOVQ    ${vt.Size()}, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))             // MOVQ    AX, (SP)
+    self.Emit("MOVQ", jit.Type(vt), _AX)                // MOVQ    ${vt}, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 8))             // MOVQ    AX, 8(SP)
+    self.Emit("MOVB", jit.Imm(1), jit.Ptr(_SP, 16))     // MOVB    $1, 16(SP)
+    self.call_go(_F_mallocgc)                           // CALL_GO mallocgc
+    self.Emit("MOVQ", jit.Ptr(_SP, 24), ret)            // MOVQ    24(SP), ${ret}
+}
+
+func (self *_Assembler) vfollow(vt reflect.Type) {
+    self.Emit("MOVQ" , jit.Ptr(_VP, 0), _AX)    // MOVQ   (VP), AX
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ  AX, AX
+    self.Sjmp("JNZ"  , "_end_{n}")              // JNZ    _end_{n}
+    self.valloc(vt, _AX)                        // VALLOC ${vt}, AX
+    self.WritePtrAX(1, jit.Ptr(_VP, 0), false)    // MOVQ   AX, (VP)
+    self.Link("_end_{n}")                       // _end_{n}:
+    self.Emit("MOVQ" , _AX, _VP)                // MOVQ   AX, VP
+}
+
+/** Value Parsing Routines **/
+
+var (
+    _F_vstring   = jit.Imm(int64(native.S_vstring))
+    _F_vnumber   = jit.Imm(int64(native.S_vnumber))
+    _F_vsigned   = jit.Imm(int64(native.S_vsigned))
+    _F_vunsigned = jit.Imm(int64(native.S_vunsigned))
+)
+
+func (self *_Assembler) check_err(vt reflect.Type, pin string, pin2 int) {
+    self.Emit("MOVQ" , _VAR_st_Vt, _AX)         // MOVQ st.Vt, AX
+    self.Emit("TESTQ", _AX, _AX)                // CMPQ AX, ${native.V_STRING}
+    // try to skip the value
+    if vt != nil {
+        self.Sjmp("JNS" , "_check_err_{n}")        // JNE  _parsing_error_v
+        self.Emit("MOVQ", jit.Type(vt), _ET)         
+        self.Emit("MOVQ", _ET, _VAR_et)
+        if pin2 != -1 {
+            self.Emit("SUBQ", jit.Imm(1), _BP)
+            self.Emit("MOVQ", _BP, _VAR_ic)
+            self.Byte(0x4c  , 0x8d, 0x0d)         // LEAQ (PC), R9
+            self.Xref(pin2, 4)
+            self.Emit("MOVQ", _R9, _VAR_pc)
+            self.Sjmp("JMP" , _LB_skip_key_value)
+        } else {
+            self.Emit("MOVQ", _BP, _VAR_ic)
+            self.Byte(0x4c  , 0x8d, 0x0d)         // LEAQ (PC), R9
+            self.Sref(pin, 4)
+            self.Emit("MOVQ", _R9, _VAR_pc)
+            self.Sjmp("JMP" , _LB_skip_one)
+        }
+        self.Link("_check_err_{n}")
+    } else {
+        self.Sjmp("JS"   , _LB_parsing_error_v)     // JNE  _parsing_error_v
+    }
+}
+
+func (self *_Assembler) check_eof(d int64) {
+    if d == 1 {
+        self.Emit("CMPQ", _IC, _IL)         // CMPQ IC, IL
+        self.Sjmp("JAE" , _LB_eof_error)    // JAE  _eof_error
+    } else {
+        self.Emit("LEAQ", jit.Ptr(_IC, d), _AX)     // LEAQ ${d}(IC), AX
+        self.Emit("CMPQ", _AX, _IL)                 // CMPQ AX, IL
+        self.Sjmp("JA"  , _LB_eof_error)            // JA   _eof_error
+    }
+}
+
+func (self *_Assembler) parse_string() {    // parse_string has a validate flag params in the last
+    self.Emit("MOVQ", _ARG_fv, _CX)
+    self.call_vf(_F_vstring)
+    self.check_err(nil, "", -1)
+}
+
+func (self *_Assembler) parse_number(vt reflect.Type, pin string, pin2 int) {
+    self.Emit("MOVQ", _IC, _BP)
+    self.call_vf(_F_vnumber)                               // call  vnumber
+    self.check_err(vt, pin, pin2)
+}
+
+func (self *_Assembler) parse_signed(vt reflect.Type, pin string, pin2 int) {
+    self.Emit("MOVQ", _IC, _BP)
+    self.call_vf(_F_vsigned)
+    self.check_err(vt, pin, pin2)
+}
+
+func (self *_Assembler) parse_unsigned(vt reflect.Type, pin string, pin2 int) {
+    self.Emit("MOVQ", _IC, _BP)
+    self.call_vf(_F_vunsigned)
+    self.check_err(vt, pin, pin2)
+}
+
+// Pointer: DI, Size: SI, Return: R9  
+func (self *_Assembler) copy_string() {
+    self.Link("_copy_string")
+    self.Emit("MOVQ", _DI, _VAR_bs_p)
+    self.Emit("MOVQ", _SI, _VAR_bs_n)
+    self.Emit("MOVQ", _R9, _VAR_bs_LR)
+    self.malloc(_SI, _AX)                              
+    self.Emit("MOVQ", _AX, _VAR_sv_p)                    
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))                    
+    self.Emit("MOVQ", _VAR_bs_p, _DI)
+    self.Emit("MOVQ", _DI, jit.Ptr(_SP, 8))
+    self.Emit("MOVQ", _VAR_bs_n, _SI)
+    self.Emit("MOVQ", _SI, jit.Ptr(_SP, 16))
+    self.call_go(_F_memmove)
+    self.Emit("MOVQ", _VAR_sv_p, _DI)
+    self.Emit("MOVQ", _VAR_bs_n, _SI)
+    self.Emit("MOVQ", _VAR_bs_LR, _R9)
+    self.Rjmp("JMP", _R9)
+}
+
+// Pointer: DI, Size: SI, Return: R9
+func (self *_Assembler) escape_string() {
+    self.Link("_escape_string")
+    self.Emit("MOVQ" , _DI, _VAR_bs_p)
+    self.Emit("MOVQ" , _SI, _VAR_bs_n)
+    self.Emit("MOVQ" , _R9, _VAR_bs_LR)
+    self.malloc(_SI, _DX)                                    // MALLOC SI, DX
+    self.Emit("MOVQ" , _DX, _VAR_sv_p)
+    self.Emit("MOVQ" , _VAR_bs_p, _DI)
+    self.Emit("MOVQ" , _VAR_bs_n, _SI)                                  
+    self.Emit("LEAQ" , _VAR_sr, _CX)                            // LEAQ   sr, CX
+    self.Emit("XORL" , _R8, _R8)                                // XORL   R8, R8
+    self.Emit("BTQ"  , jit.Imm(_F_disable_urc), _ARG_fv)        // BTQ    ${_F_disable_urc}, fv
+    self.Emit("SETCC", _R8)                                     // SETCC  R8
+    self.Emit("SHLQ" , jit.Imm(types.B_UNICODE_REPLACE), _R8)   // SHLQ   ${types.B_UNICODE_REPLACE}, R8
+    self.call(_F_unquote)                                       // CALL   unquote
+    self.Emit("MOVQ" , _VAR_bs_n, _SI)                                  // MOVQ   ${n}, SI
+    self.Emit("ADDQ" , jit.Imm(1), _SI)                         // ADDQ   $1, SI
+    self.Emit("TESTQ", _AX, _AX)                                // TESTQ  AX, AX
+    self.Sjmp("JS"   , _LB_unquote_error)                       // JS     _unquote_error
+    self.Emit("MOVQ" , _AX, _SI)
+    self.Emit("MOVQ" , _VAR_sv_p, _DI)
+    self.Emit("MOVQ" , _VAR_bs_LR, _R9)
+    self.Rjmp("JMP", _R9)
+}
+
+func (self *_Assembler) escape_string_twice() {
+    self.Link("_escape_string_twice")
+    self.Emit("MOVQ" , _DI, _VAR_bs_p)
+    self.Emit("MOVQ" , _SI, _VAR_bs_n)
+    self.Emit("MOVQ" , _R9, _VAR_bs_LR)
+    self.malloc(_SI, _DX)                                        // MALLOC SI, DX
+    self.Emit("MOVQ" , _DX, _VAR_sv_p)
+    self.Emit("MOVQ" , _VAR_bs_p, _DI)
+    self.Emit("MOVQ" , _VAR_bs_n, _SI)        
+    self.Emit("LEAQ" , _VAR_sr, _CX)                                // LEAQ   sr, CX
+    self.Emit("MOVL" , jit.Imm(types.F_DOUBLE_UNQUOTE), _R8)        // MOVL   ${types.F_DOUBLE_UNQUOTE}, R8
+    self.Emit("BTQ"  , jit.Imm(_F_disable_urc), _ARG_fv)            // BTQ    ${_F_disable_urc}, AX
+    self.Emit("XORL" , _AX, _AX)                                    // XORL   AX, AX
+    self.Emit("SETCC", _AX)                                         // SETCC  AX
+    self.Emit("SHLQ" , jit.Imm(types.B_UNICODE_REPLACE), _AX)       // SHLQ   ${types.B_UNICODE_REPLACE}, AX
+    self.Emit("ORQ"  , _AX, _R8)                                    // ORQ    AX, R8
+    self.call(_F_unquote)                                           // CALL   unquote
+    self.Emit("MOVQ" , _VAR_bs_n, _SI)                              // MOVQ   ${n}, SI
+    self.Emit("ADDQ" , jit.Imm(3), _SI)                             // ADDQ   $3, SI
+    self.Emit("TESTQ", _AX, _AX)                                    // TESTQ  AX, AX
+    self.Sjmp("JS"   , _LB_unquote_error)                           // JS     _unquote_error
+    self.Emit("MOVQ" , _AX, _SI)
+    self.Emit("MOVQ" , _VAR_sv_p, _DI)
+    self.Emit("MOVQ" , _VAR_bs_LR, _R9)
+    self.Rjmp("JMP", _R9)
+}
+
+/** Range Checking Routines **/
+
+var (
+    _V_max_f32 = jit.Imm(int64(uintptr(unsafe.Pointer(_Vp_max_f32))))
+    _V_min_f32 = jit.Imm(int64(uintptr(unsafe.Pointer(_Vp_min_f32))))
+)
+
+var (
+    _Vp_max_f32 = new(float64)
+    _Vp_min_f32 = new(float64)
+)
+
+func init() {
+    *_Vp_max_f32 = math.MaxFloat32
+    *_Vp_min_f32 = -math.MaxFloat32
+}
+
+func (self *_Assembler) range_single() {
+    self.Emit("MOVSD"   , _VAR_st_Dv, _X0)              // MOVSD    st.Dv, X0
+    self.Emit("MOVQ"    , _V_max_f32, _AX)              // MOVQ     _max_f32, AX
+    self.Emit("MOVQ"    , jit.Gitab(_I_float32), _ET)   // MOVQ     ${itab(float32)}, ET
+    self.Emit("MOVQ"    , jit.Gtype(_T_float32), _EP)   // MOVQ     ${type(float32)}, EP
+    self.Emit("UCOMISD" , jit.Ptr(_AX, 0), _X0)         // UCOMISD  (AX), X0
+    self.Sjmp("JA"      , _LB_range_error)              // JA       _range_error
+    self.Emit("MOVQ"    , _V_min_f32, _AX)              // MOVQ     _min_f32, AX
+    self.Emit("MOVSD"   , jit.Ptr(_AX, 0), _X1)         // MOVSD    (AX), X1
+    self.Emit("UCOMISD" , _X0, _X1)                     // UCOMISD  X0, X1
+    self.Sjmp("JA"      , _LB_range_error)              // JA       _range_error
+    self.Emit("CVTSD2SS", _X0, _X0)                     // CVTSD2SS X0, X0
+}
+
+func (self *_Assembler) range_signed(i *rt.GoItab, t *rt.GoType, a int64, b int64) {
+    self.Emit("MOVQ", _VAR_st_Iv, _AX)      // MOVQ st.Iv, AX
+    self.Emit("MOVQ", jit.Gitab(i), _ET)    // MOVQ ${i}, ET
+    self.Emit("MOVQ", jit.Gtype(t), _EP)    // MOVQ ${t}, EP
+    self.Emit("CMPQ", _AX, jit.Imm(a))      // CMPQ AX, ${a}
+    self.Sjmp("JL"  , _LB_range_error)      // JL   _range_error
+    self.Emit("CMPQ", _AX, jit.Imm(b))      // CMPQ AX, ${B}
+    self.Sjmp("JG"  , _LB_range_error)      // JG   _range_error
+}
+
+func (self *_Assembler) range_unsigned(i *rt.GoItab, t *rt.GoType, v uint64) {
+    self.Emit("MOVQ" , _VAR_st_Iv, _AX)         // MOVQ  st.Iv, AX
+    self.Emit("MOVQ" , jit.Gitab(i), _ET)       // MOVQ  ${i}, ET
+    self.Emit("MOVQ" , jit.Gtype(t), _EP)       // MOVQ  ${t}, EP
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ AX, AX
+    self.Sjmp("JS"   , _LB_range_error)         // JS    _range_error
+    self.Emit("CMPQ" , _AX, jit.Imm(int64(v)))  // CMPQ  AX, ${a}
+    self.Sjmp("JA"   , _LB_range_error)         // JA    _range_error
+}
+
+/** String Manipulating Routines **/
+
+var (
+    _F_unquote = jit.Imm(int64(native.S_unquote))
+)
+
+func (self *_Assembler) slice_from(p obj.Addr, d int64) {
+    self.Emit("MOVQ", p, _SI)   // MOVQ    ${p}, SI
+    self.slice_from_r(_SI, d)   // SLICE_R SI, ${d}
+}
+
+func (self *_Assembler) slice_from_r(p obj.Addr, d int64) {
+    self.Emit("LEAQ", jit.Sib(_IP, p, 1, 0), _DI)   // LEAQ (IP)(${p}), DI
+    self.Emit("NEGQ", p)                            // NEGQ ${p}
+    self.Emit("LEAQ", jit.Sib(_IC, p, 1, d), _SI)   // LEAQ d(IC)(${p}), SI
+}
+
+func (self *_Assembler) unquote_once(p obj.Addr, n obj.Addr, stack bool, copy bool) {
+    self.slice_from(_VAR_st_Iv, -1)                             // SLICE  st.Iv, $-1
+    self.Emit("CMPQ" , _VAR_st_Ep, jit.Imm(-1))                 // CMPQ   st.Ep, $-1
+    self.Sjmp("JE"   , "_noescape_{n}")                         // JE     _noescape_{n}
+    self.Byte(0x4c, 0x8d, 0x0d)                                 // LEAQ (PC), R9
+    self.Sref("_unquote_once_write_{n}", 4)
+    self.Sjmp("JMP" , "_escape_string")
+    self.Link("_noescape_{n}")                                  // _noescape_{n}:
+    if copy {
+        self.Emit("BTQ"  , jit.Imm(_F_copy_string), _ARG_fv)    
+        self.Sjmp("JNC", "_unquote_once_write_{n}")
+        self.Byte(0x4c, 0x8d, 0x0d)                             // LEAQ (PC), R9
+        self.Sref("_unquote_once_write_{n}", 4)
+        self.Sjmp("JMP", "_copy_string")
+    }
+    self.Link("_unquote_once_write_{n}")
+    self.Emit("MOVQ" , _SI, n)                                  // MOVQ   SI, ${n}
+    if stack {
+        self.Emit("MOVQ", _DI, p) 
+    } else {
+        self.WriteRecNotAX(10, _DI, p, false, false)
+    }
+}
+
+func (self *_Assembler) unquote_twice(p obj.Addr, n obj.Addr, stack bool) {
+    self.Emit("CMPQ" , _VAR_st_Ep, jit.Imm(-1))                     // CMPQ   st.Ep, $-1
+    self.Sjmp("JE"   , _LB_eof_error)                               // JE     _eof_error
+    self.Emit("CMPB" , jit.Sib(_IP, _IC, 1, -3), jit.Imm('\\'))     // CMPB   -3(IP)(IC), $'\\'
+    self.Sjmp("JNE"  , _LB_char_m3_error)                           // JNE    _char_m3_error
+    self.Emit("CMPB" , jit.Sib(_IP, _IC, 1, -2), jit.Imm('"'))      // CMPB   -2(IP)(IC), $'"'
+    self.Sjmp("JNE"  , _LB_char_m2_error)                           // JNE    _char_m2_error
+    self.slice_from(_VAR_st_Iv, -3)                                 // SLICE  st.Iv, $-3
+    self.Emit("MOVQ" , _SI, _AX)                                    // MOVQ   SI, AX
+    self.Emit("ADDQ" , _VAR_st_Iv, _AX)                             // ADDQ   st.Iv, AX
+    self.Emit("CMPQ" , _VAR_st_Ep, _AX)                             // CMPQ   st.Ep, AX
+    self.Sjmp("JE"   , "_noescape_{n}")                             // JE     _noescape_{n}
+    self.Byte(0x4c, 0x8d, 0x0d)                                     // LEAQ (PC), R9
+    self.Sref("_unquote_twice_write_{n}", 4)
+    self.Sjmp("JMP" , "_escape_string_twice")
+    self.Link("_noescape_{n}")                                      // _noescape_{n}:
+    self.Emit("BTQ"  , jit.Imm(_F_copy_string), _ARG_fv)    
+    self.Sjmp("JNC", "_unquote_twice_write_{n}") 
+    self.Byte(0x4c, 0x8d, 0x0d)                                     // LEAQ (PC), R9
+    self.Sref("_unquote_twice_write_{n}", 4)
+    self.Sjmp("JMP", "_copy_string")
+    self.Link("_unquote_twice_write_{n}")
+    self.Emit("MOVQ" , _SI, n)                                      // MOVQ   SI, ${n}
+    if stack {
+        self.Emit("MOVQ", _DI, p) 
+    } else {
+        self.WriteRecNotAX(12, _DI, p, false, false)
+    }
+}
+
+/** Memory Clearing Routines **/
+
+var (
+    _F_memclrHasPointers    = jit.Func(memclrHasPointers)
+    _F_memclrNoHeapPointers = jit.Func(memclrNoHeapPointers)
+)
+
+func (self *_Assembler) mem_clear_fn(ptrfree bool) {
+    if !ptrfree {
+        self.call_go(_F_memclrHasPointers)
+    } else {
+        self.call_go(_F_memclrNoHeapPointers)
+    }
+}
+
+func (self *_Assembler) mem_clear_rem(size int64, ptrfree bool) {
+    self.Emit("MOVQ", jit.Imm(size), _CX)               // MOVQ    ${size}, CX
+    self.Emit("MOVQ", jit.Ptr(_ST, 0), _AX)             // MOVQ    (ST), AX
+    self.Emit("MOVQ", jit.Sib(_ST, _AX, 1, 0), _AX)     // MOVQ    (ST)(AX), AX
+    self.Emit("SUBQ", _VP, _AX)                         // SUBQ    VP, AX
+    self.Emit("ADDQ", _AX, _CX)                         // ADDQ    AX, CX
+    self.Emit("MOVQ", _VP, jit.Ptr(_SP, 0))             // MOVQ    VP, (SP)
+    self.Emit("MOVQ", _CX, jit.Ptr(_SP, 8))             // MOVQ    CX, 8(SP)
+    self.mem_clear_fn(ptrfree)                          // CALL_GO memclr{Has,NoHeap}Pointers
+}
+
+/** Map Assigning Routines **/
+
+var (
+    _F_mapassign           = jit.Func(mapassign)
+    _F_mapassign_fast32    = jit.Func(mapassign_fast32)
+    _F_mapassign_faststr   = jit.Func(mapassign_faststr)
+    _F_mapassign_fast64ptr = jit.Func(mapassign_fast64ptr)
+)
+
+var (
+    _F_decodeJsonUnmarshaler obj.Addr
+    _F_decodeTextUnmarshaler obj.Addr
+)
+
+func init() {
+    _F_decodeJsonUnmarshaler = jit.Func(decodeJsonUnmarshaler)
+    _F_decodeTextUnmarshaler = jit.Func(decodeTextUnmarshaler)
+}
+
+func (self *_Assembler) mapaccess_ptr(t reflect.Type) {
+    if rt.MapType(rt.UnpackType(t)).IndirectElem() {
+        self.vfollow(t.Elem())
+    }
+}
+
+func (self *_Assembler) mapassign_std(t reflect.Type, v obj.Addr) {
+    self.Emit("LEAQ", v, _AX)               // LEAQ      ${v}, AX
+    self.mapassign_call(t, _F_mapassign)    // MAPASSIGN ${t}, mapassign
+}
+
+func (self *_Assembler) mapassign_str_fast(t reflect.Type, p obj.Addr, n obj.Addr) {
+    self.Emit("MOVQ", jit.Type(t), _AX)         // MOVQ    ${t}, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))     // MOVQ    AX, (SP)
+    self.Emit("MOVQ", _VP, jit.Ptr(_SP, 8))     // MOVQ    VP, 8(SP)
+    self.Emit("MOVQ", p, jit.Ptr(_SP, 16))      // MOVQ    ${p}, 16(SP)
+    self.Emit("MOVQ", n, jit.Ptr(_SP, 24))      // MOVQ    ${n}, 24(SP)
+    self.call_go(_F_mapassign_faststr)          // CALL_GO ${fn}
+    self.Emit("MOVQ", jit.Ptr(_SP, 32), _VP)    // MOVQ    32(SP), VP
+    self.mapaccess_ptr(t)
+}
+
+func (self *_Assembler) mapassign_call(t reflect.Type, fn obj.Addr) {
+    self.Emit("MOVQ", jit.Type(t), _SI)         // MOVQ    ${t}, SI
+    self.Emit("MOVQ", _SI, jit.Ptr(_SP, 0))     // MOVQ    SI, (SP)
+    self.Emit("MOVQ", _VP, jit.Ptr(_SP, 8))     // MOVQ    VP, 8(SP)
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 16))    // MOVQ    AX, 16(SP)
+    self.call_go(fn)                            // CALL_GO ${fn}
+    self.Emit("MOVQ", jit.Ptr(_SP, 24), _VP)    // MOVQ    24(SP), VP
+}
+
+func (self *_Assembler) mapassign_fastx(t reflect.Type, fn obj.Addr) {
+    self.mapassign_call(t, fn)
+    self.mapaccess_ptr(t)
+}
+
+func (self *_Assembler) mapassign_utext(t reflect.Type, addressable bool) {
+    pv := false
+    vk := t.Key()
+    tk := t.Key()
+
+    /* deref pointer if needed */
+    if vk.Kind() == reflect.Ptr {
+        pv = true
+        vk = vk.Elem()
+    }
+
+    /* addressable value with pointer receiver */
+    if addressable {
+        pv = false
+        tk = reflect.PtrTo(tk)
+    }
+
+    /* allocate the key, and call the unmarshaler */
+    self.valloc(vk, _DI)                        // VALLOC  ${vk}, DI
+    // must spill vk pointer since next call_go may invoke GC
+    self.Emit("MOVQ" , _DI, _VAR_vk)
+    self.Emit("MOVQ" , jit.Type(tk), _AX)       // MOVQ    ${tk}, AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 0))    // MOVQ    AX, (SP)
+    self.Emit("MOVQ" , _DI, jit.Ptr(_SP, 8))    // MOVQ    DI, 8(SP)
+    self.Emit("MOVOU", _VAR_sv, _X0)            // MOVOU   sv, X0
+    self.Emit("MOVOU", _X0, jit.Ptr(_SP, 16))   // MOVOU   X0, 16(SP)
+    self.call_go(_F_decodeTextUnmarshaler)      // CALL_GO decodeTextUnmarshaler
+    self.Emit("MOVQ" , jit.Ptr(_SP, 32), _ET)   // MOVQ    32(SP), ET
+    self.Emit("MOVQ" , jit.Ptr(_SP, 40), _EP)   // MOVQ    40(SP), EP
+    self.Emit("TESTQ", _ET, _ET)                // TESTQ   ET, ET
+    self.Sjmp("JNZ"  , _LB_error)               // JNZ     _error
+    self.Emit("MOVQ" , _VAR_vk, _AX)
+
+    /* select the correct assignment function */
+    if !pv {
+        self.mapassign_call(t, _F_mapassign)
+    } else {
+        self.mapassign_fastx(t, _F_mapassign_fast64ptr)
+    }
+}
+
+/** External Unmarshaler Routines **/
+
+var (
+    _F_skip_one = jit.Imm(int64(native.S_skip_one))
+    _F_skip_number = jit.Imm(int64(native.S_skip_number))
+)
+
+func (self *_Assembler) unmarshal_json(t reflect.Type, deref bool) {
+    self.call_sf(_F_skip_one)                                   // CALL_SF   skip_one
+    self.Emit("TESTQ", _AX, _AX)                                // TESTQ     AX, AX
+    self.Sjmp("JS"   , _LB_parsing_error_v)                     // JS        _parse_error_v
+    self.slice_from_r(_AX, 0)                                   // SLICE_R   AX, $0
+    self.Emit("MOVQ" , _DI, _VAR_sv_p)                          // MOVQ      DI, sv.p
+    self.Emit("MOVQ" , _SI, _VAR_sv_n)                          // MOVQ      SI, sv.n
+    self.unmarshal_func(t, _F_decodeJsonUnmarshaler, deref)     // UNMARSHAL json, ${t}, ${deref}
+}
+
+func (self *_Assembler) unmarshal_text(t reflect.Type, deref bool) {
+    self.parse_string()                                         // PARSE     STRING
+    self.unquote_once(_VAR_sv_p, _VAR_sv_n, true, true)        // UNQUOTE   once, sv.p, sv.n
+    self.unmarshal_func(t, _F_decodeTextUnmarshaler, deref)     // UNMARSHAL text, ${t}, ${deref}
+}
+
+func (self *_Assembler) unmarshal_func(t reflect.Type, fn obj.Addr, deref bool) {
+    pt := t
+    vk := t.Kind()
+
+    /* allocate the field if needed */
+    if deref && vk == reflect.Ptr {
+        self.Emit("MOVQ" , _VP, _AX)                // MOVQ   VP, AX
+        self.Emit("MOVQ" , jit.Ptr(_AX, 0), _AX)    // MOVQ   (AX), AX
+        self.Emit("TESTQ", _AX, _AX)                // TESTQ  AX, AX
+        self.Sjmp("JNZ"  , "_deref_{n}")            // JNZ    _deref_{n}
+        self.valloc(t.Elem(), _AX)                  // VALLOC ${t.Elem()}, AX
+        self.WritePtrAX(3, jit.Ptr(_VP, 0), false)    // MOVQ   AX, (VP)
+        self.Link("_deref_{n}")                     // _deref_{n}:
+    }
+
+    /* set value type */
+    self.Emit("MOVQ", jit.Type(pt), _CX)        // MOVQ ${pt}, CX
+    self.Emit("MOVQ", _CX, jit.Ptr(_SP, 0))     // MOVQ CX, (SP)
+
+    /* set value pointer */
+    if deref && vk == reflect.Ptr {
+        self.Emit("MOVQ", _AX, jit.Ptr(_SP, 8))     // MOVQ AX, 8(SP)
+    } else {
+        self.Emit("MOVQ", _VP, jit.Ptr(_SP, 8))     // MOVQ VP, 8(SP)
+    }
+
+    /* set the source string and call the unmarshaler */
+    self.Emit("MOVOU", _VAR_sv, _X0)            // MOVOU   sv, X0
+    self.Emit("MOVOU", _X0, jit.Ptr(_SP, 16))   // MOVOU   X0, 16(SP)
+    self.call_go(fn)                            // CALL_GO ${fn}
+    self.Emit("MOVQ" , jit.Ptr(_SP, 32), _ET)   // MOVQ    32(SP), ET
+    self.Emit("MOVQ" , jit.Ptr(_SP, 40), _EP)   // MOVQ    40(SP), EP
+    self.Emit("TESTQ", _ET, _ET)                // TESTQ   ET, ET
+    self.Sjmp("JNZ"  , _LB_error)               // JNZ     _error
+}
+
+/** Dynamic Decoding Routine **/
+
+var (
+    _F_decodeTypedPointer obj.Addr
+)
+
+func init() {
+    _F_decodeTypedPointer = jit.Func(decodeTypedPointer)
+}
+
+func (self *_Assembler) decode_dynamic(vt obj.Addr, vp obj.Addr) {
+    self.Emit("MOVQ" , _ARG_fv, _CX)            // MOVQ    fv, CX
+    self.Emit("MOVOU", _ARG_sp, _X0)            // MOVOU   sp, X0
+    self.Emit("MOVOU", _X0, jit.Ptr(_SP, 0))    // MOVOU   X0, (SP)
+    self.Emit("MOVQ" , _IC, jit.Ptr(_SP, 16))   // MOVQ    IC, 16(SP)
+    self.Emit("MOVQ" , vt, jit.Ptr(_SP, 24))    // MOVQ    ${vt}, 24(SP)
+    self.Emit("MOVQ" , vp, jit.Ptr(_SP, 32))    // MOVQ    ${vp}, 32(SP)
+    self.Emit("MOVQ" , _ST, jit.Ptr(_SP, 40))   // MOVQ    ST, 40(SP)
+    self.Emit("MOVQ" , _CX, jit.Ptr(_SP, 48))   // MOVQ    CX, 48(SP)
+    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
+}
+
+/** OpCode Assembler Functions **/
+
+var (
+    _F_memequal         = jit.Func(memequal)
+    _F_memmove          = jit.Func(memmove)
+    _F_growslice        = jit.Func(growslice)
+    _F_makeslice        = jit.Func(makeslice)
+    _F_makemap_small    = jit.Func(makemap_small)
+    _F_mapassign_fast64 = jit.Func(mapassign_fast64)
+)
+
+var (
+    _F_lspace  = jit.Imm(int64(native.S_lspace))
+    _F_strhash = jit.Imm(int64(caching.S_strhash))
+)
+
+var (
+    _F_b64decode   = jit.Imm(int64(_subr__b64decode))
+    _F_decodeValue = jit.Imm(int64(_subr_decode_value))
+)
+
+var (
+    _F_skip_array  = jit.Imm(int64(native.S_skip_array))
+    _F_skip_object = jit.Imm(int64(native.S_skip_object))
+)
+
+var (
+    _F_FieldMap_GetCaseInsensitive obj.Addr
+)
+
+const (
+    _MODE_AVX2 = 1 << 2
+)
+
+const (
+    _Fe_ID   = int64(unsafe.Offsetof(caching.FieldEntry{}.ID))
+    _Fe_Name = int64(unsafe.Offsetof(caching.FieldEntry{}.Name))
+    _Fe_Hash = int64(unsafe.Offsetof(caching.FieldEntry{}.Hash))
+)
+
+const (
+    _Vk_Ptr       = int64(reflect.Ptr)
+    _Gt_KindFlags = int64(unsafe.Offsetof(rt.GoType{}.KindFlags))
+)
+
+func init() {
+    _F_FieldMap_GetCaseInsensitive = jit.Func((*caching.FieldMap).GetCaseInsensitive)
+}
+
+func (self *_Assembler) _asm_OP_any(_ *_Instr) {
+    self.Emit("MOVQ"   , jit.Ptr(_VP, 8), _CX)              // MOVQ    8(VP), CX
+    self.Emit("TESTQ"  , _CX, _CX)                          // TESTQ   CX, CX
+    self.Sjmp("JZ"     , "_decode_{n}")                     // JZ      _decode_{n}
+    self.Emit("CMPQ"   , _CX, _VP)                          // CMPQ    CX, VP
+    self.Sjmp("JE"     , "_decode_{n}")                     // JE      _decode_{n}
+    self.Emit("MOVQ"   , jit.Ptr(_VP, 0), _AX)              // MOVQ    (VP), AX
+    self.Emit("MOVBLZX", jit.Ptr(_AX, _Gt_KindFlags), _DX)  // MOVBLZX _Gt_KindFlags(AX), DX
+    self.Emit("ANDL"   , jit.Imm(rt.F_kind_mask), _DX)      // ANDL    ${F_kind_mask}, DX
+    self.Emit("CMPL"   , _DX, jit.Imm(_Vk_Ptr))             // CMPL    DX, ${reflect.Ptr}
+    self.Sjmp("JNE"    , "_decode_{n}")                     // JNE     _decode_{n}
+    self.Emit("LEAQ"   , jit.Ptr(_VP, 8), _DI)              // LEAQ    8(VP), DI
+    self.decode_dynamic(_AX, _DI)                           // DECODE  AX, DI
+    self.Sjmp("JMP"    , "_decode_end_{n}")                 // JMP     _decode_end_{n}
+    self.Link("_decode_{n}")                                // _decode_{n}:
+    self.Emit("MOVQ"   , _ARG_fv, _DF)                      // MOVQ    fv, DF
+    self.Emit("MOVQ"   , _ST, jit.Ptr(_SP, 0))              // MOVQ    _ST, (SP)
+    self.call(_F_decodeValue)                               // CALL    decodeValue
+    self.Emit("TESTQ"  , _EP, _EP)                          // TESTQ   EP, EP
+    self.Sjmp("JNZ"    , _LB_parsing_error)                 // JNZ     _parsing_error
+    self.Link("_decode_end_{n}")                            // _decode_end_{n}:
+}
+
+func (self *_Assembler) _asm_OP_dyn(p *_Instr) {
+    self.Emit("MOVQ"   , jit.Type(p.vt()), _ET)             // MOVQ    ${p.vt()}, ET
+    self.Emit("CMPQ"   , jit.Ptr(_VP, 8), jit.Imm(0))       // CMPQ    8(VP), $0
+    self.Sjmp("JE"     , _LB_type_error)                    // JE      _type_error
+    self.Emit("MOVQ"   , jit.Ptr(_VP, 0), _AX)              // MOVQ    (VP), AX
+    self.Emit("MOVQ"   , jit.Ptr(_AX, 8), _AX)              // MOVQ    8(AX), AX
+    self.Emit("MOVBLZX", jit.Ptr(_AX, _Gt_KindFlags), _DX)  // MOVBLZX _Gt_KindFlags(AX), DX
+    self.Emit("ANDL"   , jit.Imm(rt.F_kind_mask), _DX)      // ANDL    ${F_kind_mask}, DX
+    self.Emit("CMPL"   , _DX, jit.Imm(_Vk_Ptr))             // CMPL    DX, ${reflect.Ptr}
+    self.Sjmp("JNE"    , _LB_type_error)                    // JNE     _type_error
+    self.Emit("LEAQ"   , jit.Ptr(_VP, 8), _DI)              // LEAQ    8(VP), DI
+    self.decode_dynamic(_AX, _DI)                           // DECODE  AX, DI
+    self.Link("_decode_end_{n}")                            // _decode_end_{n}:
+}
+
+func (self *_Assembler) _asm_OP_str(_ *_Instr) {
+    self.parse_string()                                     // PARSE   STRING
+    self.unquote_once(jit.Ptr(_VP, 0), jit.Ptr(_VP, 8), false, true)     // UNQUOTE once, (VP), 8(VP)
+}
+
+func (self *_Assembler) _asm_OP_bin(_ *_Instr) {
+    self.parse_string()                                 // PARSE  STRING
+    self.slice_from(_VAR_st_Iv, -1)                     // SLICE  st.Iv, $-1
+    self.Emit("MOVQ" , _DI, jit.Ptr(_VP, 0))            // MOVQ   DI, (VP)
+    self.Emit("MOVQ" , _SI, jit.Ptr(_VP, 8))            // MOVQ   SI, 8(VP)
+    self.Emit("SHRQ" , jit.Imm(2), _SI)                 // SHRQ   $2, SI
+    self.Emit("LEAQ" , jit.Sib(_SI, _SI, 2, 0), _SI)    // LEAQ   (SI)(SI*2), SI
+    self.Emit("MOVQ" , _SI, jit.Ptr(_VP, 16))           // MOVQ   SI, 16(VP)
+    self.malloc(_SI, _SI)                               // MALLOC SI, SI
+
+    // TODO: due to base64x's bug, only use AVX mode now
+    self.Emit("MOVL", jit.Imm(_MODE_JSON), _CX)          //  MOVL $_MODE_JSON, CX
+
+    /* call the decoder */
+    self.Emit("XORL" , _DX, _DX)                // XORL  DX, DX
+    self.Emit("MOVQ" , _VP, _DI)                // MOVQ  VP, DI
+
+    self.Emit("MOVQ" , jit.Ptr(_VP, 0), _R9)    // MOVQ SI, （VP)
+    self.WriteRecNotAX(4, _SI, jit.Ptr(_VP, 0), true, false)    // XCHGQ SI, (VP) 
+    self.Emit("MOVQ" , _R9, _SI)
+
+    self.Emit("XCHGQ", _DX, jit.Ptr(_VP, 8))    // XCHGQ DX, 8(VP)
+    self.call(_F_b64decode)                     // CALL  b64decode
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ AX, AX
+    self.Sjmp("JS"   , _LB_base64_error)        // JS    _base64_error
+    self.Emit("MOVQ" , _AX, jit.Ptr(_VP, 8))    // MOVQ  AX, 8(VP)
+}
+
+func (self *_Assembler) _asm_OP_bool(_ *_Instr) {
+    self.Emit("LEAQ", jit.Ptr(_IC, 4), _AX)                     // LEAQ 4(IC), AX
+    self.Emit("CMPQ", _AX, _IL)                                 // CMPQ AX, IL
+    self.Sjmp("JA"  , _LB_eof_error)                            // JA   _eof_error
+    self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm('f'))    // CMPB (IP)(IC), $'f'
+    self.Sjmp("JE"  , "_false_{n}")                             // JE   _false_{n}
+    self.Emit("MOVL", jit.Imm(_IM_true), _CX)                   // MOVL $"true", CX
+    self.Emit("CMPL", _CX, jit.Sib(_IP, _IC, 1, 0))             // CMPL CX, (IP)(IC)
+    self.Sjmp("JE" , "_bool_true_{n}")  
+
+    // try to skip the value
+    self.Emit("MOVQ", _IC, _VAR_ic)           
+    self.Emit("MOVQ", _T_bool, _ET)         
+    self.Emit("MOVQ", _ET, _VAR_et)
+    self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ (PC), R9
+    self.Sref("_end_{n}", 4)
+    self.Emit("MOVQ", _R9, _VAR_pc)
+    self.Sjmp("JMP"  , _LB_skip_one) 
+
+    self.Link("_bool_true_{n}")
+    self.Emit("MOVQ", _AX, _IC)                                 // MOVQ AX, IC
+    self.Emit("MOVB", jit.Imm(1), jit.Ptr(_VP, 0))              // MOVB $1, (VP)
+    self.Sjmp("JMP" , "_end_{n}")                               // JMP  _end_{n}
+    self.Link("_false_{n}")                                     // _false_{n}:
+    self.Emit("ADDQ", jit.Imm(1), _AX)                          // ADDQ $1, AX
+    self.Emit("ADDQ", jit.Imm(1), _IC)                          // ADDQ $1, IC
+    self.Emit("CMPQ", _AX, _IL)                                 // CMPQ AX, IL
+    self.Sjmp("JA"  , _LB_eof_error)                            // JA   _eof_error
+    self.Emit("MOVL", jit.Imm(_IM_alse), _CX)                   // MOVL $"alse", CX
+    self.Emit("CMPL", _CX, jit.Sib(_IP, _IC, 1, 0))             // CMPL CX, (IP)(IC)
+    self.Sjmp("JNE" , _LB_im_error)                             // JNE  _im_error
+    self.Emit("MOVQ", _AX, _IC)                                 // MOVQ AX, IC
+    self.Emit("XORL", _AX, _AX)                                 // XORL AX, AX
+    self.Emit("MOVB", _AX, jit.Ptr(_VP, 0))                     // MOVB AX, (VP)
+    self.Link("_end_{n}")                                       // _end_{n}:
+}
+
+func (self *_Assembler) _asm_OP_num(_ *_Instr) {
+    self.Emit("MOVQ", jit.Imm(0), _VAR_fl)
+    self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm('"'))
+    self.Emit("MOVQ", _IC, _BP)
+    self.Sjmp("JNE", "_skip_number_{n}")
+    self.Emit("MOVQ", jit.Imm(1), _VAR_fl)
+    self.Emit("ADDQ", jit.Imm(1), _IC)
+    self.Link("_skip_number_{n}")
+
+    /* call skip_number */
+    self.call_sf(_F_skip_number)                   // CALL_SF skip_one
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
+    self.Sjmp("JNS"   , "_num_next_{n}")
+
+    /* call skip one */
+    self.Emit("MOVQ", _BP, _VAR_ic)           
+    self.Emit("MOVQ", _T_number, _ET)       
+    self.Emit("MOVQ", _ET, _VAR_et)
+    self.Byte(0x4c, 0x8d, 0x0d)       
+    self.Sref("_num_end_{n}", 4)
+    self.Emit("MOVQ", _R9, _VAR_pc)
+    self.Sjmp("JMP"  , _LB_skip_one)
+
+    /* assgin string */
+    self.Link("_num_next_{n}")
+    self.slice_from_r(_AX, 0)
+    self.Emit("BTQ", jit.Imm(_F_copy_string), _ARG_fv)
+    self.Sjmp("JNC", "_num_write_{n}")
+    self.Byte(0x4c, 0x8d, 0x0d)                 // LEAQ (PC), R9
+    self.Sref("_num_write_{n}", 4)
+    self.Sjmp("JMP", "_copy_string")
+    self.Link("_num_write_{n}")
+    self.Emit("MOVQ", _SI, jit.Ptr(_VP, 8))     // MOVQ  SI, 8(VP)
+    self.WriteRecNotAX(13, _DI, jit.Ptr(_VP, 0), false, false)   
+    
+    /* check if quoted */
+    self.Emit("CMPQ", _VAR_fl, jit.Imm(1))
+    self.Sjmp("JNE", "_num_end_{n}")
+    self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm('"'))
+    self.Sjmp("JNE", _LB_char_0_error)
+    self.Emit("ADDQ", jit.Imm(1), _IC)
+    self.Link("_num_end_{n}")
+}
+
+func (self *_Assembler) _asm_OP_i8(ins *_Instr) {
+    var pin = "_i8_end_{n}"
+    self.parse_signed(int8Type, pin, -1)                                                 // PARSE int8
+    self.range_signed(_I_int8, _T_int8, math.MinInt8, math.MaxInt8)     // RANGE int8
+    self.Emit("MOVB", _AX, jit.Ptr(_VP, 0))                             // MOVB  AX, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_i16(ins *_Instr) {
+    var pin = "_i16_end_{n}"
+    self.parse_signed(int16Type, pin, -1)                                                     // PARSE int16
+    self.range_signed(_I_int16, _T_int16, math.MinInt16, math.MaxInt16)     // RANGE int16
+    self.Emit("MOVW", _AX, jit.Ptr(_VP, 0))                                 // MOVW  AX, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_i32(ins *_Instr) {
+    var pin = "_i32_end_{n}"
+    self.parse_signed(int32Type, pin, -1)                                                     // PARSE int32
+    self.range_signed(_I_int32, _T_int32, math.MinInt32, math.MaxInt32)     // RANGE int32
+    self.Emit("MOVL", _AX, jit.Ptr(_VP, 0))                                 // MOVL  AX, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_i64(ins *_Instr) {
+    var pin = "_i64_end_{n}"
+    self.parse_signed(int64Type, pin, -1)                         // PARSE int64
+    self.Emit("MOVQ", _VAR_st_Iv, _AX)          // MOVQ  st.Iv, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_VP, 0))     // MOVQ  AX, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_u8(ins *_Instr) {
+    var pin = "_u8_end_{n}"
+    self.parse_unsigned(uint8Type, pin, -1)                                   // PARSE uint8
+    self.range_unsigned(_I_uint8, _T_uint8, math.MaxUint8)  // RANGE uint8
+    self.Emit("MOVB", _AX, jit.Ptr(_VP, 0))                 // MOVB  AX, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_u16(ins *_Instr) {
+    var pin = "_u16_end_{n}"
+    self.parse_unsigned(uint16Type, pin, -1)                                       // PARSE uint16
+    self.range_unsigned(_I_uint16, _T_uint16, math.MaxUint16)   // RANGE uint16
+    self.Emit("MOVW", _AX, jit.Ptr(_VP, 0))                     // MOVW  AX, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_u32(ins *_Instr) {
+    var pin = "_u32_end_{n}"
+    self.parse_unsigned(uint32Type, pin, -1)                                       // PARSE uint32
+    self.range_unsigned(_I_uint32, _T_uint32, math.MaxUint32)   // RANGE uint32
+    self.Emit("MOVL", _AX, jit.Ptr(_VP, 0))                     // MOVL  AX, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_u64(ins *_Instr) {
+    var pin = "_u64_end_{n}"
+    self.parse_unsigned(uint64Type, pin, -1)                       // PARSE uint64
+    self.Emit("MOVQ", _VAR_st_Iv, _AX)          // MOVQ  st.Iv, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_VP, 0))     // MOVQ  AX, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_f32(ins *_Instr) {
+    var pin = "_f32_end_{n}"
+    self.parse_number(float32Type, pin, -1)                         // PARSE NUMBER
+    self.range_single()                         // RANGE float32
+    self.Emit("MOVSS", _X0, jit.Ptr(_VP, 0))    // MOVSS X0, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_f64(ins *_Instr) {
+    var pin = "_f64_end_{n}"
+    self.parse_number(float64Type, pin, -1)                         // PARSE NUMBER
+    self.Emit("MOVSD", _VAR_st_Dv, _X0)         // MOVSD st.Dv, X0
+    self.Emit("MOVSD", _X0, jit.Ptr(_VP, 0))    // MOVSD X0, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_unquote(ins *_Instr) {
+    self.check_eof(2)
+    self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm('\\'))   // CMPB    (IP)(IC), $'\\'
+    self.Sjmp("JNE" , _LB_char_0_error)                         // JNE     _char_0_error
+    self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 1), jit.Imm('"'))    // CMPB    1(IP)(IC), $'"'
+    self.Sjmp("JNE" , _LB_char_1_error)                         // JNE     _char_1_error
+    self.Emit("ADDQ", jit.Imm(2), _IC)                          // ADDQ    $2, IC
+    self.parse_string()                                         // PARSE   STRING
+    self.unquote_twice(jit.Ptr(_VP, 0), jit.Ptr(_VP, 8), false)        // UNQUOTE twice, (VP), 8(VP)
+}
+
+func (self *_Assembler) _asm_OP_nil_1(_ *_Instr) {
+    self.Emit("XORL", _AX, _AX)                 // XORL AX, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_VP, 0))     // MOVQ AX, (VP)
+}
+
+func (self *_Assembler) _asm_OP_nil_2(_ *_Instr) {
+    self.Emit("PXOR" , _X0, _X0)                // PXOR  X0, X0
+    self.Emit("MOVOU", _X0, jit.Ptr(_VP, 0))    // MOVOU X0, (VP)
+}
+
+func (self *_Assembler) _asm_OP_nil_3(_ *_Instr) {
+    self.Emit("XORL" , _AX, _AX)                // XORL  AX, AX
+    self.Emit("PXOR" , _X0, _X0)                // PXOR  X0, X0
+    self.Emit("MOVOU", _X0, jit.Ptr(_VP, 0))    // MOVOU X0, (VP)
+    self.Emit("MOVQ" , _AX, jit.Ptr(_VP, 16))   // MOVOU X0, 16(VP)
+}
+
+func (self *_Assembler) _asm_OP_deref(p *_Instr) {
+    self.vfollow(p.vt())
+}
+
+func (self *_Assembler) _asm_OP_index(p *_Instr) {
+    self.Emit("MOVQ", jit.Imm(p.i64()), _AX)    // MOVQ ${p.vi()}, AX
+    self.Emit("ADDQ", _AX, _VP)                 // ADDQ _AX, _VP
+}
+
+func (self *_Assembler) _asm_OP_is_null(p *_Instr) {
+    self.Emit("LEAQ"   , jit.Ptr(_IC, 4), _AX)                          // LEAQ    4(IC), AX
+    self.Emit("CMPQ"   , _AX, _IL)                                      // CMPQ    AX, IL
+    self.Sjmp("JA"     , "_not_null_{n}")                               // JA      _not_null_{n}
+    self.Emit("CMPL"   , jit.Sib(_IP, _IC, 1, 0), jit.Imm(_IM_null))    // CMPL    (IP)(IC), $"null"
+    self.Emit("CMOVQEQ", _AX, _IC)                                      // CMOVQEQ AX, IC
+    self.Xjmp("JE"     , p.vi())                                        // JE      {p.vi()}
+    self.Link("_not_null_{n}")                                          // _not_null_{n}:
+}
+
+func (self *_Assembler) _asm_OP_is_null_quote(p *_Instr) {
+    self.Emit("LEAQ"   , jit.Ptr(_IC, 5), _AX)                          // LEAQ    4(IC), AX
+    self.Emit("CMPQ"   , _AX, _IL)                                      // CMPQ    AX, IL
+    self.Sjmp("JA"     , "_not_null_quote_{n}")                         // JA      _not_null_quote_{n}
+    self.Emit("CMPL"   , jit.Sib(_IP, _IC, 1, 0), jit.Imm(_IM_null))    // CMPL    (IP)(IC), $"null"
+    self.Sjmp("JNE"    , "_not_null_quote_{n}")                         // JNE     _not_null_quote_{n}
+    self.Emit("CMPB"   , jit.Sib(_IP, _IC, 1, 4), jit.Imm('"'))         // CMPB    4(IP)(IC), $'"'
+    self.Emit("CMOVQEQ", _AX, _IC)                                      // CMOVQEQ AX, IC
+    self.Xjmp("JE"     , p.vi())                                        // JE      {p.vi()}
+    self.Link("_not_null_quote_{n}")                                    // _not_null_quote_{n}:
+}
+
+func (self *_Assembler) _asm_OP_map_init(_ *_Instr) {
+    self.Emit("MOVQ" , jit.Ptr(_VP, 0), _AX)    // MOVQ    (VP), AX
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
+    self.Sjmp("JNZ"  , "_end_{n}")              // JNZ     _end_{n}
+    self.call_go(_F_makemap_small)              // CALL_GO makemap_small
+    self.Emit("MOVQ" , jit.Ptr(_SP, 0), _AX)    // MOVQ    (SP), AX
+    self.WritePtrAX(6, jit.Ptr(_VP, 0), false)    // MOVQ    AX, (VP)
+    self.Link("_end_{n}")                       // _end_{n}:
+    self.Emit("MOVQ" , _AX, _VP)                // MOVQ    AX, VP
+}
+
+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.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.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
+    if vt := p.vt(); !mapfast(vt) {
+        self.mapassign_std(vt, _VAR_st_Iv)                                  // MAPASSIGN int32, mapassign, st.Iv
+    } else {
+        self.mapassign_fastx(vt, _F_mapassign_fast32)                       // MAPASSIGN int32, mapassign_fast32
+    }
+}
+
+func (self *_Assembler) _asm_OP_map_key_i64(p *_Instr) {
+    self.parse_signed(int64Type, "", p.vi())                                 // PARSE     int64
+    if vt := p.vt(); !mapfast(vt) {
+        self.mapassign_std(vt, _VAR_st_Iv)              // MAPASSIGN int64, mapassign, st.Iv
+    } else {
+        self.Emit("MOVQ", _VAR_st_Iv, _AX)              // MOVQ      st.Iv, AX
+        self.mapassign_fastx(vt, _F_mapassign_fast64)   // MAPASSIGN int64, mapassign_fast64
+    }
+}
+
+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.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.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
+    if vt := p.vt(); !mapfast(vt) {
+        self.mapassign_std(vt, _VAR_st_Iv)                      // MAPASSIGN uint32, vt.Iv
+    } else {
+        self.mapassign_fastx(vt, _F_mapassign_fast32)           // MAPASSIGN uint32, mapassign_fast32
+    }
+}
+
+func (self *_Assembler) _asm_OP_map_key_u64(p *_Instr) {
+    self.parse_unsigned(uint64Type, "", p.vi())                                       // PARSE     uint64
+    if vt := p.vt(); !mapfast(vt) {
+        self.mapassign_std(vt, _VAR_st_Iv)                      // MAPASSIGN uint64, vt.Iv
+    } else {
+        self.Emit("MOVQ", _VAR_st_Iv, _AX)                      // MOVQ      st.Iv, AX
+        self.mapassign_fastx(vt, _F_mapassign_fast64)           // MAPASSIGN uint64, mapassign_fast64
+    }
+}
+
+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.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.mapassign_std(p.vt(), _VAR_st_Dv)  // MAPASSIGN ${p.vt()}, mapassign, st.Dv
+}
+
+func (self *_Assembler) _asm_OP_map_key_str(p *_Instr) {
+    self.parse_string()                          // PARSE     STRING
+    self.unquote_once(_VAR_sv_p, _VAR_sv_n, true, true)      // UNQUOTE   once, sv.p, sv.n
+    if vt := p.vt(); !mapfast(vt) {
+        self.valloc(vt.Key(), _DI)
+        self.Emit("MOVOU", _VAR_sv, _X0)
+        self.Emit("MOVOU", _X0, jit.Ptr(_DI, 0))
+        self.mapassign_std(vt, jit.Ptr(_DI, 0))        
+    } else {
+        self.Emit("MOVQ", _VAR_sv_p, _DI)        // MOVQ      sv.p, DI
+        self.Emit("MOVQ", _VAR_sv_n, _SI)        // MOVQ      sv.n, SI
+        self.mapassign_str_fast(vt, _DI, _SI)    // MAPASSIGN string, DI, SI
+    }
+}
+
+func (self *_Assembler) _asm_OP_map_key_utext(p *_Instr) {
+    self.parse_string()                         // PARSE     STRING
+    self.unquote_once(_VAR_sv_p, _VAR_sv_n, true, true)     // UNQUOTE   once, sv.p, sv.n
+    self.mapassign_utext(p.vt(), false)         // MAPASSIGN utext, ${p.vt()}, false
+}
+
+func (self *_Assembler) _asm_OP_map_key_utext_p(p *_Instr) {
+    self.parse_string()                         // PARSE     STRING
+    self.unquote_once(_VAR_sv_p, _VAR_sv_n, true, false)     // UNQUOTE   once, sv.p, sv.n
+    self.mapassign_utext(p.vt(), true)          // MAPASSIGN utext, ${p.vt()}, true
+}
+
+func (self *_Assembler) _asm_OP_array_skip(_ *_Instr) {
+    self.call_sf(_F_skip_array)                 // CALL_SF skip_array
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
+    self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
+}
+
+func (self *_Assembler) _asm_OP_array_clear(p *_Instr) {
+    self.mem_clear_rem(p.i64(), true)
+}
+
+func (self *_Assembler) _asm_OP_array_clear_p(p *_Instr) {
+    self.mem_clear_rem(p.i64(), false)
+}
+
+func (self *_Assembler) _asm_OP_slice_init(p *_Instr) {
+    self.Emit("XORL" , _AX, _AX)                    // XORL    AX, AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_VP, 8))        // MOVQ    AX, 8(VP)
+    self.Emit("MOVQ" , jit.Ptr(_VP, 16), _AX)       // MOVQ    16(VP), AX
+    self.Emit("TESTQ", _AX, _AX)                    // TESTQ   AX, AX
+    self.Sjmp("JNZ"  , "_done_{n}")                 // JNZ     _done_{n}
+    self.Emit("MOVQ" , jit.Imm(_MinSlice), _CX)     // MOVQ    ${_MinSlice}, CX
+    self.Emit("MOVQ" , _CX, jit.Ptr(_VP, 16))       // MOVQ    CX, 16(VP)
+    self.Emit("MOVQ" , jit.Type(p.vt()), _DX)       // MOVQ    ${p.vt()}, DX
+    self.Emit("MOVQ" , _DX, jit.Ptr(_SP, 0))        // MOVQ    DX, (SP)
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 8))        // MOVQ    AX, 8(SP)
+    self.Emit("MOVQ" , _CX, jit.Ptr(_SP, 16))       // MOVQ    CX, 16(SP)
+    self.call_go(_F_makeslice)                      // CALL_GO makeslice
+    self.Emit("MOVQ" , jit.Ptr(_SP, 24), _AX)       // MOVQ    24(SP), AX
+    self.WritePtrAX(7, jit.Ptr(_VP, 0), false)      // MOVQ    AX, (VP)
+    self.Link("_done_{n}")                          // _done_{n}:
+    self.Emit("XORL" , _AX, _AX)                    // XORL    AX, AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_VP, 8))        // MOVQ    AX, 8(VP)
+}
+
+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)
+    self.Sjmp("JB"   , "_index_{n}")                    // JB      _index_{n}
+    self.Emit("MOVQ" , jit.Type(p.vt()), _AX)           // MOVQ    ${p.vt()}, AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 0))            // MOVQ    AX, (SP)
+    self.Emit("MOVOU", jit.Ptr(_VP, 0), _X0)            // MOVOU   (VP), X0
+    self.Emit("MOVOU", _X0, jit.Ptr(_SP, 8))            // MOVOU   X0, 8(SP)
+    self.Emit("MOVQ" , jit.Ptr(_VP, 16), _AX)           // MOVQ    16(VP), AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 24))           // MOVQ    AX, 24(SP)
+    self.Emit("SHLQ" , jit.Imm(1), _AX)                 // SHLQ    $1, AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 32))           // MOVQ    AX, 32(SP)
+    self.call_go(_F_growslice)                          // CALL_GO growslice
+    self.Emit("MOVQ" , jit.Ptr(_SP, 40), _DI)           // MOVQ    40(SP), DI
+    self.Emit("MOVQ" , jit.Ptr(_SP, 48), _AX)           // MOVQ    48(SP), AX
+    self.Emit("MOVQ" , jit.Ptr(_SP, 56), _SI)           // MOVQ    56(SP), SI
+    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)
+    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
+}
+
+func (self *_Assembler) _asm_OP_object_skip(_ *_Instr) {
+    self.call_sf(_F_skip_object)                // CALL_SF skip_object
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
+    self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
+}
+
+func (self *_Assembler) _asm_OP_object_next(_ *_Instr) {
+    self.call_sf(_F_skip_one)                   // CALL_SF skip_one
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
+    self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
+}
+
+func (self *_Assembler) _asm_OP_struct_field(p *_Instr) {
+    assert_eq(caching.FieldEntrySize, 32, "invalid field entry size")
+    self.Emit("MOVQ" , jit.Imm(-1), _AX)                        // MOVQ    $-1, AX
+    self.Emit("MOVQ" , _AX, _VAR_sr)                            // MOVQ    AX, sr
+    self.parse_string()                                         // PARSE   STRING
+    self.unquote_once(_VAR_sv_p, _VAR_sv_n, true, false)                     // UNQUOTE once, sv.p, sv.n
+    self.Emit("LEAQ" , _VAR_sv, _AX)                            // LEAQ    sv, AX
+    self.Emit("XORL" , _CX, _CX)                                // XORL    CX, CX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 0))                    // MOVQ    AX, (SP)
+    self.Emit("MOVQ" , _CX, jit.Ptr(_SP, 8))                    // MOVQ    CX, 8(SP)
+    self.call_go(_F_strhash)                                    // CALL_GO strhash
+    self.Emit("MOVQ" , jit.Ptr(_SP, 16), _AX)                   // MOVQ    16(SP), AX
+    self.Emit("MOVQ" , _AX, _R9)                                // MOVQ    AX, R9
+    self.Emit("MOVQ" , jit.Imm(freezeFields(p.vf())), _CX)      // MOVQ    ${p.vf()}, CX
+    self.Emit("MOVQ" , jit.Ptr(_CX, caching.FieldMap_b), _SI)   // MOVQ    FieldMap.b(CX), SI
+    self.Emit("MOVQ" , jit.Ptr(_CX, caching.FieldMap_N), _CX)   // MOVQ    FieldMap.N(CX), CX
+    self.Emit("TESTQ", _CX, _CX)                                // TESTQ   CX, CX
+    self.Sjmp("JZ"   , "_try_lowercase_{n}")                    // JZ      _try_lowercase_{n}
+    self.Link("_loop_{n}")                                      // _loop_{n}:
+    self.Emit("XORL" , _DX, _DX)                                // XORL    DX, DX
+    self.From("DIVQ" , _CX)                                     // DIVQ    CX
+    self.Emit("LEAQ" , jit.Ptr(_DX, 1), _AX)                    // LEAQ    1(DX), AX
+    self.Emit("SHLQ" , jit.Imm(5), _DX)                         // SHLQ    $5, DX
+    self.Emit("LEAQ" , jit.Sib(_SI, _DX, 1, 0), _DI)            // LEAQ    (SI)(DX), DI
+    self.Emit("MOVQ" , jit.Ptr(_DI, _Fe_Hash), _R8)             // MOVQ    FieldEntry.Hash(DI), R8
+    self.Emit("TESTQ", _R8, _R8)                                // TESTQ   R8, R8
+    self.Sjmp("JZ"   , "_try_lowercase_{n}")                    // JZ      _try_lowercase_{n}
+    self.Emit("CMPQ" , _R8, _R9)                                // CMPQ    R8, R9
+    self.Sjmp("JNE"  , "_loop_{n}")                             // JNE     _loop_{n}
+    self.Emit("MOVQ" , jit.Ptr(_DI, _Fe_Name + 8), _DX)         // MOVQ    FieldEntry.Name+8(DI), DX
+    self.Emit("CMPQ" , _DX, _VAR_sv_n)                          // CMPQ    DX, sv.n
+    self.Sjmp("JNE"  , "_loop_{n}")                             // JNE     _loop_{n}
+    self.Emit("MOVQ" , jit.Ptr(_DI, _Fe_ID), _R8)               // MOVQ    FieldEntry.ID(DI), R8
+    self.Emit("MOVQ" , _AX, _VAR_ss_AX)                         // MOVQ    AX, ss.AX
+    self.Emit("MOVQ" , _CX, _VAR_ss_CX)                         // MOVQ    CX, ss.CX
+    self.Emit("MOVQ" , _SI, _VAR_ss_SI)                         // MOVQ    SI, ss.SI
+    self.Emit("MOVQ" , _R8, _VAR_ss_R8)                         // MOVQ    R8, ss.R8
+    self.Emit("MOVQ" , _R9, _VAR_ss_R9)                         // MOVQ    R9, ss.R9
+    self.Emit("MOVQ" , _VAR_sv_p, _AX)                          // MOVQ    _VAR_sv_p, AX
+    self.Emit("MOVQ" , jit.Ptr(_DI, _Fe_Name), _CX)             // MOVQ    FieldEntry.Name(DI), CX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 0))                    // MOVQ    AX, (SP)
+    self.Emit("MOVQ" , _CX, jit.Ptr(_SP, 8))                    // MOVQ    CX, 8(SP)
+    self.Emit("MOVQ" , _DX, jit.Ptr(_SP, 16))                   // MOVQ    DX, 16(SP)
+    self.call_go(_F_memequal)                                   // CALL_GO memequal
+    self.Emit("MOVQ" , _VAR_ss_AX, _AX)                         // MOVQ    ss.AX, AX
+    self.Emit("MOVQ" , _VAR_ss_CX, _CX)                         // MOVQ    ss.CX, CX
+    self.Emit("MOVQ" , _VAR_ss_SI, _SI)                         // MOVQ    ss.SI, SI
+    self.Emit("MOVQ" , _VAR_ss_R9, _R9)                         // MOVQ    ss.R9, R9
+    self.Emit("MOVB" , jit.Ptr(_SP, 24), _DX)                   // MOVB    24(SP), DX
+    self.Emit("TESTB", _DX, _DX)                                // TESTB   DX, DX
+    self.Sjmp("JZ"   , "_loop_{n}")                             // JZ      _loop_{n}
+    self.Emit("MOVQ" , _VAR_ss_R8, _R8)                         // MOVQ    ss.R8, R8
+    self.Emit("MOVQ" , _R8, _VAR_sr)                            // MOVQ    R8, sr
+    self.Sjmp("JMP"  , "_end_{n}")                              // JMP     _end_{n}
+    self.Link("_try_lowercase_{n}")                             // _try_lowercase_{n}:
+    self.Emit("MOVQ" , jit.Imm(referenceFields(p.vf())), _AX)   // MOVQ    ${p.vf()}, AX
+    self.Emit("MOVOU", _VAR_sv, _X0)                            // MOVOU   sv, X0
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 0))                    // MOVQ    AX, (SP)
+    self.Emit("MOVOU", _X0, jit.Ptr(_SP, 8))                    // MOVOU   X0, 8(SP)
+    self.call_go(_F_FieldMap_GetCaseInsensitive)                // CALL_GO FieldMap::GetCaseInsensitive
+    self.Emit("MOVQ" , jit.Ptr(_SP, 24), _AX)                   // MOVQ    24(SP), AX
+    self.Emit("MOVQ" , _AX, _VAR_sr)                            // MOVQ    AX, _VAR_sr
+    self.Emit("TESTQ", _AX, _AX)                                // TESTQ   AX, AX
+    self.Sjmp("JNS"  , "_end_{n}")                              // JNS     _end_{n}
+    self.Emit("BTQ"  , jit.Imm(_F_disable_unknown), _ARG_fv)    // BTQ     ${_F_disable_unknown}, fv
+    self.Sjmp("JC"   , _LB_field_error)                         // JC      _field_error
+    self.Link("_end_{n}")                                       // _end_{n}:
+}
+
+func (self *_Assembler) _asm_OP_unmarshal(p *_Instr) {
+    self.unmarshal_json(p.vt(), true)
+}
+
+func (self *_Assembler) _asm_OP_unmarshal_p(p *_Instr) {
+    self.unmarshal_json(p.vt(), false)
+}
+
+func (self *_Assembler) _asm_OP_unmarshal_text(p *_Instr) {
+    self.unmarshal_text(p.vt(), true)
+}
+
+func (self *_Assembler) _asm_OP_unmarshal_text_p(p *_Instr) {
+    self.unmarshal_text(p.vt(), false)
+}
+
+func (self *_Assembler) _asm_OP_lspace(_ *_Instr) {
+    self.lspace("_{n}")
+}
+
+func (self *_Assembler) lspace(subfix string) {
+    var label = "_lspace" + subfix
+
+    self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
+    self.Sjmp("JAE"    , _LB_eof_error)                 // JAE     _eof_error
+    self.Emit("MOVQ"   , jit.Imm(_BM_space), _DX)       // MOVQ    _BM_space, DX
+    self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
+    self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
+    self.Sjmp("JA"     , label)                // JA      _nospace_{n}
+    self.Emit("BTQ"    , _AX, _DX)                      // BTQ     AX, DX
+    self.Sjmp("JNC"    , label)                // JNC     _nospace_{n}
+
+    /* test up to 4 characters */
+    for i := 0; i < 3; i++ {
+        self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
+        self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
+        self.Sjmp("JAE"    , _LB_eof_error)                 // JAE     _eof_error
+        self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
+        self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
+        self.Sjmp("JA"     , label)                // JA      _nospace_{n}
+        self.Emit("BTQ"    , _AX, _DX)                      // BTQ     AX, DX
+        self.Sjmp("JNC"    , label)                // JNC     _nospace_{n}
+    }
+
+    /* handle over to the native function */
+    self.Emit("MOVQ"   , _IP, _DI)                      // MOVQ    IP, DI
+    self.Emit("MOVQ"   , _IL, _SI)                      // MOVQ    IL, SI
+    self.Emit("MOVQ"   , _IC, _DX)                      // MOVQ    IC, DX
+    self.call(_F_lspace)                                // CALL    lspace
+    self.Emit("TESTQ"  , _AX, _AX)                      // TESTQ   AX, AX
+    self.Sjmp("JS"     , _LB_parsing_error_v)           // JS      _parsing_error_v
+    self.Emit("CMPQ"   , _AX, _IL)                      // CMPQ    AX, IL
+    self.Sjmp("JAE"    , _LB_eof_error)                 // JAE     _eof_error
+    self.Emit("MOVQ"   , _AX, _IC)                      // MOVQ    AX, IC
+    self.Link(label)                           // _nospace_{n}:
+}
+
+func (self *_Assembler) _asm_OP_match_char(p *_Instr) {
+    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
+}
+
+func (self *_Assembler) _asm_OP_check_char(p *_Instr) {
+    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(p.vb())))   // CMPB    (IP)(IC), ${p.vb()}
+    self.Emit("CMOVQEQ", _AX, _IC)                                          // CMOVQEQ AX, IC
+    self.Xjmp("JE"     , p.vi())                                            // JE      {p.vi()}
+}
+
+func (self *_Assembler) _asm_OP_check_char_0(p *_Instr) {
+    self.check_eof(1)
+    self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(int64(p.vb())))   // CMPB    (IP)(IC), ${p.vb()}
+    self.Xjmp("JE"  , p.vi())                                            // JE      {p.vi()}
+}
+
+func (self *_Assembler) _asm_OP_add(p *_Instr) {
+    self.Emit("ADDQ", jit.Imm(int64(p.vi())), _IC)  // ADDQ ${p.vi()}, IC
+}
+
+func (self *_Assembler) _asm_OP_load(_ *_Instr) {
+    self.Emit("MOVQ", jit.Ptr(_ST, 0), _AX)             // MOVQ (ST), AX
+    self.Emit("MOVQ", jit.Sib(_ST, _AX, 1, 0), _VP)     // MOVQ (ST)(AX), VP
+}
+
+func (self *_Assembler) _asm_OP_save(_ *_Instr) {
+    self.Emit("MOVQ", jit.Ptr(_ST, 0), _CX)             // MOVQ (ST), CX
+    self.Emit("CMPQ", _CX, jit.Imm(_MaxStackBytes))          // CMPQ CX, ${_MaxStackBytes}
+    self.Sjmp("JAE"  , _LB_stack_error)                 // JA   _stack_error
+    self.WriteRecNotAX(0 , _VP, jit.Sib(_ST, _CX, 1, 8), false, false) // MOVQ VP, 8(ST)(CX)
+    self.Emit("ADDQ", jit.Imm(8), _CX)                  // ADDQ $8, CX
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, 0))             // MOVQ CX, (ST)
+}
+
+func (self *_Assembler) _asm_OP_drop(_ *_Instr) {
+    self.Emit("MOVQ", jit.Ptr(_ST, 0), _AX)             // MOVQ (ST), AX
+    self.Emit("SUBQ", jit.Imm(8), _AX)                  // SUBQ $8, AX
+    self.Emit("MOVQ", jit.Sib(_ST, _AX, 1, 8), _VP)     // MOVQ 8(ST)(AX), VP
+    self.Emit("MOVQ", _AX, jit.Ptr(_ST, 0))             // MOVQ AX, (ST)
+    self.Emit("XORL", _ET, _ET)                         // XORL ET, ET
+    self.Emit("MOVQ", _ET, jit.Sib(_ST, _AX, 1, 8))     // MOVQ ET, 8(ST)(AX)
+}
+
+func (self *_Assembler) _asm_OP_drop_2(_ *_Instr) {
+    self.Emit("MOVQ" , jit.Ptr(_ST, 0), _AX)            // MOVQ  (ST), AX
+    self.Emit("SUBQ" , jit.Imm(16), _AX)                // SUBQ  $16, AX
+    self.Emit("MOVQ" , jit.Sib(_ST, _AX, 1, 8), _VP)    // MOVQ  8(ST)(AX), VP
+    self.Emit("MOVQ" , _AX, jit.Ptr(_ST, 0))            // MOVQ  AX, (ST)
+    self.Emit("PXOR" , _X0, _X0)                        // PXOR  X0, X0
+    self.Emit("MOVOU", _X0, jit.Sib(_ST, _AX, 1, 8))    // MOVOU X0, 8(ST)(AX)
+}
+
+func (self *_Assembler) _asm_OP_recurse(p *_Instr) {
+    self.Emit("MOVQ", jit.Type(p.vt()), _AX)    // MOVQ   ${p.vt()}, AX
+    self.decode_dynamic(_AX, _VP)               // DECODE AX, VP
+}
+
+func (self *_Assembler) _asm_OP_goto(p *_Instr) {
+    self.Xjmp("JMP", p.vi())
+}
+
+func (self *_Assembler) _asm_OP_switch(p *_Instr) {
+    self.Emit("MOVQ", _VAR_sr, _AX)             // MOVQ sr, AX
+    self.Emit("CMPQ", _AX, jit.Imm(p.i64()))    // CMPQ AX, ${len(p.vs())}
+    self.Sjmp("JAE" , "_default_{n}")           // JAE  _default_{n}
+
+    /* jump table selector */
+    self.Byte(0x48, 0x8d, 0x3d)                         // LEAQ    ?(PC), DI
+    self.Sref("_switch_table_{n}", 4)                   // ....    &_switch_table_{n}
+    self.Emit("MOVLQSX", jit.Sib(_DI, _AX, 4, 0), _AX)  // MOVLQSX (DI)(AX*4), AX
+    self.Emit("ADDQ"   , _DI, _AX)                      // ADDQ    DI, AX
+    self.Rjmp("JMP"    , _AX)                           // JMP     AX
+    self.Link("_switch_table_{n}")                      // _switch_table_{n}:
+
+    /* generate the jump table */
+    for i, v := range p.vs() {
+        self.Xref(v, int64(-i) * 4)
+    }
+
+    /* default case */
+    self.Link("_default_{n}")
+    self.NOP()
+}
+
+func (self *_Assembler) print_gc(i int, p1 *_Instr, p2 *_Instr) {
+    self.Emit("MOVQ", jit.Imm(int64(p2.op())),  jit.Ptr(_SP, 16))// MOVQ $(p2.op()), 16(SP)
+    self.Emit("MOVQ", jit.Imm(int64(p1.op())),  jit.Ptr(_SP, 8)) // MOVQ $(p1.op()), 8(SP)
+    self.Emit("MOVQ", jit.Imm(int64(i)),  jit.Ptr(_SP, 0))       // MOVQ $(i), (SP)
+    self.call_go(_F_println)
+}
+
+var _runtime_writeBarrier uintptr = rt.GcwbAddr()
+
+//go:linkname gcWriteBarrierAX runtime.gcWriteBarrier
+func gcWriteBarrierAX()
+
+var (
+    _V_writeBarrier = jit.Imm(int64(_runtime_writeBarrier))
+
+    _F_gcWriteBarrierAX = jit.Func(gcWriteBarrierAX)
+)
+
+func (self *_Assembler) WritePtrAX(i int, rec obj.Addr, saveDI bool) {
+    self.Emit("MOVQ", _V_writeBarrier, _R10)
+    self.Emit("CMPL", jit.Ptr(_R10, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    if saveDI {
+        self.save(_DI)
+    }
+    self.Emit("LEAQ", rec, _DI)
+    self.Emit("MOVQ", _F_gcWriteBarrierAX, _R10)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _R10)  
+    if saveDI {
+        self.load(_DI)
+    }    
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", _AX, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}
+
+func (self *_Assembler) WriteRecNotAX(i int, ptr obj.Addr, rec obj.Addr, saveDI bool, saveAX bool) {
+    if rec.Reg == x86.REG_AX || rec.Index == x86.REG_AX {
+        panic("rec contains AX!")
+    }
+    self.Emit("MOVQ", _V_writeBarrier, _R10)
+    self.Emit("CMPL", jit.Ptr(_R10, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    if saveAX {
+        self.Emit("XCHGQ", ptr, _AX)
+    } else {
+        self.Emit("MOVQ", ptr, _AX)
+    }
+    if saveDI {
+        self.save(_DI)
+    }
+    self.Emit("LEAQ", rec, _DI)
+    self.Emit("MOVQ", _F_gcWriteBarrierAX, _R10)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _R10)  
+    if saveDI {
+        self.load(_DI)
+    } 
+    if saveAX {
+        self.Emit("XCHGQ", ptr, _AX)
+    }    
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/decoder/assembler_amd64_go117.go b/vendor/github.com/bytedance/sonic/decoder/assembler_amd64_go117.go
new file mode 100644
index 000000000..8a70cfff6
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/assembler_amd64_go117.go
@@ -0,0 +1,1922 @@
+//go:build go1.17 && !go1.21
+// +build go1.17,!go1.21
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `encoding/json`
+    `fmt`
+    `math`
+    `reflect`
+    `strconv`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/caching`
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/twitchyliquid64/golang-asm/obj`
+    `github.com/twitchyliquid64/golang-asm/obj/x86`
+)
+
+/** Register Allocations
+ *
+ *  State Registers:
+ *
+ *      %r13 : stack base
+ *      %r10 : input pointer
+ *      %r12 : input length
+ *      %r11 : input cursor
+ *      %r15 : value pointer
+ *
+ *  Error Registers:
+ *
+ *      %rax : error type register
+ *      %rbx : error pointer register
+ */
+
+/** Function Prototype & Stack Map
+ *
+ *  func (s string, ic int, vp unsafe.Pointer, sb *_Stack, fv uint64, sv string) (rc int, err error)
+ *
+ *  s.buf  :   (FP)
+ *  s.len  :  8(FP)
+ *  ic     : 16(FP)
+ *  vp     : 24(FP)
+ *  sb     : 32(FP)
+ *  fv     : 40(FP)
+ *  sv     : 56(FP)
+ *  err.vt : 72(FP)
+ *  err.vp : 80(FP)
+ */
+
+const (
+    _FP_args   = 72     // 72 bytes to pass and spill register arguements
+    _FP_fargs  = 80     // 80 bytes for passing arguments to other Go functions
+    _FP_saves  = 48     // 48 bytes for saving the registers before CALL instructions
+    _FP_locals = 144    // 144 bytes for local variables
+)
+
+const (
+    _FP_offs = _FP_fargs + _FP_saves + _FP_locals
+    _FP_size = _FP_offs + 8     // 8 bytes for the parent frame pointer
+    _FP_base = _FP_size + 8     // 8 bytes for the return address
+)
+
+const (
+    _IM_null = 0x6c6c756e   // 'null'
+    _IM_true = 0x65757274   // 'true'
+    _IM_alse = 0x65736c61   // 'alse' ('false' without the 'f')
+)
+
+const (
+    _BM_space = (1 << ' ') | (1 << '\t') | (1 << '\r') | (1 << '\n')
+)
+
+const (
+    _MODE_JSON = 1 << 3 // base64 mode
+)
+
+const (
+    _LB_error           = "_error"
+    _LB_im_error        = "_im_error"
+    _LB_eof_error       = "_eof_error"
+    _LB_type_error      = "_type_error"
+    _LB_field_error     = "_field_error"
+    _LB_range_error     = "_range_error"
+    _LB_stack_error     = "_stack_error"
+    _LB_base64_error    = "_base64_error"
+    _LB_unquote_error   = "_unquote_error"
+    _LB_parsing_error   = "_parsing_error"
+    _LB_parsing_error_v = "_parsing_error_v"
+    _LB_mismatch_error   = "_mismatch_error"
+)
+
+const (
+    _LB_char_0_error  = "_char_0_error"
+    _LB_char_1_error  = "_char_1_error"
+    _LB_char_2_error  = "_char_2_error"
+    _LB_char_3_error  = "_char_3_error"
+    _LB_char_4_error  = "_char_4_error"
+    _LB_char_m2_error = "_char_m2_error"
+    _LB_char_m3_error = "_char_m3_error"
+)
+
+const (
+    _LB_skip_one = "_skip_one"
+    _LB_skip_key_value = "_skip_key_value"
+)
+
+var (
+    _AX = jit.Reg("AX")
+    _BX = jit.Reg("BX")
+    _CX = jit.Reg("CX")
+    _DX = jit.Reg("DX")
+    _DI = jit.Reg("DI")
+    _SI = jit.Reg("SI")
+    _BP = jit.Reg("BP")
+    _SP = jit.Reg("SP")
+    _R8 = jit.Reg("R8")
+    _R9 = jit.Reg("R9")
+    _X0 = jit.Reg("X0")
+    _X1 = jit.Reg("X1")
+)
+
+var (
+    _IP = jit.Reg("R10")  // saved on BP when callc
+    _IC = jit.Reg("R11")  // saved on BX when call_c
+    _IL = jit.Reg("R12")
+    _ST = jit.Reg("R13")
+    _VP = jit.Reg("R15")
+)
+
+var (
+    _DF = jit.Reg("AX")    // reuse AX in generic decoder for flags
+    _ET = jit.Reg("AX")
+    _EP = jit.Reg("BX")
+)
+
+
+
+var (
+    _ARG_s  = _ARG_sp
+    _ARG_sp = jit.Ptr(_SP, _FP_base + 0)
+    _ARG_sl = jit.Ptr(_SP, _FP_base + 8)
+    _ARG_ic = jit.Ptr(_SP, _FP_base + 16)
+    _ARG_vp = jit.Ptr(_SP, _FP_base + 24)
+    _ARG_sb = jit.Ptr(_SP, _FP_base + 32)
+    _ARG_fv = jit.Ptr(_SP, _FP_base + 40)
+)
+
+var (
+    _ARG_sv   = _ARG_sv_p
+    _ARG_sv_p = jit.Ptr(_SP, _FP_base + 48)
+    _ARG_sv_n = jit.Ptr(_SP, _FP_base + 56)
+    _ARG_vk   = jit.Ptr(_SP, _FP_base + 64)
+)
+
+var (
+    _VAR_st = _VAR_st_Vt
+    _VAR_sr = jit.Ptr(_SP, _FP_fargs + _FP_saves)
+)
+
+var (
+    _VAR_st_Vt = jit.Ptr(_SP, _FP_fargs + _FP_saves + 0)
+    _VAR_st_Dv = jit.Ptr(_SP, _FP_fargs + _FP_saves + 8)
+    _VAR_st_Iv = jit.Ptr(_SP, _FP_fargs + _FP_saves + 16)
+    _VAR_st_Ep = jit.Ptr(_SP, _FP_fargs + _FP_saves + 24)
+    _VAR_st_Db = jit.Ptr(_SP, _FP_fargs + _FP_saves + 32)
+    _VAR_st_Dc = jit.Ptr(_SP, _FP_fargs + _FP_saves + 40)
+)
+
+var (
+    _VAR_ss_AX = jit.Ptr(_SP, _FP_fargs + _FP_saves + 48)
+    _VAR_ss_CX = jit.Ptr(_SP, _FP_fargs + _FP_saves + 56)
+    _VAR_ss_SI = jit.Ptr(_SP, _FP_fargs + _FP_saves + 64)
+    _VAR_ss_R8 = jit.Ptr(_SP, _FP_fargs + _FP_saves + 72)
+    _VAR_ss_R9 = jit.Ptr(_SP, _FP_fargs + _FP_saves + 80)
+)
+
+var (
+    _VAR_bs_p = jit.Ptr(_SP, _FP_fargs + _FP_saves + 88)
+    _VAR_bs_n = jit.Ptr(_SP, _FP_fargs + _FP_saves + 96)
+    _VAR_bs_LR = jit.Ptr(_SP, _FP_fargs + _FP_saves + 104)
+)
+
+var _VAR_fl = jit.Ptr(_SP, _FP_fargs + _FP_saves + 112)
+
+var (
+    _VAR_et = jit.Ptr(_SP, _FP_fargs + _FP_saves + 120) // save dismatched type
+    _VAR_pc = jit.Ptr(_SP, _FP_fargs + _FP_saves + 128) // save skip return pc
+    _VAR_ic = jit.Ptr(_SP, _FP_fargs + _FP_saves + 136) // save dismatched position
+)
+
+type _Assembler struct {
+    jit.BaseAssembler
+    p _Program
+    name string
+}
+
+func newAssembler(p _Program) *_Assembler {
+    return new(_Assembler).Init(p)
+}
+
+/** Assembler Interface **/
+
+func (self *_Assembler) Load() _Decoder {
+    return ptodec(self.BaseAssembler.Load("decode_"+self.name, _FP_size, _FP_args, argPtrs, localPtrs))
+}
+
+func (self *_Assembler) Init(p _Program) *_Assembler {
+    self.p = p
+    self.BaseAssembler.Init(self.compile)
+    return self
+}
+
+func (self *_Assembler) compile() {
+    self.prologue()
+    self.instrs()
+    self.epilogue()
+    self.copy_string()
+    self.escape_string()
+    self.escape_string_twice()
+    self.skip_one()
+    self.skip_key_value()
+    self.type_error()
+    self.mismatch_error()
+    self.field_error()
+    self.range_error()
+    self.stack_error()
+    self.base64_error()
+    self.parsing_error()
+}
+
+/** Assembler Stages **/
+
+var _OpFuncTab = [256]func(*_Assembler, *_Instr) {
+    _OP_any              : (*_Assembler)._asm_OP_any,
+    _OP_dyn              : (*_Assembler)._asm_OP_dyn,
+    _OP_str              : (*_Assembler)._asm_OP_str,
+    _OP_bin              : (*_Assembler)._asm_OP_bin,
+    _OP_bool             : (*_Assembler)._asm_OP_bool,
+    _OP_num              : (*_Assembler)._asm_OP_num,
+    _OP_i8               : (*_Assembler)._asm_OP_i8,
+    _OP_i16              : (*_Assembler)._asm_OP_i16,
+    _OP_i32              : (*_Assembler)._asm_OP_i32,
+    _OP_i64              : (*_Assembler)._asm_OP_i64,
+    _OP_u8               : (*_Assembler)._asm_OP_u8,
+    _OP_u16              : (*_Assembler)._asm_OP_u16,
+    _OP_u32              : (*_Assembler)._asm_OP_u32,
+    _OP_u64              : (*_Assembler)._asm_OP_u64,
+    _OP_f32              : (*_Assembler)._asm_OP_f32,
+    _OP_f64              : (*_Assembler)._asm_OP_f64,
+    _OP_unquote          : (*_Assembler)._asm_OP_unquote,
+    _OP_nil_1            : (*_Assembler)._asm_OP_nil_1,
+    _OP_nil_2            : (*_Assembler)._asm_OP_nil_2,
+    _OP_nil_3            : (*_Assembler)._asm_OP_nil_3,
+    _OP_deref            : (*_Assembler)._asm_OP_deref,
+    _OP_index            : (*_Assembler)._asm_OP_index,
+    _OP_is_null          : (*_Assembler)._asm_OP_is_null,
+    _OP_is_null_quote    : (*_Assembler)._asm_OP_is_null_quote,
+    _OP_map_init         : (*_Assembler)._asm_OP_map_init,
+    _OP_map_key_i8       : (*_Assembler)._asm_OP_map_key_i8,
+    _OP_map_key_i16      : (*_Assembler)._asm_OP_map_key_i16,
+    _OP_map_key_i32      : (*_Assembler)._asm_OP_map_key_i32,
+    _OP_map_key_i64      : (*_Assembler)._asm_OP_map_key_i64,
+    _OP_map_key_u8       : (*_Assembler)._asm_OP_map_key_u8,
+    _OP_map_key_u16      : (*_Assembler)._asm_OP_map_key_u16,
+    _OP_map_key_u32      : (*_Assembler)._asm_OP_map_key_u32,
+    _OP_map_key_u64      : (*_Assembler)._asm_OP_map_key_u64,
+    _OP_map_key_f32      : (*_Assembler)._asm_OP_map_key_f32,
+    _OP_map_key_f64      : (*_Assembler)._asm_OP_map_key_f64,
+    _OP_map_key_str      : (*_Assembler)._asm_OP_map_key_str,
+    _OP_map_key_utext    : (*_Assembler)._asm_OP_map_key_utext,
+    _OP_map_key_utext_p  : (*_Assembler)._asm_OP_map_key_utext_p,
+    _OP_array_skip       : (*_Assembler)._asm_OP_array_skip,
+    _OP_array_clear      : (*_Assembler)._asm_OP_array_clear,
+    _OP_array_clear_p    : (*_Assembler)._asm_OP_array_clear_p,
+    _OP_slice_init       : (*_Assembler)._asm_OP_slice_init,
+    _OP_slice_append     : (*_Assembler)._asm_OP_slice_append,
+    _OP_object_skip      : (*_Assembler)._asm_OP_object_skip,
+    _OP_object_next      : (*_Assembler)._asm_OP_object_next,
+    _OP_struct_field     : (*_Assembler)._asm_OP_struct_field,
+    _OP_unmarshal        : (*_Assembler)._asm_OP_unmarshal,
+    _OP_unmarshal_p      : (*_Assembler)._asm_OP_unmarshal_p,
+    _OP_unmarshal_text   : (*_Assembler)._asm_OP_unmarshal_text,
+    _OP_unmarshal_text_p : (*_Assembler)._asm_OP_unmarshal_text_p,
+    _OP_lspace           : (*_Assembler)._asm_OP_lspace,
+    _OP_match_char       : (*_Assembler)._asm_OP_match_char,
+    _OP_check_char       : (*_Assembler)._asm_OP_check_char,
+    _OP_load             : (*_Assembler)._asm_OP_load,
+    _OP_save             : (*_Assembler)._asm_OP_save,
+    _OP_drop             : (*_Assembler)._asm_OP_drop,
+    _OP_drop_2           : (*_Assembler)._asm_OP_drop_2,
+    _OP_recurse          : (*_Assembler)._asm_OP_recurse,
+    _OP_goto             : (*_Assembler)._asm_OP_goto,
+    _OP_switch           : (*_Assembler)._asm_OP_switch,
+    _OP_check_char_0     : (*_Assembler)._asm_OP_check_char_0,
+    _OP_dismatch_err     : (*_Assembler)._asm_OP_dismatch_err,
+    _OP_go_skip          : (*_Assembler)._asm_OP_go_skip,
+    _OP_add              : (*_Assembler)._asm_OP_add,
+    _OP_debug            : (*_Assembler)._asm_OP_debug,
+}
+
+func (self *_Assembler) _asm_OP_debug(_ *_Instr) {
+    self.Byte(0xcc)
+}
+
+func (self *_Assembler) instr(v *_Instr) {
+    if fn := _OpFuncTab[v.op()]; fn != nil {
+        fn(self, v)
+    } else {
+        panic(fmt.Sprintf("invalid opcode: %d", v.op()))
+    }
+}
+
+func (self *_Assembler) instrs() {
+    for i, v := range self.p {
+        self.Mark(i)
+        self.instr(&v)
+        self.debug_instr(i, &v)
+    }
+}
+
+func (self *_Assembler) epilogue() {
+    self.Mark(len(self.p))
+    self.Emit("XORL", _EP, _EP)                     // XORL EP, EP
+    self.Emit("MOVQ", _VAR_et, _ET)                 // MOVQ VAR_et, ET
+    self.Emit("TESTQ", _ET, _ET)                    // TESTQ ET, ET
+    self.Sjmp("JNZ", _LB_mismatch_error)            // JNZ _LB_mismatch_error
+    self.Link(_LB_error)                            // _error:
+    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_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
+    self.Emit("ADDQ", jit.Imm(_FP_size), _SP)       // ADDQ $_FP_size, SP
+    self.Emit("RET")                                // RET
+}
+
+func (self *_Assembler) prologue() {
+    self.Emit("SUBQ", jit.Imm(_FP_size), _SP)       // SUBQ $_FP_size, SP
+    self.Emit("MOVQ", _BP, jit.Ptr(_SP, _FP_offs))  // MOVQ BP, _FP_offs(SP)
+    self.Emit("LEAQ", jit.Ptr(_SP, _FP_offs), _BP)  // LEAQ _FP_offs(SP), BP
+    self.Emit("MOVQ", _AX, _ARG_sp)                 // MOVQ AX, s.p<>+0(FP)
+    self.Emit("MOVQ", _AX, _IP)                     // MOVQ AX, IP
+    self.Emit("MOVQ", _BX, _ARG_sl)                 // MOVQ BX, s.l<>+8(FP)
+    self.Emit("MOVQ", _BX, _IL)                     // MOVQ BX, IL
+    self.Emit("MOVQ", _CX, _ARG_ic)                 // MOVQ CX, ic<>+16(FP)
+    self.Emit("MOVQ", _CX, _IC)                     // MOVQ CX, IC
+    self.Emit("MOVQ", _DI, _ARG_vp)                 // MOVQ DI, vp<>+24(FP)
+    self.Emit("MOVQ", _DI, _VP)                     // MOVQ DI, VP
+    self.Emit("MOVQ", _SI, _ARG_sb)                 // MOVQ SI, sb<>+32(FP)
+    self.Emit("MOVQ", _SI, _ST)                     // MOVQ SI, ST
+    self.Emit("MOVQ", _R8, _ARG_fv)                 // MOVQ R8, fv<>+40(FP)
+    self.Emit("MOVQ", jit.Imm(0), _ARG_sv_p)        // MOVQ $0, sv.p<>+48(FP)
+    self.Emit("MOVQ", jit.Imm(0), _ARG_sv_n)        // MOVQ $0, sv.n<>+56(FP)
+    self.Emit("MOVQ", jit.Imm(0), _ARG_vk)          // MOVQ $0, vk<>+64(FP)
+    self.Emit("MOVQ", jit.Imm(0), _VAR_et)          // MOVQ $0, et<>+120(FP)
+    // initialize digital buffer first
+    self.Emit("MOVQ", jit.Imm(_MaxDigitNums), _VAR_st_Dc)    // MOVQ $_MaxDigitNums, ss.Dcap
+    self.Emit("LEAQ", jit.Ptr(_ST, _DbufOffset), _AX)        // LEAQ _DbufOffset(ST), AX
+    self.Emit("MOVQ", _AX, _VAR_st_Db)                       // MOVQ AX, ss.Dbuf
+}
+
+/** Function Calling Helpers **/
+
+var (
+    _REG_go = []obj.Addr { _ST, _VP, _IP, _IL, _IC }
+    _REG_rt = []obj.Addr { _ST, _VP, _IP, _IL, _IC, _IL }
+)
+
+func (self *_Assembler) save(r ...obj.Addr) {
+    for i, v := range r {
+        if i > _FP_saves / 8 - 1 {
+            panic("too many registers to save")
+        } else {
+            self.Emit("MOVQ", v, jit.Ptr(_SP, _FP_fargs + int64(i) * 8))
+        }
+    }
+}
+
+func (self *_Assembler) load(r ...obj.Addr) {
+    for i, v := range r {
+        if i > _FP_saves / 8 - 1 {
+            panic("too many registers to load")
+        } else {
+            self.Emit("MOVQ", jit.Ptr(_SP, _FP_fargs + int64(i) * 8), v)
+        }
+    }
+}
+
+func (self *_Assembler) call(fn obj.Addr) {
+    self.Emit("MOVQ", fn, _R9)  // MOVQ ${fn}, R11
+    self.Rjmp("CALL", _R9)      // CALL R11
+}
+
+func (self *_Assembler) call_go(fn obj.Addr) {
+    self.save(_REG_go...)   // SAVE $REG_go
+    self.call(fn)
+    self.load(_REG_go...)   // LOAD $REG_go
+}
+
+func (self *_Assembler) callc(fn obj.Addr) {
+    self.Emit("XCHGQ", _IP, _BP)
+    self.call(fn)
+    self.Emit("XCHGQ", _IP, _BP)
+}
+
+func (self *_Assembler) call_c(fn obj.Addr) {
+    self.Emit("XCHGQ", _IC, _BX)
+    self.callc(fn)
+    self.Emit("XCHGQ", _IC, _BX)
+}
+
+func (self *_Assembler) call_sf(fn obj.Addr) {
+    self.Emit("LEAQ", _ARG_s, _DI)                      // LEAQ s<>+0(FP), DI
+    self.Emit("MOVQ", _IC, _ARG_ic)                     // MOVQ IC, ic<>+16(FP)
+    self.Emit("LEAQ", _ARG_ic, _SI)                     // LEAQ ic<>+16(FP), SI
+    self.Emit("LEAQ", jit.Ptr(_ST, _FsmOffset), _DX)    // LEAQ _FsmOffset(ST), DX
+    self.Emit("MOVQ", _ARG_fv, _CX)
+    self.callc(fn)
+    self.Emit("MOVQ", _ARG_ic, _IC)                     // MOVQ ic<>+16(FP), IC
+}
+
+func (self *_Assembler) call_vf(fn obj.Addr) {
+    self.Emit("LEAQ", _ARG_s, _DI)      // LEAQ s<>+0(FP), DI
+    self.Emit("MOVQ", _IC, _ARG_ic)     // MOVQ IC, ic<>+16(FP)
+    self.Emit("LEAQ", _ARG_ic, _SI)     // LEAQ ic<>+16(FP), SI
+    self.Emit("LEAQ", _VAR_st, _DX)     // LEAQ st, DX
+    self.callc(fn)
+    self.Emit("MOVQ", _ARG_ic, _IC)     // MOVQ ic<>+16(FP), IC
+}
+
+/** Assembler Error Handlers **/
+
+var (
+    _F_convT64        = jit.Func(convT64)
+    _F_error_wrap     = jit.Func(error_wrap)
+    _F_error_type     = jit.Func(error_type)
+    _F_error_field    = jit.Func(error_field)
+    _F_error_value    = jit.Func(error_value)
+    _F_error_mismatch = jit.Func(error_mismatch)
+)
+
+var (
+    _I_int8    , _T_int8    = rtype(reflect.TypeOf(int8(0)))
+    _I_int16   , _T_int16   = rtype(reflect.TypeOf(int16(0)))
+    _I_int32   , _T_int32   = rtype(reflect.TypeOf(int32(0)))
+    _I_uint8   , _T_uint8   = rtype(reflect.TypeOf(uint8(0)))
+    _I_uint16  , _T_uint16  = rtype(reflect.TypeOf(uint16(0)))
+    _I_uint32  , _T_uint32  = rtype(reflect.TypeOf(uint32(0)))
+    _I_float32 , _T_float32 = rtype(reflect.TypeOf(float32(0)))
+)
+
+var (
+    _T_error                    = rt.UnpackType(errorType)
+    _I_base64_CorruptInputError = jit.Itab(_T_error, base64CorruptInputError)
+)
+
+var (
+    _V_stackOverflow              = jit.Imm(int64(uintptr(unsafe.Pointer(&stackOverflow))))
+    _I_json_UnsupportedValueError = jit.Itab(_T_error, reflect.TypeOf(new(json.UnsupportedValueError)))
+)
+
+func (self *_Assembler) type_error() {
+    self.Link(_LB_type_error)                   // _type_error:
+    self.call_go(_F_error_type)                 // CALL_GO error_type
+    self.Sjmp("JMP" , _LB_error)                // JMP     _error
+}
+
+func (self *_Assembler) mismatch_error() {
+    self.Link(_LB_mismatch_error)               // _type_error:
+    self.Emit("MOVQ", _ARG_sp, _AX)
+    self.Emit("MOVQ", _ARG_sl, _BX)
+    self.Emit("MOVQ", _VAR_ic, _CX)
+    self.Emit("MOVQ", _VAR_et, _DI)
+    self.call_go(_F_error_mismatch)             // CALL_GO error_type
+    self.Sjmp("JMP" , _LB_error)                // JMP     _error
+}
+
+func (self *_Assembler) field_error() {
+    self.Link(_LB_field_error)                  // _field_error:
+    self.Emit("MOVQ", _ARG_sv_p, _AX)           // MOVQ   sv.p, AX
+    self.Emit("MOVQ", _ARG_sv_n, _BX)           // MOVQ   sv.n, BX
+    self.call_go(_F_error_field)                // CALL_GO error_field
+    self.Sjmp("JMP" , _LB_error)                // JMP     _error
+}
+
+func (self *_Assembler) range_error() {
+    self.Link(_LB_range_error)                  // _range_error:
+    self.Emit("MOVQ", _ET, _CX)                 // MOVQ    ET, CX
+    self.slice_from(_VAR_st_Ep, 0)              // SLICE   st.Ep, $0
+    self.Emit("MOVQ", _DI, _AX)                 // MOVQ    DI, AX
+    self.Emit("MOVQ", _EP, _DI)                 // MOVQ    EP, DI
+    self.Emit("MOVQ", _SI, _BX)                 // MOVQ    SI, BX
+    self.call_go(_F_error_value)                // CALL_GO error_value
+    self.Sjmp("JMP" , _LB_error)                // JMP     _error
+}
+
+func (self *_Assembler) stack_error() {
+    self.Link(_LB_stack_error)                              // _stack_error:
+    self.Emit("MOVQ", _V_stackOverflow, _EP)                // MOVQ ${_V_stackOverflow}, EP
+    self.Emit("MOVQ", _I_json_UnsupportedValueError, _ET)   // MOVQ ${_I_json_UnsupportedValueError}, ET
+    self.Sjmp("JMP" , _LB_error)                            // JMP  _error
+}
+
+func (self *_Assembler) base64_error() {
+    self.Link(_LB_base64_error)
+    self.Emit("NEGQ", _AX)                                  // NEGQ    AX
+    self.Emit("SUBQ", jit.Imm(1), _AX)                      // SUBQ    $1, AX
+    self.call_go(_F_convT64)                                // CALL_GO convT64
+    self.Emit("MOVQ", _AX, _EP)                             // MOVQ    AX, EP
+    self.Emit("MOVQ", _I_base64_CorruptInputError, _ET)     // MOVQ    ${itab(base64.CorruptInputError)}, ET
+    self.Sjmp("JMP" , _LB_error)                            // JMP     _error
+}
+
+func (self *_Assembler) parsing_error() {
+    self.Link(_LB_eof_error)                                            // _eof_error:
+    self.Emit("MOVQ" , _IL, _IC)                                        // MOVQ    IL, IC
+    self.Emit("MOVL" , jit.Imm(int64(types.ERR_EOF)), _EP)              // MOVL    ${types.ERR_EOF}, EP
+    self.Sjmp("JMP"  , _LB_parsing_error)                               // JMP     _parsing_error
+    self.Link(_LB_unquote_error)                                        // _unquote_error:
+    self.Emit("SUBQ" , _VAR_sr, _SI)                                    // SUBQ    sr, SI
+    self.Emit("SUBQ" , _SI, _IC)                                        // SUBQ    IL, IC
+    self.Link(_LB_parsing_error_v)                                      // _parsing_error_v:
+    self.Emit("MOVQ" , _AX, _EP)                                        // MOVQ    AX, EP
+    self.Emit("NEGQ" , _EP)                                             // NEGQ    EP
+    self.Sjmp("JMP"  , _LB_parsing_error)                               // JMP     _parsing_error
+    self.Link(_LB_char_m3_error)                                        // _char_m3_error:
+    self.Emit("SUBQ" , jit.Imm(1), _IC)                                 // SUBQ    $1, IC
+    self.Link(_LB_char_m2_error)                                        // _char_m2_error:
+    self.Emit("SUBQ" , jit.Imm(2), _IC)                                 // SUBQ    $2, IC
+    self.Sjmp("JMP"  , _LB_char_0_error)                                // JMP     _char_0_error
+    self.Link(_LB_im_error)                                             // _im_error:
+    self.Emit("CMPB" , _CX, jit.Sib(_IP, _IC, 1, 0))                    // CMPB    CX, (IP)(IC)
+    self.Sjmp("JNE"  , _LB_char_0_error)                                // JNE     _char_0_error
+    self.Emit("SHRL" , jit.Imm(8), _CX)                                 // SHRL    $8, CX
+    self.Emit("CMPB" , _CX, jit.Sib(_IP, _IC, 1, 1))                    // CMPB    CX, 1(IP)(IC)
+    self.Sjmp("JNE"  , _LB_char_1_error)                                // JNE     _char_1_error
+    self.Emit("SHRL" , jit.Imm(8), _CX)                                 // SHRL    $8, CX
+    self.Emit("CMPB" , _CX, jit.Sib(_IP, _IC, 1, 2))                    // CMPB    CX, 2(IP)(IC)
+    self.Sjmp("JNE"  , _LB_char_2_error)                                // JNE     _char_2_error
+    self.Sjmp("JMP"  , _LB_char_3_error)                                // JNE     _char_3_error
+    self.Link(_LB_char_4_error)                                         // _char_4_error:
+    self.Emit("ADDQ" , jit.Imm(1), _IC)                                 // ADDQ    $1, IC
+    self.Link(_LB_char_3_error)                                         // _char_3_error:
+    self.Emit("ADDQ" , jit.Imm(1), _IC)                                 // ADDQ    $1, IC
+    self.Link(_LB_char_2_error)                                         // _char_2_error:
+    self.Emit("ADDQ" , jit.Imm(1), _IC)                                 // ADDQ    $1, IC
+    self.Link(_LB_char_1_error)                                         // _char_1_error:
+    self.Emit("ADDQ" , jit.Imm(1), _IC)                                 // ADDQ    $1, IC
+    self.Link(_LB_char_0_error)                                         // _char_0_error:
+    self.Emit("MOVL" , jit.Imm(int64(types.ERR_INVALID_CHAR)), _EP)     // MOVL    ${types.ERR_INVALID_CHAR}, EP
+    self.Link(_LB_parsing_error)                                        // _parsing_error:
+    self.Emit("MOVQ" , _EP, _DI)                                        // MOVQ    EP, DI
+    self.Emit("MOVQ",  _ARG_sp, _AX)                                     // MOVQ  sp, AX
+    self.Emit("MOVQ",  _ARG_sl, _BX)                                     // MOVQ  sl, BX
+    self.Emit("MOVQ" , _IC, _CX)                                        // MOVQ    IC, CX
+    self.call_go(_F_error_wrap)                                         // CALL_GO error_wrap
+    self.Sjmp("JMP"  , _LB_error)                                       // JMP     _error
+}
+
+func (self *_Assembler) _asm_OP_dismatch_err(p *_Instr) {
+    self.Emit("MOVQ", _IC, _VAR_ic)      
+    self.Emit("MOVQ", jit.Type(p.vt()), _ET)     
+    self.Emit("MOVQ", _ET, _VAR_et)
+}
+
+func (self *_Assembler) _asm_OP_go_skip(p *_Instr) {
+    self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ (PC), R9
+    self.Xref(p.vi(), 4)
+    // self.Byte(0xcc)
+    self.Emit("MOVQ", _R9, _VAR_pc)
+    self.Sjmp("JMP"  , _LB_skip_one)            // JMP     _skip_one
+}
+
+func (self *_Assembler) skip_one() {
+    self.Link(_LB_skip_one)                     // _skip:
+    self.Emit("MOVQ", _VAR_ic, _IC)             // MOVQ    _VAR_ic, IC
+    self.call_sf(_F_skip_one)                   // CALL_SF skip_one
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
+    self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
+    self.Emit("MOVQ" , _VAR_pc, _R9)            // MOVQ    pc, R9
+    // self.Byte(0xcc)
+    self.Rjmp("JMP"  , _R9)                     // JMP     (R9)
+}
+
+func (self *_Assembler) skip_key_value() {
+    self.Link(_LB_skip_key_value)               // _skip:
+    // skip the key
+    self.Emit("MOVQ", _VAR_ic, _IC)             // MOVQ    _VAR_ic, IC
+    self.call_sf(_F_skip_one)                   // CALL_SF skip_one
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
+    self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
+    // match char ':'
+    self.lspace("_global_1")
+    self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(':'))
+    self.Sjmp("JNE"  , _LB_parsing_error_v)     // JNE     _parse_error_v
+    self.Emit("ADDQ", jit.Imm(1), _IC)          // ADDQ    $1, IC
+    self.lspace("_global_2")
+    // skip the value
+    self.call_sf(_F_skip_one)                   // CALL_SF skip_one
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
+    self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
+    // jump back to specified address
+    self.Emit("MOVQ" , _VAR_pc, _R9)            // MOVQ    pc, R9
+    self.Rjmp("JMP"  , _R9)                     // JMP     (R9)
+}
+
+
+/** Memory Management Routines **/
+
+var (
+    _T_byte     = jit.Type(byteType)
+    _F_mallocgc = jit.Func(mallocgc)
+)
+
+func (self *_Assembler) malloc_AX(nb obj.Addr, ret obj.Addr) {
+    self.Emit("MOVQ", nb, _AX)                  // MOVQ    ${nb}, AX
+    self.Emit("MOVQ", _T_byte, _BX)             // MOVQ    ${type(byte)}, BX
+    self.Emit("XORL", _CX, _CX)                 // XORL    CX, CX
+    self.call_go(_F_mallocgc)                   // CALL_GO mallocgc
+    self.Emit("MOVQ", _AX, ret)                 // MOVQ    AX, ${ret}
+}
+
+func (self *_Assembler) valloc(vt reflect.Type, ret obj.Addr) {
+    self.Emit("MOVQ", jit.Imm(int64(vt.Size())), _AX)   // MOVQ    ${vt.Size()}, AX
+    self.Emit("MOVQ", jit.Type(vt), _BX)                // MOVQ    ${vt}, BX
+    self.Emit("MOVB", jit.Imm(1), _CX)                  // MOVB    $1, CX
+    self.call_go(_F_mallocgc)                           // CALL_GO mallocgc
+    self.Emit("MOVQ", _AX, ret)                         // MOVQ    AX, ${ret}
+}
+
+func (self *_Assembler) valloc_AX(vt reflect.Type) {
+    self.Emit("MOVQ", jit.Imm(int64(vt.Size())), _AX)   // MOVQ    ${vt.Size()}, AX
+    self.Emit("MOVQ", jit.Type(vt), _BX)                // MOVQ    ${vt}, BX
+    self.Emit("MOVB", jit.Imm(1), _CX)                  // MOVB    $1, CX
+    self.call_go(_F_mallocgc)                           // CALL_GO mallocgc
+}
+
+func (self *_Assembler) vfollow(vt reflect.Type) {
+    self.Emit("MOVQ" , jit.Ptr(_VP, 0), _AX)    // MOVQ   (VP), AX
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ  AX, AX
+    self.Sjmp("JNZ"  , "_end_{n}")              // JNZ    _end_{n}
+    self.valloc_AX(vt)                          // VALLOC ${vt}, AX
+    self.WritePtrAX(1, jit.Ptr(_VP, 0), true)   // MOVQ   AX, (VP)
+    self.Link("_end_{n}")                       // _end_{n}:
+    self.Emit("MOVQ" , _AX, _VP)                // MOVQ   AX, VP
+}
+
+/** Value Parsing Routines **/
+
+var (
+    _F_vstring   = jit.Imm(int64(native.S_vstring))
+    _F_vnumber   = jit.Imm(int64(native.S_vnumber))
+    _F_vsigned   = jit.Imm(int64(native.S_vsigned))
+    _F_vunsigned = jit.Imm(int64(native.S_vunsigned))
+)
+
+func (self *_Assembler) check_err(vt reflect.Type, pin string, pin2 int) {
+    self.Emit("MOVQ" , _VAR_st_Vt, _AX)         // MOVQ st.Vt, AX
+    self.Emit("TESTQ", _AX, _AX)                // CMPQ AX, ${native.V_STRING}
+    // try to skip the value
+    if vt != nil {
+        self.Sjmp("JNS" , "_check_err_{n}")        // JNE  _parsing_error_v
+        self.Emit("MOVQ", jit.Type(vt), _ET)         
+        self.Emit("MOVQ", _ET, _VAR_et)
+        if pin2 != -1 {
+            self.Emit("SUBQ", jit.Imm(1), _BX)
+            self.Emit("MOVQ", _BX, _VAR_ic)
+            self.Byte(0x4c  , 0x8d, 0x0d)         // LEAQ (PC), R9
+            self.Xref(pin2, 4)
+            self.Emit("MOVQ", _R9, _VAR_pc)
+            self.Sjmp("JMP" , _LB_skip_key_value)
+        } else {
+            self.Emit("MOVQ", _BX, _VAR_ic)
+            self.Byte(0x4c  , 0x8d, 0x0d)         // LEAQ (PC), R9
+            self.Sref(pin, 4)
+            self.Emit("MOVQ", _R9, _VAR_pc)
+            self.Sjmp("JMP" , _LB_skip_one)
+        }
+        self.Link("_check_err_{n}")
+    } else {
+        self.Sjmp("JS"   , _LB_parsing_error_v)     // JNE  _parsing_error_v
+    }
+}
+
+func (self *_Assembler) check_eof(d int64) {
+    if d == 1 {
+        self.Emit("CMPQ", _IC, _IL)         // CMPQ IC, IL
+        self.Sjmp("JAE" , _LB_eof_error)    // JAE  _eof_error
+    } else {
+        self.Emit("LEAQ", jit.Ptr(_IC, d), _AX)     // LEAQ ${d}(IC), AX
+        self.Emit("CMPQ", _AX, _IL)                 // CMPQ AX, IL
+        self.Sjmp("JA"  , _LB_eof_error)            // JA   _eof_error
+    }
+}
+
+
+func (self *_Assembler) parse_string() {
+    self.Emit("MOVQ", _ARG_fv, _CX)
+    self.call_vf(_F_vstring)
+    self.check_err(nil, "", -1)
+}
+
+func (self *_Assembler) parse_number(vt reflect.Type, pin string, pin2 int) {
+    self.Emit("MOVQ", _IC, _BX)       // save ic when call native func    
+    self.call_vf(_F_vnumber)
+    self.check_err(vt, pin, pin2)
+}
+
+func (self *_Assembler) parse_signed(vt reflect.Type, pin string, pin2 int) {
+    self.Emit("MOVQ", _IC, _BX)       // save ic when call native func    
+    self.call_vf(_F_vsigned)
+    self.check_err(vt, pin, pin2)
+}
+
+func (self *_Assembler) parse_unsigned(vt reflect.Type, pin string, pin2 int) {
+    self.Emit("MOVQ", _IC, _BX)       // save ic when call native func    
+    self.call_vf(_F_vunsigned)
+    self.check_err(vt, pin, pin2)
+}
+
+// Pointer: DI, Size: SI, Return: R9  
+func (self *_Assembler) copy_string() {
+    self.Link("_copy_string")
+    self.Emit("MOVQ", _DI, _VAR_bs_p)
+    self.Emit("MOVQ", _SI, _VAR_bs_n)
+    self.Emit("MOVQ", _R9, _VAR_bs_LR)
+    self.malloc_AX(_SI, _ARG_sv_p)                              
+    self.Emit("MOVQ", _VAR_bs_p, _BX)
+    self.Emit("MOVQ", _VAR_bs_n, _CX)
+    self.call_go(_F_memmove)
+    self.Emit("MOVQ", _ARG_sv_p, _DI)
+    self.Emit("MOVQ", _VAR_bs_n, _SI)
+    self.Emit("MOVQ", _VAR_bs_LR, _R9)
+    self.Rjmp("JMP", _R9)
+}
+
+// Pointer: DI, Size: SI, Return: R9
+func (self *_Assembler) escape_string() {
+    self.Link("_escape_string")
+    self.Emit("MOVQ" , _DI, _VAR_bs_p)
+    self.Emit("MOVQ" , _SI, _VAR_bs_n)
+    self.Emit("MOVQ" , _R9, _VAR_bs_LR)
+    self.malloc_AX(_SI, _DX)                                    // MALLOC SI, DX
+    self.Emit("MOVQ" , _DX, _ARG_sv_p)
+    self.Emit("MOVQ" , _VAR_bs_p, _DI)
+    self.Emit("MOVQ" , _VAR_bs_n, _SI)                                  
+    self.Emit("LEAQ" , _VAR_sr, _CX)                            // LEAQ   sr, CX
+    self.Emit("XORL" , _R8, _R8)                                // XORL   R8, R8
+    self.Emit("BTQ"  , jit.Imm(_F_disable_urc), _ARG_fv)        // BTQ    ${_F_disable_urc}, fv
+    self.Emit("SETCC", _R8)                                     // SETCC  R8
+    self.Emit("SHLQ" , jit.Imm(types.B_UNICODE_REPLACE), _R8)   // SHLQ   ${types.B_UNICODE_REPLACE}, R8
+    self.call_c(_F_unquote)                                       // CALL   unquote
+    self.Emit("MOVQ" , _VAR_bs_n, _SI)                                  // MOVQ   ${n}, SI
+    self.Emit("ADDQ" , jit.Imm(1), _SI)                         // ADDQ   $1, SI
+    self.Emit("TESTQ", _AX, _AX)                                // TESTQ  AX, AX
+    self.Sjmp("JS"   , _LB_unquote_error)                       // JS     _unquote_error
+    self.Emit("MOVQ" , _AX, _SI)
+    self.Emit("MOVQ" , _ARG_sv_p, _DI)
+    self.Emit("MOVQ" , _VAR_bs_LR, _R9)
+    self.Rjmp("JMP", _R9)
+}
+
+func (self *_Assembler) escape_string_twice() {
+    self.Link("_escape_string_twice")
+    self.Emit("MOVQ" , _DI, _VAR_bs_p)
+    self.Emit("MOVQ" , _SI, _VAR_bs_n)
+    self.Emit("MOVQ" , _R9, _VAR_bs_LR)
+    self.malloc_AX(_SI, _DX)                                        // MALLOC SI, DX
+    self.Emit("MOVQ" , _DX, _ARG_sv_p)
+    self.Emit("MOVQ" , _VAR_bs_p, _DI)
+    self.Emit("MOVQ" , _VAR_bs_n, _SI)        
+    self.Emit("LEAQ" , _VAR_sr, _CX)                                // LEAQ   sr, CX
+    self.Emit("MOVL" , jit.Imm(types.F_DOUBLE_UNQUOTE), _R8)        // MOVL   ${types.F_DOUBLE_UNQUOTE}, R8
+    self.Emit("BTQ"  , jit.Imm(_F_disable_urc), _ARG_fv)            // BTQ    ${_F_disable_urc}, AX
+    self.Emit("XORL" , _AX, _AX)                                    // XORL   AX, AX
+    self.Emit("SETCC", _AX)                                         // SETCC  AX
+    self.Emit("SHLQ" , jit.Imm(types.B_UNICODE_REPLACE), _AX)       // SHLQ   ${types.B_UNICODE_REPLACE}, AX
+    self.Emit("ORQ"  , _AX, _R8)                                    // ORQ    AX, R8
+    self.call_c(_F_unquote)                                         // CALL   unquote
+    self.Emit("MOVQ" , _VAR_bs_n, _SI)                              // MOVQ   ${n}, SI
+    self.Emit("ADDQ" , jit.Imm(3), _SI)                             // ADDQ   $3, SI
+    self.Emit("TESTQ", _AX, _AX)                                    // TESTQ  AX, AX
+    self.Sjmp("JS"   , _LB_unquote_error)                           // JS     _unquote_error
+    self.Emit("MOVQ" , _AX, _SI)
+    self.Emit("MOVQ" , _ARG_sv_p, _DI)
+    self.Emit("MOVQ" , _VAR_bs_LR, _R9)
+    self.Rjmp("JMP", _R9)
+}
+
+/** Range Checking Routines **/
+
+var (
+    _V_max_f32 = jit.Imm(int64(uintptr(unsafe.Pointer(_Vp_max_f32))))
+    _V_min_f32 = jit.Imm(int64(uintptr(unsafe.Pointer(_Vp_min_f32))))
+)
+
+var (
+    _Vp_max_f32 = new(float64)
+    _Vp_min_f32 = new(float64)
+)
+
+func init() {
+    *_Vp_max_f32 = math.MaxFloat32
+    *_Vp_min_f32 = -math.MaxFloat32
+}
+
+func (self *_Assembler) range_single_X0() {
+    self.Emit("MOVSD"   , _VAR_st_Dv, _X0)              // MOVSD    st.Dv, X0
+    self.Emit("MOVQ"    , _V_max_f32, _CX)              // MOVQ     _max_f32, CX
+    self.Emit("MOVQ"    , jit.Gitab(_I_float32), _ET)   // MOVQ     ${itab(float32)}, ET
+    self.Emit("MOVQ"    , jit.Gtype(_T_float32), _EP)   // MOVQ     ${type(float32)}, EP
+    self.Emit("UCOMISD" , jit.Ptr(_CX, 0), _X0)         // UCOMISD  (CX), X0
+    self.Sjmp("JA"      , _LB_range_error)              // JA       _range_error
+    self.Emit("MOVQ"    , _V_min_f32, _CX)              // MOVQ     _min_f32, CX
+    self.Emit("MOVSD"   , jit.Ptr(_CX, 0), _X1)         // MOVSD    (CX), X1
+    self.Emit("UCOMISD" , _X0, _X1)                     // UCOMISD  X0, X1
+    self.Sjmp("JA"      , _LB_range_error)              // JA       _range_error
+    self.Emit("CVTSD2SS", _X0, _X0)                     // CVTSD2SS X0, X0
+}
+
+func (self *_Assembler) range_signed_CX(i *rt.GoItab, t *rt.GoType, a int64, b int64) {
+    self.Emit("MOVQ", _VAR_st_Iv, _CX)      // MOVQ st.Iv, CX
+    self.Emit("MOVQ", jit.Gitab(i), _ET)    // MOVQ ${i}, ET
+    self.Emit("MOVQ", jit.Gtype(t), _EP)    // MOVQ ${t}, EP
+    self.Emit("CMPQ", _CX, jit.Imm(a))      // CMPQ CX, ${a}
+    self.Sjmp("JL"  , _LB_range_error)      // JL   _range_error
+    self.Emit("CMPQ", _CX, jit.Imm(b))      // CMPQ CX, ${B}
+    self.Sjmp("JG"  , _LB_range_error)      // JG   _range_error
+}
+
+func (self *_Assembler) range_unsigned_CX(i *rt.GoItab, t *rt.GoType, v uint64) {
+    self.Emit("MOVQ" , _VAR_st_Iv, _CX)         // MOVQ  st.Iv, CX
+    self.Emit("MOVQ" , jit.Gitab(i), _ET)       // MOVQ  ${i}, ET
+    self.Emit("MOVQ" , jit.Gtype(t), _EP)       // MOVQ  ${t}, EP
+    self.Emit("TESTQ", _CX, _CX)                // TESTQ CX, CX
+    self.Sjmp("JS"   , _LB_range_error)         // JS    _range_error
+    self.Emit("CMPQ" , _CX, jit.Imm(int64(v)))  // CMPQ  CX, ${a}
+    self.Sjmp("JA"   , _LB_range_error)         // JA    _range_error
+}
+
+/** String Manipulating Routines **/
+
+var (
+    _F_unquote = jit.Imm(int64(native.S_unquote))
+)
+
+func (self *_Assembler) slice_from(p obj.Addr, d int64) {
+    self.Emit("MOVQ", p, _SI)   // MOVQ    ${p}, SI
+    self.slice_from_r(_SI, d)   // SLICE_R SI, ${d}
+}
+
+func (self *_Assembler) slice_from_r(p obj.Addr, d int64) {
+    self.Emit("LEAQ", jit.Sib(_IP, p, 1, 0), _DI)   // LEAQ (IP)(${p}), DI
+    self.Emit("NEGQ", p)                            // NEGQ ${p}
+    self.Emit("LEAQ", jit.Sib(_IC, p, 1, d), _SI)   // LEAQ d(IC)(${p}), SI
+}
+
+func (self *_Assembler) unquote_once(p obj.Addr, n obj.Addr, stack bool, copy bool) {
+    self.slice_from(_VAR_st_Iv, -1)                             // SLICE  st.Iv, $-1
+    self.Emit("CMPQ", _VAR_st_Ep, jit.Imm(-1))                 // CMPQ   st.Ep, $-1
+    self.Sjmp("JE"  , "_noescape_{n}")                         // JE     _escape_{n}
+    self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ (PC), R9
+    self.Sref("_unquote_once_write_{n}", 4)
+    self.Sjmp("JMP" , "_escape_string")
+    self.Link("_noescape_{n}")
+    if copy {
+        self.Emit("BTQ" , jit.Imm(_F_copy_string), _ARG_fv)    
+        self.Sjmp("JNC", "_unquote_once_write_{n}")
+        self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ (PC), R9
+        self.Sref("_unquote_once_write_{n}", 4)
+        self.Sjmp("JMP", "_copy_string")
+    }
+    self.Link("_unquote_once_write_{n}")
+    self.Emit("MOVQ", _SI, n)                                  // MOVQ   SI, ${n}
+    if stack {
+        self.Emit("MOVQ", _DI, p) 
+    } else {
+        self.WriteRecNotAX(10, _DI, p, false, false)
+    }
+}
+
+func (self *_Assembler) unquote_twice(p obj.Addr, n obj.Addr, stack bool) {
+    self.Emit("CMPQ" , _VAR_st_Ep, jit.Imm(-1))                     // CMPQ   st.Ep, $-1
+    self.Sjmp("JE"   , _LB_eof_error)                               // JE     _eof_error
+    self.Emit("CMPB" , jit.Sib(_IP, _IC, 1, -3), jit.Imm('\\'))     // CMPB   -3(IP)(IC), $'\\'
+    self.Sjmp("JNE"  , _LB_char_m3_error)                           // JNE    _char_m3_error
+    self.Emit("CMPB" , jit.Sib(_IP, _IC, 1, -2), jit.Imm('"'))      // CMPB   -2(IP)(IC), $'"'
+    self.Sjmp("JNE"  , _LB_char_m2_error)                           // JNE    _char_m2_error
+    self.slice_from(_VAR_st_Iv, -3)                                 // SLICE  st.Iv, $-3
+    self.Emit("MOVQ" , _SI, _AX)                                    // MOVQ   SI, AX
+    self.Emit("ADDQ" , _VAR_st_Iv, _AX)                             // ADDQ   st.Iv, AX
+    self.Emit("CMPQ" , _VAR_st_Ep, _AX)                             // CMPQ   st.Ep, AX
+    self.Sjmp("JE"   , "_noescape_{n}")                             // JE     _noescape_{n}
+    self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ (PC), R9
+    self.Sref("_unquote_twice_write_{n}", 4)
+    self.Sjmp("JMP" , "_escape_string_twice")
+    self.Link("_noescape_{n}")                                      // _noescape_{n}:
+    self.Emit("BTQ"  , jit.Imm(_F_copy_string), _ARG_fv)    
+    self.Sjmp("JNC", "_unquote_twice_write_{n}") 
+    self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ (PC), R9
+    self.Sref("_unquote_twice_write_{n}", 4)
+    self.Sjmp("JMP", "_copy_string")
+    self.Link("_unquote_twice_write_{n}")
+    self.Emit("MOVQ" , _SI, n)                                      // MOVQ   SI, ${n}
+    if stack {
+        self.Emit("MOVQ", _DI, p) 
+    } else {
+        self.WriteRecNotAX(12, _DI, p, false, false)
+    }
+    self.Link("_unquote_twice_end_{n}")
+}
+
+/** Memory Clearing Routines **/
+
+var (
+    _F_memclrHasPointers    = jit.Func(memclrHasPointers)
+    _F_memclrNoHeapPointers = jit.Func(memclrNoHeapPointers)
+)
+
+func (self *_Assembler) mem_clear_fn(ptrfree bool) {
+    if !ptrfree {
+        self.call_go(_F_memclrHasPointers)
+    } else {
+        self.call_go(_F_memclrNoHeapPointers)
+    }
+}
+
+func (self *_Assembler) mem_clear_rem(size int64, ptrfree bool) {
+    self.Emit("MOVQ", jit.Imm(size), _BX)               // MOVQ    ${size}, BX
+    self.Emit("MOVQ", jit.Ptr(_ST, 0), _AX)             // MOVQ    (ST), AX
+    self.Emit("MOVQ", jit.Sib(_ST, _AX, 1, 0), _AX)     // MOVQ    (ST)(AX), AX
+    self.Emit("SUBQ", _VP, _AX)                         // SUBQ    VP, AX
+    self.Emit("ADDQ", _AX, _BX)                         // ADDQ    AX, BX
+    self.Emit("MOVQ", _VP, _AX)                         // MOVQ    VP, (SP)
+    self.mem_clear_fn(ptrfree)                          // CALL_GO memclr{Has,NoHeap}Pointers
+}
+
+/** Map Assigning Routines **/
+
+var (
+    _F_mapassign           = jit.Func(mapassign)
+    _F_mapassign_fast32    = jit.Func(mapassign_fast32)
+    _F_mapassign_faststr   = jit.Func(mapassign_faststr)
+    _F_mapassign_fast64ptr = jit.Func(mapassign_fast64ptr)
+)
+
+var (
+    _F_decodeJsonUnmarshaler obj.Addr
+    _F_decodeTextUnmarshaler obj.Addr
+)
+
+func init() {
+    _F_decodeJsonUnmarshaler = jit.Func(decodeJsonUnmarshaler)
+    _F_decodeTextUnmarshaler = jit.Func(decodeTextUnmarshaler)
+}
+
+func (self *_Assembler) mapaccess_ptr(t reflect.Type) {
+    if rt.MapType(rt.UnpackType(t)).IndirectElem() {
+        self.vfollow(t.Elem())
+    }
+}
+
+func (self *_Assembler) mapassign_std(t reflect.Type, v obj.Addr) {
+    self.Emit("LEAQ", v, _AX)               // LEAQ      ${v}, AX
+    self.mapassign_call_from_AX(t, _F_mapassign)    // MAPASSIGN ${t}, mapassign
+}
+
+func (self *_Assembler) mapassign_str_fast(t reflect.Type, p obj.Addr, n obj.Addr) {
+    self.Emit("MOVQ", jit.Type(t), _AX)         // MOVQ    ${t}, AX
+    self.Emit("MOVQ", _VP, _BX)                 // MOVQ    VP, BX
+    self.Emit("MOVQ", p, _CX)                   // MOVQ    ${p}, CX
+    self.Emit("MOVQ", n, _DI)                   // MOVQ    ${n}, DI
+    self.call_go(_F_mapassign_faststr)          // CALL_GO ${fn}
+    self.Emit("MOVQ", _AX, _VP)                 // MOVQ    AX, VP
+    self.mapaccess_ptr(t)
+}
+
+func (self *_Assembler) mapassign_call_from_AX(t reflect.Type, fn obj.Addr) {
+    self.Emit("MOVQ", _AX, _CX)
+    self.Emit("MOVQ", jit.Type(t), _AX)         // MOVQ    ${t}, AX
+    self.Emit("MOVQ", _VP, _BX)                 // MOVQ    VP, _BX
+    self.call_go(fn)                            // CALL_GO ${fn}
+    self.Emit("MOVQ", _AX, _VP)                 // MOVQ    AX, VP
+}
+
+func (self *_Assembler) mapassign_fastx(t reflect.Type, fn obj.Addr) {
+    self.mapassign_call_from_AX(t, fn)
+    self.mapaccess_ptr(t)
+}
+
+func (self *_Assembler) mapassign_utext(t reflect.Type, addressable bool) {
+    pv := false
+    vk := t.Key()
+    tk := t.Key()
+
+    /* deref pointer if needed */
+    if vk.Kind() == reflect.Ptr {
+        pv = true
+        vk = vk.Elem()
+    }
+
+    /* addressable value with pointer receiver */
+    if addressable {
+        pv = false
+        tk = reflect.PtrTo(tk)
+    }
+
+    /* allocate the key, and call the unmarshaler */
+    self.valloc(vk, _BX)                        // VALLOC  ${vk}, BX
+    // must spill vk pointer since next call_go may invoke GC
+    self.Emit("MOVQ" , _BX, _ARG_vk)
+    self.Emit("MOVQ" , jit.Type(tk), _AX)       // MOVQ    ${tk}, AX
+    self.Emit("MOVQ" , _ARG_sv_p, _CX)          // MOVQ    sv.p, CX
+    self.Emit("MOVQ" , _ARG_sv_n, _DI)          // MOVQ    sv.n, DI
+    self.call_go(_F_decodeTextUnmarshaler)      // CALL_GO decodeTextUnmarshaler
+    self.Emit("TESTQ", _ET, _ET)                // TESTQ   ET, ET
+    self.Sjmp("JNZ"  , _LB_error)               // JNZ     _error
+    self.Emit("MOVQ" , _ARG_vk, _AX)            // MOVQ    VAR.vk, AX
+    self.Emit("MOVQ", jit.Imm(0), _ARG_vk)
+
+    /* select the correct assignment function */
+    if !pv {
+        self.mapassign_call_from_AX(t, _F_mapassign)
+    } else {
+        self.mapassign_fastx(t, _F_mapassign_fast64ptr)
+    }
+}
+
+/** External Unmarshaler Routines **/
+
+var (
+    _F_skip_one = jit.Imm(int64(native.S_skip_one))
+    _F_skip_array  = jit.Imm(int64(native.S_skip_array))
+    _F_skip_object = jit.Imm(int64(native.S_skip_object))
+    _F_skip_number = jit.Imm(int64(native.S_skip_number))
+)
+
+func (self *_Assembler) unmarshal_json(t reflect.Type, deref bool) {
+    self.call_sf(_F_skip_one)                                   // CALL_SF   skip_one
+    self.Emit("TESTQ", _AX, _AX)                                // TESTQ     AX, AX
+    self.Sjmp("JS"   , _LB_parsing_error_v)                     // JS        _parse_error_v
+    self.slice_from_r(_AX, 0)                                   // SLICE_R   AX, $0
+    self.Emit("MOVQ" , _DI, _ARG_sv_p)                          // MOVQ      DI, sv.p
+    self.Emit("MOVQ" , _SI, _ARG_sv_n)                          // MOVQ      SI, sv.n
+    self.unmarshal_func(t, _F_decodeJsonUnmarshaler, deref)     // UNMARSHAL json, ${t}, ${deref}
+}
+
+func (self *_Assembler) unmarshal_text(t reflect.Type, deref bool) {
+    self.parse_string()                                         // PARSE     STRING
+    self.unquote_once(_ARG_sv_p, _ARG_sv_n, true, true)        // UNQUOTE   once, sv.p, sv.n
+    self.unmarshal_func(t, _F_decodeTextUnmarshaler, deref)     // UNMARSHAL text, ${t}, ${deref}
+}
+
+func (self *_Assembler) unmarshal_func(t reflect.Type, fn obj.Addr, deref bool) {
+    pt := t
+    vk := t.Kind()
+
+    /* allocate the field if needed */
+    if deref && vk == reflect.Ptr {
+        self.Emit("MOVQ" , _VP, _BX)                // MOVQ   VP, BX
+        self.Emit("MOVQ" , jit.Ptr(_BX, 0), _BX)    // MOVQ   (BX), BX
+        self.Emit("TESTQ", _BX, _BX)                // TESTQ  BX, BX
+        self.Sjmp("JNZ"  , "_deref_{n}")            // JNZ    _deref_{n}
+        self.valloc(t.Elem(), _BX)                  // VALLOC ${t.Elem()}, BX
+        self.WriteRecNotAX(3, _BX, jit.Ptr(_VP, 0), false, false)    // MOVQ   BX, (VP)
+        self.Link("_deref_{n}")                     // _deref_{n}:
+    } else {
+        /* set value pointer */
+        self.Emit("MOVQ", _VP, _BX)                 // MOVQ   (VP), BX
+    }
+
+    /* set value type */
+    self.Emit("MOVQ", jit.Type(pt), _AX)        // MOVQ ${pt}, AX
+
+    /* set the source string and call the unmarshaler */
+    self.Emit("MOVQ" , _ARG_sv_p, _CX)          // MOVQ    sv.p, CX
+    self.Emit("MOVQ" , _ARG_sv_n, _DI)          // MOVQ    sv.n, DI
+    self.call_go(fn)                            // CALL_GO ${fn}
+    self.Emit("TESTQ", _ET, _ET)                // TESTQ   ET, ET
+    self.Sjmp("JNZ"  , _LB_error)               // JNZ     _error
+}
+
+/** Dynamic Decoding Routine **/
+
+var (
+    _F_decodeTypedPointer obj.Addr
+)
+
+func init() {
+    _F_decodeTypedPointer = jit.Func(decodeTypedPointer)
+}
+
+func (self *_Assembler) decode_dynamic(vt obj.Addr, vp obj.Addr) {
+    self.Emit("MOVQ" , vp, _SI)    // MOVQ    ${vp}, SI
+    self.Emit("MOVQ" , vt, _DI)    // MOVQ    ${vt}, DI
+    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" , _ARG_fv, _R9)            // MOVQ    fv, R9
+    self.save(_REG_rt...)
+    self.Emit("MOVQ", _F_decodeTypedPointer, _IL)  // MOVQ ${fn}, R11
+    self.Rjmp("CALL", _IL)      // CALL R11
+    self.load(_REG_rt...)
+    self.Emit("MOVQ" , _AX, _IC)                // MOVQ    AX, IC
+    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
+}
+
+/** OpCode Assembler Functions **/
+
+var (
+    _F_memequal         = jit.Func(memequal)
+    _F_memmove          = jit.Func(memmove)
+    _F_growslice        = jit.Func(growslice)
+    _F_makeslice        = jit.Func(makeslice)
+    _F_makemap_small    = jit.Func(makemap_small)
+    _F_mapassign_fast64 = jit.Func(mapassign_fast64)
+)
+
+var (
+    _F_lspace  = jit.Imm(int64(native.S_lspace))
+    _F_strhash = jit.Imm(int64(caching.S_strhash))
+)
+
+var (
+    _F_b64decode   = jit.Imm(int64(_subr__b64decode))
+    _F_decodeValue = jit.Imm(int64(_subr_decode_value))
+)
+
+var (
+    _F_FieldMap_GetCaseInsensitive obj.Addr
+)
+
+const (
+    _MODE_AVX2 = 1 << 2
+)
+
+const (
+    _Fe_ID   = int64(unsafe.Offsetof(caching.FieldEntry{}.ID))
+    _Fe_Name = int64(unsafe.Offsetof(caching.FieldEntry{}.Name))
+    _Fe_Hash = int64(unsafe.Offsetof(caching.FieldEntry{}.Hash))
+)
+
+const (
+    _Vk_Ptr       = int64(reflect.Ptr)
+    _Gt_KindFlags = int64(unsafe.Offsetof(rt.GoType{}.KindFlags))
+)
+
+func init() {
+    _F_FieldMap_GetCaseInsensitive = jit.Func((*caching.FieldMap).GetCaseInsensitive)
+}
+
+func (self *_Assembler) _asm_OP_any(_ *_Instr) {
+    self.Emit("MOVQ"   , jit.Ptr(_VP, 8), _CX)              // MOVQ    8(VP), CX
+    self.Emit("TESTQ"  , _CX, _CX)                          // TESTQ   CX, CX
+    self.Sjmp("JZ"     , "_decode_{n}")                     // JZ      _decode_{n}
+    self.Emit("CMPQ"   , _CX, _VP)                          // CMPQ    CX, VP
+    self.Sjmp("JE"     , "_decode_{n}")                     // JE      _decode_{n}
+    self.Emit("MOVQ"   , jit.Ptr(_VP, 0), _AX)              // MOVQ    (VP), AX
+    self.Emit("MOVBLZX", jit.Ptr(_AX, _Gt_KindFlags), _DX)  // MOVBLZX _Gt_KindFlags(AX), DX
+    self.Emit("ANDL"   , jit.Imm(rt.F_kind_mask), _DX)      // ANDL    ${F_kind_mask}, DX
+    self.Emit("CMPL"   , _DX, jit.Imm(_Vk_Ptr))             // CMPL    DX, ${reflect.Ptr}
+    self.Sjmp("JNE"    , "_decode_{n}")                     // JNE     _decode_{n}
+    self.Emit("LEAQ"   , jit.Ptr(_VP, 8), _DI)              // LEAQ    8(VP), DI
+    self.decode_dynamic(_AX, _DI)                           // DECODE  AX, DI
+    self.Sjmp("JMP"    , "_decode_end_{n}")                 // JMP     _decode_end_{n}
+    self.Link("_decode_{n}")                                // _decode_{n}:
+    self.Emit("MOVQ"   , _ARG_fv, _DF)                      // MOVQ    fv, DF
+    self.Emit("MOVQ"   , _ST, jit.Ptr(_SP, 0))              // MOVQ    _ST, (SP)
+    self.call(_F_decodeValue)                               // CALL    decodeValue
+    self.Emit("MOVQ"   , jit.Imm(0), jit.Ptr(_SP, 0))              // MOVQ    _ST, (SP)
+    self.Emit("TESTQ"  , _EP, _EP)                          // TESTQ   EP, EP
+    self.Sjmp("JNZ"    , _LB_parsing_error)                 // JNZ     _parsing_error
+    self.Link("_decode_end_{n}")                            // _decode_end_{n}:
+}
+
+func (self *_Assembler) _asm_OP_dyn(p *_Instr) {
+    self.Emit("MOVQ"   , jit.Type(p.vt()), _ET)             // MOVQ    ${p.vt()}, ET
+    self.Emit("CMPQ"   , jit.Ptr(_VP, 8), jit.Imm(0))       // CMPQ    8(VP), $0
+    self.Sjmp("JE"     , _LB_type_error)                    // JE      _type_error
+    self.Emit("MOVQ"   , jit.Ptr(_VP, 0), _CX)              // MOVQ    (VP), CX
+    self.Emit("MOVQ"   , jit.Ptr(_CX, 8), _CX)              // MOVQ    8(CX), CX
+    self.Emit("MOVBLZX", jit.Ptr(_CX, _Gt_KindFlags), _DX)  // MOVBLZX _Gt_KindFlags(CX), DX
+    self.Emit("ANDL"   , jit.Imm(rt.F_kind_mask), _DX)      // ANDL    ${F_kind_mask}, DX
+    self.Emit("CMPL"   , _DX, jit.Imm(_Vk_Ptr))             // CMPL    DX, ${reflect.Ptr}
+    self.Sjmp("JNE"    , _LB_type_error)                    // JNE     _type_error
+    self.Emit("LEAQ"   , jit.Ptr(_VP, 8), _DI)              // LEAQ    8(VP), DI
+    self.decode_dynamic(_CX, _DI)                           // DECODE  CX, DI
+    self.Link("_decode_end_{n}")                            // _decode_end_{n}:
+}
+
+func (self *_Assembler) _asm_OP_str(_ *_Instr) {
+    self.parse_string()                                     // PARSE   STRING
+    self.unquote_once(jit.Ptr(_VP, 0), jit.Ptr(_VP, 8), false, true)     // UNQUOTE once, (VP), 8(VP)
+}
+
+func (self *_Assembler) _asm_OP_bin(_ *_Instr) {
+    self.parse_string()                                 // PARSE  STRING
+    self.slice_from(_VAR_st_Iv, -1)                     // SLICE  st.Iv, $-1
+    self.Emit("MOVQ" , _DI, jit.Ptr(_VP, 0))            // MOVQ   DI, (VP)
+    self.Emit("MOVQ" , _SI, jit.Ptr(_VP, 8))            // MOVQ   SI, 8(VP)
+    self.Emit("SHRQ" , jit.Imm(2), _SI)                 // SHRQ   $2, SI
+    self.Emit("LEAQ" , jit.Sib(_SI, _SI, 2, 0), _SI)    // LEAQ   (SI)(SI*2), SI
+    self.Emit("MOVQ" , _SI, jit.Ptr(_VP, 16))           // MOVQ   SI, 16(VP)
+    self.malloc_AX(_SI, _SI)                               // MALLOC SI, SI
+
+    // TODO: due to base64x's bug, only use AVX mode now
+    self.Emit("MOVL", jit.Imm(_MODE_JSON), _CX)          //  MOVL $_MODE_JSON, CX
+
+    /* call the decoder */
+    self.Emit("XORL" , _DX, _DX)                // XORL  DX, DX
+    self.Emit("MOVQ" , _VP, _DI)                // MOVQ  VP, DI
+
+    self.Emit("MOVQ" , jit.Ptr(_VP, 0), _R8)    // MOVQ SI, （VP)
+    self.WriteRecNotAX(4, _SI, jit.Ptr(_VP, 0), true, false)    // XCHGQ SI, (VP) 
+    self.Emit("MOVQ" , _R8, _SI)
+
+    self.Emit("XCHGQ", _DX, jit.Ptr(_VP, 8))    // XCHGQ DX, 8(VP)
+    self.call_c(_F_b64decode)                     // CALL  b64decode
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ AX, AX
+    self.Sjmp("JS"   , _LB_base64_error)        // JS    _base64_error
+    self.Emit("MOVQ" , _AX, jit.Ptr(_VP, 8))    // MOVQ  AX, 8(VP)
+}
+
+func (self *_Assembler) _asm_OP_bool(_ *_Instr) {
+    self.Emit("LEAQ", jit.Ptr(_IC, 4), _AX)                     // LEAQ 4(IC), AX
+    self.Emit("CMPQ", _AX, _IL)                                 // CMPQ AX, IL
+    self.Sjmp("JA"  , _LB_eof_error)                            // JA   _eof_error
+    self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm('f'))    // CMPB (IP)(IC), $'f'
+    self.Sjmp("JE"  , "_false_{n}")                             // JE   _false_{n}
+    self.Emit("MOVL", jit.Imm(_IM_true), _CX)                   // MOVL $"true", CX
+    self.Emit("CMPL", _CX, jit.Sib(_IP, _IC, 1, 0))             // CMPL CX, (IP)(IC)
+    self.Sjmp("JE" , "_bool_true_{n}")          
+    // try to skip the value
+    self.Emit("MOVQ", _IC, _VAR_ic)           
+    self.Emit("MOVQ", _T_bool, _ET)     
+    self.Emit("MOVQ", _ET, _VAR_et)
+    self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ (PC), R9
+    self.Sref("_end_{n}", 4)
+    self.Emit("MOVQ", _R9, _VAR_pc)
+    self.Sjmp("JMP"  , _LB_skip_one) 
+
+    self.Link("_bool_true_{n}")
+    self.Emit("MOVQ", _AX, _IC)                                 // MOVQ AX, IC
+    self.Emit("MOVB", jit.Imm(1), jit.Ptr(_VP, 0))              // MOVB $1, (VP)
+    self.Sjmp("JMP" , "_end_{n}")                               // JMP  _end_{n}
+    self.Link("_false_{n}")                                     // _false_{n}:
+    self.Emit("ADDQ", jit.Imm(1), _AX)                          // ADDQ $1, AX
+    self.Emit("ADDQ", jit.Imm(1), _IC)                          // ADDQ $1, IC
+    self.Emit("CMPQ", _AX, _IL)                                 // CMPQ AX, IL
+    self.Sjmp("JA"  , _LB_eof_error)                            // JA   _eof_error
+    self.Emit("MOVL", jit.Imm(_IM_alse), _CX)                   // MOVL $"alse", CX
+    self.Emit("CMPL", _CX, jit.Sib(_IP, _IC, 1, 0))             // CMPL CX, (IP)(IC)
+    self.Sjmp("JNE" , _LB_im_error)                             // JNE  _im_error
+    self.Emit("MOVQ", _AX, _IC)                                 // MOVQ AX, IC
+    self.Emit("XORL", _AX, _AX)                                 // XORL AX, AX
+    self.Emit("MOVB", _AX, jit.Ptr(_VP, 0))                     // MOVB AX, (VP)
+    self.Link("_end_{n}")                                       // _end_{n}:
+}
+
+func (self *_Assembler) _asm_OP_num(_ *_Instr) {
+    self.Emit("MOVQ", jit.Imm(0), _VAR_fl)
+    self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm('"'))
+    self.Emit("MOVQ", _IC, _BX)
+    self.Sjmp("JNE", "_skip_number_{n}")
+    self.Emit("MOVQ", jit.Imm(1), _VAR_fl)
+    self.Emit("ADDQ", jit.Imm(1), _IC)
+    self.Link("_skip_number_{n}")
+
+    /* call skip_number */
+    self.Emit("LEAQ", _ARG_s, _DI)                      // LEAQ  s<>+0(FP), DI
+    self.Emit("MOVQ", _IC, _ARG_ic)                     // MOVQ  IC, ic<>+16(FP)
+    self.Emit("LEAQ", _ARG_ic, _SI)                     // LEAQ  ic<>+16(FP), SI
+    self.callc(_F_skip_number)                          // CALL  _F_skip_number
+    self.Emit("MOVQ", _ARG_ic, _IC)                     // MOVQ  ic<>+16(FP), IC
+    self.Emit("TESTQ", _AX, _AX)                        // TESTQ AX, AX
+    self.Sjmp("JNS"   , "_num_next_{n}")
+
+    /* call skip one */
+    self.Emit("MOVQ", _BX, _VAR_ic)           
+    self.Emit("MOVQ", _T_number, _ET)     
+    self.Emit("MOVQ", _ET, _VAR_et)
+    self.Byte(0x4c, 0x8d, 0x0d)       
+    self.Sref("_num_end_{n}", 4)
+    self.Emit("MOVQ", _R9, _VAR_pc)
+    self.Sjmp("JMP"  , _LB_skip_one)
+
+    /* assgin string */
+    self.Link("_num_next_{n}")
+    self.slice_from_r(_AX, 0)
+    self.Emit("BTQ", jit.Imm(_F_copy_string), _ARG_fv)
+    self.Sjmp("JNC", "_num_write_{n}")
+    self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ (PC), R9
+    self.Sref("_num_write_{n}", 4)
+    self.Sjmp("JMP", "_copy_string")
+    self.Link("_num_write_{n}")
+    self.Emit("MOVQ", _SI, jit.Ptr(_VP, 8))     // MOVQ  SI, 8(VP)
+    self.WriteRecNotAX(13, _DI, jit.Ptr(_VP, 0), false, false)
+    self.Emit("CMPQ", _VAR_fl, jit.Imm(1))
+    self.Sjmp("JNE", "_num_end_{n}")
+    self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm('"'))
+    self.Sjmp("JNE", _LB_char_0_error)
+    self.Emit("ADDQ", jit.Imm(1), _IC)
+    self.Link("_num_end_{n}")
+}
+
+func (self *_Assembler) _asm_OP_i8(_ *_Instr) {
+    var pin = "_i8_end_{n}"
+    self.parse_signed(int8Type, pin, -1)                                                 // PARSE int8
+    self.range_signed_CX(_I_int8, _T_int8, math.MinInt8, math.MaxInt8)     // RANGE int8
+    self.Emit("MOVB", _CX, jit.Ptr(_VP, 0))                             // MOVB  CX, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_i16(_ *_Instr) {
+    var pin = "_i16_end_{n}"
+    self.parse_signed(int16Type, pin, -1)                                                     // PARSE int16
+    self.range_signed_CX(_I_int16, _T_int16, math.MinInt16, math.MaxInt16)     // RANGE int16
+    self.Emit("MOVW", _CX, jit.Ptr(_VP, 0))                                 // MOVW  CX, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_i32(_ *_Instr) {
+    var pin = "_i32_end_{n}"
+    self.parse_signed(int32Type, pin, -1)                                                     // PARSE int32
+    self.range_signed_CX(_I_int32, _T_int32, math.MinInt32, math.MaxInt32)     // RANGE int32
+    self.Emit("MOVL", _CX, jit.Ptr(_VP, 0))                                 // MOVL  CX, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_i64(_ *_Instr) {
+    var pin = "_i64_end_{n}"
+    self.parse_signed(int64Type, pin, -1)                         // PARSE int64
+    self.Emit("MOVQ", _VAR_st_Iv, _AX)          // MOVQ  st.Iv, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_VP, 0))     // MOVQ  AX, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_u8(_ *_Instr) {
+    var pin = "_u8_end_{n}"
+    self.parse_unsigned(uint8Type, pin, -1)                                   // PARSE uint8
+    self.range_unsigned_CX(_I_uint8, _T_uint8, math.MaxUint8)  // RANGE uint8
+    self.Emit("MOVB", _CX, jit.Ptr(_VP, 0))                 // MOVB  CX, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_u16(_ *_Instr) {
+    var pin = "_u16_end_{n}"
+    self.parse_unsigned(uint16Type, pin, -1)                                       // PARSE uint16
+    self.range_unsigned_CX(_I_uint16, _T_uint16, math.MaxUint16)   // RANGE uint16
+    self.Emit("MOVW", _CX, jit.Ptr(_VP, 0))                     // MOVW  CX, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_u32(_ *_Instr) {
+    var pin = "_u32_end_{n}"
+    self.parse_unsigned(uint32Type, pin, -1)                                       // PARSE uint32
+    self.range_unsigned_CX(_I_uint32, _T_uint32, math.MaxUint32)   // RANGE uint32
+    self.Emit("MOVL", _CX, jit.Ptr(_VP, 0))                     // MOVL  CX, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_u64(_ *_Instr) {
+    var pin = "_u64_end_{n}"
+    self.parse_unsigned(uint64Type, pin, -1)                       // PARSE uint64
+    self.Emit("MOVQ", _VAR_st_Iv, _AX)          // MOVQ  st.Iv, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_VP, 0))     // MOVQ  AX, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_f32(_ *_Instr) {
+    var pin = "_f32_end_{n}"
+    self.parse_number(float32Type, pin, -1)                         // PARSE NUMBER
+    self.range_single_X0()                         // RANGE float32
+    self.Emit("MOVSS", _X0, jit.Ptr(_VP, 0))    // MOVSS X0, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_f64(_ *_Instr) {
+    var pin = "_f64_end_{n}"
+    self.parse_number(float64Type, pin, -1)                         // PARSE NUMBER
+    self.Emit("MOVSD", _VAR_st_Dv, _X0)         // MOVSD st.Dv, X0
+    self.Emit("MOVSD", _X0, jit.Ptr(_VP, 0))    // MOVSD X0, (VP)
+    self.Link(pin)
+}
+
+func (self *_Assembler) _asm_OP_unquote(_ *_Instr) {
+    self.check_eof(2)
+    self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm('\\'))   // CMPB    (IP)(IC), $'\\'
+    self.Sjmp("JNE" , _LB_char_0_error)                         // JNE     _char_0_error
+    self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 1), jit.Imm('"'))    // CMPB    1(IP)(IC), $'"'
+    self.Sjmp("JNE" , _LB_char_1_error)                         // JNE     _char_1_error
+    self.Emit("ADDQ", jit.Imm(2), _IC)                          // ADDQ    $2, IC
+    self.parse_string()                                         // PARSE   STRING
+    self.unquote_twice(jit.Ptr(_VP, 0), jit.Ptr(_VP, 8), false)        // UNQUOTE twice, (VP), 8(VP)
+}
+
+func (self *_Assembler) _asm_OP_nil_1(_ *_Instr) {
+    self.Emit("XORL", _AX, _AX)                 // XORL AX, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_VP, 0))     // MOVQ AX, (VP)
+}
+
+func (self *_Assembler) _asm_OP_nil_2(_ *_Instr) {
+    self.Emit("PXOR" , _X0, _X0)                // PXOR  X0, X0
+    self.Emit("MOVOU", _X0, jit.Ptr(_VP, 0))    // MOVOU X0, (VP)
+}
+
+func (self *_Assembler) _asm_OP_nil_3(_ *_Instr) {
+    self.Emit("XORL" , _AX, _AX)                // XORL  AX, AX
+    self.Emit("PXOR" , _X0, _X0)                // PXOR  X0, X0
+    self.Emit("MOVOU", _X0, jit.Ptr(_VP, 0))    // MOVOU X0, (VP)
+    self.Emit("MOVQ" , _AX, jit.Ptr(_VP, 16))   // MOVOU AX, 16(VP)
+}
+
+func (self *_Assembler) _asm_OP_deref(p *_Instr) {
+    self.vfollow(p.vt())
+}
+
+func (self *_Assembler) _asm_OP_index(p *_Instr) {
+    self.Emit("MOVQ", jit.Imm(p.i64()), _AX)    // MOVQ ${p.vi()}, AX
+    self.Emit("ADDQ", _AX, _VP)                 // ADDQ _AX, _VP
+}
+
+func (self *_Assembler) _asm_OP_is_null(p *_Instr) {
+    self.Emit("LEAQ"   , jit.Ptr(_IC, 4), _AX)                          // LEAQ    4(IC), AX
+    self.Emit("CMPQ"   , _AX, _IL)                                      // CMPQ    AX, IL
+    self.Sjmp("JA"     , "_not_null_{n}")                               // JA      _not_null_{n}
+    self.Emit("CMPL"   , jit.Sib(_IP, _IC, 1, 0), jit.Imm(_IM_null))    // CMPL    (IP)(IC), $"null"
+    self.Emit("CMOVQEQ", _AX, _IC)                                      // CMOVQEQ AX, IC
+    self.Xjmp("JE"     , p.vi())                                        // JE      {p.vi()}
+    self.Link("_not_null_{n}")                                          // _not_null_{n}:
+}
+
+func (self *_Assembler) _asm_OP_is_null_quote(p *_Instr) {
+    self.Emit("LEAQ"   , jit.Ptr(_IC, 5), _AX)                          // LEAQ    4(IC), AX
+    self.Emit("CMPQ"   , _AX, _IL)                                      // CMPQ    AX, IL
+    self.Sjmp("JA"     , "_not_null_quote_{n}")                         // JA      _not_null_quote_{n}
+    self.Emit("CMPL"   , jit.Sib(_IP, _IC, 1, 0), jit.Imm(_IM_null))    // CMPL    (IP)(IC), $"null"
+    self.Sjmp("JNE"    , "_not_null_quote_{n}")                         // JNE     _not_null_quote_{n}
+    self.Emit("CMPB"   , jit.Sib(_IP, _IC, 1, 4), jit.Imm('"'))         // CMPB    4(IP)(IC), $'"'
+    self.Emit("CMOVQEQ", _AX, _IC)                                      // CMOVQEQ AX, IC
+    self.Xjmp("JE"     , p.vi())                                        // JE      {p.vi()}
+    self.Link("_not_null_quote_{n}")                                    // _not_null_quote_{n}:
+}
+
+func (self *_Assembler) _asm_OP_map_init(_ *_Instr) {
+    self.Emit("MOVQ" , jit.Ptr(_VP, 0), _AX)    // MOVQ    (VP), AX
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
+    self.Sjmp("JNZ"  , "_end_{n}")              // JNZ     _end_{n}
+    self.call_go(_F_makemap_small)              // CALL_GO makemap_small
+    self.WritePtrAX(6, jit.Ptr(_VP, 0), false)    // MOVQ    AX, (VP)
+    self.Link("_end_{n}")                       // _end_{n}:
+    self.Emit("MOVQ" , _AX, _VP)                // MOVQ    AX, VP
+}
+
+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.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.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
+    if vt := p.vt(); !mapfast(vt) {
+        self.mapassign_std(vt, _VAR_st_Iv)                                  // MAPASSIGN int32, mapassign, st.Iv
+    } else {
+        self.Emit("MOVQ", _CX, _AX)                                         // MOVQ CX, AX
+        self.mapassign_fastx(vt, _F_mapassign_fast32)                       // MAPASSIGN int32, mapassign_fast32
+    }
+}
+
+func (self *_Assembler) _asm_OP_map_key_i64(p *_Instr) {
+    self.parse_signed(int64Type, "", p.vi())                                 // PARSE     int64
+    if vt := p.vt(); !mapfast(vt) {
+        self.mapassign_std(vt, _VAR_st_Iv)              // MAPASSIGN int64, mapassign, st.Iv
+    } else {
+        self.Emit("MOVQ", _VAR_st_Iv, _AX)              // MOVQ      st.Iv, AX
+        self.mapassign_fastx(vt, _F_mapassign_fast64)   // MAPASSIGN int64, mapassign_fast64
+    }
+}
+
+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
+}
+
+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.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
+    if vt := p.vt(); !mapfast(vt) {
+        self.mapassign_std(vt, _VAR_st_Iv)                      // MAPASSIGN uint32, vt.Iv
+    } else {
+        self.Emit("MOVQ", _CX, _AX)                             // MOVQ CX, AX
+        self.mapassign_fastx(vt, _F_mapassign_fast32)           // MAPASSIGN uint32, mapassign_fast32
+    }
+}
+
+func (self *_Assembler) _asm_OP_map_key_u64(p *_Instr) {
+    self.parse_unsigned(uint64Type, "", p.vi())                                       // PARSE     uint64
+    if vt := p.vt(); !mapfast(vt) {
+        self.mapassign_std(vt, _VAR_st_Iv)                      // MAPASSIGN uint64, vt.Iv
+    } else {
+        self.Emit("MOVQ", _VAR_st_Iv, _AX)                      // MOVQ      st.Iv, AX
+        self.mapassign_fastx(vt, _F_mapassign_fast64)           // MAPASSIGN uint64, mapassign_fast64
+    }
+}
+
+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.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.mapassign_std(p.vt(), _VAR_st_Dv)  // MAPASSIGN ${p.vt()}, mapassign, st.Dv
+}
+
+func (self *_Assembler) _asm_OP_map_key_str(p *_Instr) {
+    self.parse_string()                          // PARSE     STRING
+    self.unquote_once(_ARG_sv_p, _ARG_sv_n, true, true)      // UNQUOTE   once, sv.p, sv.n
+    if vt := p.vt(); !mapfast(vt) {
+        self.valloc(vt.Key(), _DI)
+        self.Emit("MOVOU", _ARG_sv, _X0)
+        self.Emit("MOVOU", _X0, jit.Ptr(_DI, 0))
+        self.mapassign_std(vt, jit.Ptr(_DI, 0))        // MAPASSIGN string, DI, SI
+    } else {
+        self.mapassign_str_fast(vt, _ARG_sv_p, _ARG_sv_n)    // MAPASSIGN string, DI, SI
+    }
+}
+
+func (self *_Assembler) _asm_OP_map_key_utext(p *_Instr) {
+    self.parse_string()                         // PARSE     STRING
+    self.unquote_once(_ARG_sv_p, _ARG_sv_n, true, true)     // UNQUOTE   once, sv.p, sv.n
+    self.mapassign_utext(p.vt(), false)         // MAPASSIGN utext, ${p.vt()}, false
+}
+
+func (self *_Assembler) _asm_OP_map_key_utext_p(p *_Instr) {
+    self.parse_string()                         // PARSE     STRING
+    self.unquote_once(_ARG_sv_p, _ARG_sv_n, true, true)     // UNQUOTE   once, sv.p, sv.n
+    self.mapassign_utext(p.vt(), true)          // MAPASSIGN utext, ${p.vt()}, true
+}
+
+func (self *_Assembler) _asm_OP_array_skip(_ *_Instr) {
+    self.call_sf(_F_skip_array)                 // CALL_SF skip_array
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
+    self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
+}
+
+func (self *_Assembler) _asm_OP_array_clear(p *_Instr) {
+    self.mem_clear_rem(p.i64(), true)
+}
+
+func (self *_Assembler) _asm_OP_array_clear_p(p *_Instr) {
+    self.mem_clear_rem(p.i64(), false)
+}
+
+func (self *_Assembler) _asm_OP_slice_init(p *_Instr) {
+    self.Emit("XORL" , _AX, _AX)                    // XORL    AX, AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_VP, 8))        // MOVQ    AX, 8(VP)
+    self.Emit("MOVQ" , jit.Ptr(_VP, 16), _BX)       // MOVQ    16(VP), BX
+    self.Emit("TESTQ", _BX, _BX)                    // TESTQ   BX, BX
+    self.Sjmp("JNZ"  , "_done_{n}")                 // JNZ     _done_{n}
+    self.Emit("MOVQ" , jit.Imm(_MinSlice), _CX)     // MOVQ    ${_MinSlice}, CX
+    self.Emit("MOVQ" , _CX, jit.Ptr(_VP, 16))       // MOVQ    CX, 16(VP)
+    self.Emit("MOVQ" , jit.Type(p.vt()), _AX)       // MOVQ    ${p.vt()}, DX
+    self.call_go(_F_makeslice)                      // CALL_GO makeslice
+    self.WritePtrAX(7, jit.Ptr(_VP, 0), false)      // MOVQ    AX, (VP)
+    self.Emit("XORL" , _AX, _AX)                    // XORL    AX, AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_VP, 8))        // MOVQ    AX, 8(VP)
+    self.Link("_done_{n}")                          // _done_{n}
+}
+
+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)
+    self.Sjmp("JB"   , "_index_{n}")                    // JB      _index_{n}
+    self.Emit("MOVQ" , _AX, _SI)                        // MOVQ    AX, SI
+    self.Emit("SHLQ" , jit.Imm(1), _SI)                 // SHLQ    $1, SI
+    self.Emit("MOVQ" , jit.Type(p.vt()), _AX)           // MOVQ    ${p.vt()}, AX
+    self.Emit("MOVQ" , jit.Ptr(_VP, 0), _BX)            // MOVQ   (VP), BX
+    self.Emit("MOVQ" , jit.Ptr(_VP, 8), _CX)            // MOVQ    8(VP), CX
+    self.Emit("MOVQ" , jit.Ptr(_VP, 16), _DI)           // MOVQ    16(VP), DI
+    self.call_go(_F_growslice)                          // CALL_GO growslice
+    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)
+    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)
+    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
+}
+
+func (self *_Assembler) _asm_OP_object_skip(_ *_Instr) {
+    self.call_sf(_F_skip_object)                // CALL_SF skip_object
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
+    self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
+}
+
+func (self *_Assembler) _asm_OP_object_next(_ *_Instr) {
+    self.call_sf(_F_skip_one)                   // CALL_SF skip_one
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ   AX, AX
+    self.Sjmp("JS"   , _LB_parsing_error_v)     // JS      _parse_error_v
+}
+
+func (self *_Assembler) _asm_OP_struct_field(p *_Instr) {
+    assert_eq(caching.FieldEntrySize, 32, "invalid field entry size")
+    self.Emit("MOVQ" , jit.Imm(-1), _AX)                        // MOVQ    $-1, AX
+    self.Emit("MOVQ" , _AX, _VAR_sr)                            // MOVQ    AX, sr
+    self.parse_string()                                         // PARSE   STRING
+    self.unquote_once(_ARG_sv_p, _ARG_sv_n, true, false)                     // UNQUOTE once, sv.p, sv.n
+    self.Emit("LEAQ" , _ARG_sv, _AX)                            // LEAQ    sv, AX
+    self.Emit("XORL" , _BX, _BX)                                // XORL    BX, BX
+    self.call_go(_F_strhash)                                    // CALL_GO strhash
+    self.Emit("MOVQ" , _AX, _R9)                                // MOVQ    AX, R9
+    self.Emit("MOVQ" , jit.Imm(freezeFields(p.vf())), _CX)      // MOVQ    ${p.vf()}, CX
+    self.Emit("MOVQ" , jit.Ptr(_CX, caching.FieldMap_b), _SI)   // MOVQ    FieldMap.b(CX), SI
+    self.Emit("MOVQ" , jit.Ptr(_CX, caching.FieldMap_N), _CX)   // MOVQ    FieldMap.N(CX), CX
+    self.Emit("TESTQ", _CX, _CX)                                // TESTQ   CX, CX
+    self.Sjmp("JZ"   , "_try_lowercase_{n}")                    // JZ      _try_lowercase_{n}
+    self.Link("_loop_{n}")                                      // _loop_{n}:
+    self.Emit("XORL" , _DX, _DX)                                // XORL    DX, DX
+    self.From("DIVQ" , _CX)                                     // DIVQ    CX
+    self.Emit("LEAQ" , jit.Ptr(_DX, 1), _AX)                    // LEAQ    1(DX), AX
+    self.Emit("SHLQ" , jit.Imm(5), _DX)                         // SHLQ    $5, DX
+    self.Emit("LEAQ" , jit.Sib(_SI, _DX, 1, 0), _DI)            // LEAQ    (SI)(DX), DI
+    self.Emit("MOVQ" , jit.Ptr(_DI, _Fe_Hash), _R8)             // MOVQ    FieldEntry.Hash(DI), R8
+    self.Emit("TESTQ", _R8, _R8)                                // TESTQ   R8, R8
+    self.Sjmp("JZ"   , "_try_lowercase_{n}")                    // JZ      _try_lowercase_{n}
+    self.Emit("CMPQ" , _R8, _R9)                                // CMPQ    R8, R9
+    self.Sjmp("JNE"  , "_loop_{n}")                             // JNE     _loop_{n}
+    self.Emit("MOVQ" , jit.Ptr(_DI, _Fe_Name + 8), _DX)         // MOVQ    FieldEntry.Name+8(DI), DX
+    self.Emit("CMPQ" , _DX, _ARG_sv_n)                          // CMPQ    DX, sv.n
+    self.Sjmp("JNE"  , "_loop_{n}")                             // JNE     _loop_{n}
+    self.Emit("MOVQ" , jit.Ptr(_DI, _Fe_ID), _R8)               // MOVQ    FieldEntry.ID(DI), R8
+    self.Emit("MOVQ" , _AX, _VAR_ss_AX)                         // MOVQ    AX, ss.AX
+    self.Emit("MOVQ" , _CX, _VAR_ss_CX)                         // MOVQ    CX, ss.CX
+    self.Emit("MOVQ" , _SI, _VAR_ss_SI)                         // MOVQ    SI, ss.SI
+    self.Emit("MOVQ" , _R8, _VAR_ss_R8)                         // MOVQ    R8, ss.R8
+    self.Emit("MOVQ" , _R9, _VAR_ss_R9)                         // MOVQ    R9, ss.R9
+    self.Emit("MOVQ" , _ARG_sv_p, _AX)                          // MOVQ    _VAR_sv_p, AX
+    self.Emit("MOVQ" , jit.Ptr(_DI, _Fe_Name), _CX)             // MOVQ    FieldEntry.Name(DI), CX
+    self.Emit("MOVQ" , _CX, _BX)                                // MOVQ    CX, 8(SP)
+    self.Emit("MOVQ" , _DX, _CX)                                // MOVQ    DX, 16(SP)
+    self.call_go(_F_memequal)                                   // CALL_GO memequal
+    self.Emit("MOVB" , _AX, _DX)                                // MOVB    24(SP), DX
+    self.Emit("MOVQ" , _VAR_ss_AX, _AX)                         // MOVQ    ss.AX, AX
+    self.Emit("MOVQ" , _VAR_ss_CX, _CX)                         // MOVQ    ss.CX, CX
+    self.Emit("MOVQ" , _VAR_ss_SI, _SI)                         // MOVQ    ss.SI, SI
+    self.Emit("MOVQ" , _VAR_ss_R9, _R9)                         // MOVQ    ss.R9, R9
+    self.Emit("TESTB", _DX, _DX)                                // TESTB   DX, DX
+    self.Sjmp("JZ"   , "_loop_{n}")                             // JZ      _loop_{n}
+    self.Emit("MOVQ" , _VAR_ss_R8, _R8)                         // MOVQ    ss.R8, R8
+    self.Emit("MOVQ" , _R8, _VAR_sr)                            // MOVQ    R8, sr
+    self.Sjmp("JMP"  , "_end_{n}")                              // JMP     _end_{n}
+    self.Link("_try_lowercase_{n}")                             // _try_lowercase_{n}:
+    self.Emit("MOVQ" , jit.Imm(referenceFields(p.vf())), _AX)   // MOVQ    ${p.vf()}, AX
+    self.Emit("MOVQ", _ARG_sv_p, _BX)                            // MOVQ   sv, BX
+    self.Emit("MOVQ", _ARG_sv_n, _CX)                            // MOVQ   sv, CX
+    self.call_go(_F_FieldMap_GetCaseInsensitive)                // CALL_GO FieldMap::GetCaseInsensitive
+    self.Emit("MOVQ" , _AX, _VAR_sr)                            // MOVQ    AX, _VAR_sr
+    self.Emit("TESTQ", _AX, _AX)                                // TESTQ   AX, AX
+    self.Sjmp("JNS"  , "_end_{n}")                              // JNS     _end_{n}
+    self.Emit("BTQ"  , jit.Imm(_F_disable_unknown), _ARG_fv)    // BTQ     ${_F_disable_unknown}, fv
+    self.Sjmp("JC"   , _LB_field_error)                         // JC      _field_error
+    self.Link("_end_{n}")                                       // _end_{n}:
+}
+
+func (self *_Assembler) _asm_OP_unmarshal(p *_Instr) {
+    self.unmarshal_json(p.vt(), true)
+}
+
+func (self *_Assembler) _asm_OP_unmarshal_p(p *_Instr) {
+    self.unmarshal_json(p.vt(), false)
+}
+
+func (self *_Assembler) _asm_OP_unmarshal_text(p *_Instr) {
+    self.unmarshal_text(p.vt(), true)
+}
+
+func (self *_Assembler) _asm_OP_unmarshal_text_p(p *_Instr) {
+    self.unmarshal_text(p.vt(), false)
+}
+
+func (self *_Assembler) _asm_OP_lspace(_ *_Instr) {
+    self.lspace("_{n}")
+}
+
+func (self *_Assembler) lspace(subfix string) {
+    var label = "_lspace" + subfix
+    self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
+    self.Sjmp("JAE"    , _LB_eof_error)                 // JAE     _eof_error
+    self.Emit("MOVQ"   , jit.Imm(_BM_space), _DX)       // MOVQ    _BM_space, DX
+    self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
+    self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
+    self.Sjmp("JA"     , label)                // JA      _nospace_{n}
+    self.Emit("BTQ"    , _AX, _DX)                      // BTQ     AX, DX
+    self.Sjmp("JNC"    , label)                // JNC     _nospace_{n}
+
+    /* test up to 4 characters */
+    for i := 0; i < 3; i++ {
+        self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
+        self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
+        self.Sjmp("JAE"    , _LB_eof_error)                 // JAE     _eof_error
+        self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
+        self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
+        self.Sjmp("JA"     , label)                // JA      _nospace_{n}
+        self.Emit("BTQ"    , _AX, _DX)                      // BTQ     AX, DX
+        self.Sjmp("JNC"    , label)                // JNC     _nospace_{n}
+    }
+
+    /* handle over to the native function */
+    self.Emit("MOVQ"   , _IP, _DI)                      // MOVQ    IP, DI
+    self.Emit("MOVQ"   , _IL, _SI)                      // MOVQ    IL, SI
+    self.Emit("MOVQ"   , _IC, _DX)                      // MOVQ    IC, DX
+    self.callc(_F_lspace)                                // CALL    lspace
+    self.Emit("TESTQ"  , _AX, _AX)                      // TESTQ   AX, AX
+    self.Sjmp("JS"     , _LB_parsing_error_v)           // JS      _parsing_error_v
+    self.Emit("CMPQ"   , _AX, _IL)                      // CMPQ    AX, IL
+    self.Sjmp("JAE"    , _LB_eof_error)                 // JAE     _eof_error
+    self.Emit("MOVQ"   , _AX, _IC)                      // MOVQ    AX, IC
+    self.Link(label)                           // _nospace_{n}:
+}
+
+func (self *_Assembler) _asm_OP_match_char(p *_Instr) {
+    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
+}
+
+func (self *_Assembler) _asm_OP_check_char(p *_Instr) {
+    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(p.vb())))   // CMPB    (IP)(IC), ${p.vb()}
+    self.Emit("CMOVQEQ", _AX, _IC)                                          // CMOVQEQ AX, IC
+    self.Xjmp("JE"     , p.vi())                                            // JE      {p.vi()}
+}
+
+func (self *_Assembler) _asm_OP_check_char_0(p *_Instr) {
+    self.check_eof(1)
+    self.Emit("CMPB", jit.Sib(_IP, _IC, 1, 0), jit.Imm(int64(p.vb())))   // CMPB    (IP)(IC), ${p.vb()}
+    self.Xjmp("JE"  , p.vi())                                            // JE      {p.vi()}
+}
+
+func (self *_Assembler) _asm_OP_add(p *_Instr) {
+    self.Emit("ADDQ", jit.Imm(int64(p.vi())), _IC)  // ADDQ ${p.vi()}, IC
+}
+
+func (self *_Assembler) _asm_OP_load(_ *_Instr) {
+    self.Emit("MOVQ", jit.Ptr(_ST, 0), _AX)             // MOVQ (ST), AX
+    self.Emit("MOVQ", jit.Sib(_ST, _AX, 1, 0), _VP)     // MOVQ (ST)(AX), VP
+}
+
+func (self *_Assembler) _asm_OP_save(_ *_Instr) {
+    self.Emit("MOVQ", jit.Ptr(_ST, 0), _CX)             // MOVQ (ST), CX
+    self.Emit("CMPQ", _CX, jit.Imm(_MaxStackBytes))     // CMPQ CX, ${_MaxStackBytes}
+    self.Sjmp("JAE"  , _LB_stack_error)                  // JA   _stack_error
+    self.WriteRecNotAX(0 , _VP, jit.Sib(_ST, _CX, 1, 8), false, false) // MOVQ VP, 8(ST)(CX)
+    self.Emit("ADDQ", jit.Imm(8), _CX)                  // ADDQ $8, CX
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, 0))             // MOVQ CX, (ST)
+}
+
+func (self *_Assembler) _asm_OP_drop(_ *_Instr) {
+    self.Emit("MOVQ", jit.Ptr(_ST, 0), _AX)             // MOVQ (ST), AX
+    self.Emit("SUBQ", jit.Imm(8), _AX)                  // SUBQ $8, AX
+    self.Emit("MOVQ", jit.Sib(_ST, _AX, 1, 8), _VP)     // MOVQ 8(ST)(AX), VP
+    self.Emit("MOVQ", _AX, jit.Ptr(_ST, 0))             // MOVQ AX, (ST)
+    self.Emit("XORL", _BX, _BX)                         // XORL BX, BX
+    self.Emit("MOVQ", _BX, jit.Sib(_ST, _AX, 1, 8))     // MOVQ BX, 8(ST)(AX)
+}
+
+func (self *_Assembler) _asm_OP_drop_2(_ *_Instr) {
+    self.Emit("MOVQ" , jit.Ptr(_ST, 0), _AX)            // MOVQ  (ST), AX
+    self.Emit("SUBQ" , jit.Imm(16), _AX)                // SUBQ  $16, AX
+    self.Emit("MOVQ" , jit.Sib(_ST, _AX, 1, 8), _VP)    // MOVQ  8(ST)(AX), VP
+    self.Emit("MOVQ" , _AX, jit.Ptr(_ST, 0))            // MOVQ  AX, (ST)
+    self.Emit("PXOR" , _X0, _X0)                        // PXOR  X0, X0
+    self.Emit("MOVOU", _X0, jit.Sib(_ST, _AX, 1, 8))    // MOVOU X0, 8(ST)(AX)
+}
+
+func (self *_Assembler) _asm_OP_recurse(p *_Instr) {
+    self.Emit("MOVQ", jit.Type(p.vt()), _AX)    // MOVQ   ${p.vt()}, AX
+    self.decode_dynamic(_AX, _VP)               // DECODE AX, VP
+}
+
+func (self *_Assembler) _asm_OP_goto(p *_Instr) {
+    self.Xjmp("JMP", p.vi())
+}
+
+func (self *_Assembler) _asm_OP_switch(p *_Instr) {
+    self.Emit("MOVQ", _VAR_sr, _AX)             // MOVQ sr, AX
+    self.Emit("CMPQ", _AX, jit.Imm(p.i64()))    // CMPQ AX, ${len(p.vs())}
+    self.Sjmp("JAE" , "_default_{n}")           // JAE  _default_{n}
+
+    /* jump table selector */
+    self.Byte(0x48, 0x8d, 0x3d)                         // LEAQ    ?(PC), DI
+    self.Sref("_switch_table_{n}", 4)                   // ....    &_switch_table_{n}
+    self.Emit("MOVLQSX", jit.Sib(_DI, _AX, 4, 0), _AX)  // MOVLQSX (DI)(AX*4), AX
+    self.Emit("ADDQ"   , _DI, _AX)                      // ADDQ    DI, AX
+    self.Rjmp("JMP"    , _AX)                           // JMP     AX
+    self.Link("_switch_table_{n}")                      // _switch_table_{n}:
+
+    /* generate the jump table */
+    for i, v := range p.vs() {
+        self.Xref(v, int64(-i) * 4)
+    }
+
+    /* default case */
+    self.Link("_default_{n}")
+    self.NOP()
+}
+
+func (self *_Assembler) print_gc(i int, p1 *_Instr, p2 *_Instr) {
+    self.Emit("MOVQ", jit.Imm(int64(p2.op())),  _CX)// MOVQ $(p2.op()), 16(SP)
+    self.Emit("MOVQ", jit.Imm(int64(p1.op())),  _BX) // MOVQ $(p1.op()), 8(SP)
+    self.Emit("MOVQ", jit.Imm(int64(i)),  _AX)       // MOVQ $(i), (SP)
+    self.call_go(_F_println)
+}
+
+//go:linkname _runtime_writeBarrier runtime.writeBarrier
+var _runtime_writeBarrier uintptr
+
+//go:linkname gcWriteBarrierAX runtime.gcWriteBarrier
+func gcWriteBarrierAX()
+
+var (
+    _V_writeBarrier = jit.Imm(int64(uintptr(unsafe.Pointer(&_runtime_writeBarrier))))
+
+    _F_gcWriteBarrierAX = jit.Func(gcWriteBarrierAX)
+)
+
+func (self *_Assembler) WritePtrAX(i int, rec obj.Addr, saveDI bool) {
+    self.Emit("MOVQ", _V_writeBarrier, _R9)
+    self.Emit("CMPL", jit.Ptr(_R9, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    if saveDI {
+        self.save(_DI)
+    }
+    self.Emit("LEAQ", rec, _DI)
+    self.call(_F_gcWriteBarrierAX)  
+    if saveDI {
+        self.load(_DI)
+    }    
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", _AX, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}
+
+func (self *_Assembler) WriteRecNotAX(i int, ptr obj.Addr, rec obj.Addr, saveDI bool, saveAX bool) {
+    if rec.Reg == x86.REG_AX || rec.Index == x86.REG_AX {
+        panic("rec contains AX!")
+    }
+    self.Emit("MOVQ", _V_writeBarrier, _R9)
+    self.Emit("CMPL", jit.Ptr(_R9, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    if saveAX {
+        self.Emit("XCHGQ", ptr, _AX)
+    } else {
+        self.Emit("MOVQ", ptr, _AX)
+    }
+    if saveDI {
+        self.save(_DI)
+    }
+    self.Emit("LEAQ", rec, _DI)
+    self.call(_F_gcWriteBarrierAX) 
+    if saveDI {
+        self.load(_DI)
+    } 
+    if saveAX {
+        self.Emit("XCHGQ", ptr, _AX)
+    }    
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/decoder/compiler.go b/vendor/github.com/bytedance/sonic/decoder/compiler.go
new file mode 100644
index 000000000..b4fc2fed2
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/compiler.go
@@ -0,0 +1,1136 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `encoding/json`
+    `fmt`
+    `reflect`
+    `sort`
+    `strconv`
+    `strings`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/caching`
+    `github.com/bytedance/sonic/internal/resolver`
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/bytedance/sonic/option`
+)
+
+type _Op uint8
+
+const (
+    _OP_any _Op = iota + 1
+    _OP_dyn
+    _OP_str
+    _OP_bin
+    _OP_bool
+    _OP_num
+    _OP_i8
+    _OP_i16
+    _OP_i32
+    _OP_i64
+    _OP_u8
+    _OP_u16
+    _OP_u32
+    _OP_u64
+    _OP_f32
+    _OP_f64
+    _OP_unquote
+    _OP_nil_1
+    _OP_nil_2
+    _OP_nil_3
+    _OP_deref
+    _OP_index
+    _OP_is_null
+    _OP_is_null_quote
+    _OP_map_init
+    _OP_map_key_i8
+    _OP_map_key_i16
+    _OP_map_key_i32
+    _OP_map_key_i64
+    _OP_map_key_u8
+    _OP_map_key_u16
+    _OP_map_key_u32
+    _OP_map_key_u64
+    _OP_map_key_f32
+    _OP_map_key_f64
+    _OP_map_key_str
+    _OP_map_key_utext
+    _OP_map_key_utext_p
+    _OP_array_skip
+    _OP_array_clear
+    _OP_array_clear_p
+    _OP_slice_init
+    _OP_slice_append
+    _OP_object_skip
+    _OP_object_next
+    _OP_struct_field
+    _OP_unmarshal
+    _OP_unmarshal_p
+    _OP_unmarshal_text
+    _OP_unmarshal_text_p
+    _OP_lspace
+    _OP_match_char
+    _OP_check_char
+    _OP_load
+    _OP_save
+    _OP_drop
+    _OP_drop_2
+    _OP_recurse
+    _OP_goto
+    _OP_switch
+    _OP_check_char_0
+    _OP_dismatch_err
+    _OP_go_skip
+    _OP_add
+    _OP_debug
+)
+
+const (
+    _INT_SIZE = 32 << (^uint(0) >> 63)
+    _PTR_SIZE = 32 << (^uintptr(0) >> 63)
+    _PTR_BYTE = unsafe.Sizeof(uintptr(0))
+)
+
+const (
+    _MAX_ILBUF = 100000     // cutoff at 100k of IL instructions
+    _MAX_FIELDS = 50        // cutoff at 50 fields struct
+)
+
+var _OpNames = [256]string {
+    _OP_any              : "any",
+    _OP_dyn              : "dyn",
+    _OP_str              : "str",
+    _OP_bin              : "bin",
+    _OP_bool             : "bool",
+    _OP_num              : "num",
+    _OP_i8               : "i8",
+    _OP_i16              : "i16",
+    _OP_i32              : "i32",
+    _OP_i64              : "i64",
+    _OP_u8               : "u8",
+    _OP_u16              : "u16",
+    _OP_u32              : "u32",
+    _OP_u64              : "u64",
+    _OP_f32              : "f32",
+    _OP_f64              : "f64",
+    _OP_unquote          : "unquote",
+    _OP_nil_1            : "nil_1",
+    _OP_nil_2            : "nil_2",
+    _OP_nil_3            : "nil_3",
+    _OP_deref            : "deref",
+    _OP_index            : "index",
+    _OP_is_null          : "is_null",
+    _OP_is_null_quote    : "is_null_quote",
+    _OP_map_init         : "map_init",
+    _OP_map_key_i8       : "map_key_i8",
+    _OP_map_key_i16      : "map_key_i16",
+    _OP_map_key_i32      : "map_key_i32",
+    _OP_map_key_i64      : "map_key_i64",
+    _OP_map_key_u8       : "map_key_u8",
+    _OP_map_key_u16      : "map_key_u16",
+    _OP_map_key_u32      : "map_key_u32",
+    _OP_map_key_u64      : "map_key_u64",
+    _OP_map_key_f32      : "map_key_f32",
+    _OP_map_key_f64      : "map_key_f64",
+    _OP_map_key_str      : "map_key_str",
+    _OP_map_key_utext    : "map_key_utext",
+    _OP_map_key_utext_p  : "map_key_utext_p",
+    _OP_array_skip       : "array_skip",
+    _OP_slice_init       : "slice_init",
+    _OP_slice_append     : "slice_append",
+    _OP_object_skip      : "object_skip",
+    _OP_object_next      : "object_next",
+    _OP_struct_field     : "struct_field",
+    _OP_unmarshal        : "unmarshal",
+    _OP_unmarshal_p      : "unmarshal_p",
+    _OP_unmarshal_text   : "unmarshal_text",
+    _OP_unmarshal_text_p : "unmarshal_text_p",
+    _OP_lspace           : "lspace",
+    _OP_match_char       : "match_char",
+    _OP_check_char       : "check_char",
+    _OP_load             : "load",
+    _OP_save             : "save",
+    _OP_drop             : "drop",
+    _OP_drop_2           : "drop_2",
+    _OP_recurse          : "recurse",
+    _OP_goto             : "goto",
+    _OP_switch           : "switch",
+    _OP_check_char_0     : "check_char_0",
+    _OP_dismatch_err     : "dismatch_err",
+    _OP_add              : "add",
+}
+
+func (self _Op) String() string {
+    if ret := _OpNames[self]; ret != "" {
+        return ret
+    } else {
+        return "<invalid>"
+    }
+}
+
+func _OP_int() _Op {
+    switch _INT_SIZE {
+        case 32: return _OP_i32
+        case 64: return _OP_i64
+        default: panic("unsupported int size")
+    }
+}
+
+func _OP_uint() _Op {
+    switch _INT_SIZE {
+        case 32: return _OP_u32
+        case 64: return _OP_u64
+        default: panic("unsupported uint size")
+    }
+}
+
+func _OP_uintptr() _Op {
+    switch _PTR_SIZE {
+        case 32: return _OP_u32
+        case 64: return _OP_u64
+        default: panic("unsupported pointer size")
+    }
+}
+
+func _OP_map_key_int() _Op {
+    switch _INT_SIZE {
+        case 32: return _OP_map_key_i32
+        case 64: return _OP_map_key_i64
+        default: panic("unsupported int size")
+    }
+}
+
+func _OP_map_key_uint() _Op {
+    switch _INT_SIZE {
+        case 32: return _OP_map_key_u32
+        case 64: return _OP_map_key_u64
+        default: panic("unsupported uint size")
+    }
+}
+
+func _OP_map_key_uintptr() _Op {
+    switch _PTR_SIZE {
+        case 32: return _OP_map_key_u32
+        case 64: return _OP_map_key_u64
+        default: panic("unsupported pointer size")
+    }
+}
+
+type _Instr struct {
+    u uint64            // union {op: 8, vb: 8, vi: 48}, iv maybe int or len([]int)
+    p unsafe.Pointer    // maybe GoSlice.Data, *GoType or *caching.FieldMap
+}
+
+func packOp(op _Op) uint64 {
+    return uint64(op) << 56
+}
+
+func newInsOp(op _Op) _Instr {
+    return _Instr{u: packOp(op)}
+}
+
+func newInsVi(op _Op, vi int) _Instr {
+    return _Instr{u: packOp(op) | rt.PackInt(vi)}
+}
+
+func newInsVb(op _Op, vb byte) _Instr {
+    return _Instr{u: packOp(op) | (uint64(vb) << 48)}
+}
+
+func newInsVs(op _Op, vs []int) _Instr {
+    return _Instr {
+        u: packOp(op) | rt.PackInt(len(vs)),
+        p: (*rt.GoSlice)(unsafe.Pointer(&vs)).Ptr,
+    }
+}
+
+func newInsVt(op _Op, vt reflect.Type) _Instr {
+    return _Instr {
+        u: packOp(op),
+        p: unsafe.Pointer(rt.UnpackType(vt)),
+    }
+}
+
+func newInsVf(op _Op, vf *caching.FieldMap) _Instr {
+    return _Instr {
+        u: packOp(op),
+        p: unsafe.Pointer(vf),
+    }
+}
+
+func (self _Instr) op() _Op {
+    return _Op(self.u >> 56)
+}
+
+func (self _Instr) vi() int {
+    return rt.UnpackInt(self.u)
+}
+
+func (self _Instr) vb() byte {
+    return byte(self.u >> 48)
+}
+
+func (self _Instr) vs() (v []int) {
+    (*rt.GoSlice)(unsafe.Pointer(&v)).Ptr = self.p
+    (*rt.GoSlice)(unsafe.Pointer(&v)).Cap = self.vi()
+    (*rt.GoSlice)(unsafe.Pointer(&v)).Len = self.vi()
+    return
+}
+
+func (self _Instr) vf() *caching.FieldMap {
+    return (*caching.FieldMap)(self.p)
+}
+
+func (self _Instr) vk() reflect.Kind {
+    return (*rt.GoType)(self.p).Kind()
+}
+
+func (self _Instr) vt() reflect.Type {
+    return (*rt.GoType)(self.p).Pack()
+}
+
+func (self _Instr) i64() int64 {
+    return int64(self.vi())
+}
+
+func (self _Instr) vlen() int {
+    return int((*rt.GoType)(self.p).Size)
+}
+
+func (self _Instr) isBranch() bool {
+    switch self.op() {
+        case _OP_goto          : fallthrough
+        case _OP_switch        : fallthrough
+        case _OP_is_null       : fallthrough
+        case _OP_is_null_quote : fallthrough
+        case _OP_check_char    : return true
+        default                : return false
+    }
+}
+
+func (self _Instr) disassemble() string {
+    switch self.op() {
+        case _OP_dyn              : fallthrough
+        case _OP_deref            : fallthrough
+        case _OP_map_key_i8       : fallthrough
+        case _OP_map_key_i16      : fallthrough
+        case _OP_map_key_i32      : fallthrough
+        case _OP_map_key_i64      : fallthrough
+        case _OP_map_key_u8       : fallthrough
+        case _OP_map_key_u16      : fallthrough
+        case _OP_map_key_u32      : fallthrough
+        case _OP_map_key_u64      : fallthrough
+        case _OP_map_key_f32      : fallthrough
+        case _OP_map_key_f64      : fallthrough
+        case _OP_map_key_str      : fallthrough
+        case _OP_map_key_utext    : fallthrough
+        case _OP_map_key_utext_p  : fallthrough
+        case _OP_slice_init       : fallthrough
+        case _OP_slice_append     : fallthrough
+        case _OP_unmarshal        : fallthrough
+        case _OP_unmarshal_p      : fallthrough
+        case _OP_unmarshal_text   : fallthrough
+        case _OP_unmarshal_text_p : fallthrough
+        case _OP_recurse          : return fmt.Sprintf("%-18s%s", self.op(), self.vt())
+        case _OP_goto             : fallthrough
+        case _OP_is_null_quote    : fallthrough
+        case _OP_is_null          : return fmt.Sprintf("%-18sL_%d", self.op(), self.vi())
+        case _OP_index            : fallthrough
+        case _OP_array_clear      : fallthrough
+        case _OP_array_clear_p    : return fmt.Sprintf("%-18s%d", self.op(), self.vi())
+        case _OP_switch           : return fmt.Sprintf("%-18s%s", self.op(), self.formatSwitchLabels())
+        case _OP_struct_field     : return fmt.Sprintf("%-18s%s", self.op(), self.formatStructFields())
+        case _OP_match_char       : return fmt.Sprintf("%-18s%s", self.op(), strconv.QuoteRune(rune(self.vb())))
+        case _OP_check_char       : return fmt.Sprintf("%-18sL_%d, %s", self.op(), self.vi(), strconv.QuoteRune(rune(self.vb())))
+        default                   : return self.op().String()
+    }
+}
+
+func (self _Instr) formatSwitchLabels() string {
+    var i int
+    var v int
+    var m []string
+
+    /* format each label */
+    for i, v = range self.vs() {
+        m = append(m, fmt.Sprintf("%d=L_%d", i, v))
+    }
+
+    /* join them with "," */
+    return strings.Join(m, ", ")
+}
+
+func (self _Instr) formatStructFields() string {
+    var i uint64
+    var r []string
+    var m []struct{i int; n string}
+
+    /* extract all the fields */
+    for i = 0; i < self.vf().N; i++ {
+        if v := self.vf().At(i); v.Hash != 0 {
+            m = append(m, struct{i int; n string}{i: v.ID, n: v.Name})
+        }
+    }
+
+    /* sort by field name */
+    sort.Slice(m, func(i, j int) bool {
+        return m[i].n < m[j].n
+    })
+
+    /* format each field */
+    for _, v := range m {
+        r = append(r, fmt.Sprintf("%s=%d", v.n, v.i))
+    }
+
+    /* join them with "," */
+    return strings.Join(r, ", ")
+}
+
+type (
+    _Program []_Instr
+)
+
+func (self _Program) pc() int {
+    return len(self)
+}
+
+func (self _Program) tag(n int) {
+    if n >= _MaxStack {
+        panic("type nesting too deep")
+    }
+}
+
+func (self _Program) pin(i int) {
+    v := &self[i]
+    v.u &= 0xffff000000000000
+    v.u |= rt.PackInt(self.pc())
+}
+
+func (self _Program) rel(v []int) {
+    for _, i := range v {
+        self.pin(i)
+    }
+}
+
+func (self *_Program) add(op _Op) {
+    *self = append(*self, newInsOp(op))
+}
+
+func (self *_Program) int(op _Op, vi int) {
+    *self = append(*self, newInsVi(op, vi))
+}
+
+func (self *_Program) chr(op _Op, vb byte) {
+    *self = append(*self, newInsVb(op, vb))
+}
+
+func (self *_Program) tab(op _Op, vs []int) {
+    *self = append(*self, newInsVs(op, vs))
+}
+
+func (self *_Program) rtt(op _Op, vt reflect.Type) {
+    *self = append(*self, newInsVt(op, vt))
+}
+
+func (self *_Program) fmv(op _Op, vf *caching.FieldMap) {
+    *self = append(*self, newInsVf(op, vf))
+}
+
+func (self _Program) disassemble() string {
+    nb  := len(self)
+    tab := make([]bool, nb + 1)
+    ret := make([]string, 0, nb + 1)
+
+    /* prescan to get all the labels */
+    for _, ins := range self {
+        if ins.isBranch() {
+            if ins.op() != _OP_switch {
+                tab[ins.vi()] = true
+            } else {
+                for _, v := range ins.vs() {
+                    tab[v] = true
+                }
+            }
+        }
+    }
+
+    /* disassemble each instruction */
+    for i, ins := range self {
+        if !tab[i] {
+            ret = append(ret, "\t" + ins.disassemble())
+        } else {
+            ret = append(ret, fmt.Sprintf("L_%d:\n\t%s", i, ins.disassemble()))
+        }
+    }
+
+    /* add the last label, if needed */
+    if tab[nb] {
+        ret = append(ret, fmt.Sprintf("L_%d:", nb))
+    }
+
+    /* add an "end" indicator, and join all the strings */
+    return strings.Join(append(ret, "\tend"), "\n")
+}
+
+type _Compiler struct {
+    opts option.CompileOptions
+    tab  map[reflect.Type]bool
+    rec  map[reflect.Type]bool
+}
+
+func newCompiler() *_Compiler {
+    return &_Compiler {
+        opts: option.DefaultCompileOptions(),
+        tab: map[reflect.Type]bool{},
+        rec: map[reflect.Type]bool{},
+    }
+}
+
+func (self *_Compiler) apply(opts option.CompileOptions) *_Compiler {
+    self.opts = opts
+    return self
+}
+
+func (self *_Compiler) rescue(ep *error) {
+    if val := recover(); val != nil {
+        if err, ok := val.(error); ok {
+            *ep = err
+        } else {
+            panic(val)
+        }
+    }
+}
+
+func (self *_Compiler) compile(vt reflect.Type) (ret _Program, err error) {
+    defer self.rescue(&err)
+    self.compileOne(&ret, 0, vt)
+    return
+}
+
+func (self *_Compiler) compileOne(p *_Program, sp int, vt reflect.Type) {
+    /* check for recursive nesting */
+    ok := self.tab[vt]
+    if ok {
+        p.rtt(_OP_recurse, vt)
+        return
+    }
+
+    pt := reflect.PtrTo(vt)
+
+    /* check for `json.Unmarshaler` with pointer receiver */
+    if pt.Implements(jsonUnmarshalerType) {
+        p.rtt(_OP_unmarshal_p, pt)
+        return
+    }
+
+    /* check for `json.Unmarshaler` */
+    if vt.Implements(jsonUnmarshalerType) {
+        p.add(_OP_lspace)
+        self.compileUnmarshalJson(p, vt)
+        return
+    }
+
+    /* check for `encoding.TextMarshaler` with pointer receiver */
+    if pt.Implements(encodingTextUnmarshalerType) {
+        p.add(_OP_lspace)
+        self.compileUnmarshalTextPtr(p, pt)
+        return
+    }
+
+    /* check for `encoding.TextUnmarshaler` */
+    if vt.Implements(encodingTextUnmarshalerType) {
+        p.add(_OP_lspace)
+        self.compileUnmarshalText(p, vt)
+        return
+    }
+
+    /* enter the recursion */
+    p.add(_OP_lspace)
+    self.tab[vt] = true
+    self.compileOps(p, sp, vt)
+    delete(self.tab, vt)
+}
+
+func (self *_Compiler) compileOps(p *_Program, sp int, vt reflect.Type) {
+    switch vt.Kind() {
+        case reflect.Bool      : self.compilePrimitive (vt, p, _OP_bool)
+        case reflect.Int       : self.compilePrimitive (vt, p, _OP_int())
+        case reflect.Int8      : self.compilePrimitive (vt, p, _OP_i8)
+        case reflect.Int16     : self.compilePrimitive (vt, p, _OP_i16)
+        case reflect.Int32     : self.compilePrimitive (vt, p, _OP_i32)
+        case reflect.Int64     : self.compilePrimitive (vt, p, _OP_i64)
+        case reflect.Uint      : self.compilePrimitive (vt, p, _OP_uint())
+        case reflect.Uint8     : self.compilePrimitive (vt, p, _OP_u8)
+        case reflect.Uint16    : self.compilePrimitive (vt, p, _OP_u16)
+        case reflect.Uint32    : self.compilePrimitive (vt, p, _OP_u32)
+        case reflect.Uint64    : self.compilePrimitive (vt, p, _OP_u64)
+        case reflect.Uintptr   : self.compilePrimitive (vt, p, _OP_uintptr())
+        case reflect.Float32   : self.compilePrimitive (vt, p, _OP_f32)
+        case reflect.Float64   : self.compilePrimitive (vt, p, _OP_f64)
+        case reflect.String    : self.compileString    (p, vt)
+        case reflect.Array     : self.compileArray     (p, sp, vt)
+        case reflect.Interface : self.compileInterface (p, vt)
+        case reflect.Map       : self.compileMap       (p, sp, vt)
+        case reflect.Ptr       : self.compilePtr       (p, sp, vt)
+        case reflect.Slice     : self.compileSlice     (p, sp, vt)
+        case reflect.Struct    : self.compileStruct    (p, sp, vt)
+        default                : panic                 (&json.UnmarshalTypeError{Type: vt})
+    }
+}
+
+func (self *_Compiler) compileMap(p *_Program, sp int, vt reflect.Type) {
+    if reflect.PtrTo(vt.Key()).Implements(encodingTextUnmarshalerType) {
+        self.compileMapOp(p, sp, vt, _OP_map_key_utext_p)
+    } else if vt.Key().Implements(encodingTextUnmarshalerType) {
+        self.compileMapOp(p, sp, vt, _OP_map_key_utext)
+    } else {
+        self.compileMapUt(p, sp, vt)
+    }
+}
+
+func (self *_Compiler) compileMapUt(p *_Program, sp int, vt reflect.Type) {
+    switch vt.Key().Kind() {
+        case reflect.Int     : self.compileMapOp(p, sp, vt, _OP_map_key_int())
+        case reflect.Int8    : self.compileMapOp(p, sp, vt, _OP_map_key_i8)
+        case reflect.Int16   : self.compileMapOp(p, sp, vt, _OP_map_key_i16)
+        case reflect.Int32   : self.compileMapOp(p, sp, vt, _OP_map_key_i32)
+        case reflect.Int64   : self.compileMapOp(p, sp, vt, _OP_map_key_i64)
+        case reflect.Uint    : self.compileMapOp(p, sp, vt, _OP_map_key_uint())
+        case reflect.Uint8   : self.compileMapOp(p, sp, vt, _OP_map_key_u8)
+        case reflect.Uint16  : self.compileMapOp(p, sp, vt, _OP_map_key_u16)
+        case reflect.Uint32  : self.compileMapOp(p, sp, vt, _OP_map_key_u32)
+        case reflect.Uint64  : self.compileMapOp(p, sp, vt, _OP_map_key_u64)
+        case reflect.Uintptr : self.compileMapOp(p, sp, vt, _OP_map_key_uintptr())
+        case reflect.Float32 : self.compileMapOp(p, sp, vt, _OP_map_key_f32)
+        case reflect.Float64 : self.compileMapOp(p, sp, vt, _OP_map_key_f64)
+        case reflect.String  : self.compileMapOp(p, sp, vt, _OP_map_key_str)
+        default              : panic(&json.UnmarshalTypeError{Type: vt})
+    }
+}
+
+func (self *_Compiler) compileMapOp(p *_Program, sp int, vt reflect.Type, op _Op) {
+    i := p.pc()
+    p.add(_OP_is_null)
+    p.tag(sp + 1)
+    skip := self.checkIfSkip(p, vt, '{')
+    p.add(_OP_save)
+    p.add(_OP_map_init)
+    p.add(_OP_save)
+    p.add(_OP_lspace)
+    j := p.pc()
+    p.chr(_OP_check_char, '}')
+    p.chr(_OP_match_char, '"')
+    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, ':')
+    self.compileOne(p, sp + 2, vt.Elem())
+    p.pin(skip2)
+    p.add(_OP_load)
+    k0 := p.pc()
+    p.add(_OP_lspace)
+    k1 := p.pc()
+    p.chr(_OP_check_char, '}')
+    p.chr(_OP_match_char, ',')
+    p.add(_OP_lspace)
+    p.chr(_OP_match_char, '"')
+    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, ':')
+    self.compileOne(p, sp + 2, vt.Elem())
+    p.pin(skip3)
+    p.add(_OP_load)
+    p.int(_OP_goto, k0)
+    p.pin(j)
+    p.pin(k1)
+    p.add(_OP_drop_2)
+    x := p.pc()
+    p.add(_OP_goto)
+    p.pin(i)
+    p.add(_OP_nil_1)
+    p.pin(skip)
+    p.pin(x)
+}
+
+func (self *_Compiler) compilePtr(p *_Program, sp int, et reflect.Type) {
+    i := p.pc()
+    p.add(_OP_is_null)
+
+    /* dereference all the way down */
+    for et.Kind() == reflect.Ptr {
+        et = et.Elem()
+        p.rtt(_OP_deref, et)
+    }
+
+    /* compile the element type */
+    self.compileOne(p, sp + 1, et)
+    j := p.pc()
+    p.add(_OP_goto)
+    p.pin(i)
+    p.add(_OP_nil_1)
+    p.pin(j)
+}
+
+func (self *_Compiler) compileArray(p *_Program, sp int, vt reflect.Type) {
+    x := p.pc()
+    p.add(_OP_is_null)
+    p.tag(sp)
+    skip := self.checkIfSkip(p, vt, '[')
+    
+    p.add(_OP_save)
+    p.add(_OP_lspace)
+    v := []int{p.pc()}
+    p.chr(_OP_check_char, ']')
+
+    /* decode every item */
+    for i := 1; i <= vt.Len(); i++ {
+        self.compileOne(p, sp + 1, vt.Elem())
+        p.add(_OP_load)
+        p.int(_OP_index, i * int(vt.Elem().Size()))
+        p.add(_OP_lspace)
+        v = append(v, p.pc())
+        p.chr(_OP_check_char, ']')
+        p.chr(_OP_match_char, ',')
+    }
+
+    /* drop rest of the array */
+    p.add(_OP_array_skip)
+    w := p.pc()
+    p.add(_OP_goto)
+    p.rel(v)
+
+    /* check for pointer data */
+    if rt.UnpackType(vt.Elem()).PtrData == 0 {
+        p.int(_OP_array_clear, int(vt.Size()))
+    } else {
+        p.int(_OP_array_clear_p, int(vt.Size()))
+    }
+
+    /* restore the stack */
+    p.pin(w)
+    p.add(_OP_drop)
+
+    p.pin(skip)
+    p.pin(x)
+}
+
+func (self *_Compiler) compileSlice(p *_Program, sp int, vt reflect.Type) {
+    if vt.Elem().Kind() == byteType.Kind() {
+        self.compileSliceBin(p, sp, vt)
+    } else {
+        self.compileSliceList(p, sp, vt)
+    }
+}
+
+func (self *_Compiler) compileSliceBin(p *_Program, sp int, vt reflect.Type) {
+    i := p.pc()
+    p.add(_OP_is_null)
+    j := p.pc()
+    p.chr(_OP_check_char, '[')
+    skip := self.checkIfSkip(p, vt, '"')
+    k := p.pc()
+    p.chr(_OP_check_char, '"')
+    p.add(_OP_bin)
+    x := p.pc()
+    p.add(_OP_goto)
+    p.pin(j)
+    self.compileSliceBody(p, sp, vt.Elem())
+    y := p.pc()
+    p.add(_OP_goto)
+    p.pin(i)
+    p.pin(k)
+    p.add(_OP_nil_3)
+    p.pin(x)
+    p.pin(skip)
+    p.pin(y)
+}
+
+func (self *_Compiler) compileSliceList(p *_Program, sp int, vt reflect.Type) {
+    i := p.pc()
+    p.add(_OP_is_null)
+    p.tag(sp)
+    skip := self.checkIfSkip(p, vt, '[')
+    self.compileSliceBody(p, sp, vt.Elem())
+    x := p.pc()
+    p.add(_OP_goto)
+    p.pin(i)
+    p.add(_OP_nil_3)
+    p.pin(x)
+    p.pin(skip)
+}
+
+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.rtt(_OP_slice_append, et)
+    self.compileOne(p, sp + 1, et)
+    p.add(_OP_load)
+    k0 := p.pc()
+    p.add(_OP_lspace)
+    k1 := p.pc()
+    p.chr(_OP_check_char, ']')
+    p.chr(_OP_match_char, ',')
+    p.rtt(_OP_slice_append, et)
+    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)
+}
+
+func (self *_Compiler) compileString(p *_Program, vt reflect.Type) {
+    if vt == jsonNumberType {
+        self.compilePrimitive(vt, p, _OP_num)
+    } else {
+        self.compileStringBody(vt, p)
+    }
+}
+
+func (self *_Compiler) compileStringBody(vt reflect.Type, p *_Program) {
+    i := p.pc()
+    p.add(_OP_is_null)
+    skip := self.checkIfSkip(p, vt, '"')
+    p.add(_OP_str)
+    p.pin(i)
+    p.pin(skip)
+}
+
+func (self *_Compiler) compileStruct(p *_Program, sp int, vt reflect.Type) {
+    if sp >= self.opts.MaxInlineDepth || p.pc() >= _MAX_ILBUF || (sp > 0 && vt.NumField() >= _MAX_FIELDS) {
+        p.rtt(_OP_recurse, vt)
+        if self.opts.RecursiveDepth > 0 {
+            self.rec[vt] = true
+        }
+    } else {
+        self.compileStructBody(p, sp, vt)
+    }
+}
+
+func (self *_Compiler) compileStructBody(p *_Program, sp int, vt reflect.Type) {
+    fv := resolver.ResolveStruct(vt)
+    fm, sw := caching.CreateFieldMap(len(fv)), make([]int, len(fv))
+
+    /* start of object */
+    p.tag(sp)
+    n := p.pc()
+    p.add(_OP_is_null)
+
+    skip := self.checkIfSkip(p, vt, '{')
+    
+    p.add(_OP_save)
+    p.add(_OP_lspace)
+    x := p.pc()
+    p.chr(_OP_check_char, '}')
+    p.chr(_OP_match_char, '"')
+    p.fmv(_OP_struct_field, fm)
+    p.add(_OP_lspace)
+    p.chr(_OP_match_char, ':')
+    p.tab(_OP_switch, sw)
+    p.add(_OP_object_next)
+    y0 := p.pc()
+    p.add(_OP_lspace)
+    y1 := p.pc()
+    p.chr(_OP_check_char, '}')
+    p.chr(_OP_match_char, ',')
+
+    /* special case of an empty struct */
+    if len(fv) == 0 {
+        p.add(_OP_object_skip)
+        goto end_of_object
+    }
+
+    /* match the remaining fields */
+    p.add(_OP_lspace)
+    p.chr(_OP_match_char, '"')
+    p.fmv(_OP_struct_field, fm)
+    p.add(_OP_lspace)
+    p.chr(_OP_match_char, ':')
+    p.tab(_OP_switch, sw)
+    p.add(_OP_object_next)
+    p.int(_OP_goto, y0)
+
+    /* process each field */
+    for i, f := range fv {
+        sw[i] = p.pc()
+        fm.Set(f.Name, i)
+
+        /* index to the field */
+        for _, o := range f.Path {
+            if p.int(_OP_index, int(o.Size)); o.Kind == resolver.F_deref {
+                p.rtt(_OP_deref, o.Type)
+            }
+        }
+
+        /* check for "stringnize" option */
+        if (f.Opts & resolver.F_stringize) == 0 {
+            self.compileOne(p, sp + 1, f.Type)
+        } else {
+            self.compileStructFieldStr(p, sp + 1, f.Type)
+        }
+
+        /* load the state, and try next field */
+        p.add(_OP_load)
+        p.int(_OP_goto, y0)
+    }
+
+end_of_object:
+    p.pin(x)
+    p.pin(y1)
+    p.add(_OP_drop)
+    p.pin(n)
+    p.pin(skip)
+}
+
+func (self *_Compiler) compileStructFieldStr(p *_Program, sp int, vt reflect.Type) {
+    n1 := -1
+    ft := vt
+    sv := false
+
+    /* dereference the pointer if needed */
+    if ft.Kind() == reflect.Ptr {
+        ft = ft.Elem()
+    }
+
+    /* check if it can be stringized */
+    switch ft.Kind() {
+        case reflect.Bool    : sv = true
+        case reflect.Int     : sv = true
+        case reflect.Int8    : sv = true
+        case reflect.Int16   : sv = true
+        case reflect.Int32   : sv = true
+        case reflect.Int64   : sv = true
+        case reflect.Uint    : sv = true
+        case reflect.Uint8   : sv = true
+        case reflect.Uint16  : sv = true
+        case reflect.Uint32  : sv = true
+        case reflect.Uint64  : sv = true
+        case reflect.Uintptr : sv = true
+        case reflect.Float32 : sv = true
+        case reflect.Float64 : sv = true
+        case reflect.String  : sv = true
+    }
+
+    /* if it's not, ignore the "string" and follow the regular path */
+    if !sv {
+        self.compileOne(p, sp, vt)
+        return
+    }
+
+    /* remove the leading space, and match the leading quote */
+    vk := vt.Kind()
+    p.add(_OP_lspace)
+    n0 := p.pc()
+    p.add(_OP_is_null)
+    
+    skip := self.checkIfSkip(p, stringType, '"')
+
+    /* also check for inner "null" */
+    n1 = p.pc()
+    p.add(_OP_is_null_quote)
+
+    /* dereference the pointer only when it is not null */
+    if vk == reflect.Ptr {
+        vt = vt.Elem()
+        p.rtt(_OP_deref, vt)
+    }
+
+    n2 := p.pc()
+    p.chr(_OP_check_char_0, '"')
+
+    /* string opcode selector */
+    _OP_string := func() _Op {
+        if ft == jsonNumberType {
+            return _OP_num
+        } else {
+            return _OP_unquote
+        }
+    }
+
+    /* compile for each type */
+    switch vt.Kind() {
+        case reflect.Bool    : p.add(_OP_bool)
+        case reflect.Int     : p.add(_OP_int())
+        case reflect.Int8    : p.add(_OP_i8)
+        case reflect.Int16   : p.add(_OP_i16)
+        case reflect.Int32   : p.add(_OP_i32)
+        case reflect.Int64   : p.add(_OP_i64)
+        case reflect.Uint    : p.add(_OP_uint())
+        case reflect.Uint8   : p.add(_OP_u8)
+        case reflect.Uint16  : p.add(_OP_u16)
+        case reflect.Uint32  : p.add(_OP_u32)
+        case reflect.Uint64  : p.add(_OP_u64)
+        case reflect.Uintptr : p.add(_OP_uintptr())
+        case reflect.Float32 : p.add(_OP_f32)
+        case reflect.Float64 : p.add(_OP_f64)
+        case reflect.String  : p.add(_OP_string())
+        default              : panic("not reachable")
+    }
+
+    /* the closing quote is not needed when parsing a pure string */
+    if vt == jsonNumberType || vt.Kind() != reflect.String {
+        p.chr(_OP_match_char, '"')
+    }
+
+    /* pin the `is_null_quote` jump location */
+    if n1 != -1 && vk != reflect.Ptr {
+        p.pin(n1)
+    }
+
+    /* "null" but not a pointer, act as if the field is not present */
+    if vk != reflect.Ptr {
+        pc2 := p.pc()
+        p.add(_OP_goto)
+        p.pin(n2)
+        p.rtt(_OP_dismatch_err, vt)
+        p.int(_OP_add, 1)
+        p.pin(pc2)
+        p.pin(n0)
+        return
+    }
+
+    /* the "null" case of the pointer */
+    pc := p.pc()
+    p.add(_OP_goto)
+    p.pin(n0) // `is_null` jump location
+    p.pin(n1) // `is_null_quote` jump location
+    p.add(_OP_nil_1)
+    pc2 := p.pc()
+    p.add(_OP_goto)
+    p.pin(n2)
+    p.rtt(_OP_dismatch_err, vt)
+    p.int(_OP_add, 1)
+    p.pin(pc)
+    p.pin(pc2)
+    p.pin(skip)
+}
+
+func (self *_Compiler) compileInterface(p *_Program, vt reflect.Type) {
+    i := p.pc()
+    p.add(_OP_is_null)
+
+    /* check for empty interface */
+    if vt.NumMethod() == 0 {
+        p.add(_OP_any)
+    } else {
+        p.rtt(_OP_dyn, vt)
+    }
+
+    /* finish the OpCode */
+    j := p.pc()
+    p.add(_OP_goto)
+    p.pin(i)
+    p.add(_OP_nil_2)
+    p.pin(j)
+}
+
+func (self *_Compiler) compilePrimitive(vt reflect.Type, p *_Program, op _Op) {
+    i := p.pc()
+    p.add(_OP_is_null)
+    // skip := self.checkPrimitive(p, vt)
+    p.add(op)
+    p.pin(i)
+    // p.pin(skip)
+}
+
+func (self *_Compiler) compileUnmarshalEnd(p *_Program, vt reflect.Type, i int) {
+    j := p.pc()
+    k := vt.Kind()
+
+    /* not a pointer */
+    if k != reflect.Ptr {
+        p.pin(i)
+        return
+    }
+
+    /* it seems that in Go JSON library, "null" takes priority over any kind of unmarshaler */
+    p.add(_OP_goto)
+    p.pin(i)
+    p.add(_OP_nil_1)
+    p.pin(j)
+}
+
+func (self *_Compiler) compileUnmarshalJson(p *_Program, vt reflect.Type) {
+    i := p.pc()
+    v := _OP_unmarshal
+    p.add(_OP_is_null)
+
+    /* check for dynamic interface */
+    if vt.Kind() == reflect.Interface {
+        v = _OP_dyn
+    }
+
+    /* call the unmarshaler */
+    p.rtt(v, vt)
+    self.compileUnmarshalEnd(p, vt, i)
+}
+
+func (self *_Compiler) compileUnmarshalText(p *_Program, vt reflect.Type) {
+    i := p.pc()
+    v := _OP_unmarshal_text
+    p.add(_OP_is_null)
+
+    /* check for dynamic interface */
+    if vt.Kind() == reflect.Interface {
+        v = _OP_dyn
+    } else {
+        p.chr(_OP_match_char, '"')
+    }
+
+    /* call the unmarshaler */
+    p.rtt(v, vt)
+    self.compileUnmarshalEnd(p, vt, i)
+}
+
+func (self *_Compiler) compileUnmarshalTextPtr(p *_Program, vt reflect.Type) {
+    i := p.pc()
+    p.add(_OP_is_null)
+    p.chr(_OP_match_char, '"')
+    p.rtt(_OP_unmarshal_text_p, vt)
+    p.pin(i)
+}
+
+func (self *_Compiler) checkIfSkip(p *_Program, vt reflect.Type, c byte) int {
+    j := p.pc()
+    p.chr(_OP_check_char_0, c)
+    p.rtt(_OP_dismatch_err, vt)
+    s := p.pc()
+    p.add(_OP_go_skip)
+    p.pin(j)
+    p.int(_OP_add, 1)
+    return s
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/decoder/debug.go b/vendor/github.com/bytedance/sonic/decoder/debug.go
new file mode 100644
index 000000000..9cf3a6a00
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/debug.go
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+	`os`
+	`runtime`
+	`runtime/debug`
+	`strings`
+
+	`github.com/bytedance/sonic/internal/jit`
+)
+
+
+var (
+    debugSyncGC  = os.Getenv("SONIC_SYNC_GC") != ""
+    debugAsyncGC = os.Getenv("SONIC_NO_ASYNC_GC") == ""
+)
+
+var (
+    _Instr_End _Instr = newInsOp(_OP_nil_1)
+
+    _F_gc       = jit.Func(runtime.GC)
+    _F_force_gc = jit.Func(debug.FreeOSMemory)
+    _F_println  = jit.Func(println_wrapper)
+    _F_print    = jit.Func(print)
+)
+
+func println_wrapper(i int, op1 int, op2 int){
+    println(i, " Intrs ", op1, _OpNames[op1], "next: ", op2, _OpNames[op2])
+}
+
+func print(i int){
+    println(i)
+}
+
+func (self *_Assembler) force_gc() {
+    self.call_go(_F_gc)
+    self.call_go(_F_force_gc)
+}
+
+func (self *_Assembler) debug_instr(i int, v *_Instr) {
+    if debugSyncGC {
+        if (i+1 == len(self.p)) {
+            self.print_gc(i, v, &_Instr_End) 
+        } else {
+            next := &(self.p[i+1])
+            self.print_gc(i, v, next)
+            name := _OpNames[next.op()]
+            if strings.Contains(name, "save") {
+                return
+            }
+        }
+        self.force_gc()
+    }
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/decoder/decoder.go b/vendor/github.com/bytedance/sonic/decoder/decoder.go
new file mode 100644
index 000000000..5326f9728
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/decoder.go
@@ -0,0 +1,245 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `encoding/json`
+    `reflect`
+    `runtime`
+
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/bytedance/sonic/option`
+    `github.com/bytedance/sonic/utf8`
+)
+
+const (
+    _F_use_int64 = 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
+}
+
+func (self *Decoder) CheckTrailings() error {
+    pos := self.i
+    buf := self.s
+    /* skip all the trailing spaces */
+    if pos != len(buf) {
+        for pos < len(buf) && (types.SPACE_MASK & (1 << buf[pos])) != 0 {
+            pos++
+        }
+    }
+
+    /* then it must be at EOF */
+    if pos == len(buf) {
+        return nil
+    }
+
+    /* junk after JSON value */
+    return SyntaxError {
+        Src  : buf,
+        Pos  : pos,
+        Code : types.ERR_INVALID_CHAR,
+    }
+}
+
+
+// Decode parses the JSON-encoded data from current position and stores the result
+// in the value pointed to by val.
+func (self *Decoder) Decode(val interface{}) error {
+    /* validate json if needed */
+    if (self.f & (1 << _F_validate_string)) != 0  && !utf8.ValidateString(self.s){
+        dbuf := utf8.CorrectWith(nil, rt.Str2Mem(self.s), "\ufffd")
+        self.s = rt.Mem2Str(dbuf)
+    }
+
+    vv := rt.UnpackEface(val)
+    vp := vv.Value
+
+    /* check for nil type */
+    if vv.Type == nil {
+        return &json.InvalidUnmarshalError{}
+    }
+
+    /* must be a non-nil pointer */
+    if vp == nil || vv.Type.Kind() != reflect.Ptr {
+        return &json.InvalidUnmarshalError{Type: vv.Type.Pack()}
+    }
+
+    /* create a new stack, and call the decoder */
+    sb, etp := newStack(), rt.PtrElem(vv.Type)
+    nb, err := decodeTypedPointer(self.s, self.i, etp, vp, sb, self.f)
+    /* return the stack back */
+    self.i = nb
+    freeStack(sb)
+
+    /* avoid GC ahead */
+    runtime.KeepAlive(vv)
+    return err
+}
+
+// UseInt64 indicates the Decoder to unmarshal an integer into an interface{} as an
+// int64 instead of as a float64.
+func (self *Decoder) UseInt64() {
+    self.f  |= 1 << _F_use_int64
+    self.f &^= 1 << _F_use_number
+}
+
+// UseNumber indicates the Decoder to unmarshal a number into an interface{} as a
+// json.Number instead of as a float64.
+func (self *Decoder) UseNumber() {
+    self.f &^= 1 << _F_use_int64
+    self.f  |= 1 << _F_use_number
+}
+
+// UseUnicodeErrors indicates the Decoder to return an error when encounter invalid
+// UTF-8 escape sequences.
+func (self *Decoder) UseUnicodeErrors() {
+    self.f |= 1 << _F_disable_urc
+}
+
+// DisallowUnknownFields indicates the Decoder to return an error when the destination
+// is a struct and the input contains object keys which do not match any
+// non-ignored, exported fields in the destination.
+func (self *Decoder) DisallowUnknownFields() {
+    self.f |= 1 << _F_disable_unknown
+}
+
+// CopyString indicates the Decoder to decode string values by copying instead of referring.
+func (self *Decoder) CopyString() {
+    self.f |= 1 << _F_copy_string
+}
+
+// ValidateString causes the Decoder to validate string values when decoding string value 
+// in JSON. Validation is that, returning error when unescaped control chars(0x00-0x1f) or
+// invalid UTF-8 chars in the string value of JSON.
+func (self *Decoder) ValidateString() {
+    self.f |= 1 << _F_validate_string
+}
+
+// Pretouch compiles vt ahead-of-time to avoid JIT compilation on-the-fly, in
+// order to reduce the first-hit latency.
+//
+// Opts are the compile options, for example, "option.WithCompileRecursiveDepth" is
+// a compile option to set the depth of recursive compile for the nested struct type.
+func Pretouch(vt reflect.Type, opts ...option.CompileOption) error {
+    cfg := option.DefaultCompileOptions()
+    for _, opt := range opts {
+        opt(&cfg)
+    }
+    return pretouchRec(map[reflect.Type]bool{vt:true}, cfg)
+}
+
+func pretouchType(_vt reflect.Type, opts option.CompileOptions) (map[reflect.Type]bool, error) {
+    /* compile function */
+    compiler := newCompiler().apply(opts)
+    decoder := func(vt *rt.GoType, _ ...interface{}) (interface{}, error) {
+        if pp, err := compiler.compile(_vt); err != nil {
+            return nil, err
+        } else {
+            as := newAssembler(pp)
+            as.name = _vt.String()
+            return as.Load(), nil
+        }
+    }
+
+    /* find or compile */
+    vt := rt.UnpackType(_vt)
+    if val := programCache.Get(vt); val != nil {
+        return nil, nil
+    } else if _, err := programCache.Compute(vt, decoder); err == nil {
+        return compiler.rec, nil
+    } else {
+        return nil, err
+    }
+}
+
+func pretouchRec(vtm map[reflect.Type]bool, opts option.CompileOptions) error {
+    if opts.RecursiveDepth < 0 || len(vtm) == 0 {
+        return nil
+    }
+    next := make(map[reflect.Type]bool)
+    for vt := range(vtm) {
+        sub, err := pretouchType(vt, opts)
+        if err != nil {
+            return err
+        }
+        for svt := range(sub) {
+            next[svt] = true
+        }
+    }
+    opts.RecursiveDepth -= 1
+    return pretouchRec(next, opts)
+}
+
+// Skip skips only one json value, and returns first non-blank character position and its ending position if it is valid.
+// Otherwise, returns negative error code using start and invalid character position using end
+func Skip(data []byte) (start int, end int) {
+    s := rt.Mem2Str(data)
+    p := 0
+    m := types.NewStateMachine()
+    ret := native.SkipOne(&s, &p, m, uint64(0))
+    types.FreeStateMachine(m) 
+    return ret, p
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/decoder/errors.go b/vendor/github.com/bytedance/sonic/decoder/errors.go
new file mode 100644
index 000000000..c905fdfb0
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/errors.go
@@ -0,0 +1,181 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `encoding/json`
+    `errors`
+    `fmt`
+    `reflect`
+    `strconv`
+    `strings`
+
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+type SyntaxError struct {
+    Pos  int
+    Src  string
+    Code types.ParsingError
+    Msg  string
+}
+
+func (self SyntaxError) Error() string {
+    return fmt.Sprintf("%q", self.Description())
+}
+
+func (self SyntaxError) Description() string {
+    return "Syntax error " + self.description()
+}
+
+func (self SyntaxError) description() string {
+    i := 16
+    p := self.Pos - i
+    q := self.Pos + i
+
+    /* check for empty source */
+    if self.Src == "" {
+        return fmt.Sprintf("no sources available: %#v", self)
+    }
+
+    /* prevent slicing before the beginning */
+    if p < 0 {
+        p, q, i = 0, q - p, i + p
+    }
+
+    /* prevent slicing beyond the end */
+    if n := len(self.Src); q > n {
+        n = q - n
+        q = len(self.Src)
+
+        /* move the left bound if possible */
+        if p > n {
+            i += n
+            p -= n
+        }
+    }
+
+    /* left and right length */
+    x := clamp_zero(i)
+    y := clamp_zero(q - p - i - 1)
+
+    /* compose the error description */
+    return fmt.Sprintf(
+        "at index %d: %s\n\n\t%s\n\t%s^%s\n",
+        self.Pos,
+        self.Message(),
+        self.Src[p:q],
+        strings.Repeat(".", x),
+        strings.Repeat(".", y),
+    )
+}
+
+func (self SyntaxError) Message() string {
+    if self.Msg == "" {
+        return self.Code.Message()
+    }
+    return self.Msg
+}
+
+func clamp_zero(v int) int {
+    if v < 0 {
+        return 0
+    } else {
+        return v
+    }
+}
+
+/** JIT Error Helpers **/
+
+var stackOverflow = &json.UnsupportedValueError {
+    Str   : "Value nesting too deep",
+    Value : reflect.ValueOf("..."),
+}
+
+//go:nosplit
+func error_wrap(src string, pos int, code types.ParsingError) error {
+    return SyntaxError {
+        Pos  : pos,
+        Src  : src,
+        Code : code,
+    }
+}
+
+//go:nosplit
+func error_type(vt *rt.GoType) error {
+    return &json.UnmarshalTypeError{Type: vt.Pack()}
+}
+
+type MismatchTypeError struct {
+    Pos  int
+    Src  string
+    Type reflect.Type
+}
+
+func swithchJSONType (src string, pos int) string {
+    var val string
+    switch src[pos] {
+        case 'f': fallthrough
+        case 't': val = "bool"
+        case '"': val = "string"
+        case '{': val = "object"
+        case '[': val = "array"
+        case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': val = "number"        
+    }
+    return val
+}
+
+func (self MismatchTypeError) Error() string {
+    se := SyntaxError {
+        Pos  : self.Pos,
+        Src  : self.Src,
+        Code : types.ERR_MISMATCH,
+    }
+    return fmt.Sprintf("Mismatch type %s with value %s %q", self.Type.String(), swithchJSONType(self.Src, self.Pos), se.description())
+}
+
+func (self MismatchTypeError) Description() string {
+    se := SyntaxError {
+        Pos  : self.Pos,
+        Src  : self.Src,
+        Code : types.ERR_MISMATCH,
+    }
+    return fmt.Sprintf("Mismatch type %s with value %s %s", self.Type.String(), swithchJSONType(self.Src, self.Pos), se.description())
+}
+
+//go:nosplit
+func error_mismatch(src string, pos int, vt *rt.GoType) error {
+    return &MismatchTypeError {
+        Pos  : pos,
+        Src  : src,
+        Type : vt.Pack(),
+    }
+}
+
+//go:nosplit
+func error_field(name string) error {
+    return errors.New("json: unknown field " + strconv.Quote(name))
+}
+
+//go:nosplit
+func error_value(value string, vtype reflect.Type) error {
+    return &json.UnmarshalTypeError {
+        Type  : vtype,
+        Value : value,
+    }
+}
diff --git a/vendor/github.com/bytedance/sonic/decoder/generic_amd64_go116.go b/vendor/github.com/bytedance/sonic/decoder/generic_amd64_go116.go
new file mode 100644
index 000000000..b597043f9
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/generic_amd64_go116.go
@@ -0,0 +1,776 @@
+// +build go1.15,!go1.17
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `encoding/json`
+    `fmt`
+    `reflect`
+    `strconv`
+
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/twitchyliquid64/golang-asm/obj`
+    `github.com/twitchyliquid64/golang-asm/obj/x86`
+)
+
+/** Crucial Registers:
+ *
+ *      ST(BX)  : ro, decoder stack
+ *      DF(R10) : ro, decoder flags
+ *      EP(R11) : wo, error pointer
+ *      IP(R12) : ro, input pointer
+ *      IL(R13) : ro, input length
+ *      IC(R14) : rw, input cursor
+ *      VP(R15) : ro, value pointer (to an interface{})
+ */
+
+const (
+    _VD_args   = 8      // 8 bytes  for passing arguments to this functions
+    _VD_fargs  = 64     // 64 bytes for passing arguments to other Go functions
+    _VD_saves  = 40     // 40 bytes for saving the registers before CALL instructions
+    _VD_locals = 88     // 88 bytes for local variables
+)
+
+const (
+    _VD_offs = _VD_fargs + _VD_saves + _VD_locals
+    _VD_size = _VD_offs + 8     // 8 bytes for the parent frame pointer
+)
+
+var (
+    _VAR_ss = _VAR_ss_Vt
+    _VAR_df = jit.Ptr(_SP, _VD_fargs + _VD_saves)
+)
+
+var (
+    _VAR_ss_Vt = jit.Ptr(_SP, _VD_fargs + _VD_saves + 8)
+    _VAR_ss_Dv = jit.Ptr(_SP, _VD_fargs + _VD_saves + 16)
+    _VAR_ss_Iv = jit.Ptr(_SP, _VD_fargs + _VD_saves + 24)
+    _VAR_ss_Ep = jit.Ptr(_SP, _VD_fargs + _VD_saves + 32)
+    _VAR_ss_Db = jit.Ptr(_SP, _VD_fargs + _VD_saves + 40)
+    _VAR_ss_Dc = jit.Ptr(_SP, _VD_fargs + _VD_saves + 48)
+)
+
+var (
+    _VAR_cs_LR = jit.Ptr(_SP, _VD_fargs + _VD_saves + 56)
+    _VAR_cs_p = jit.Ptr(_SP, _VD_fargs + _VD_saves + 64)
+    _VAR_cs_n = jit.Ptr(_SP, _VD_fargs + _VD_saves + 72)
+    _VAR_cs_d = jit.Ptr(_SP, _VD_fargs + _VD_saves + 80)
+)
+
+type _ValueDecoder struct {
+    jit.BaseAssembler
+}
+
+func (self *_ValueDecoder) build() uintptr {
+    self.Init(self.compile)
+    return *(*uintptr)(self.Load("decode_value", _VD_size, _VD_args, argPtrs_generic, localPtrs_generic))
+}
+
+/** Function Calling Helpers **/
+
+func (self *_ValueDecoder) save(r ...obj.Addr) {
+    for i, v := range r {
+        if i > _VD_saves / 8 - 1 {
+            panic("too many registers to save")
+        } else {
+            self.Emit("MOVQ", v, jit.Ptr(_SP, _VD_fargs + int64(i) * 8))
+        }
+    }
+}
+
+func (self *_ValueDecoder) load(r ...obj.Addr) {
+    for i, v := range r {
+        if i > _VD_saves / 8 - 1 {
+            panic("too many registers to load")
+        } else {
+            self.Emit("MOVQ", jit.Ptr(_SP, _VD_fargs + int64(i) * 8), v)
+        }
+    }
+}
+
+func (self *_ValueDecoder) call(fn obj.Addr) {
+    self.Emit("MOVQ", fn, _AX)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _AX)      // CALL AX
+}
+
+func (self *_ValueDecoder) call_go(fn obj.Addr) {
+    self.save(_REG_go...)   // SAVE $REG_go
+    self.call(fn)           // CALL ${fn}
+    self.load(_REG_go...)   // LOAD $REG_go
+}
+
+/** Decoder Assembler **/
+
+const (
+    _S_val = iota + 1
+    _S_arr
+    _S_arr_0
+    _S_obj
+    _S_obj_0
+    _S_obj_delim
+    _S_obj_sep
+)
+
+const (
+    _S_omask_key = (1 << _S_obj_0) | (1 << _S_obj_sep)
+    _S_omask_end = (1 << _S_obj_0) | (1 << _S_obj)
+    _S_vmask = (1 << _S_val) | (1 << _S_arr_0)
+)
+
+const (
+    _A_init_len = 1
+    _A_init_cap = 16
+)
+
+const (
+    _ST_Sp = 0
+    _ST_Vt = _PtrBytes
+    _ST_Vp = _PtrBytes * (types.MAX_RECURSE + 1)
+)
+
+var (
+    _V_true  = jit.Imm(int64(pbool(true)))
+    _V_false = jit.Imm(int64(pbool(false)))
+    _F_value = jit.Imm(int64(native.S_value))
+)
+
+var (
+    _V_max     = jit.Imm(int64(types.V_MAX))
+    _E_eof     = jit.Imm(int64(types.ERR_EOF))
+    _E_invalid = jit.Imm(int64(types.ERR_INVALID_CHAR))
+    _E_recurse = jit.Imm(int64(types.ERR_RECURSE_EXCEED_MAX))
+)
+
+var (
+    _F_convTslice    = jit.Func(convTslice)
+    _F_convTstring   = jit.Func(convTstring)
+    _F_invalid_vtype = jit.Func(invalid_vtype)
+)
+
+var (
+    _T_map     = jit.Type(reflect.TypeOf((map[string]interface{})(nil)))
+    _T_bool    = jit.Type(reflect.TypeOf(false))
+    _T_int64   = jit.Type(reflect.TypeOf(int64(0)))
+    _T_eface   = jit.Type(reflect.TypeOf((*interface{})(nil)).Elem())
+    _T_slice   = jit.Type(reflect.TypeOf(([]interface{})(nil)))
+    _T_string  = jit.Type(reflect.TypeOf(""))
+    _T_number  = jit.Type(reflect.TypeOf(json.Number("")))
+    _T_float64 = jit.Type(reflect.TypeOf(float64(0)))
+)
+
+var _R_tab = map[int]string {
+    '[': "_decode_V_ARRAY",
+    '{': "_decode_V_OBJECT",
+    ':': "_decode_V_KEY_SEP",
+    ',': "_decode_V_ELEM_SEP",
+    ']': "_decode_V_ARRAY_END",
+    '}': "_decode_V_OBJECT_END",
+}
+
+func (self *_ValueDecoder) compile() {
+    self.Emit("SUBQ", jit.Imm(_VD_size), _SP)       // SUBQ $_VD_size, SP
+    self.Emit("MOVQ", _BP, jit.Ptr(_SP, _VD_offs))  // MOVQ BP, _VD_offs(SP)
+    self.Emit("LEAQ", jit.Ptr(_SP, _VD_offs), _BP)  // LEAQ _VD_offs(SP), BP
+
+    /* initialize the state machine */
+    self.Emit("XORL", _CX, _CX)                                 // XORL CX, CX
+    self.Emit("MOVQ", _DF, _VAR_df)                             // MOVQ DF, df
+    /* initialize digital buffer first */
+    self.Emit("MOVQ", jit.Imm(_MaxDigitNums), _VAR_ss_Dc)       // MOVQ $_MaxDigitNums, ss.Dcap
+    self.Emit("LEAQ", jit.Ptr(_ST, _DbufOffset), _AX)           // LEAQ _DbufOffset(ST), AX
+    self.Emit("MOVQ", _AX, _VAR_ss_Db)                          // MOVQ AX, ss.Dbuf
+    /* add ST offset */
+    self.Emit("ADDQ", jit.Imm(_FsmOffset), _ST)                 // ADDQ _FsmOffset, _ST
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                // MOVQ CX, ST.Sp
+    self.WriteRecNotAX(0, _VP, jit.Ptr(_ST, _ST_Vp), false)                // MOVQ VP, ST.Vp[0]
+    self.Emit("MOVQ", jit.Imm(_S_val), jit.Ptr(_ST, _ST_Vt))    // MOVQ _S_val, ST.Vt[0]
+    self.Sjmp("JMP" , "_next")                                  // JMP  _next
+
+    /* set the value from previous round */
+    self.Link("_set_value")                                 // _set_value:
+    self.Emit("MOVL" , jit.Imm(_S_vmask), _DX)              // MOVL  _S_vmask, DX
+    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _CX)           // MOVQ  ST.Sp, CX
+    self.Emit("MOVQ" , jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)   // MOVQ  ST.Vt[CX], AX
+    self.Emit("BTQ"  , _AX, _DX)                            // BTQ   AX, DX
+    self.Sjmp("JNC"  , "_vtype_error")                      // JNC   _vtype_error
+    self.Emit("XORL" , _SI, _SI)                            // XORL  SI, SI
+    self.Emit("SUBQ" , jit.Imm(1), jit.Ptr(_ST, _ST_Sp))    // SUBQ  $1, ST.Sp
+    self.Emit("XCHGQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)   // XCHGQ ST.Vp[CX], SI
+    self.Emit("MOVQ" , _R8, jit.Ptr(_SI, 0))                // MOVQ  R8, (SI)
+    self.WriteRecNotAX(1, _R9, jit.Ptr(_SI, 8), false)           // MOVQ  R9, 8(SI)
+
+    /* check for value stack */
+    self.Link("_next")                              // _next:
+    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _AX)   // MOVQ  ST.Sp, AX
+    self.Emit("TESTQ", _AX, _AX)                    // TESTQ AX, AX
+    self.Sjmp("JS"   , "_return")                   // JS    _return
+
+    /* fast path: test up to 4 characters manually */
+    self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
+    self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
+    self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
+    self.Emit("MOVQ"   , jit.Imm(_BM_space), _DX)       // MOVQ    _BM_space, DX
+    self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
+    self.Sjmp("JA"     , "_decode_fast")                // JA      _decode_fast
+    self.Emit("BTQ"    , _AX, _DX)                      // BTQ     _AX, _DX
+    self.Sjmp("JNC"    , "_decode_fast")                // JNC     _decode_fast
+    self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
+
+    /* at least 1 to 3 spaces */
+    for i := 0; i < 3; i++ {
+        self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
+        self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
+        self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
+        self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
+        self.Sjmp("JA"     , "_decode_fast")                // JA      _decode_fast
+        self.Emit("BTQ"    , _AX, _DX)                      // BTQ     _AX, _DX
+        self.Sjmp("JNC"    , "_decode_fast")                // JNC     _decode_fast
+        self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
+    }
+
+    /* at least 4 spaces */
+    self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
+    self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
+    self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
+
+    /* fast path: use lookup table to select decoder */
+    self.Link("_decode_fast")                           // _decode_fast:
+    self.Byte(0x48, 0x8d, 0x3d)                         // LEAQ    ?(PC), DI
+    self.Sref("_decode_tab", 4)                         // ....    &_decode_tab
+    self.Emit("MOVLQSX", jit.Sib(_DI, _AX, 4, 0), _AX)  // MOVLQSX (DI)(AX*4), AX
+    self.Emit("TESTQ"  , _AX, _AX)                      // TESTQ   AX, AX
+    self.Sjmp("JZ"     , "_decode_native")              // JZ      _decode_native
+    self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
+    self.Emit("ADDQ"   , _DI, _AX)                      // ADDQ    DI, AX
+    self.Rjmp("JMP"    , _AX)                           // JMP     AX
+
+    /* decode with native decoder */
+    self.Link("_decode_native")         // _decode_native:
+    self.Emit("MOVQ", _IP, _DI)         // MOVQ IP, DI
+    self.Emit("MOVQ", _IL, _SI)         // MOVQ IL, SI
+    self.Emit("MOVQ", _IC, _DX)         // MOVQ IC, DX
+    self.Emit("LEAQ", _VAR_ss, _CX)     // LEAQ ss, CX
+    self.Emit("MOVQ", _VAR_df, _R8)     // MOVQ $df, R8
+    self.Emit("BTSQ", jit.Imm(_F_allow_control), _R8)  // ANDQ $1<<_F_allow_control, R8
+    self.call(_F_value)                 // CALL value
+    self.Emit("MOVQ", _AX, _IC)         // MOVQ AX, IC
+
+    /* check for errors */
+    self.Emit("MOVQ" , _VAR_ss_Vt, _AX)     // MOVQ  ss.Vt, AX
+    self.Emit("TESTQ", _AX, _AX)            // TESTQ AX, AX
+    self.Sjmp("JS"   , "_parsing_error")
+    self.Sjmp("JZ"   , "_invalid_vtype")    // JZ    _invalid_vtype
+    self.Emit("CMPQ" , _AX, _V_max)         // CMPQ  AX, _V_max
+    self.Sjmp("JA"   , "_invalid_vtype")    // JA    _invalid_vtype
+
+    /* jump table selector */
+    self.Byte(0x48, 0x8d, 0x3d)                             // LEAQ    ?(PC), DI
+    self.Sref("_switch_table", 4)                           // ....    &_switch_table
+    self.Emit("MOVLQSX", jit.Sib(_DI, _AX, 4, -4), _AX)     // MOVLQSX -4(DI)(AX*4), AX
+    self.Emit("ADDQ"   , _DI, _AX)                          // ADDQ    DI, AX
+    self.Rjmp("JMP"    , _AX)                               // JMP     AX
+
+    /** V_EOF **/
+    self.Link("_decode_V_EOF")          // _decode_V_EOF:
+    self.Emit("MOVL", _E_eof, _EP)      // MOVL _E_eof, EP
+    self.Sjmp("JMP" , "_error")         // JMP  _error
+
+    /** V_NULL **/
+    self.Link("_decode_V_NULL")                 // _decode_V_NULL:
+    self.Emit("XORL", _R8, _R8)                 // XORL R8, R8
+    self.Emit("XORL", _R9, _R9)                 // XORL R9, R9
+    self.Emit("LEAQ", jit.Ptr(_IC, -4), _DI)    // LEAQ -4(IC), DI
+    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
+
+    /** V_TRUE **/
+    self.Link("_decode_V_TRUE")                 // _decode_V_TRUE:
+    self.Emit("MOVQ", _T_bool, _R8)             // MOVQ _T_bool, R8
+    // TODO: maybe modified by users?
+    self.Emit("MOVQ", _V_true, _R9)             // MOVQ _V_true, R9 
+    self.Emit("LEAQ", jit.Ptr(_IC, -4), _DI)    // LEAQ -4(IC), DI
+    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
+
+    /** V_FALSE **/
+    self.Link("_decode_V_FALSE")                // _decode_V_FALSE:
+    self.Emit("MOVQ", _T_bool, _R8)             // MOVQ _T_bool, R8
+    self.Emit("MOVQ", _V_false, _R9)            // MOVQ _V_false, R9
+    self.Emit("LEAQ", jit.Ptr(_IC, -5), _DI)    // LEAQ -5(IC), DI
+    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
+
+    /** V_ARRAY **/
+    self.Link("_decode_V_ARRAY")                            // _decode_V_ARRAY
+    self.Emit("MOVL", jit.Imm(_S_vmask), _DX)               // MOVL _S_vmask, DX
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
+    self.Emit("BTQ" , _AX, _DX)                             // BTQ  AX, DX
+    self.Sjmp("JNC" , "_invalid_char")                      // JNC  _invalid_char
+
+    /* create a new array */
+    self.Emit("MOVQ", _T_eface, _AX)                            // MOVQ    _T_eface, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))                     // MOVQ    AX, (SP)
+    self.Emit("MOVQ", jit.Imm(_A_init_len), jit.Ptr(_SP, 8))    // MOVQ    _A_init_len, 8(SP)
+    self.Emit("MOVQ", jit.Imm(_A_init_cap), jit.Ptr(_SP, 16))   // MOVQ    _A_init_cap, 16(SP)
+    self.call_go(_F_makeslice)                                  // CALL_GO runtime.makeslice
+    self.Emit("MOVQ", jit.Ptr(_SP, 24), _DX)                    // MOVQ    24(SP), DX
+
+    /* pack into an interface */
+    self.Emit("MOVQ", _DX, jit.Ptr(_SP, 0))                     // MOVQ    DX, (SP)
+    self.Emit("MOVQ", jit.Imm(_A_init_len), jit.Ptr(_SP, 8))    // MOVQ    _A_init_len, 8(SP)
+    self.Emit("MOVQ", jit.Imm(_A_init_cap), jit.Ptr(_SP, 16))   // MOVQ    _A_init_cap, 16(SP)
+    self.call_go(_F_convTslice)                                 // CALL_GO runtime.convTslice
+    self.Emit("MOVQ", jit.Ptr(_SP, 24), _R8)                    // MOVQ    24(SP), R8
+
+    /* replace current state with an array */
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)                // MOVQ ST.Vp[CX], SI
+    self.Emit("MOVQ", jit.Imm(_S_arr), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ _S_arr, ST.Vt[CX]
+    self.Emit("MOVQ", _T_slice, _AX)                                    // MOVQ _T_slice, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_SI, 0))                             // MOVQ AX, (SI)
+    self.WriteRecNotAX(2, _R8, jit.Ptr(_SI, 8), false)                            // MOVQ R8, 8(SI)
+
+    /* add a new slot for the first element */
+    self.Emit("ADDQ", jit.Imm(1), _CX)                                  // ADDQ $1, CX
+    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                  // CMPQ CX, ${types.MAX_RECURSE}
+    self.Sjmp("JAE"  , "_stack_overflow")                                // JA   _stack_overflow
+    self.Emit("MOVQ", jit.Ptr(_R8, 0), _AX)                             // MOVQ (R8), AX
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                        // MOVQ CX, ST.Sp
+    self.WritePtrAX(3, jit.Sib(_ST, _CX, 8, _ST_Vp), false)                // MOVQ AX, ST.Vp[CX]
+    self.Emit("MOVQ", jit.Imm(_S_arr_0), jit.Sib(_ST, _CX, 8, _ST_Vt))  // MOVQ _S_arr_0, ST.Vt[CX]
+    self.Sjmp("JMP" , "_next")                                          // JMP  _next
+
+    /** V_OBJECT **/
+    self.Link("_decode_V_OBJECT")                                       // _decode_V_OBJECT:
+    self.Emit("MOVL", jit.Imm(_S_vmask), _DX)                           // MOVL    _S_vmask, DX
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ    ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)                // MOVQ    ST.Vt[CX], AX
+    self.Emit("BTQ" , _AX, _DX)                                         // BTQ     AX, DX
+    self.Sjmp("JNC" , "_invalid_char")                                  // JNC     _invalid_char
+    self.call_go(_F_makemap_small)                                      // CALL_GO runtime.makemap_small
+    self.Emit("MOVQ", jit.Ptr(_SP, 0), _AX)                             // MOVQ    (SP), AX
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ    ST.Sp, CX
+    self.Emit("MOVQ", jit.Imm(_S_obj_0), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ    _S_obj, ST.Vt[CX]
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)                // MOVQ    ST.Vp[CX], SI
+    self.Emit("MOVQ", _T_map, _DX)                                      // MOVQ    _T_map, DX
+    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 0))                             // MOVQ    DX, (SI)
+    self.WritePtrAX(4, jit.Ptr(_SI, 8), false)                             // MOVQ    AX, 8(SI)
+    self.Sjmp("JMP" , "_next")                                          // JMP     _next
+
+    /** V_STRING **/
+    self.Link("_decode_V_STRING")       // _decode_V_STRING:
+    self.Emit("MOVQ", _VAR_ss_Iv, _CX)  // MOVQ ss.Iv, CX
+    self.Emit("MOVQ", _IC, _AX)         // MOVQ IC, AX
+    self.Emit("SUBQ", _CX, _AX)         // SUBQ CX, AX
+
+    /* check for escapes */
+    self.Emit("CMPQ", _VAR_ss_Ep, jit.Imm(-1))          // CMPQ ss.Ep, $-1
+    self.Sjmp("JNE" , "_unquote")                       // JNE  _unquote
+    self.Emit("SUBQ", jit.Imm(1), _AX)                  // SUBQ $1, AX
+    self.Emit("LEAQ", jit.Sib(_IP, _CX, 1, 0), _R8)     // LEAQ (IP)(CX), R8
+    self.Byte(0x48, 0x8d, 0x3d)                         // LEAQ (PC), DI
+    self.Sref("_copy_string_end", 4)
+    self.Emit("BTQ", jit.Imm(_F_copy_string), _VAR_df)
+    self.Sjmp("JC", "copy_string")
+    self.Link("_copy_string_end")                                 
+    self.Emit("XORL", _DX, _DX)                             // XORL DX, DX
+    /* strings with no escape sequences */
+    self.Link("_noescape")                                  // _noescape:
+    self.Emit("MOVL", jit.Imm(_S_omask_key), _DI)               // MOVL _S_omask, DI
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _SI)    // MOVQ ST.Vt[CX], SI
+    self.Emit("BTQ" , _SI, _DI)                             // BTQ  SI, DI
+    self.Sjmp("JC"  , "_object_key")                        // JC   _object_key
+
+    /* check for pre-packed strings, avoid 1 allocation */
+    self.Emit("TESTQ", _DX, _DX)                // TESTQ   DX, DX
+    self.Sjmp("JNZ"  , "_packed_str")           // JNZ     _packed_str
+    self.Emit("MOVQ" , _R8, jit.Ptr(_SP, 0))    // MOVQ    R8, (SP)
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 8))    // MOVQ    AX, 8(SP)
+    self.call_go(_F_convTstring)                // CALL_GO runtime.convTstring
+    self.Emit("MOVQ" , jit.Ptr(_SP, 16), _R9)   // MOVQ    16(SP), R9
+
+    /* packed string already in R9 */
+    self.Link("_packed_str")            // _packed_str:
+    self.Emit("MOVQ", _T_string, _R8)   // MOVQ _T_string, R8
+    self.Emit("MOVQ", _VAR_ss_Iv, _DI)  // MOVQ ss.Iv, DI
+    self.Emit("SUBQ", jit.Imm(1), _DI)  // SUBQ $1, DI
+    self.Sjmp("JMP" , "_set_value")     // JMP  _set_value
+
+    /* the string is an object key, get the map */
+    self.Link("_object_key")
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
+
+    /* add a new delimiter */
+    self.Emit("ADDQ", jit.Imm(1), _CX)                                      // ADDQ $1, CX
+    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                      // CMPQ CX, ${types.MAX_RECURSE}
+    self.Sjmp("JAE"  , "_stack_overflow")                                    // JA   _stack_overflow
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                            // MOVQ CX, ST.Sp
+    self.Emit("MOVQ", jit.Imm(_S_obj_delim), jit.Sib(_ST, _CX, 8, _ST_Vt))  // MOVQ _S_obj_delim, ST.Vt[CX]
+
+    /* add a new slot int the map */
+    self.Emit("MOVQ", _T_map, _DX)                      // MOVQ    _T_map, DX
+    self.Emit("MOVQ", _DX, jit.Ptr(_SP, 0))             // MOVQ    DX, (SP)
+    self.Emit("MOVQ", _SI, jit.Ptr(_SP, 8))             // MOVQ    SI, 8(SP)
+    self.Emit("MOVQ", _R8, jit.Ptr(_SP, 16))            // MOVQ    R9, 16(SP)
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 24))            // MOVQ    AX, 24(SP)
+    self.call_go(_F_mapassign_faststr)                  // CALL_GO runtime.mapassign_faststr
+    self.Emit("MOVQ", jit.Ptr(_SP, 32), _AX)            // MOVQ    32(SP), AX
+
+    /* add to the pointer stack */
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                 // MOVQ ST.Sp, CX
+    self.WritePtrAX(6, jit.Sib(_ST, _CX, 8, _ST_Vp), false)    // MOVQ AX, ST.Vp[CX]
+    self.Sjmp("JMP" , "_next")                                   // JMP  _next
+
+    /* allocate memory to store the string header and unquoted result */
+    self.Link("_unquote")                               // _unquote:
+    self.Emit("ADDQ", jit.Imm(15), _AX)                 // ADDQ    $15, AX
+    self.Emit("MOVQ", _T_byte, _CX)                     // MOVQ    _T_byte, CX
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))             // MOVQ    AX, (SP)
+    self.Emit("MOVQ", _CX, jit.Ptr(_SP, 8))             // MOVQ    CX, 8(SP)
+    self.Emit("MOVB", jit.Imm(0), jit.Ptr(_SP, 16))     // MOVB    $0, 16(SP)
+    self.call_go(_F_mallocgc)                           // CALL_GO runtime.mallocgc
+    self.Emit("MOVQ", jit.Ptr(_SP, 24), _R9)            // MOVQ    24(SP), R9
+
+    /* prepare the unquoting parameters */
+    self.Emit("MOVQ" , _VAR_ss_Iv, _CX)                         // MOVQ  ss.Iv, CX
+    self.Emit("LEAQ" , jit.Sib(_IP, _CX, 1, 0), _DI)            // LEAQ  (IP)(CX), DI
+    self.Emit("NEGQ" , _CX)                                     // NEGQ  CX
+    self.Emit("LEAQ" , jit.Sib(_IC, _CX, 1, -1), _SI)           // LEAQ  -1(IC)(CX), SI
+    self.Emit("LEAQ" , jit.Ptr(_R9, 16), _DX)                   // LEAQ  16(R8), DX
+    self.Emit("LEAQ" , _VAR_ss_Ep, _CX)                         // LEAQ  ss.Ep, CX
+    self.Emit("XORL" , _R8, _R8)                                // XORL  R8, R8
+    self.Emit("BTQ"  , jit.Imm(_F_disable_urc), _VAR_df)        // BTQ   ${_F_disable_urc}, fv
+    self.Emit("SETCC", _R8)                                     // SETCC R8
+    self.Emit("SHLQ" , jit.Imm(types.B_UNICODE_REPLACE), _R8)   // SHLQ  ${types.B_UNICODE_REPLACE}, R8
+
+    /* unquote the string, with R9 been preserved */
+    self.save(_R9)                                      // SAVE R9
+    self.call(_F_unquote)                               // CALL unquote
+    self.load(_R9)                                      // LOAD R9
+
+    /* check for errors */
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ AX, AX
+    self.Sjmp("JS"   , "_unquote_error")        // JS    _unquote_error
+    self.Emit("MOVL" , jit.Imm(1), _DX)         // MOVL  $1, DX
+    self.Emit("LEAQ" , jit.Ptr(_R9, 16), _R8)   // ADDQ  $16, R8
+    self.Emit("MOVQ" , _R8, jit.Ptr(_R9, 0))    // MOVQ  R8, (R9)
+    self.Emit("MOVQ" , _AX, jit.Ptr(_R9, 8))    // MOVQ  AX, 8(R9)
+    self.Sjmp("JMP"  , "_noescape")             // JMP   _noescape
+
+    /** V_DOUBLE **/
+    self.Link("_decode_V_DOUBLE")                           // _decode_V_DOUBLE:
+    self.Emit("BTQ"  , jit.Imm(_F_use_number), _VAR_df)     // BTQ     _F_use_number, df
+    self.Sjmp("JC"   , "_use_number")                       // JC      _use_number
+    self.Emit("MOVSD", _VAR_ss_Dv, _X0)                     // MOVSD   ss.Dv, X0
+    self.Sjmp("JMP"  , "_use_float64")                      // JMP     _use_float64
+
+    /** V_INTEGER **/
+    self.Link("_decode_V_INTEGER")                          // _decode_V_INTEGER:
+    self.Emit("BTQ"     , jit.Imm(_F_use_number), _VAR_df)  // BTQ      _F_use_number, df
+    self.Sjmp("JC"      , "_use_number")                    // JC       _use_number
+    self.Emit("BTQ"     , jit.Imm(_F_use_int64), _VAR_df)   // BTQ      _F_use_int64, df
+    self.Sjmp("JC"      , "_use_int64")                     // JC       _use_int64
+    self.Emit("MOVQ"    , _VAR_ss_Iv, _AX)                  // MOVQ     ss.Iv, AX
+    self.Emit("CVTSQ2SD", _AX, _X0)                         // CVTSQ2SD AX, X0
+
+    /* represent numbers as `float64` */
+    self.Link("_use_float64")                   // _use_float64:
+    self.Emit("MOVSD", _X0, jit.Ptr(_SP, 0))    // MOVSD   X0, (SP)
+    self.call_go(_F_convT64)                    // CALL_GO runtime.convT64
+    self.Emit("MOVQ" , _T_float64, _R8)         // MOVQ    _T_float64, R8
+    self.Emit("MOVQ" , jit.Ptr(_SP, 8), _R9)    // MOVQ    8(SP), R9
+    self.Emit("MOVQ" , _VAR_ss_Ep, _DI)         // MOVQ    ss.Ep, DI
+    self.Sjmp("JMP"  , "_set_value")            // JMP     _set_value
+
+    /* represent numbers as `json.Number` */
+    self.Link("_use_number")                            // _use_number
+    self.Emit("MOVQ", _VAR_ss_Ep, _AX)                  // MOVQ    ss.Ep, AX
+    self.Emit("LEAQ", jit.Sib(_IP, _AX, 1, 0), _SI)     // LEAQ    (IP)(AX), SI
+    self.Emit("MOVQ", _IC, _CX)                         // MOVQ    IC, CX
+    self.Emit("SUBQ", _AX, _CX)                         // SUBQ    AX, CX
+    self.Emit("MOVQ", _SI, jit.Ptr(_SP, 0))             // MOVQ    SI, (SP)
+    self.Emit("MOVQ", _CX, jit.Ptr(_SP, 8))             // MOVQ    CX, 8(SP)
+    self.call_go(_F_convTstring)                        // CALL_GO runtime.convTstring
+    self.Emit("MOVQ", _T_number, _R8)                   // MOVQ    _T_number, R8
+    self.Emit("MOVQ", jit.Ptr(_SP, 16), _R9)            // MOVQ    16(SP), R9
+    self.Emit("MOVQ", _VAR_ss_Ep, _DI)                  // MOVQ    ss.Ep, DI
+    self.Sjmp("JMP" , "_set_value")                     // JMP     _set_value
+
+    /* represent numbers as `int64` */
+    self.Link("_use_int64")                     // _use_int64:
+    self.Emit("MOVQ", _VAR_ss_Iv, _AX)          // MOVQ    ss.Iv, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))     // MOVQ    AX, (SP)
+    self.call_go(_F_convT64)                    // CALL_GO runtime.convT64
+    self.Emit("MOVQ", _T_int64, _R8)            // MOVQ    _T_int64, R8
+    self.Emit("MOVQ", jit.Ptr(_SP, 8), _R9)     // MOVQ    8(SP), R9
+    self.Emit("MOVQ", _VAR_ss_Ep, _DI)          // MOVQ    ss.Ep, DI
+    self.Sjmp("JMP" , "_set_value")             // JMP     _set_value
+
+    /** V_KEY_SEP **/
+    self.Link("_decode_V_KEY_SEP")                                          // _decode_V_KEY_SEP:
+    // self.Byte(0xcc)
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)                    // MOVQ ST.Vt[CX], AX
+    self.Emit("CMPQ", _AX, jit.Imm(_S_obj_delim))                           // CMPQ AX, _S_obj_delim
+    self.Sjmp("JNE" , "_invalid_char")                                      // JNE  _invalid_char
+    self.Emit("MOVQ", jit.Imm(_S_val), jit.Sib(_ST, _CX, 8, _ST_Vt))        // MOVQ _S_val, ST.Vt[CX]
+    self.Emit("MOVQ", jit.Imm(_S_obj), jit.Sib(_ST, _CX, 8, _ST_Vt - 8))    // MOVQ _S_obj, ST.Vt[CX - 1]
+    self.Sjmp("JMP" , "_next")                                              // JMP  _next
+
+    /** V_ELEM_SEP **/
+    self.Link("_decode_V_ELEM_SEP")                             // _decode_V_ELEM_SEP:
+    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ     ST.Sp, CX
+    self.Emit("MOVQ" , jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ     ST.Vt[CX], AX
+    self.Emit("CMPQ" , _AX, jit.Imm(_S_arr))                 // CMPQ     _AX, _S_arr
+    self.Sjmp("JE"   , "_array_sep")                         // JZ       _next
+    self.Emit("CMPQ" , _AX, jit.Imm(_S_obj))                 // CMPQ     _AX, _S_arr
+    self.Sjmp("JNE"  , "_invalid_char")                      // JNE      _invalid_char
+    self.Emit("MOVQ" , jit.Imm(_S_obj_sep), jit.Sib(_ST, _CX, 8, _ST_Vt))
+    self.Sjmp("JMP"  , "_next")                              // JMP      _next
+
+    /* arrays */
+    self.Link("_array_sep")
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _DX)                 // MOVQ 8(SI), DX
+    self.Emit("CMPQ", _DX, jit.Ptr(_SI, 16))                // CMPQ DX, 16(SI)
+    self.Sjmp("JAE" , "_array_more")                        // JAE  _array_more
+
+    /* add a slot for the new element */
+    self.Link("_array_append")                                          // _array_append:
+    self.Emit("ADDQ", jit.Imm(1), jit.Ptr(_SI, 8))                      // ADDQ $1, 8(SI)
+    self.Emit("MOVQ", jit.Ptr(_SI, 0), _SI)                             // MOVQ (SI), SI
+    self.Emit("ADDQ", jit.Imm(1), _CX)                                  // ADDQ $1, CX
+    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                  // CMPQ CX, ${types.MAX_RECURSE}
+    self.Sjmp("JAE"  , "_stack_overflow") 
+    self.Emit("SHLQ", jit.Imm(1), _DX)                                  // SHLQ $1, DX
+    self.Emit("LEAQ", jit.Sib(_SI, _DX, 8, 0), _SI)                     // LEAQ (SI)(DX*8), SI
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                        // MOVQ CX, ST.Sp
+    self.WriteRecNotAX(7 , _SI, jit.Sib(_ST, _CX, 8, _ST_Vp), false)           // MOVQ SI, ST.Vp[CX]
+    self.Emit("MOVQ", jit.Imm(_S_val), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ _S_val, ST.Vt[CX}
+    self.Sjmp("JMP" , "_next")                                          // JMP  _next
+
+    /** V_ARRAY_END **/
+    self.Link("_decode_V_ARRAY_END")                        // _decode_V_ARRAY_END:
+    self.Emit("XORL", _DX, _DX)                             // XORL DX, DX
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
+    self.Emit("CMPQ", _AX, jit.Imm(_S_arr_0))               // CMPQ AX, _S_arr_0
+    self.Sjmp("JE"  , "_first_item")                        // JE   _first_item
+    self.Emit("CMPQ", _AX, jit.Imm(_S_arr))                 // CMPQ AX, _S_arr
+    self.Sjmp("JNE" , "_invalid_char")                      // JNE  _invalid_char
+    self.Emit("SUBQ", jit.Imm(1), jit.Ptr(_ST, _ST_Sp))     // SUBQ $1, ST.Sp
+    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp))    // MOVQ DX, ST.Vp[CX]
+    self.Sjmp("JMP" , "_next")                              // JMP  _next
+
+    /* first element of an array */
+    self.Link("_first_item")                                    // _first_item:
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                // MOVQ ST.Sp, CX
+    self.Emit("SUBQ", jit.Imm(2), jit.Ptr(_ST, _ST_Sp))         // SUBQ $2, ST.Sp
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp - 8), _SI)    // MOVQ ST.Vp[CX - 1], SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                     // MOVQ 8(SI), SI
+    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp - 8))    // MOVQ DX, ST.Vp[CX - 1]
+    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp))        // MOVQ DX, ST.Vp[CX]
+    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 8))                     // MOVQ DX, 8(SI)
+    self.Sjmp("JMP" , "_next")                                  // JMP  _next
+
+    /** V_OBJECT_END **/
+    self.Link("_decode_V_OBJECT_END")                       // _decode_V_OBJECT_END:
+    self.Emit("MOVL", jit.Imm(_S_omask_end), _DX)           // MOVL _S_omask, DI
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
+    self.Emit("BTQ" , _AX, _DX)                
+    self.Sjmp("JNC" , "_invalid_char")                      // JNE  _invalid_char
+    self.Emit("XORL", _AX, _AX)                             // XORL AX, AX
+    self.Emit("SUBQ", jit.Imm(1), jit.Ptr(_ST, _ST_Sp))     // SUBQ $1, ST.Sp
+    self.Emit("MOVQ", _AX, jit.Sib(_ST, _CX, 8, _ST_Vp))    // MOVQ AX, ST.Vp[CX]
+    self.Sjmp("JMP" , "_next")                              // JMP  _next
+
+    /* return from decoder */
+    self.Link("_return")                            // _return:
+    self.Emit("XORL", _EP, _EP)                     // XORL EP, EP
+    self.Emit("MOVQ", _EP, jit.Ptr(_ST, _ST_Vp))    // MOVQ EP, ST.Vp[0]
+    self.Link("_epilogue")                          // _epilogue:
+    self.Emit("SUBQ", jit.Imm(_FsmOffset), _ST)     // SUBQ _FsmOffset, _ST
+    self.Emit("MOVQ", jit.Ptr(_SP, _VD_offs), _BP)  // MOVQ _VD_offs(SP), BP
+    self.Emit("ADDQ", jit.Imm(_VD_size), _SP)       // ADDQ $_VD_size, SP
+    self.Emit("RET")                                // RET
+
+    /* array expand */
+    self.Link("_array_more")                    // _array_more:
+    self.Emit("MOVQ" , _T_eface, _AX)           // MOVQ    _T_eface, AX
+    self.Emit("MOVOU", jit.Ptr(_SI, 0), _X0)    // MOVOU   (SI), X0
+    self.Emit("MOVQ" , jit.Ptr(_SI, 16), _DX)   // MOVQ    16(SI), DX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 0))    // MOVQ    AX, (SP)
+    self.Emit("MOVOU", _X0, jit.Ptr(_SP, 8))    // MOVOU   X0, 8(SP)
+    self.Emit("MOVQ" , _DX, jit.Ptr(_SP, 24))   // MOVQ    DX, 24(SP)
+    self.Emit("SHLQ" , jit.Imm(1), _DX)         // SHLQ    $1, DX
+    self.Emit("MOVQ" , _DX, jit.Ptr(_SP, 32))   // MOVQ    DX, 32(SP)
+    self.call_go(_F_growslice)                  // CALL_GO runtime.growslice
+    self.Emit("MOVQ" , jit.Ptr(_SP, 40), _DI)   // MOVOU   40(SP), DI
+    self.Emit("MOVQ" , jit.Ptr(_SP, 48), _DX)   // MOVOU   48(SP), DX
+    self.Emit("MOVQ" , jit.Ptr(_SP, 56), _AX)   // MOVQ    56(SP), AX
+
+    /* update the slice */
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
+    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 8))                 // MOVQ DX, 8(SI)
+    self.Emit("MOVQ", _AX, jit.Ptr(_SI, 16))                // MOVQ AX, 16(AX)
+    self.WriteRecNotAX(8 , _DI, jit.Ptr(_SI, 0), false)                 // MOVQ R10, (SI)
+    self.Sjmp("JMP" , "_array_append")                      // JMP  _array_append
+
+    /* copy string */
+    self.Link("copy_string")  // pointer: R8, length: AX, return addr: DI
+    // self.Byte(0xcc)
+    self.Emit("MOVQ", _R8, _VAR_cs_p)
+    self.Emit("MOVQ", _AX, _VAR_cs_n)
+    self.Emit("MOVQ", _DI, _VAR_cs_LR)
+    self.Emit("MOVQ", _T_byte, jit.Ptr(_SP, 0))
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 8))
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 16))
+    self.call_go(_F_makeslice)                              
+    self.Emit("MOVQ", jit.Ptr(_SP, 24), _R8)      
+    self.Emit("MOVQ", _R8, _VAR_cs_d)                    
+    self.Emit("MOVQ", _R8, jit.Ptr(_SP, 0))                    
+    self.Emit("MOVQ", _VAR_cs_p, _R8)
+    self.Emit("MOVQ", _R8, jit.Ptr(_SP, 8))
+    self.Emit("MOVQ", _VAR_cs_n, _AX)
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 16))
+    self.call_go(_F_memmove)
+    self.Emit("MOVQ", _VAR_cs_d, _R8)
+    self.Emit("MOVQ", _VAR_cs_n, _AX)
+    self.Emit("MOVQ", _VAR_cs_LR, _DI)
+    // self.Byte(0xcc)
+    self.Rjmp("JMP", _DI)
+
+    /* error handlers */
+    self.Link("_stack_overflow")
+    self.Emit("MOVL" , _E_recurse, _EP)         // MOVQ  _E_recurse, EP
+    self.Sjmp("JMP"  , "_error")                // JMP   _error
+    self.Link("_vtype_error")                   // _vtype_error:
+    self.Emit("MOVQ" , _DI, _IC)                // MOVQ  DI, IC
+    self.Emit("MOVL" , _E_invalid, _EP)         // MOVL  _E_invalid, EP
+    self.Sjmp("JMP"  , "_error")                // JMP   _error
+    self.Link("_invalid_char")                  // _invalid_char:
+    self.Emit("SUBQ" , jit.Imm(1), _IC)         // SUBQ  $1, IC
+    self.Emit("MOVL" , _E_invalid, _EP)         // MOVL  _E_invalid, EP
+    self.Sjmp("JMP"  , "_error")                // JMP   _error
+    self.Link("_unquote_error")                 // _unquote_error:
+    self.Emit("MOVQ" , _VAR_ss_Iv, _IC)         // MOVQ  ss.Iv, IC
+    self.Emit("SUBQ" , jit.Imm(1), _IC)         // SUBQ  $1, IC
+    self.Link("_parsing_error")                 // _parsing_error:
+    self.Emit("NEGQ" , _AX)                     // NEGQ  AX
+    self.Emit("MOVQ" , _AX, _EP)                // MOVQ  AX, EP
+    self.Link("_error")                         // _error:
+    self.Emit("PXOR" , _X0, _X0)                // PXOR  X0, X0
+    self.Emit("MOVOU", _X0, jit.Ptr(_VP, 0))    // MOVOU X0, (VP)
+    self.Sjmp("JMP"  , "_epilogue")             // JMP   _epilogue
+
+    /* invalid value type, never returns */
+    self.Link("_invalid_vtype")
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))     // MOVQ AX, (SP)
+    self.call(_F_invalid_vtype)                 // CALL invalid_type
+    self.Emit("UD2")                            // UD2
+
+    /* switch jump table */
+    self.Link("_switch_table")              // _switch_table:
+    self.Sref("_decode_V_EOF", 0)           // SREF &_decode_V_EOF, $0
+    self.Sref("_decode_V_NULL", -4)         // SREF &_decode_V_NULL, $-4
+    self.Sref("_decode_V_TRUE", -8)         // SREF &_decode_V_TRUE, $-8
+    self.Sref("_decode_V_FALSE", -12)       // SREF &_decode_V_FALSE, $-12
+    self.Sref("_decode_V_ARRAY", -16)       // SREF &_decode_V_ARRAY, $-16
+    self.Sref("_decode_V_OBJECT", -20)      // SREF &_decode_V_OBJECT, $-20
+    self.Sref("_decode_V_STRING", -24)      // SREF &_decode_V_STRING, $-24
+    self.Sref("_decode_V_DOUBLE", -28)      // SREF &_decode_V_DOUBLE, $-28
+    self.Sref("_decode_V_INTEGER", -32)     // SREF &_decode_V_INTEGER, $-32
+    self.Sref("_decode_V_KEY_SEP", -36)     // SREF &_decode_V_KEY_SEP, $-36
+    self.Sref("_decode_V_ELEM_SEP", -40)    // SREF &_decode_V_ELEM_SEP, $-40
+    self.Sref("_decode_V_ARRAY_END", -44)   // SREF &_decode_V_ARRAY_END, $-44
+    self.Sref("_decode_V_OBJECT_END", -48)  // SREF &_decode_V_OBJECT_END, $-48
+
+    /* fast character lookup table */
+    self.Link("_decode_tab")        // _decode_tab:
+    self.Sref("_decode_V_EOF", 0)   // SREF &_decode_V_EOF, $0
+
+    /* generate rest of the tabs */
+    for i := 1; i < 256; i++ {
+        if to, ok := _R_tab[i]; ok {
+            self.Sref(to, -int64(i) * 4)
+        } else {
+            self.Byte(0x00, 0x00, 0x00, 0x00)
+        }
+    }
+}
+
+func (self *_ValueDecoder) WritePtrAX(i int, rec obj.Addr, saveDI bool) {
+    self.Emit("MOVQ", _V_writeBarrier, _R10)
+    self.Emit("CMPL", jit.Ptr(_R10, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    if saveDI {
+        self.save(_DI)
+    }
+    self.Emit("LEAQ", rec, _DI)
+    self.Emit("MOVQ", _F_gcWriteBarrierAX, _R10)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _R10)  
+    if saveDI {
+        self.load(_DI)
+    }    
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", _AX, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}
+
+func (self *_ValueDecoder) WriteRecNotAX(i int, ptr obj.Addr, rec obj.Addr, saveDI bool) {
+    if rec.Reg == x86.REG_AX || rec.Index == x86.REG_AX {
+        panic("rec contains AX!")
+    }
+    self.Emit("MOVQ", _V_writeBarrier, _R10)
+    self.Emit("CMPL", jit.Ptr(_R10, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, _AX)
+    if saveDI {
+        self.save(_DI)
+    }
+    self.Emit("LEAQ", rec, _DI)
+    self.Emit("MOVQ", _F_gcWriteBarrierAX, _R10)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _R10)  
+    if saveDI {
+        self.load(_DI)
+    }    
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}
+
+/** Generic Decoder **/
+
+var (
+    _subr_decode_value = new(_ValueDecoder).build()
+)
+
+//go:nosplit
+func invalid_vtype(vt types.ValueType) {
+    throw(fmt.Sprintf("invalid value type: %d", vt))
+}
diff --git a/vendor/github.com/bytedance/sonic/decoder/generic_amd64_go117.go b/vendor/github.com/bytedance/sonic/decoder/generic_amd64_go117.go
new file mode 100644
index 000000000..df1cd9f5b
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/generic_amd64_go117.go
@@ -0,0 +1,772 @@
+//go:build go1.17 && !go1.21
+// +build go1.17,!go1.21
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `encoding/json`
+    `fmt`
+    `reflect`
+    `strconv`
+
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/twitchyliquid64/golang-asm/obj`
+    `github.com/twitchyliquid64/golang-asm/obj/x86`
+)
+
+/** Crucial Registers:
+ *
+ *      ST(R13) && 0(SP) : ro, decoder stack
+ *      DF(AX)  : ro, decoder flags
+ *      EP(BX) : wo, error pointer
+ *      IP(R10) : ro, input pointer
+ *      IL(R12) : ro, input length
+ *      IC(R11) : rw, input cursor
+ *      VP(R15) : ro, value pointer (to an interface{})
+ */
+
+const (
+    _VD_args   = 8      // 8 bytes  for passing arguments to this functions
+    _VD_fargs  = 64     // 64 bytes for passing arguments to other Go functions
+    _VD_saves  = 48     // 48 bytes for saving the registers before CALL instructions
+    _VD_locals = 96     // 96 bytes for local variables
+)
+
+const (
+    _VD_offs = _VD_fargs + _VD_saves + _VD_locals
+    _VD_size = _VD_offs + 8     // 8 bytes for the parent frame pointer
+)
+
+var (
+    _VAR_ss = _VAR_ss_Vt
+    _VAR_df = jit.Ptr(_SP, _VD_fargs + _VD_saves)
+)
+
+var (
+    _VAR_ss_Vt = jit.Ptr(_SP, _VD_fargs + _VD_saves + 8)
+    _VAR_ss_Dv = jit.Ptr(_SP, _VD_fargs + _VD_saves + 16)
+    _VAR_ss_Iv = jit.Ptr(_SP, _VD_fargs + _VD_saves + 24)
+    _VAR_ss_Ep = jit.Ptr(_SP, _VD_fargs + _VD_saves + 32)
+    _VAR_ss_Db = jit.Ptr(_SP, _VD_fargs + _VD_saves + 40)
+    _VAR_ss_Dc = jit.Ptr(_SP, _VD_fargs + _VD_saves + 48)
+)
+
+var (
+    _VAR_R9 = jit.Ptr(_SP, _VD_fargs + _VD_saves + 56)
+)
+type _ValueDecoder struct {
+    jit.BaseAssembler
+}
+
+var (
+    _VAR_cs_LR = jit.Ptr(_SP, _VD_fargs + _VD_saves + 64)
+    _VAR_cs_p = jit.Ptr(_SP, _VD_fargs + _VD_saves + 72)
+    _VAR_cs_n = jit.Ptr(_SP, _VD_fargs + _VD_saves + 80)
+    _VAR_cs_d = jit.Ptr(_SP, _VD_fargs + _VD_saves + 88)
+)
+
+func (self *_ValueDecoder) build() uintptr {
+    self.Init(self.compile)
+    return *(*uintptr)(self.Load("decode_value", _VD_size, _VD_args, argPtrs_generic, localPtrs_generic))
+}
+
+/** Function Calling Helpers **/
+
+func (self *_ValueDecoder) save(r ...obj.Addr) {
+    for i, v := range r {
+        if i > _VD_saves / 8 - 1 {
+            panic("too many registers to save")
+        } else {
+            self.Emit("MOVQ", v, jit.Ptr(_SP, _VD_fargs + int64(i) * 8))
+        }
+    }
+}
+
+func (self *_ValueDecoder) load(r ...obj.Addr) {
+    for i, v := range r {
+        if i > _VD_saves / 8 - 1 {
+            panic("too many registers to load")
+        } else {
+            self.Emit("MOVQ", jit.Ptr(_SP, _VD_fargs + int64(i) * 8), v)
+        }
+    }
+}
+
+func (self *_ValueDecoder) call(fn obj.Addr) {
+    self.Emit("MOVQ", fn, _R9)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _R9)      // CALL AX
+}
+
+func (self *_ValueDecoder) call_go(fn obj.Addr) {
+    self.save(_REG_go...)   // SAVE $REG_go
+    self.call(fn)           // CALL ${fn}
+    self.load(_REG_go...)   // LOAD $REG_go
+}
+
+func (self *_ValueDecoder) callc(fn obj.Addr) {
+    self.Emit("XCHGQ", _IP, _BP)
+    self.call(fn)
+    self.Emit("XCHGQ", _IP, _BP)
+}
+
+func (self *_ValueDecoder) call_c(fn obj.Addr) {
+    self.Emit("XCHGQ", _IC, _BX)
+    self.callc(fn)
+    self.Emit("XCHGQ", _IC, _BX)
+}
+
+/** Decoder Assembler **/
+
+const (
+    _S_val = iota + 1
+    _S_arr
+    _S_arr_0
+    _S_obj
+    _S_obj_0
+    _S_obj_delim
+    _S_obj_sep
+)
+
+const (
+    _S_omask_key = (1 << _S_obj_0) | (1 << _S_obj_sep)
+    _S_omask_end = (1 << _S_obj_0) | (1 << _S_obj)
+    _S_vmask = (1 << _S_val) | (1 << _S_arr_0)
+)
+
+const (
+    _A_init_len = 1
+    _A_init_cap = 16
+)
+
+const (
+    _ST_Sp = 0
+    _ST_Vt = _PtrBytes
+    _ST_Vp = _PtrBytes * (types.MAX_RECURSE + 1)
+)
+
+var (
+    _V_true  = jit.Imm(int64(pbool(true)))
+    _V_false = jit.Imm(int64(pbool(false)))
+    _F_value = jit.Imm(int64(native.S_value))
+)
+
+var (
+    _V_max     = jit.Imm(int64(types.V_MAX))
+    _E_eof     = jit.Imm(int64(types.ERR_EOF))
+    _E_invalid = jit.Imm(int64(types.ERR_INVALID_CHAR))
+    _E_recurse = jit.Imm(int64(types.ERR_RECURSE_EXCEED_MAX))
+)
+
+var (
+    _F_convTslice    = jit.Func(convTslice)
+    _F_convTstring   = jit.Func(convTstring)
+    _F_invalid_vtype = jit.Func(invalid_vtype)
+)
+
+var (
+    _T_map     = jit.Type(reflect.TypeOf((map[string]interface{})(nil)))
+    _T_bool    = jit.Type(reflect.TypeOf(false))
+    _T_int64   = jit.Type(reflect.TypeOf(int64(0)))
+    _T_eface   = jit.Type(reflect.TypeOf((*interface{})(nil)).Elem())
+    _T_slice   = jit.Type(reflect.TypeOf(([]interface{})(nil)))
+    _T_string  = jit.Type(reflect.TypeOf(""))
+    _T_number  = jit.Type(reflect.TypeOf(json.Number("")))
+    _T_float64 = jit.Type(reflect.TypeOf(float64(0)))
+)
+
+var _R_tab = map[int]string {
+    '[': "_decode_V_ARRAY",
+    '{': "_decode_V_OBJECT",
+    ':': "_decode_V_KEY_SEP",
+    ',': "_decode_V_ELEM_SEP",
+    ']': "_decode_V_ARRAY_END",
+    '}': "_decode_V_OBJECT_END",
+}
+
+func (self *_ValueDecoder) compile() {
+    self.Emit("SUBQ", jit.Imm(_VD_size), _SP)       // SUBQ $_VD_size, SP
+    self.Emit("MOVQ", _BP, jit.Ptr(_SP, _VD_offs))  // MOVQ BP, _VD_offs(SP)
+    self.Emit("LEAQ", jit.Ptr(_SP, _VD_offs), _BP)  // LEAQ _VD_offs(SP), BP
+
+    /* initialize the state machine */
+    self.Emit("XORL", _CX, _CX)                                 // XORL CX, CX
+    self.Emit("MOVQ", _DF, _VAR_df)                             // MOVQ DF, df
+    /* initialize digital buffer first */
+    self.Emit("MOVQ", jit.Imm(_MaxDigitNums), _VAR_ss_Dc)       // MOVQ $_MaxDigitNums, ss.Dcap
+    self.Emit("LEAQ", jit.Ptr(_ST, _DbufOffset), _AX)           // LEAQ _DbufOffset(ST), AX
+    self.Emit("MOVQ", _AX, _VAR_ss_Db)                          // MOVQ AX, ss.Dbuf
+    /* add ST offset */
+    self.Emit("ADDQ", jit.Imm(_FsmOffset), _ST)                 // ADDQ _FsmOffset, _ST
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                // MOVQ CX, ST.Sp
+    self.WriteRecNotAX(0, _VP, jit.Ptr(_ST, _ST_Vp), false)                // MOVQ VP, ST.Vp[0]
+    self.Emit("MOVQ", jit.Imm(_S_val), jit.Ptr(_ST, _ST_Vt))    // MOVQ _S_val, ST.Vt[0]
+    self.Sjmp("JMP" , "_next")                                  // JMP  _next
+
+    /* set the value from previous round */
+    self.Link("_set_value")                                 // _set_value:
+    self.Emit("MOVL" , jit.Imm(_S_vmask), _DX)              // MOVL  _S_vmask, DX
+    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _CX)           // MOVQ  ST.Sp, CX
+    self.Emit("MOVQ" , jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)   // MOVQ  ST.Vt[CX], AX
+    self.Emit("BTQ"  , _AX, _DX)                            // BTQ   AX, DX
+    self.Sjmp("JNC"  , "_vtype_error")                      // JNC   _vtype_error
+    self.Emit("XORL" , _SI, _SI)                            // XORL  SI, SI
+    self.Emit("SUBQ" , jit.Imm(1), jit.Ptr(_ST, _ST_Sp))    // SUBQ  $1, ST.Sp
+    self.Emit("XCHGQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)   // XCHGQ ST.Vp[CX], SI
+    self.Emit("MOVQ" , _R8, jit.Ptr(_SI, 0))                // MOVQ  R8, (SI)
+    self.WriteRecNotAX(1, _R9, jit.Ptr(_SI, 8), false)           // MOVQ  R9, 8(SI)
+
+    /* check for value stack */
+    self.Link("_next")                              // _next:
+    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _AX)   // MOVQ  ST.Sp, AX
+    self.Emit("TESTQ", _AX, _AX)                    // TESTQ AX, AX
+    self.Sjmp("JS"   , "_return")                   // JS    _return
+
+    /* fast path: test up to 4 characters manually */
+    self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
+    self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
+    self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
+    self.Emit("MOVQ"   , jit.Imm(_BM_space), _DX)       // MOVQ    _BM_space, DX
+    self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
+    self.Sjmp("JA"     , "_decode_fast")                // JA      _decode_fast
+    self.Emit("BTQ"    , _AX, _DX)                      // BTQ     _AX, _DX
+    self.Sjmp("JNC"    , "_decode_fast")                // JNC     _decode_fast
+    self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
+
+    /* at least 1 to 3 spaces */
+    for i := 0; i < 3; i++ {
+        self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
+        self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
+        self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
+        self.Emit("CMPQ"   , _AX, jit.Imm(' '))             // CMPQ    AX, $' '
+        self.Sjmp("JA"     , "_decode_fast")                // JA      _decode_fast
+        self.Emit("BTQ"    , _AX, _DX)                      // BTQ     _AX, _DX
+        self.Sjmp("JNC"    , "_decode_fast")                // JNC     _decode_fast
+        self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
+    }
+
+    /* at least 4 spaces */
+    self.Emit("CMPQ"   , _IC, _IL)                      // CMPQ    IC, IL
+    self.Sjmp("JAE"    , "_decode_V_EOF")               // JAE     _decode_V_EOF
+    self.Emit("MOVBQZX", jit.Sib(_IP, _IC, 1, 0), _AX)  // MOVBQZX (IP)(IC), AX
+
+    /* fast path: use lookup table to select decoder */
+    self.Link("_decode_fast")                           // _decode_fast:
+    self.Byte(0x48, 0x8d, 0x3d)                         // LEAQ    ?(PC), DI
+    self.Sref("_decode_tab", 4)                         // ....    &_decode_tab
+    self.Emit("MOVLQSX", jit.Sib(_DI, _AX, 4, 0), _AX)  // MOVLQSX (DI)(AX*4), AX
+    self.Emit("TESTQ"  , _AX, _AX)                      // TESTQ   AX, AX
+    self.Sjmp("JZ"     , "_decode_native")              // JZ      _decode_native
+    self.Emit("ADDQ"   , jit.Imm(1), _IC)               // ADDQ    $1, IC
+    self.Emit("ADDQ"   , _DI, _AX)                      // ADDQ    DI, AX
+    self.Rjmp("JMP"    , _AX)                           // JMP     AX
+
+    /* decode with native decoder */
+    self.Link("_decode_native")         // _decode_native:
+    self.Emit("MOVQ", _IP, _DI)         // MOVQ IP, DI
+    self.Emit("MOVQ", _IL, _SI)         // MOVQ IL, SI
+    self.Emit("MOVQ", _IC, _DX)         // MOVQ IC, DX
+    self.Emit("LEAQ", _VAR_ss, _CX)     // LEAQ ss, CX
+    self.Emit("MOVQ", _VAR_df, _R8)     // MOVQ $df, R8
+    self.Emit("BTSQ", jit.Imm(_F_allow_control), _R8)  // ANDQ $1<<_F_allow_control, R8
+    self.callc(_F_value)               // CALL value
+    self.Emit("MOVQ", _AX, _IC)         // MOVQ AX, IC
+
+    /* check for errors */
+    self.Emit("MOVQ" , _VAR_ss_Vt, _AX)     // MOVQ  ss.Vt, AX
+    self.Emit("TESTQ", _AX, _AX)            // TESTQ AX, AX
+    self.Sjmp("JS"   , "_parsing_error")       
+    self.Sjmp("JZ"   , "_invalid_vtype")    // JZ    _invalid_vtype
+    self.Emit("CMPQ" , _AX, _V_max)         // CMPQ  AX, _V_max
+    self.Sjmp("JA"   , "_invalid_vtype")    // JA    _invalid_vtype
+
+    /* jump table selector */
+    self.Byte(0x48, 0x8d, 0x3d)                             // LEAQ    ?(PC), DI
+    self.Sref("_switch_table", 4)                           // ....    &_switch_table
+    self.Emit("MOVLQSX", jit.Sib(_DI, _AX, 4, -4), _AX)     // MOVLQSX -4(DI)(AX*4), AX
+    self.Emit("ADDQ"   , _DI, _AX)                          // ADDQ    DI, AX
+    self.Rjmp("JMP"    , _AX)                               // JMP     AX
+
+    /** V_EOF **/
+    self.Link("_decode_V_EOF")          // _decode_V_EOF:
+    self.Emit("MOVL", _E_eof, _EP)      // MOVL _E_eof, EP
+    self.Sjmp("JMP" , "_error")         // JMP  _error
+
+    /** V_NULL **/
+    self.Link("_decode_V_NULL")                 // _decode_V_NULL:
+    self.Emit("XORL", _R8, _R8)                 // XORL R8, R8
+    self.Emit("XORL", _R9, _R9)                 // XORL R9, R9
+    self.Emit("LEAQ", jit.Ptr(_IC, -4), _DI)    // LEAQ -4(IC), DI
+    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
+
+    /** V_TRUE **/
+    self.Link("_decode_V_TRUE")                 // _decode_V_TRUE:
+    self.Emit("MOVQ", _T_bool, _R8)             // MOVQ _T_bool, R8
+    // TODO: maybe modified by users?
+    self.Emit("MOVQ", _V_true, _R9)             // MOVQ _V_true, R9 
+    self.Emit("LEAQ", jit.Ptr(_IC, -4), _DI)    // LEAQ -4(IC), DI
+    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
+
+    /** V_FALSE **/
+    self.Link("_decode_V_FALSE")                // _decode_V_FALSE:
+    self.Emit("MOVQ", _T_bool, _R8)             // MOVQ _T_bool, R8
+    self.Emit("MOVQ", _V_false, _R9)            // MOVQ _V_false, R9
+    self.Emit("LEAQ", jit.Ptr(_IC, -5), _DI)    // LEAQ -5(IC), DI
+    self.Sjmp("JMP" , "_set_value")             // JMP  _set_value
+
+    /** V_ARRAY **/
+    self.Link("_decode_V_ARRAY")                            // _decode_V_ARRAY
+    self.Emit("MOVL", jit.Imm(_S_vmask), _DX)               // MOVL _S_vmask, DX
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
+    self.Emit("BTQ" , _AX, _DX)                             // BTQ  AX, DX
+    self.Sjmp("JNC" , "_invalid_char")                      // JNC  _invalid_char
+
+    /* create a new array */
+    self.Emit("MOVQ", _T_eface, _AX)                            // MOVQ    _T_eface, AX
+    self.Emit("MOVQ", jit.Imm(_A_init_len), _BX)                // MOVQ    _A_init_len, BX
+    self.Emit("MOVQ", jit.Imm(_A_init_cap), _CX)                // MOVQ    _A_init_cap, CX
+    self.call_go(_F_makeslice)                                  // CALL_GO runtime.makeslice
+
+    /* pack into an interface */
+    self.Emit("MOVQ", jit.Imm(_A_init_len), _BX)                // MOVQ    _A_init_len, BX
+    self.Emit("MOVQ", jit.Imm(_A_init_cap), _CX)                // MOVQ    _A_init_cap, CX
+    self.call_go(_F_convTslice)                                 // CALL_GO runtime.convTslice
+    self.Emit("MOVQ", _AX, _R8)                                 // MOVQ    AX, R8
+
+    /* replace current state with an array */
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)                // MOVQ ST.Vp[CX], SI
+    self.Emit("MOVQ", jit.Imm(_S_arr), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ _S_arr, ST.Vt[CX]
+    self.Emit("MOVQ", _T_slice, _AX)                                    // MOVQ _T_slice, AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_SI, 0))                             // MOVQ AX, (SI)
+    self.WriteRecNotAX(2, _R8, jit.Ptr(_SI, 8), false)                  // MOVQ R8, 8(SI)
+
+    /* add a new slot for the first element */
+    self.Emit("ADDQ", jit.Imm(1), _CX)                                  // ADDQ $1, CX
+    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                  // CMPQ CX, ${types.MAX_RECURSE}
+    self.Sjmp("JAE"  , "_stack_overflow")                                // JA   _stack_overflow
+    self.Emit("MOVQ", jit.Ptr(_R8, 0), _AX)                             // MOVQ (R8), AX
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                        // MOVQ CX, ST.Sp
+    self.WritePtrAX(3, jit.Sib(_ST, _CX, 8, _ST_Vp), false)             // MOVQ AX, ST.Vp[CX]
+    self.Emit("MOVQ", jit.Imm(_S_arr_0), jit.Sib(_ST, _CX, 8, _ST_Vt))  // MOVQ _S_arr_0, ST.Vt[CX]
+    self.Sjmp("JMP" , "_next")                                          // JMP  _next
+
+    /** V_OBJECT **/
+    self.Link("_decode_V_OBJECT")                                       // _decode_V_OBJECT:
+    self.Emit("MOVL", jit.Imm(_S_vmask), _DX)                           // MOVL    _S_vmask, DX
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ    ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)                // MOVQ    ST.Vt[CX], AX
+    self.Emit("BTQ" , _AX, _DX)                                         // BTQ     AX, DX
+    self.Sjmp("JNC" , "_invalid_char")                                  // JNC     _invalid_char
+    self.call_go(_F_makemap_small)                                      // CALL_GO runtime.makemap_small
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                        // MOVQ    ST.Sp, CX
+    self.Emit("MOVQ", jit.Imm(_S_obj_0), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ    _S_obj_0, ST.Vt[CX]
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)                // MOVQ    ST.Vp[CX], SI
+    self.Emit("MOVQ", _T_map, _DX)                                      // MOVQ    _T_map, DX
+    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 0))                             // MOVQ    DX, (SI)
+    self.WritePtrAX(4, jit.Ptr(_SI, 8), false)                          // MOVQ    AX, 8(SI)
+    self.Sjmp("JMP" , "_next")                                          // JMP     _next
+
+    /** V_STRING **/
+    self.Link("_decode_V_STRING")       // _decode_V_STRING:
+    self.Emit("MOVQ", _VAR_ss_Iv, _CX)  // MOVQ ss.Iv, CX
+    self.Emit("MOVQ", _IC, _AX)         // MOVQ IC, AX
+    self.Emit("SUBQ", _CX, _AX)         // SUBQ CX, AX
+
+    /* check for escapes */
+    self.Emit("CMPQ", _VAR_ss_Ep, jit.Imm(-1))          // CMPQ ss.Ep, $-1
+    self.Sjmp("JNE" , "_unquote")                       // JNE  _unquote
+    self.Emit("SUBQ", jit.Imm(1), _AX)                  // SUBQ $1, AX
+    self.Emit("LEAQ", jit.Sib(_IP, _CX, 1, 0), _R8)     // LEAQ (IP)(CX), R8
+    self.Byte(0x48, 0x8d, 0x3d)                         // LEAQ (PC), DI
+    self.Sref("_copy_string_end", 4)
+    self.Emit("BTQ", jit.Imm(_F_copy_string), _VAR_df)
+    self.Sjmp("JC", "copy_string")
+    self.Link("_copy_string_end")                                 
+    self.Emit("XORL", _DX, _DX)   
+
+    /* strings with no escape sequences */
+    self.Link("_noescape")                                  // _noescape:
+    self.Emit("MOVL", jit.Imm(_S_omask_key), _DI)               // MOVL _S_omask, DI
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _SI)    // MOVQ ST.Vt[CX], SI
+    self.Emit("BTQ" , _SI, _DI)                             // BTQ  SI, DI
+    self.Sjmp("JC"  , "_object_key")                        // JC   _object_key
+
+    /* check for pre-packed strings, avoid 1 allocation */
+    self.Emit("TESTQ", _DX, _DX)                // TESTQ   DX, DX
+    self.Sjmp("JNZ"  , "_packed_str")           // JNZ     _packed_str
+    self.Emit("MOVQ" , _AX, _BX)                // MOVQ    AX, BX
+    self.Emit("MOVQ" , _R8, _AX)                // MOVQ    R8, AX
+    self.call_go(_F_convTstring)                // CALL_GO runtime.convTstring
+    self.Emit("MOVQ" , _AX, _R9)                // MOVQ    AX, R9
+
+    /* packed string already in R9 */
+    self.Link("_packed_str")            // _packed_str:
+    self.Emit("MOVQ", _T_string, _R8)   // MOVQ _T_string, R8
+    self.Emit("MOVQ", _VAR_ss_Iv, _DI)  // MOVQ ss.Iv, DI
+    self.Emit("SUBQ", jit.Imm(1), _DI)  // SUBQ $1, DI
+    self.Sjmp("JMP" , "_set_value")     // JMP  _set_value
+
+    /* the string is an object key, get the map */
+    self.Link("_object_key")
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
+
+    /* add a new delimiter */
+    self.Emit("ADDQ", jit.Imm(1), _CX)                                      // ADDQ $1, CX
+    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                      // CMPQ CX, ${types.MAX_RECURSE}
+    self.Sjmp("JAE"  , "_stack_overflow")                                    // JA   _stack_overflow
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                            // MOVQ CX, ST.Sp
+    self.Emit("MOVQ", jit.Imm(_S_obj_delim), jit.Sib(_ST, _CX, 8, _ST_Vt))  // MOVQ _S_obj_delim, ST.Vt[CX]
+
+    /* add a new slot int the map */
+    self.Emit("MOVQ", _AX, _DI)                         // MOVQ    AX, DI
+    self.Emit("MOVQ", _T_map, _AX)                      // MOVQ    _T_map, AX
+    self.Emit("MOVQ", _SI, _BX)                         // MOVQ    SI, BX
+    self.Emit("MOVQ", _R8, _CX)                         // MOVQ    R9, CX
+    self.call_go(_F_mapassign_faststr)                  // CALL_GO runtime.mapassign_faststr
+
+    /* add to the pointer stack */
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                 // MOVQ ST.Sp, CX
+    self.WritePtrAX(6, jit.Sib(_ST, _CX, 8, _ST_Vp), false)    // MOVQ AX, ST.Vp[CX]
+    self.Sjmp("JMP" , "_next")                                   // JMP  _next
+
+    /* allocate memory to store the string header and unquoted result */
+    self.Link("_unquote")                               // _unquote:
+    self.Emit("ADDQ", jit.Imm(15), _AX)                 // ADDQ    $15, AX
+    self.Emit("MOVQ", _T_byte, _BX)                     // MOVQ    _T_byte, BX
+    self.Emit("MOVB", jit.Imm(0), _CX)                  // MOVB    $0, CX
+    self.call_go(_F_mallocgc)                           // CALL_GO runtime.mallocgc
+    self.Emit("MOVQ", _AX, _R9)                         // MOVQ    AX, R9
+
+    /* prepare the unquoting parameters */
+    self.Emit("MOVQ" , _VAR_ss_Iv, _CX)                         // MOVQ  ss.Iv, CX
+    self.Emit("LEAQ" , jit.Sib(_IP, _CX, 1, 0), _DI)            // LEAQ  (IP)(CX), DI
+    self.Emit("NEGQ" , _CX)                                     // NEGQ  CX
+    self.Emit("LEAQ" , jit.Sib(_IC, _CX, 1, -1), _SI)           // LEAQ  -1(IC)(CX), SI
+    self.Emit("LEAQ" , jit.Ptr(_R9, 16), _DX)                   // LEAQ  16(R8), DX
+    self.Emit("LEAQ" , _VAR_ss_Ep, _CX)                         // LEAQ  ss.Ep, CX
+    self.Emit("XORL" , _R8, _R8)                                // XORL  R8, R8
+    self.Emit("BTQ"  , jit.Imm(_F_disable_urc), _VAR_df)        // BTQ   ${_F_disable_urc}, fv
+    self.Emit("SETCC", _R8)                                     // SETCC R8
+    self.Emit("SHLQ" , jit.Imm(types.B_UNICODE_REPLACE), _R8)   // SHLQ  ${types.B_UNICODE_REPLACE}, R8
+
+    /* unquote the string, with R9 been preserved */
+    self.Emit("MOVQ", _R9, _VAR_R9)             // SAVE R9
+    self.call_c(_F_unquote)                     // CALL unquote
+    self.Emit("MOVQ", _VAR_R9, _R9)             // LOAD R9
+
+    /* check for errors */
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ AX, AX
+    self.Sjmp("JS"   , "_unquote_error")        // JS    _unquote_error
+    self.Emit("MOVL" , jit.Imm(1), _DX)         // MOVL  $1, DX
+    self.Emit("LEAQ" , jit.Ptr(_R9, 16), _R8)   // ADDQ  $16, R8
+    self.Emit("MOVQ" , _R8, jit.Ptr(_R9, 0))    // MOVQ  R8, (R9)
+    self.Emit("MOVQ" , _AX, jit.Ptr(_R9, 8))    // MOVQ  AX, 8(R9)
+    self.Sjmp("JMP"  , "_noescape")             // JMP   _noescape
+
+    /** V_DOUBLE **/
+    self.Link("_decode_V_DOUBLE")                           // _decode_V_DOUBLE:
+    self.Emit("BTQ"  , jit.Imm(_F_use_number), _VAR_df)     // BTQ     _F_use_number, df
+    self.Sjmp("JC"   , "_use_number")                       // JC      _use_number
+    self.Emit("MOVSD", _VAR_ss_Dv, _X0)                     // MOVSD   ss.Dv, X0
+    self.Sjmp("JMP"  , "_use_float64")                      // JMP     _use_float64
+
+    /** V_INTEGER **/
+    self.Link("_decode_V_INTEGER")                          // _decode_V_INTEGER:
+    self.Emit("BTQ"     , jit.Imm(_F_use_number), _VAR_df)  // BTQ      _F_use_number, df
+    self.Sjmp("JC"      , "_use_number")                    // JC       _use_number
+    self.Emit("BTQ"     , jit.Imm(_F_use_int64), _VAR_df)   // BTQ      _F_use_int64, df
+    self.Sjmp("JC"      , "_use_int64")                     // JC       _use_int64
+    //TODO: use ss.Dv directly
+    self.Emit("MOVSD", _VAR_ss_Dv, _X0)                  // MOVSD   ss.Dv, X0
+
+    /* represent numbers as `float64` */
+    self.Link("_use_float64")                   // _use_float64:
+    self.Emit("MOVQ" , _X0, _AX)                // MOVQ   X0, AX
+    self.call_go(_F_convT64)                    // CALL_GO runtime.convT64
+    self.Emit("MOVQ" , _T_float64, _R8)         // MOVQ    _T_float64, R8
+    self.Emit("MOVQ" , _AX, _R9)                // MOVQ    AX, R9
+    self.Emit("MOVQ" , _VAR_ss_Ep, _DI)         // MOVQ    ss.Ep, DI
+    self.Sjmp("JMP"  , "_set_value")            // JMP     _set_value
+
+    /* represent numbers as `json.Number` */
+    self.Link("_use_number")                            // _use_number
+    self.Emit("MOVQ", _VAR_ss_Ep, _AX)                  // MOVQ    ss.Ep, AX
+    self.Emit("LEAQ", jit.Sib(_IP, _AX, 1, 0), _SI)     // LEAQ    (IP)(AX), SI
+    self.Emit("MOVQ", _IC, _CX)                         // MOVQ    IC, CX
+    self.Emit("SUBQ", _AX, _CX)                         // SUBQ    AX, CX
+    self.Emit("MOVQ", _SI, _AX)                         // MOVQ    SI, AX
+    self.Emit("MOVQ", _CX, _BX)                         // MOVQ    CX, BX
+    self.call_go(_F_convTstring)                        // CALL_GO runtime.convTstring
+    self.Emit("MOVQ", _T_number, _R8)                   // MOVQ    _T_number, R8
+    self.Emit("MOVQ", _AX, _R9)                         // MOVQ    AX, R9
+    self.Emit("MOVQ", _VAR_ss_Ep, _DI)                  // MOVQ    ss.Ep, DI
+    self.Sjmp("JMP" , "_set_value")                     // JMP     _set_value
+
+    /* represent numbers as `int64` */
+    self.Link("_use_int64")                     // _use_int64:
+    self.Emit("MOVQ", _VAR_ss_Iv, _AX)          // MOVQ    ss.Iv, AX
+    self.call_go(_F_convT64)                    // CALL_GO runtime.convT64
+    self.Emit("MOVQ", _T_int64, _R8)            // MOVQ    _T_int64, R8
+    self.Emit("MOVQ", _AX, _R9)                 // MOVQ    AX, R9
+    self.Emit("MOVQ", _VAR_ss_Ep, _DI)          // MOVQ    ss.Ep, DI
+    self.Sjmp("JMP" , "_set_value")             // JMP     _set_value
+
+    /** V_KEY_SEP **/
+    self.Link("_decode_V_KEY_SEP")                                          // _decode_V_KEY_SEP:
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)                    // MOVQ ST.Vt[CX], AX
+    self.Emit("CMPQ", _AX, jit.Imm(_S_obj_delim))                           // CMPQ AX, _S_obj_delim
+    self.Sjmp("JNE" , "_invalid_char")                                      // JNE  _invalid_char
+    self.Emit("MOVQ", jit.Imm(_S_val), jit.Sib(_ST, _CX, 8, _ST_Vt))        // MOVQ _S_val, ST.Vt[CX]
+    self.Emit("MOVQ", jit.Imm(_S_obj), jit.Sib(_ST, _CX, 8, _ST_Vt - 8))    // MOVQ _S_obj, ST.Vt[CX - 1]
+    self.Sjmp("JMP" , "_next")                                              // JMP  _next
+
+    /** V_ELEM_SEP **/
+    self.Link("_decode_V_ELEM_SEP")                          // _decode_V_ELEM_SEP:
+    self.Emit("MOVQ" , jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ     ST.Sp, CX
+    self.Emit("MOVQ" , jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ     ST.Vt[CX], AX
+    self.Emit("CMPQ" , _AX, jit.Imm(_S_arr))      
+    self.Sjmp("JE"   , "_array_sep")                         // JZ       _next
+    self.Emit("CMPQ" , _AX, jit.Imm(_S_obj))                 // CMPQ     _AX, _S_arr
+    self.Sjmp("JNE"  , "_invalid_char")                      // JNE      _invalid_char
+    self.Emit("MOVQ" , jit.Imm(_S_obj_sep), jit.Sib(_ST, _CX, 8, _ST_Vt))
+    self.Sjmp("JMP"  , "_next")                              // JMP      _next
+
+    /* arrays */
+    self.Link("_array_sep")
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _DX)                 // MOVQ 8(SI), DX
+    self.Emit("CMPQ", _DX, jit.Ptr(_SI, 16))                // CMPQ DX, 16(SI)
+    self.Sjmp("JAE" , "_array_more")                        // JAE  _array_more
+
+    /* add a slot for the new element */
+    self.Link("_array_append")                                          // _array_append:
+    self.Emit("ADDQ", jit.Imm(1), jit.Ptr(_SI, 8))                      // ADDQ $1, 8(SI)
+    self.Emit("MOVQ", jit.Ptr(_SI, 0), _SI)                             // MOVQ (SI), SI
+    self.Emit("ADDQ", jit.Imm(1), _CX)                                  // ADDQ $1, CX
+    self.Emit("CMPQ", _CX, jit.Imm(types.MAX_RECURSE))                  // CMPQ CX, ${types.MAX_RECURSE}
+    self.Sjmp("JAE"  , "_stack_overflow")                                // JA   _stack_overflow
+    self.Emit("SHLQ", jit.Imm(1), _DX)                                  // SHLQ $1, DX
+    self.Emit("LEAQ", jit.Sib(_SI, _DX, 8, 0), _SI)                     // LEAQ (SI)(DX*8), SI
+    self.Emit("MOVQ", _CX, jit.Ptr(_ST, _ST_Sp))                        // MOVQ CX, ST.Sp
+    self.WriteRecNotAX(7 , _SI, jit.Sib(_ST, _CX, 8, _ST_Vp), false)           // MOVQ SI, ST.Vp[CX]
+    self.Emit("MOVQ", jit.Imm(_S_val), jit.Sib(_ST, _CX, 8, _ST_Vt))    // MOVQ _S_val, ST.Vt[CX}
+    self.Sjmp("JMP" , "_next")                                          // JMP  _next
+
+    /** V_ARRAY_END **/
+    self.Link("_decode_V_ARRAY_END")                        // _decode_V_ARRAY_END:
+    self.Emit("XORL", _DX, _DX)                             // XORL DX, DX
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
+    self.Emit("CMPQ", _AX, jit.Imm(_S_arr_0))               // CMPQ AX, _S_arr_0
+    self.Sjmp("JE"  , "_first_item")                        // JE   _first_item
+    self.Emit("CMPQ", _AX, jit.Imm(_S_arr))                 // CMPQ AX, _S_arr
+    self.Sjmp("JNE" , "_invalid_char")                      // JNE  _invalid_char
+    self.Emit("SUBQ", jit.Imm(1), jit.Ptr(_ST, _ST_Sp))     // SUBQ $1, ST.Sp
+    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp))    // MOVQ DX, ST.Vp[CX]
+    self.Sjmp("JMP" , "_next")                              // JMP  _next
+
+    /* first element of an array */
+    self.Link("_first_item")                                    // _first_item:
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)                // MOVQ ST.Sp, CX
+    self.Emit("SUBQ", jit.Imm(2), jit.Ptr(_ST, _ST_Sp))         // SUBQ $2, ST.Sp
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp - 8), _SI)    // MOVQ ST.Vp[CX - 1], SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                     // MOVQ 8(SI), SI
+    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp - 8))    // MOVQ DX, ST.Vp[CX - 1]
+    self.Emit("MOVQ", _DX, jit.Sib(_ST, _CX, 8, _ST_Vp))        // MOVQ DX, ST.Vp[CX]
+    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 8))                     // MOVQ DX, 8(SI)
+    self.Sjmp("JMP" , "_next")                                  // JMP  _next
+
+    /** V_OBJECT_END **/
+    self.Link("_decode_V_OBJECT_END")                       // _decode_V_OBJECT_END:
+    self.Emit("MOVL", jit.Imm(_S_omask_end), _DI)           // MOVL _S_omask, DI
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vt), _AX)    // MOVQ ST.Vt[CX], AX
+    self.Emit("BTQ" , _AX, _DI)                    
+    self.Sjmp("JNC" , "_invalid_char")                      // JNE  _invalid_char
+    self.Emit("XORL", _AX, _AX)                             // XORL AX, AX
+    self.Emit("SUBQ", jit.Imm(1), jit.Ptr(_ST, _ST_Sp))     // SUBQ $1, ST.Sp
+    self.Emit("MOVQ", _AX, jit.Sib(_ST, _CX, 8, _ST_Vp))    // MOVQ AX, ST.Vp[CX]
+    self.Sjmp("JMP" , "_next")                              // JMP  _next
+
+    /* return from decoder */
+    self.Link("_return")                            // _return:
+    self.Emit("XORL", _EP, _EP)                     // XORL EP, EP
+    self.Emit("MOVQ", _EP, jit.Ptr(_ST, _ST_Vp))    // MOVQ EP, ST.Vp[0]
+    self.Link("_epilogue")                          // _epilogue:
+    self.Emit("SUBQ", jit.Imm(_FsmOffset), _ST)     // SUBQ _FsmOffset, _ST
+    self.Emit("MOVQ", jit.Ptr(_SP, _VD_offs), _BP)  // MOVQ _VD_offs(SP), BP
+    self.Emit("ADDQ", jit.Imm(_VD_size), _SP)       // ADDQ $_VD_size, SP
+    self.Emit("RET")                                // RET
+
+    /* array expand */
+    self.Link("_array_more")                    // _array_more:
+    self.Emit("MOVQ" , _T_eface, _AX)           // MOVQ    _T_eface, AX
+    self.Emit("MOVQ" , jit.Ptr(_SI, 0), _BX)    // MOVQ   (SI), BX
+    self.Emit("MOVQ" , jit.Ptr(_SI, 8), _CX)    // MOVQ   8(SI), CX
+    self.Emit("MOVQ" , jit.Ptr(_SI, 16), _DI)   // MOVQ    16(SI), DI
+    self.Emit("MOVQ" , _DI, _SI)                // MOVQ    DI, 24(SP)
+    self.Emit("SHLQ" , jit.Imm(1), _SI)         // SHLQ    $1, SI
+    self.call_go(_F_growslice)                  // CALL_GO runtime.growslice
+    self.Emit("MOVQ" , _AX, _DI)                // MOVQ   AX, DI
+    self.Emit("MOVQ" , _BX, _DX)                // MOVQ   BX, DX
+    self.Emit("MOVQ" , _CX, _AX)                // MOVQ   CX, AX
+             
+    /* update the slice */
+    self.Emit("MOVQ", jit.Ptr(_ST, _ST_Sp), _CX)            // MOVQ ST.Sp, CX
+    self.Emit("MOVQ", jit.Sib(_ST, _CX, 8, _ST_Vp), _SI)    // MOVQ ST.Vp[CX], SI
+    self.Emit("MOVQ", jit.Ptr(_SI, 8), _SI)                 // MOVQ 8(SI), SI
+    self.Emit("MOVQ", _DX, jit.Ptr(_SI, 8))                 // MOVQ DX, 8(SI)
+    self.Emit("MOVQ", _AX, jit.Ptr(_SI, 16))                // MOVQ AX, 16(AX)
+    self.WriteRecNotAX(8 , _DI, jit.Ptr(_SI, 0), false)                 // MOVQ R10, (SI)
+    self.Sjmp("JMP" , "_array_append")                      // JMP  _array_append
+
+    /* copy string */
+    self.Link("copy_string")  // pointer: R8, length: AX, return addr: DI
+    self.Emit("MOVQ", _R8, _VAR_cs_p)
+    self.Emit("MOVQ", _AX, _VAR_cs_n)
+    self.Emit("MOVQ", _DI, _VAR_cs_LR)
+    self.Emit("MOVQ", _AX, _BX)
+    self.Emit("MOVQ", _AX, _CX)
+    self.Emit("MOVQ", _T_byte, _AX)
+    self.call_go(_F_makeslice)                              
+    self.Emit("MOVQ", _AX, _VAR_cs_d)                    
+    self.Emit("MOVQ", _VAR_cs_p, _BX)
+    self.Emit("MOVQ", _VAR_cs_n, _CX)
+    self.call_go(_F_memmove)
+    self.Emit("MOVQ", _VAR_cs_d, _R8)
+    self.Emit("MOVQ", _VAR_cs_n, _AX)
+    self.Emit("MOVQ", _VAR_cs_LR, _DI)
+    self.Rjmp("JMP", _DI)
+
+    /* error handlers */
+    self.Link("_stack_overflow")
+    self.Emit("MOVL" , _E_recurse, _EP)         // MOVQ  _E_recurse, EP
+    self.Sjmp("JMP"  , "_error")                // JMP   _error
+    self.Link("_vtype_error")                   // _vtype_error:
+    self.Emit("MOVQ" , _DI, _IC)                // MOVQ  DI, IC
+    self.Emit("MOVL" , _E_invalid, _EP)         // MOVL  _E_invalid, EP
+    self.Sjmp("JMP"  , "_error")                // JMP   _error
+    self.Link("_invalid_char")                  // _invalid_char:
+    self.Emit("SUBQ" , jit.Imm(1), _IC)         // SUBQ  $1, IC
+    self.Emit("MOVL" , _E_invalid, _EP)         // MOVL  _E_invalid, EP
+    self.Sjmp("JMP"  , "_error")                // JMP   _error
+    self.Link("_unquote_error")                 // _unquote_error:
+    self.Emit("MOVQ" , _VAR_ss_Iv, _IC)         // MOVQ  ss.Iv, IC
+    self.Emit("SUBQ" , jit.Imm(1), _IC)         // SUBQ  $1, IC
+    self.Link("_parsing_error")                 // _parsing_error:
+    self.Emit("NEGQ" , _AX)                     // NEGQ  AX
+    self.Emit("MOVQ" , _AX, _EP)                // MOVQ  AX, EP
+    self.Link("_error")                         // _error:
+    self.Emit("PXOR" , _X0, _X0)                // PXOR  X0, X0
+    self.Emit("MOVOU", _X0, jit.Ptr(_VP, 0))    // MOVOU X0, (VP)
+    self.Sjmp("JMP"  , "_epilogue")             // JMP   _epilogue
+
+    /* invalid value type, never returns */
+    self.Link("_invalid_vtype")
+    self.call_go(_F_invalid_vtype)                 // CALL invalid_type
+    self.Emit("UD2")                            // UD2
+
+    /* switch jump table */
+    self.Link("_switch_table")              // _switch_table:
+    self.Sref("_decode_V_EOF", 0)           // SREF &_decode_V_EOF, $0
+    self.Sref("_decode_V_NULL", -4)         // SREF &_decode_V_NULL, $-4
+    self.Sref("_decode_V_TRUE", -8)         // SREF &_decode_V_TRUE, $-8
+    self.Sref("_decode_V_FALSE", -12)       // SREF &_decode_V_FALSE, $-12
+    self.Sref("_decode_V_ARRAY", -16)       // SREF &_decode_V_ARRAY, $-16
+    self.Sref("_decode_V_OBJECT", -20)      // SREF &_decode_V_OBJECT, $-20
+    self.Sref("_decode_V_STRING", -24)      // SREF &_decode_V_STRING, $-24
+    self.Sref("_decode_V_DOUBLE", -28)      // SREF &_decode_V_DOUBLE, $-28
+    self.Sref("_decode_V_INTEGER", -32)     // SREF &_decode_V_INTEGER, $-32
+    self.Sref("_decode_V_KEY_SEP", -36)     // SREF &_decode_V_KEY_SEP, $-36
+    self.Sref("_decode_V_ELEM_SEP", -40)    // SREF &_decode_V_ELEM_SEP, $-40
+    self.Sref("_decode_V_ARRAY_END", -44)   // SREF &_decode_V_ARRAY_END, $-44
+    self.Sref("_decode_V_OBJECT_END", -48)  // SREF &_decode_V_OBJECT_END, $-48
+
+    /* fast character lookup table */
+    self.Link("_decode_tab")        // _decode_tab:
+    self.Sref("_decode_V_EOF", 0)   // SREF &_decode_V_EOF, $0
+
+    /* generate rest of the tabs */
+    for i := 1; i < 256; i++ {
+        if to, ok := _R_tab[i]; ok {
+            self.Sref(to, -int64(i) * 4)
+        } else {
+            self.Byte(0x00, 0x00, 0x00, 0x00)
+        }
+    }
+}
+
+func (self *_ValueDecoder) WritePtrAX(i int, rec obj.Addr, saveDI bool) {
+    self.Emit("MOVQ", _V_writeBarrier, _R9)
+    self.Emit("CMPL", jit.Ptr(_R9, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    if saveDI {
+        self.save(_DI)
+    }
+    self.Emit("LEAQ", rec, _DI)
+    self.call(_F_gcWriteBarrierAX)
+    if saveDI {
+        self.load(_DI)
+    }    
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", _AX, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}
+
+func (self *_ValueDecoder) WriteRecNotAX(i int, ptr obj.Addr, rec obj.Addr, saveDI bool) {
+    if rec.Reg == x86.REG_AX || rec.Index == x86.REG_AX {
+        panic("rec contains AX!")
+    }
+    self.Emit("MOVQ", _V_writeBarrier, _AX)
+    self.Emit("CMPL", jit.Ptr(_AX, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, _AX)
+    if saveDI {
+        self.save(_DI)
+    }
+    self.Emit("LEAQ", rec, _DI)
+    self.call(_F_gcWriteBarrierAX)
+    if saveDI {
+        self.load(_DI)
+    }    
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}
+
+/** Generic Decoder **/
+
+var (
+    _subr_decode_value = new(_ValueDecoder).build()
+)
+
+//go:nosplit
+func invalid_vtype(vt types.ValueType) {
+    throw(fmt.Sprintf("invalid value type: %d", vt))
+}
diff --git a/vendor/github.com/bytedance/sonic/decoder/generic_amd64_go117_test.s b/vendor/github.com/bytedance/sonic/decoder/generic_amd64_go117_test.s
new file mode 100644
index 000000000..6c2686de9
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/generic_amd64_go117_test.s
@@ -0,0 +1,37 @@
+// +build go1.17,!go1.21
+
+//
+// Copyright 2021 ByteDance Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "go_asm.h"
+#include "funcdata.h"
+#include "textflag.h"
+
+TEXT ·decodeValueStub(SB), NOSPLIT, $0 - 72
+    NO_LOCAL_POINTERS
+    PXOR  X0, X0
+    MOVOU X0, rv+48(FP)
+    MOVQ  st+0(FP) , R13
+    MOVQ  sp+8(FP) , R10
+    MOVQ  sn+16(FP), R12
+    MOVQ  ic+24(FP), R11
+    MOVQ  vp+32(FP), R15
+    MOVQ  df+40(FP), AX
+    MOVQ  ·_subr_decode_value(SB), BX
+    CALL  BX
+    MOVQ  R11, rp+48(FP)
+    MOVQ  BX, ex+56(FP)
+    RET
diff --git a/vendor/github.com/bytedance/sonic/decoder/generic_amd64_test.s b/vendor/github.com/bytedance/sonic/decoder/generic_amd64_test.s
new file mode 100644
index 000000000..36cb1f5f3
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/generic_amd64_test.s
@@ -0,0 +1,37 @@
+// +build go1.15,!go1.17
+
+//
+// Copyright 2021 ByteDance Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "go_asm.h"
+#include "funcdata.h"
+#include "textflag.h"
+
+TEXT ·decodeValueStub(SB), NOSPLIT, $0 - 72
+    NO_LOCAL_POINTERS
+    PXOR  X0, X0
+    MOVOU X0, rv+48(FP)
+    MOVQ  st+0(FP), BX
+    MOVQ  sp+8(FP), R12
+    MOVQ  sn+16(FP), R13
+    MOVQ  ic+24(FP), R14
+    MOVQ  vp+32(FP), R15
+    MOVQ  df+40(FP), R10
+    MOVQ  ·_subr_decode_value(SB), AX
+    CALL  AX
+    MOVQ  R14, rp+48(FP)
+    MOVQ  R11, ex+56(FP)
+    RET
diff --git a/vendor/github.com/bytedance/sonic/decoder/pools.go b/vendor/github.com/bytedance/sonic/decoder/pools.go
new file mode 100644
index 000000000..ab1e5f23c
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/pools.go
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `sync`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/caching`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+const (
+    _MinSlice = 16
+    _MaxStack = 4096 // 4k slots
+    _MaxStackBytes = _MaxStack * _PtrBytes
+    _MaxDigitNums = 800  // used in atof fallback algorithm
+)
+
+const (
+    _PtrBytes   = _PTR_SIZE / 8
+    _FsmOffset  = (_MaxStack + 1) * _PtrBytes
+    _DbufOffset = _FsmOffset + int64(unsafe.Sizeof(types.StateMachine{})) + types.MAX_RECURSE * _PtrBytes
+    _StackSize  = unsafe.Sizeof(_Stack{})
+)
+
+var (
+    stackPool     = sync.Pool{}
+    valueCache    = []unsafe.Pointer(nil)
+    fieldCache    = []*caching.FieldMap(nil)
+    fieldCacheMux = sync.Mutex{}
+    programCache  = caching.CreateProgramCache()
+)
+
+type _Stack struct {
+    sp uintptr
+    sb [_MaxStack]unsafe.Pointer
+    mm types.StateMachine
+    vp [types.MAX_RECURSE]unsafe.Pointer
+    dp [_MaxDigitNums]byte
+}
+
+type _Decoder func(
+    s  string,
+    i  int,
+    vp unsafe.Pointer,
+    sb *_Stack,
+    fv uint64,
+    sv string, // DO NOT pass value to this arguement, since it is only used for local _VAR_sv
+    vk unsafe.Pointer, // DO NOT pass value to this arguement, since it is only used for local _VAR_vk
+) (int, error)
+
+var _KeepAlive struct {
+    s string
+    i int
+    vp unsafe.Pointer
+    sb *_Stack
+    fv uint64
+    sv string
+    vk unsafe.Pointer
+
+    ret int
+    err error
+
+    frame_decoder [_FP_offs]byte
+    frame_generic [_VD_offs]byte
+}
+
+var (
+    argPtrs   = []bool{true, false, false, true, true, false, true, false, true}
+    localPtrs = []bool{}
+)
+
+var (
+    argPtrs_generic   = []bool{true}
+    localPtrs_generic = []bool{}
+)
+
+func newStack() *_Stack {
+    if ret := stackPool.Get(); ret == nil {
+        return new(_Stack)
+    } else {
+        return ret.(*_Stack)
+    }
+}
+
+func resetStack(p *_Stack) {
+    memclrNoHeapPointers(unsafe.Pointer(p), _StackSize)
+}
+
+func freeStack(p *_Stack) {
+    p.sp = 0
+    stackPool.Put(p)
+}
+
+func freezeValue(v unsafe.Pointer) uintptr {
+    valueCache = append(valueCache, v)
+    return uintptr(v)
+}
+
+func freezeFields(v *caching.FieldMap) int64 {
+    fieldCacheMux.Lock()
+    fieldCache = append(fieldCache, v)
+    fieldCacheMux.Unlock()
+    return referenceFields(v)
+}
+
+func referenceFields(v *caching.FieldMap) int64 {
+    return int64(uintptr(unsafe.Pointer(v)))
+}
+
+func makeDecoder(vt *rt.GoType, _ ...interface{}) (interface{}, error) {
+    if pp, err := newCompiler().compile(vt.Pack()); err != nil {
+        return nil, err
+    } else {
+        return newAssembler(pp).Load(), nil
+    }
+}
+
+func findOrCompile(vt *rt.GoType) (_Decoder, error) {
+    if val := programCache.Get(vt); val != nil {
+        return val.(_Decoder), nil
+    } else if ret, err := programCache.Compute(vt, makeDecoder); err == nil {
+        return ret.(_Decoder), nil
+    } else {
+        return nil, err
+    }
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/decoder/primitives.go b/vendor/github.com/bytedance/sonic/decoder/primitives.go
new file mode 100644
index 000000000..d6053e2cb
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/primitives.go
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `encoding`
+    `encoding/json`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+func decodeTypedPointer(s string, i int, vt *rt.GoType, vp unsafe.Pointer, sb *_Stack, fv uint64) (int, error) {
+    if fn, err := findOrCompile(vt); err != nil {
+        return 0, err
+    } else {
+        rt.MoreStack(_FP_size + _VD_size + native.MaxFrameSize)
+        rt.StopProf()
+        ret, err := fn(s, i, vp, sb, fv, "", nil)
+        rt.StartProf()
+        return ret, err
+    }
+}
+
+func decodeJsonUnmarshaler(vv interface{}, s string) error {
+    return vv.(json.Unmarshaler).UnmarshalJSON(rt.Str2Mem(s))
+}
+
+func decodeTextUnmarshaler(vv interface{}, s string) error {
+    return vv.(encoding.TextUnmarshaler).UnmarshalText(rt.Str2Mem(s))
+}
diff --git a/vendor/github.com/bytedance/sonic/decoder/stream.go b/vendor/github.com/bytedance/sonic/decoder/stream.go
new file mode 100644
index 000000000..06dc8185b
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/stream.go
@@ -0,0 +1,217 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `bytes`
+    `io`
+    `sync`
+
+    `github.com/bytedance/sonic/internal/native/types`
+)
+
+var (
+    defaultBufferSize    uint = 4096
+    growSliceFactorShift uint = 1
+    minLeftBufferShift   uint = 2
+)
+
+type StreamDecoder struct {
+    r       io.Reader
+    buf     []byte
+    scanp   int
+    scanned int64
+    err     error
+    Decoder
+}
+
+var bufPool = sync.Pool{
+    New: func () interface{} {
+        return make([]byte, 0, defaultBufferSize)
+    },
+}
+
+// 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) {
+    if self.err != nil {
+        return self.err
+    }
+
+    var buf = self.buf[self.scanp:]
+    var p = 0
+    var recycle bool
+    if cap(buf) == 0 {
+        buf = bufPool.Get().([]byte)
+        recycle = true
+    }
+    
+    var first = true
+    var repeat = true
+read_more:
+    for {
+        l := len(buf)
+        realloc(&buf)
+        n, err := self.r.Read(buf[l:cap(buf)])
+        buf = buf[:l+n]
+        if err != nil {
+            repeat = false
+            if err == io.EOF {
+                if len(buf) == 0 {
+                    return err
+                }
+                break
+            }
+            self.err = err
+            return err
+        }
+        if n > 0 || first {
+            break
+        }
+    }
+    first = false
+
+    l := len(buf)
+    if l > 0 {
+        self.Decoder.Reset(string(buf))
+        err = self.Decoder.Decode(val)
+        if err != nil {
+            if repeat && self.repeatable(err) {
+                goto read_more
+            }
+            self.err = err
+        }
+
+        p = self.Decoder.Pos()
+        self.scanned += int64(p)
+        self.scanp = 0
+    }
+    
+    if l > p {
+        // remain undecoded bytes, so copy them into self.buf
+        self.buf = append(self.buf[:0], buf[p:]...)
+    } else {
+        self.buf = nil
+        recycle = true
+    }
+
+    if recycle {
+        buf = buf[:0]
+        bufPool.Put(buf)
+    }
+    return err
+}
+
+func (self StreamDecoder) repeatable(err error) bool {
+    if ee, ok := err.(SyntaxError); ok && 
+    (ee.Code == types.ERR_EOF || (ee.Code == types.ERR_INVALID_CHAR && self.i >= len(self.s)-1)) {
+        return true
+    }
+    return false
+}
+
+// InputOffset returns the input stream byte offset of the current decoder position. 
+// The offset gives the location of the end of the most recently returned token and the beginning of the next token.
+func (self *StreamDecoder) InputOffset() int64 {
+    return self.scanned + int64(self.scanp)
+}
+
+// Buffered returns a reader of the data remaining in the Decoder's buffer. 
+// The reader is valid until the next call to Decode.
+func (self *StreamDecoder) Buffered() io.Reader {
+    return bytes.NewReader(self.buf[self.scanp:])
+}
+
+// More reports whether there is another element in the
+// current array or object being parsed.
+func (self *StreamDecoder) More() bool {
+    if self.err != nil {
+        return false
+    }
+    c, err := self.peek()
+    return err == nil && c != ']' && c != '}'
+}
+
+func (self *StreamDecoder) peek() (byte, error) {
+    var err error
+    for {
+        for i := self.scanp; i < len(self.buf); i++ {
+            c := self.buf[i]
+            if isSpace(c) {
+                continue
+            }
+            self.scanp = i
+            return c, nil
+        }
+        // buffer has been scanned, now report any error
+        if err != nil {
+            if err != io.EOF {
+                self.err = err
+            }
+            return 0, err
+        }
+        err = self.refill()
+    }
+}
+
+func isSpace(c byte) bool {
+    return types.SPACE_MASK & (1 << c) != 0
+}
+
+func (self *StreamDecoder) refill() error {
+    // Make room to read more into the buffer.
+    // First slide down data already consumed.
+    if self.scanp > 0 {
+        self.scanned += int64(self.scanp)
+        n := copy(self.buf, self.buf[self.scanp:])
+        self.buf = self.buf[:n]
+        self.scanp = 0
+    }
+
+    // Grow buffer if not large enough.
+    realloc(&self.buf)
+
+    // Read. Delay error for next iteration (after scan).
+    n, err := self.r.Read(self.buf[len(self.buf):cap(self.buf)])
+    self.buf = self.buf[0 : len(self.buf)+n]
+
+    return err
+}
+
+func realloc(buf *[]byte) {
+    l := uint(len(*buf))
+    c := uint(cap(*buf))
+    if c - l <= c >> minLeftBufferShift {
+        e := l+(l>>minLeftBufferShift)
+        if e < defaultBufferSize {
+            e = defaultBufferSize
+        }
+        tmp := make([]byte, l, e)
+        copy(tmp, *buf)
+        *buf = tmp
+    }
+}
+
diff --git a/vendor/github.com/bytedance/sonic/decoder/stubs_go115.go b/vendor/github.com/bytedance/sonic/decoder/stubs_go115.go
new file mode 100644
index 000000000..1a0917c3c
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/stubs_go115.go
@@ -0,0 +1,111 @@
+// +build go1.15,!go1.20
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `unsafe`
+    `reflect`
+
+    _ `github.com/chenzhuoyu/base64x`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+//go:linkname _subr__b64decode github.com/chenzhuoyu/base64x._subr__b64decode
+var _subr__b64decode uintptr
+
+// runtime.maxElementSize
+const _max_map_element_size uintptr = 128
+
+func mapfast(vt reflect.Type) bool {
+    return vt.Elem().Size() <= _max_map_element_size
+}
+
+//go:nosplit
+//go:linkname throw runtime.throw
+//goland:noinspection GoUnusedParameter
+func throw(s string)
+
+//go:linkname convT64 runtime.convT64
+//goland:noinspection GoUnusedParameter
+func convT64(v uint64) unsafe.Pointer
+
+//go:linkname convTslice runtime.convTslice
+//goland:noinspection GoUnusedParameter
+func convTslice(v []byte) unsafe.Pointer
+
+//go:linkname convTstring runtime.convTstring
+//goland:noinspection GoUnusedParameter
+func convTstring(v string) unsafe.Pointer
+
+//go:noescape
+//go:linkname memequal runtime.memequal
+//goland:noinspection GoUnusedParameter
+func memequal(a unsafe.Pointer, b unsafe.Pointer, size uintptr) bool
+
+//go:noescape
+//go:linkname memmove runtime.memmove
+//goland:noinspection GoUnusedParameter
+func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
+
+//go:linkname mallocgc runtime.mallocgc
+//goland:noinspection GoUnusedParameter
+func mallocgc(size uintptr, typ *rt.GoType, needzero bool) unsafe.Pointer
+
+//go:linkname makeslice runtime.makeslice
+//goland:noinspection GoUnusedParameter
+func makeslice(et *rt.GoType, len int, cap int) unsafe.Pointer
+
+//go:noescape
+//go:linkname growslice runtime.growslice
+//goland:noinspection GoUnusedParameter
+func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
+
+//go:linkname makemap_small runtime.makemap_small
+func makemap_small() unsafe.Pointer
+
+//go:linkname mapassign runtime.mapassign
+//goland:noinspection GoUnusedParameter
+func mapassign(t *rt.GoType, h unsafe.Pointer, k unsafe.Pointer) unsafe.Pointer
+
+//go:linkname mapassign_fast32 runtime.mapassign_fast32
+//goland:noinspection GoUnusedParameter
+func mapassign_fast32(t *rt.GoType, h unsafe.Pointer, k uint32) unsafe.Pointer
+
+//go:linkname mapassign_fast64 runtime.mapassign_fast64
+//goland:noinspection GoUnusedParameter
+func mapassign_fast64(t *rt.GoType, h unsafe.Pointer, k uint64) unsafe.Pointer
+
+//go:linkname mapassign_fast64ptr runtime.mapassign_fast64ptr
+//goland:noinspection GoUnusedParameter
+func mapassign_fast64ptr(t *rt.GoType, h unsafe.Pointer, k unsafe.Pointer) unsafe.Pointer
+
+//go:linkname mapassign_faststr runtime.mapassign_faststr
+//goland:noinspection GoUnusedParameter
+func mapassign_faststr(t *rt.GoType, h unsafe.Pointer, s string) unsafe.Pointer
+
+//go:nosplit
+//go:linkname memclrHasPointers runtime.memclrHasPointers
+//goland:noinspection GoUnusedParameter
+func memclrHasPointers(ptr unsafe.Pointer, n uintptr)
+
+//go:noescape
+//go:linkname memclrNoHeapPointers runtime.memclrNoHeapPointers
+//goland:noinspection GoUnusedParameter
+func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/decoder/stubs_go120.go b/vendor/github.com/bytedance/sonic/decoder/stubs_go120.go
new file mode 100644
index 000000000..cde6a1972
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/stubs_go120.go
@@ -0,0 +1,111 @@
+// +build go1.20
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `unsafe`
+    `reflect`
+
+    _ `github.com/chenzhuoyu/base64x`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+//go:linkname _subr__b64decode github.com/chenzhuoyu/base64x._subr__b64decode
+var _subr__b64decode uintptr
+
+// runtime.maxElementSize
+const _max_map_element_size uintptr = 128
+
+func mapfast(vt reflect.Type) bool {
+    return vt.Elem().Size() <= _max_map_element_size
+}
+
+//go:nosplit
+//go:linkname throw runtime.throw
+//goland:noinspection GoUnusedParameter
+func throw(s string)
+
+//go:linkname convT64 runtime.convT64
+//goland:noinspection GoUnusedParameter
+func convT64(v uint64) unsafe.Pointer
+
+//go:linkname convTslice runtime.convTslice
+//goland:noinspection GoUnusedParameter
+func convTslice(v []byte) unsafe.Pointer
+
+//go:linkname convTstring runtime.convTstring
+//goland:noinspection GoUnusedParameter
+func convTstring(v string) unsafe.Pointer
+
+//go:noescape
+//go:linkname memequal runtime.memequal
+//goland:noinspection GoUnusedParameter
+func memequal(a unsafe.Pointer, b unsafe.Pointer, size uintptr) bool
+
+//go:noescape
+//go:linkname memmove runtime.memmove
+//goland:noinspection GoUnusedParameter
+func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
+
+//go:linkname mallocgc runtime.mallocgc
+//goland:noinspection GoUnusedParameter
+func mallocgc(size uintptr, typ *rt.GoType, needzero bool) unsafe.Pointer
+
+//go:linkname makeslice runtime.makeslice
+//goland:noinspection GoUnusedParameter
+func makeslice(et *rt.GoType, len int, cap int) unsafe.Pointer
+
+//go:noescape
+//go:linkname growslice reflect.growslice
+//goland:noinspection GoUnusedParameter
+func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
+
+//go:linkname makemap_small runtime.makemap_small
+func makemap_small() unsafe.Pointer
+
+//go:linkname mapassign runtime.mapassign
+//goland:noinspection GoUnusedParameter
+func mapassign(t *rt.GoType, h unsafe.Pointer, k unsafe.Pointer) unsafe.Pointer
+
+//go:linkname mapassign_fast32 runtime.mapassign_fast32
+//goland:noinspection GoUnusedParameter
+func mapassign_fast32(t *rt.GoType, h unsafe.Pointer, k uint32) unsafe.Pointer
+
+//go:linkname mapassign_fast64 runtime.mapassign_fast64
+//goland:noinspection GoUnusedParameter
+func mapassign_fast64(t *rt.GoType, h unsafe.Pointer, k uint64) unsafe.Pointer
+
+//go:linkname mapassign_fast64ptr runtime.mapassign_fast64ptr
+//goland:noinspection GoUnusedParameter
+func mapassign_fast64ptr(t *rt.GoType, h unsafe.Pointer, k unsafe.Pointer) unsafe.Pointer
+
+//go:linkname mapassign_faststr runtime.mapassign_faststr
+//goland:noinspection GoUnusedParameter
+func mapassign_faststr(t *rt.GoType, h unsafe.Pointer, s string) unsafe.Pointer
+
+//go:nosplit
+//go:linkname memclrHasPointers runtime.memclrHasPointers
+//goland:noinspection GoUnusedParameter
+func memclrHasPointers(ptr unsafe.Pointer, n uintptr)
+
+//go:noescape
+//go:linkname memclrNoHeapPointers runtime.memclrNoHeapPointers
+//goland:noinspection GoUnusedParameter
+func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/decoder/types.go b/vendor/github.com/bytedance/sonic/decoder/types.go
new file mode 100644
index 000000000..6fc0e706c
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/types.go
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `encoding`
+    `encoding/base64`
+    `encoding/json`
+    `reflect`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var (
+    byteType                = reflect.TypeOf(byte(0))
+    intType                 = reflect.TypeOf(int(0))
+    int8Type                = reflect.TypeOf(int8(0))
+    int16Type               = reflect.TypeOf(int16(0))
+    int32Type               = reflect.TypeOf(int32(0))
+    int64Type               = reflect.TypeOf(int64(0))
+    uintType                = reflect.TypeOf(uint(0))
+    uint8Type               = reflect.TypeOf(uint8(0))
+    uint16Type              = reflect.TypeOf(uint16(0))
+    uint32Type              = reflect.TypeOf(uint32(0))
+    uint64Type              = reflect.TypeOf(uint64(0))
+    float32Type             = reflect.TypeOf(float32(0))
+    float64Type             = reflect.TypeOf(float64(0))
+    stringType              = reflect.TypeOf("")
+    bytesType               = reflect.TypeOf([]byte(nil))
+    jsonNumberType          = reflect.TypeOf(json.Number(""))
+    base64CorruptInputError = reflect.TypeOf(base64.CorruptInputError(0))
+)
+
+var (
+    errorType                   = reflect.TypeOf((*error)(nil)).Elem()
+    jsonUnmarshalerType         = reflect.TypeOf((*json.Unmarshaler)(nil)).Elem()
+    encodingTextUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
+)
+
+func rtype(t reflect.Type) (*rt.GoItab, *rt.GoType) {
+    p := (*rt.GoIface)(unsafe.Pointer(&t))
+    return p.Itab, (*rt.GoType)(p.Value)
+}
diff --git a/vendor/github.com/bytedance/sonic/decoder/utils.go b/vendor/github.com/bytedance/sonic/decoder/utils.go
new file mode 100644
index 000000000..23ee5d501
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/decoder/utils.go
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package decoder
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/loader`
+)
+
+//go:nosplit
+func pbool(v bool) uintptr {
+    return freezeValue(unsafe.Pointer(&v))
+}
+
+//go:nosplit
+func ptodec(p loader.Function) _Decoder {
+    return *(*_Decoder)(unsafe.Pointer(&p))
+}
+
+func assert_eq(v int64, exp int64, msg string) {
+    if v != exp {
+        panic(msg)
+    }
+}
diff --git a/vendor/github.com/bytedance/sonic/encoder/asm.s b/vendor/github.com/bytedance/sonic/encoder/asm.s
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/asm.s
diff --git a/vendor/github.com/bytedance/sonic/encoder/assembler_amd64_go116.go b/vendor/github.com/bytedance/sonic/encoder/assembler_amd64_go116.go
new file mode 100644
index 000000000..9b5978431
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/assembler_amd64_go116.go
@@ -0,0 +1,1198 @@
+// +build go1.15,!go1.17
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `fmt`
+    `reflect`
+    `strconv`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/cpu`
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/twitchyliquid64/golang-asm/obj`
+    `github.com/twitchyliquid64/golang-asm/obj/x86`
+
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+/** Register Allocations
+ *
+ *  State Registers:
+ *
+ *      %rbx : stack base
+ *      %rdi : result pointer
+ *      %rsi : result length
+ *      %rdx : result capacity
+ *      %r12 : sp->p
+ *      %r13 : sp->q
+ *      %r14 : sp->x
+ *      %r15 : sp->f
+ *
+ *  Error Registers:
+ *
+ *      %r10 : error type register
+ *      %r11 : error pointer register
+ */
+
+/** Function Prototype & Stack Map
+ *
+ *  func (buf *[]byte, p unsafe.Pointer, sb *_Stack, fv uint64) (err error)
+ *
+ *  buf    :   (FP)
+ *  p      :  8(FP)
+ *  sb     : 16(FP)
+ *  fv     : 24(FP)
+ *  err.vt : 32(FP)
+ *  err.vp : 40(FP)
+ */
+
+const (
+    _S_cond = iota
+    _S_init
+)
+
+const (
+    _FP_args   = 48     // 48 bytes for passing arguments to this function
+    _FP_fargs  = 64     // 64 bytes for passing arguments to other Go functions
+    _FP_saves  = 64     // 64 bytes for saving the registers before CALL instructions
+    _FP_locals = 24     // 24 bytes for local variables
+)
+
+const (
+    _FP_offs = _FP_fargs + _FP_saves + _FP_locals
+    _FP_size = _FP_offs + 8     // 8 bytes for the parent frame pointer
+    _FP_base = _FP_size + 8     // 8 bytes for the return address
+)
+
+const (
+    _FM_exp32 = 0x7f800000
+    _FM_exp64 = 0x7ff0000000000000
+)
+
+const (
+    _IM_null   = 0x6c6c756e           // 'null'
+    _IM_true   = 0x65757274           // 'true'
+    _IM_fals   = 0x736c6166           // 'fals' ('false' without the 'e')
+    _IM_open   = 0x00225c22           // '"\"∅'
+    _IM_array  = 0x5d5b               // '[]'
+    _IM_object = 0x7d7b               // '{}'
+    _IM_mulv   = -0x5555555555555555
+)
+
+const (
+    _LB_more_space        = "_more_space"
+    _LB_more_space_return = "_more_space_return_"
+)
+
+const (
+    _LB_error                 = "_error"
+    _LB_error_too_deep        = "_error_too_deep"
+    _LB_error_invalid_number  = "_error_invalid_number"
+    _LB_error_nan_or_infinite = "_error_nan_or_infinite"
+    _LB_panic = "_panic"
+)
+
+var (
+    _AX = jit.Reg("AX")
+    _CX = jit.Reg("CX")
+    _DX = jit.Reg("DX")
+    _DI = jit.Reg("DI")
+    _SI = jit.Reg("SI")
+    _BP = jit.Reg("BP")
+    _SP = jit.Reg("SP")
+    _R8 = jit.Reg("R8")
+)
+
+var (
+    _X0 = jit.Reg("X0")
+    _Y0 = jit.Reg("Y0")
+)
+
+var (
+    _ST = jit.Reg("BX")
+    _RP = jit.Reg("DI")
+    _RL = jit.Reg("SI")
+    _RC = jit.Reg("DX")
+)
+
+var (
+    _LR  = jit.Reg("R9")
+    _R10 = jit.Reg("R10")   // used for gcWriterBarrier
+    _ET  = jit.Reg("R10")
+    _EP  = jit.Reg("R11")
+)
+
+var (
+    _SP_p = jit.Reg("R12")
+    _SP_q = jit.Reg("R13")
+    _SP_x = jit.Reg("R14")
+    _SP_f = jit.Reg("R15")
+)
+
+var (
+    _ARG_rb = jit.Ptr(_SP, _FP_base)
+    _ARG_vp = jit.Ptr(_SP, _FP_base + 8)
+    _ARG_sb = jit.Ptr(_SP, _FP_base + 16)
+    _ARG_fv = jit.Ptr(_SP, _FP_base + 24)
+)
+
+var (
+    _RET_et = jit.Ptr(_SP, _FP_base + 32)
+    _RET_ep = jit.Ptr(_SP, _FP_base + 40)
+)
+
+var (
+    _VAR_sp = jit.Ptr(_SP, _FP_fargs + _FP_saves)
+    _VAR_dn = jit.Ptr(_SP, _FP_fargs + _FP_saves + 8)
+    _VAR_vp = jit.Ptr(_SP, _FP_fargs + _FP_saves + 16)
+)
+
+var (
+    _REG_ffi = []obj.Addr{_RP, _RL, _RC}
+    _REG_enc = []obj.Addr{_ST, _SP_x, _SP_f, _SP_p, _SP_q, _RL}
+    _REG_jsr = []obj.Addr{_ST, _SP_x, _SP_f, _SP_p, _SP_q, _LR}
+    _REG_all = []obj.Addr{_ST, _SP_x, _SP_f, _SP_p, _SP_q, _RP, _RL, _RC}
+)
+
+type _Assembler struct {
+    jit.BaseAssembler
+    p _Program
+    x int
+    name string
+}
+
+func newAssembler(p _Program) *_Assembler {
+    return new(_Assembler).Init(p)
+}
+
+/** Assembler Interface **/
+func (self *_Assembler) Load() _Encoder {
+    return ptoenc(self.BaseAssembler.Load("encode_"+self.name, _FP_size, _FP_args, argPtrs, localPtrs))
+}
+
+func (self *_Assembler) Init(p _Program) *_Assembler {
+    self.p = p
+    self.BaseAssembler.Init(self.compile)
+    return self
+}
+
+func (self *_Assembler) compile() {
+    self.prologue()
+    self.instrs()
+    self.epilogue()
+    self.builtins()
+}
+
+/** Assembler Stages **/
+
+var _OpFuncTab = [256]func(*_Assembler, *_Instr) {
+    _OP_null           : (*_Assembler)._asm_OP_null,
+    _OP_empty_arr      : (*_Assembler)._asm_OP_empty_arr,
+    _OP_empty_obj      : (*_Assembler)._asm_OP_empty_obj, 
+    _OP_bool           : (*_Assembler)._asm_OP_bool,
+    _OP_i8             : (*_Assembler)._asm_OP_i8,
+    _OP_i16            : (*_Assembler)._asm_OP_i16,
+    _OP_i32            : (*_Assembler)._asm_OP_i32,
+    _OP_i64            : (*_Assembler)._asm_OP_i64,
+    _OP_u8             : (*_Assembler)._asm_OP_u8,
+    _OP_u16            : (*_Assembler)._asm_OP_u16,
+    _OP_u32            : (*_Assembler)._asm_OP_u32,
+    _OP_u64            : (*_Assembler)._asm_OP_u64,
+    _OP_f32            : (*_Assembler)._asm_OP_f32,
+    _OP_f64            : (*_Assembler)._asm_OP_f64,
+    _OP_str            : (*_Assembler)._asm_OP_str,
+    _OP_bin            : (*_Assembler)._asm_OP_bin,
+    _OP_quote          : (*_Assembler)._asm_OP_quote,
+    _OP_number         : (*_Assembler)._asm_OP_number,
+    _OP_eface          : (*_Assembler)._asm_OP_eface,
+    _OP_iface          : (*_Assembler)._asm_OP_iface,
+    _OP_byte           : (*_Assembler)._asm_OP_byte,
+    _OP_text           : (*_Assembler)._asm_OP_text,
+    _OP_deref          : (*_Assembler)._asm_OP_deref,
+    _OP_index          : (*_Assembler)._asm_OP_index,
+    _OP_load           : (*_Assembler)._asm_OP_load,
+    _OP_save           : (*_Assembler)._asm_OP_save,
+    _OP_drop           : (*_Assembler)._asm_OP_drop,
+    _OP_drop_2         : (*_Assembler)._asm_OP_drop_2,
+    _OP_recurse        : (*_Assembler)._asm_OP_recurse,
+    _OP_is_nil         : (*_Assembler)._asm_OP_is_nil,
+    _OP_is_nil_p1      : (*_Assembler)._asm_OP_is_nil_p1,
+    _OP_is_zero_1      : (*_Assembler)._asm_OP_is_zero_1,
+    _OP_is_zero_2      : (*_Assembler)._asm_OP_is_zero_2,
+    _OP_is_zero_4      : (*_Assembler)._asm_OP_is_zero_4,
+    _OP_is_zero_8      : (*_Assembler)._asm_OP_is_zero_8,
+    _OP_is_zero_map    : (*_Assembler)._asm_OP_is_zero_map,
+    _OP_goto           : (*_Assembler)._asm_OP_goto,
+    _OP_map_iter       : (*_Assembler)._asm_OP_map_iter,
+    _OP_map_stop       : (*_Assembler)._asm_OP_map_stop,
+    _OP_map_check_key  : (*_Assembler)._asm_OP_map_check_key,
+    _OP_map_write_key  : (*_Assembler)._asm_OP_map_write_key,
+    _OP_map_value_next : (*_Assembler)._asm_OP_map_value_next,
+    _OP_slice_len      : (*_Assembler)._asm_OP_slice_len,
+    _OP_slice_next     : (*_Assembler)._asm_OP_slice_next,
+    _OP_marshal        : (*_Assembler)._asm_OP_marshal,
+    _OP_marshal_p      : (*_Assembler)._asm_OP_marshal_p,
+    _OP_marshal_text   : (*_Assembler)._asm_OP_marshal_text,
+    _OP_marshal_text_p : (*_Assembler)._asm_OP_marshal_text_p,
+    _OP_cond_set       : (*_Assembler)._asm_OP_cond_set,
+    _OP_cond_testc     : (*_Assembler)._asm_OP_cond_testc,
+}
+
+func (self *_Assembler) instr(v *_Instr) {
+    if fn := _OpFuncTab[v.op()]; fn != nil {
+        fn(self, v)
+    } else {
+        panic(fmt.Sprintf("invalid opcode: %d", v.op()))
+    }
+}
+
+func (self *_Assembler) instrs() {
+    for i, v := range self.p {
+        self.Mark(i)
+        self.instr(&v)
+        self.debug_instr(i, &v)
+    }
+}
+
+func (self *_Assembler) builtins() {
+    self.more_space()
+    self.error_too_deep()
+    self.error_invalid_number()
+    self.error_nan_or_infinite()
+    self.go_panic()
+}
+
+func (self *_Assembler) epilogue() {
+    self.Mark(len(self.p))
+    self.Emit("XORL", _ET, _ET)
+    self.Emit("XORL", _EP, _EP)
+    self.Link(_LB_error)
+    self.Emit("MOVQ", _ARG_rb, _AX)                 // MOVQ rb<>+0(FP), AX
+    self.Emit("MOVQ", _RL, jit.Ptr(_AX, 8))         // MOVQ RL, 8(AX)
+    self.Emit("MOVQ", _ET, _RET_et)                 // MOVQ ET, et<>+24(FP)
+    self.Emit("MOVQ", _EP, _RET_ep)                 // MOVQ EP, ep<>+32(FP)
+    self.Emit("MOVQ", jit.Ptr(_SP, _FP_offs), _BP)  // MOVQ _FP_offs(SP), BP
+    self.Emit("ADDQ", jit.Imm(_FP_size), _SP)       // ADDQ $_FP_size, SP
+    self.Emit("RET")                                // RET
+}
+
+func (self *_Assembler) prologue() {
+    self.Emit("SUBQ", jit.Imm(_FP_size), _SP)       // SUBQ $_FP_size, SP
+    self.Emit("MOVQ", _BP, jit.Ptr(_SP, _FP_offs))  // MOVQ BP, _FP_offs(SP)
+    self.Emit("LEAQ", jit.Ptr(_SP, _FP_offs), _BP)  // LEAQ _FP_offs(SP), BP
+    self.load_buffer()                              // LOAD {buf}
+    self.Emit("MOVQ", _ARG_vp, _SP_p)               // MOVQ vp<>+8(FP), SP.p
+    self.Emit("MOVQ", _ARG_sb, _ST)                 // MOVQ sb<>+16(FP), ST
+    self.Emit("XORL", _SP_x, _SP_x)                 // XORL SP.x, SP.x
+    self.Emit("XORL", _SP_f, _SP_f)                 // XORL SP.f, SP.f
+    self.Emit("XORL", _SP_q, _SP_q)                 // XORL SP.q, SP.q
+}
+
+/** Assembler Inline Functions **/
+
+func (self *_Assembler) xsave(reg ...obj.Addr) {
+    for i, v := range reg {
+        if i > _FP_saves / 8 - 1 {
+            panic("too many registers to save")
+        } else {
+            self.Emit("MOVQ", v, jit.Ptr(_SP, _FP_fargs + int64(i) * 8))
+        }
+    }
+}
+
+func (self *_Assembler) xload(reg ...obj.Addr) {
+    for i, v := range reg {
+        if i > _FP_saves / 8 - 1 {
+            panic("too many registers to load")
+        } else {
+            self.Emit("MOVQ", jit.Ptr(_SP, _FP_fargs + int64(i) * 8), v)
+        }
+    }
+}
+
+func (self *_Assembler) rbuf_di() {
+    if _RP.Reg != x86.REG_DI {
+        panic("register allocation messed up: RP != DI")
+    } else {
+        self.Emit("ADDQ", _RL, _RP)
+    }
+}
+
+func (self *_Assembler) store_int(nd int, fn obj.Addr, ins string) {
+    self.check_size(nd)
+    self.save_c()                           // SAVE   $C_regs
+    self.rbuf_di()                          // MOVQ   RP, DI
+    self.Emit(ins, jit.Ptr(_SP_p, 0), _SI)  // $ins   (SP.p), SI
+    self.call_c(fn)                         // CALL_C $fn
+    self.Emit("ADDQ", _AX, _RL)             // ADDQ   AX, RL
+}
+
+func (self *_Assembler) store_str(s string) {
+    i := 0
+    m := rt.Str2Mem(s)
+
+    /* 8-byte stores */
+    for i <= len(m) - 8 {
+        self.Emit("MOVQ", jit.Imm(rt.Get64(m[i:])), _AX)        // MOVQ $s[i:], AX
+        self.Emit("MOVQ", _AX, jit.Sib(_RP, _RL, 1, int64(i)))  // MOVQ AX, i(RP)(RL)
+        i += 8
+    }
+
+    /* 4-byte stores */
+    if i <= len(m) - 4 {
+        self.Emit("MOVL", jit.Imm(int64(rt.Get32(m[i:]))), jit.Sib(_RP, _RL, 1, int64(i)))  // MOVL $s[i:], i(RP)(RL)
+        i += 4
+    }
+
+    /* 2-byte stores */
+    if i <= len(m) - 2 {
+        self.Emit("MOVW", jit.Imm(int64(rt.Get16(m[i:]))), jit.Sib(_RP, _RL, 1, int64(i)))  // MOVW $s[i:], i(RP)(RL)
+        i += 2
+    }
+
+    /* last byte */
+    if i < len(m) {
+        self.Emit("MOVB", jit.Imm(int64(m[i])), jit.Sib(_RP, _RL, 1, int64(i)))     // MOVB $s[i:], i(RP)(RL)
+    }
+}
+
+func (self *_Assembler) check_size(n int) {
+    self.check_size_rl(jit.Ptr(_RL, int64(n)))
+}
+
+func (self *_Assembler) check_size_r(r obj.Addr, d int) {
+    self.check_size_rl(jit.Sib(_RL, r, 1, int64(d)))
+}
+
+func (self *_Assembler) check_size_rl(v obj.Addr) {
+    idx := self.x
+    key := _LB_more_space_return + strconv.Itoa(idx)
+
+    /* the following code relies on LR == R9 to work */
+    if _LR.Reg != x86.REG_R9 {
+        panic("register allocation messed up: LR != R9")
+    }
+
+    /* check for buffer capacity */
+    self.x++
+    self.Emit("LEAQ", v, _AX)       // LEAQ $v, AX
+    self.Emit("CMPQ", _AX, _RC)     // CMPQ AX, RC
+    self.Sjmp("JBE" , key)          // JBE  _more_space_return_{n}
+    self.slice_grow_ax(key)         // GROW $key
+    self.Link(key)                  // _more_space_return_{n}:
+}
+
+func (self *_Assembler) slice_grow_ax(ret string) {
+    self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ ?(PC), R9
+    self.Sref(ret, 4)                   // .... &ret
+    self.Sjmp("JMP" , _LB_more_space)   // JMP  _more_space
+}
+
+/** State Stack Helpers **/
+
+const (
+    _StateSize  = int64(unsafe.Sizeof(_State{}))
+    _StackLimit = _MaxStack * _StateSize
+)
+
+func (self *_Assembler) save_state() {
+    self.Emit("MOVQ", jit.Ptr(_ST, 0), _CX)             // MOVQ (ST), CX
+    self.Emit("LEAQ", jit.Ptr(_CX, _StateSize), _R8)    // LEAQ _StateSize(CX), R8
+    self.Emit("CMPQ", _R8, jit.Imm(_StackLimit))        // CMPQ R8, $_StackLimit
+    self.Sjmp("JAE" , _LB_error_too_deep)               // JA   _error_too_deep
+    self.Emit("MOVQ", _SP_x, jit.Sib(_ST, _CX, 1, 8))   // MOVQ SP.x, 8(ST)(CX)
+    self.Emit("MOVQ", _SP_f, jit.Sib(_ST, _CX, 1, 16))  // MOVQ SP.f, 16(ST)(CX)
+    self.WriteRecNotAX(0, _SP_p, jit.Sib(_ST, _CX, 1, 24)) // MOVQ SP.p, 24(ST)(CX)
+    self.WriteRecNotAX(1, _SP_q, jit.Sib(_ST, _CX, 1, 32)) // MOVQ SP.q, 32(ST)(CX)
+    self.Emit("MOVQ", _R8, jit.Ptr(_ST, 0))             // MOVQ R8, (ST)
+}
+
+func (self *_Assembler) drop_state(decr int64) {
+    self.Emit("MOVQ" , jit.Ptr(_ST, 0), _AX)                // MOVQ  (ST), AX
+    self.Emit("SUBQ" , jit.Imm(decr), _AX)                  // SUBQ  $decr, AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_ST, 0))                // MOVQ  AX, (ST)
+    self.Emit("MOVQ" , jit.Sib(_ST, _AX, 1, 8), _SP_x)      // MOVQ  8(ST)(AX), SP.x
+    self.Emit("MOVQ" , jit.Sib(_ST, _AX, 1, 16), _SP_f)     // MOVQ  16(ST)(AX), SP.f
+    self.Emit("MOVQ" , jit.Sib(_ST, _AX, 1, 24), _SP_p)     // MOVQ  24(ST)(AX), SP.p
+    self.Emit("MOVQ" , jit.Sib(_ST, _AX, 1, 32), _SP_q)     // MOVQ  32(ST)(AX), SP.q
+    self.Emit("PXOR" , _X0, _X0)                            // PXOR  X0, X0
+    self.Emit("MOVOU", _X0, jit.Sib(_ST, _AX, 1, 8))        // MOVOU X0, 8(ST)(AX)
+    self.Emit("MOVOU", _X0, jit.Sib(_ST, _AX, 1, 24))       // MOVOU X0, 24(ST)(AX)
+}
+
+/** Buffer Helpers **/
+
+func (self *_Assembler) add_char(ch byte) {
+    self.Emit("MOVB", jit.Imm(int64(ch)), jit.Sib(_RP, _RL, 1, 0))  // MOVB $ch, (RP)(RL)
+    self.Emit("ADDQ", jit.Imm(1), _RL)                              // ADDQ $1, RL
+}
+
+func (self *_Assembler) add_long(ch uint32, n int64) {
+    self.Emit("MOVL", jit.Imm(int64(ch)), jit.Sib(_RP, _RL, 1, 0))  // MOVL $ch, (RP)(RL)
+    self.Emit("ADDQ", jit.Imm(n), _RL)                              // ADDQ $n, RL
+}
+
+func (self *_Assembler) add_text(ss string) {
+    self.store_str(ss)                                  // TEXT $ss
+    self.Emit("ADDQ", jit.Imm(int64(len(ss))), _RL)     // ADDQ ${len(ss)}, RL
+}
+
+func (self *_Assembler) prep_buffer() {
+    self.Emit("MOVQ", _ARG_rb, _AX)             // MOVQ rb<>+0(FP), AX
+    self.Emit("MOVQ", _RL, jit.Ptr(_AX, 8))     // MOVQ RL, 8(AX)
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 0))     // MOVQ AX, (SP)
+}
+
+func (self *_Assembler) prep_buffer_c() {
+    self.Emit("MOVQ", _ARG_rb, _DI)             // MOVQ rb<>+0(FP), DI
+    self.Emit("MOVQ", _RL, jit.Ptr(_DI, 8))     // MOVQ RL, 8(DI)
+}
+
+func (self *_Assembler) save_buffer() {
+    self.Emit("MOVQ", _ARG_rb, _CX)             // MOVQ rb<>+0(FP), CX
+    self.Emit("MOVQ", _RP, jit.Ptr(_CX,  0))    // MOVQ RP, (CX)
+    self.Emit("MOVQ", _RL, jit.Ptr(_CX,  8))    // MOVQ RL, 8(CX)
+    self.Emit("MOVQ", _RC, jit.Ptr(_CX, 16))    // MOVQ RC, 16(CX)
+}
+
+func (self *_Assembler) load_buffer() {
+    self.Emit("MOVQ", _ARG_rb, _AX)             // MOVQ rb<>+0(FP), AX
+    self.Emit("MOVQ", jit.Ptr(_AX,  0), _RP)    // MOVQ (AX), RP
+    self.Emit("MOVQ", jit.Ptr(_AX,  8), _RL)    // MOVQ 8(AX), RL
+    self.Emit("MOVQ", jit.Ptr(_AX, 16), _RC)    // MOVQ 16(AX), RC
+}
+
+/** Function Interface Helpers **/
+
+func (self *_Assembler) call(pc obj.Addr) {
+    self.Emit("MOVQ", pc, _AX)  // MOVQ $pc, AX
+    self.Rjmp("CALL", _AX)      // CALL AX
+}
+
+func (self *_Assembler) save_c() {
+    self.xsave(_REG_ffi...)     // SAVE $REG_ffi
+}
+
+func (self *_Assembler) call_c(pc obj.Addr) {
+    self.call(pc)               // CALL $pc
+    self.xload(_REG_ffi...)     // LOAD $REG_ffi
+}
+
+func (self *_Assembler) call_go(pc obj.Addr) {
+    self.xsave(_REG_all...)     // SAVE $REG_all
+    self.call(pc)               // CALL $pc
+    self.xload(_REG_all...)     // LOAD $REG_all
+}
+
+func (self *_Assembler) call_encoder(pc obj.Addr) {
+    self.xsave(_REG_enc...)     // SAVE $REG_enc
+    self.call(pc)               // CALL $pc
+    self.xload(_REG_enc...)     // LOAD $REG_enc
+    self.load_buffer()          // LOAD {buf}
+}
+
+func (self *_Assembler) call_marshaler(fn obj.Addr, it *rt.GoType, vt reflect.Type) {
+    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)
+    }
+}
+
+func (self *_Assembler) call_marshaler_i(fn obj.Addr, it *rt.GoType) {
+    self.Emit("MOVQ" , jit.Gtype(it), _AX)                          // MOVQ    $it, AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 0))                        // MOVQ    AX, (SP)
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 0), _AX)                      // MOVQ    (SP.p), AX
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 8), _CX)                      // MOVQ    8(SP.p), CX
+    self.Emit("TESTQ", _AX, _AX)                                    // TESTQ   AX, AX
+    self.Sjmp("JZ"   , "_null_{n}")                                 // JZ      _null_{n}
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 8))                        // MOVQ    AX, 8(SP)
+    self.Emit("MOVQ" , _CX, jit.Ptr(_SP, 16))                       // MOVQ    CX, 16(SP)
+    self.call_go(_F_assertI2I)                                      // CALL_GO assertI2I
+    self.prep_buffer()                                              // MOVE    {buf}, (SP)
+    self.Emit("MOVOU", jit.Ptr(_SP, 24), _X0)                       // MOVOU   24(SP), X0
+    self.Emit("MOVOU", _X0, jit.Ptr(_SP, 8))                        // MOVOU   X0, 8(SP)
+    self.Emit("MOVQ", _ARG_fv,  _CX)                                // MOVQ   ARG.fv, CX
+    self.Emit("MOVQ", _CX,  jit.Ptr(_SP, 24))                       // MOVQ   CX, 24(SP)
+    self.call_encoder(fn)                                           // CALL    $fn
+    self.Emit("MOVQ" , jit.Ptr(_SP, 32), _ET)                       // MOVQ    32(SP), ET
+    self.Emit("MOVQ" , jit.Ptr(_SP, 40), _EP)                       // MOVQ    40(SP), EP
+    self.Emit("TESTQ", _ET, _ET)                                    // TESTQ   ET, ET
+    self.Sjmp("JNZ"  , _LB_error)                                   // JNZ     _error
+    self.Sjmp("JMP"  , "_done_{n}")                                 // JMP     _done_{n}
+    self.Link("_null_{n}")                                          // _null_{n}:
+    self.check_size(4)                                              // SIZE    $4
+    self.Emit("MOVL", jit.Imm(_IM_null), jit.Sib(_RP, _RL, 1, 0))   // MOVL    $'null', (RP)(RL*1)
+    self.Emit("ADDQ", jit.Imm(4), _RL)                              // ADDQ    $4, RL
+    self.Link("_done_{n}")                                          // _done_{n}:
+}
+
+func (self *_Assembler) call_marshaler_v(fn obj.Addr, it *rt.GoType, vt reflect.Type, deref bool) {
+    self.prep_buffer()                          // MOVE {buf}, (SP)
+    self.Emit("MOVQ", jit.Itab(it, vt), _AX)    // MOVQ $(itab(it, vt)), AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 8))     // MOVQ AX, 8(SP)
+
+    /* dereference the pointer if needed */
+    if !deref {
+        self.Emit("MOVQ", _SP_p, jit.Ptr(_SP, 16))  // MOVQ SP.p, 16(SP)
+    } else {
+        self.Emit("MOVQ", jit.Ptr(_SP_p, 0), _AX)   // MOVQ (SP.p), AX
+        self.Emit("MOVQ", _AX, jit.Ptr(_SP, 16))    // MOVQ AX, 16(SP)
+    }
+
+    /* call the encoder, and perform error checks */
+    self.Emit("MOVQ", _ARG_fv,  _CX)            // MOVQ   ARG.fv, CX
+    self.Emit("MOVQ", _CX,  jit.Ptr(_SP, 24))   // MOVQ   CX, 24(SP)
+    self.call_encoder(fn)                       // CALL  $fn
+    self.Emit("MOVQ" , jit.Ptr(_SP, 32), _ET)   // MOVQ  32(SP), ET
+    self.Emit("MOVQ" , jit.Ptr(_SP, 40), _EP)   // MOVQ  40(SP), EP
+    self.Emit("TESTQ", _ET, _ET)                // TESTQ ET, ET
+    self.Sjmp("JNZ"  , _LB_error)               // JNZ   _error
+}
+
+/** Builtin: _more_space **/
+
+var (
+    _T_byte      = jit.Type(byteType)
+    _F_growslice = jit.Func(growslice)
+)
+
+func (self *_Assembler) more_space() {
+    self.Link(_LB_more_space)
+    self.Emit("MOVQ", _T_byte, jit.Ptr(_SP, 0))     // MOVQ $_T_byte, (SP)
+    self.Emit("MOVQ", _RP, jit.Ptr(_SP, 8))         // MOVQ RP, 8(SP)
+    self.Emit("MOVQ", _RL, jit.Ptr(_SP, 16))        // MOVQ RL, 16(SP)
+    self.Emit("MOVQ", _RC, jit.Ptr(_SP, 24))        // MOVQ RC, 24(SP)
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 32))        // MOVQ AX, 32(SP)
+    self.xsave(_REG_jsr...)                         // SAVE $REG_jsr
+    self.call(_F_growslice)                         // CALL $pc
+    self.xload(_REG_jsr...)                         // LOAD $REG_jsr
+    self.Emit("MOVQ", jit.Ptr(_SP, 40), _RP)        // MOVQ 40(SP), RP
+    self.Emit("MOVQ", jit.Ptr(_SP, 48), _RL)        // MOVQ 48(SP), RL
+    self.Emit("MOVQ", jit.Ptr(_SP, 56), _RC)        // MOVQ 56(SP), RC
+    self.save_buffer()                              // SAVE {buf}
+    self.Rjmp("JMP" , _LR)                          // JMP  LR
+}
+
+/** Builtin Errors **/
+
+var (
+    _V_ERR_too_deep               = jit.Imm(int64(uintptr(unsafe.Pointer(_ERR_too_deep))))
+    _V_ERR_nan_or_infinite        = jit.Imm(int64(uintptr(unsafe.Pointer(_ERR_nan_or_infinite))))
+    _I_json_UnsupportedValueError = jit.Itab(rt.UnpackType(errorType), jsonUnsupportedValueType)
+)
+
+func (self *_Assembler) error_too_deep() {
+    self.Link(_LB_error_too_deep)
+    self.Emit("MOVQ", _V_ERR_too_deep, _EP)                 // MOVQ $_V_ERR_too_deep, EP
+    self.Emit("MOVQ", _I_json_UnsupportedValueError, _ET)   // MOVQ $_I_json_UnsupportedValuError, ET
+    self.Sjmp("JMP" , _LB_error)                            // JMP  _error
+}
+
+func (self *_Assembler) error_invalid_number() {
+    self.Link(_LB_error_invalid_number)
+    self.call_go(_F_error_number)               // CALL_GO error_number
+    self.Emit("MOVQ", jit.Ptr(_SP, 16), _ET)    // MOVQ    16(SP), ET
+    self.Emit("MOVQ", jit.Ptr(_SP, 24), _EP)    // MOVQ    24(SP), EP
+    self.Sjmp("JMP" , _LB_error)                // JMP     _error
+}
+
+func (self *_Assembler) error_nan_or_infinite()  {
+    self.Link(_LB_error_nan_or_infinite)
+    self.Emit("MOVQ", _V_ERR_nan_or_infinite, _EP)          // MOVQ $_V_ERR_nan_or_infinite, EP
+    self.Emit("MOVQ", _I_json_UnsupportedValueError, _ET)   // MOVQ $_I_json_UnsupportedValuError, ET
+    self.Sjmp("JMP" , _LB_error)                            // JMP  _error
+}
+
+/** String Encoding Routine **/
+
+var (
+    _F_quote = jit.Imm(int64(native.S_quote))
+    _F_panic = jit.Func(goPanic)
+)
+
+func (self *_Assembler) go_panic() {
+    self.Link(_LB_panic)
+    self.Emit("MOVQ", _SP_p, jit.Ptr(_SP, 8))
+    self.call_go(_F_panic)
+}
+
+func (self *_Assembler) encode_string(doubleQuote bool) {
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 8), _AX)  // MOVQ  8(SP.p), AX
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ AX, AX
+    self.Sjmp("JZ"   , "_str_empty_{n}")        // JZ    _str_empty_{n}
+    self.Emit("CMPQ", jit.Ptr(_SP_p, 0), jit.Imm(0))
+    self.Sjmp("JNE"   , "_str_next_{n}") 
+    self.Emit("MOVQ", jit.Imm(int64(panicNilPointerOfNonEmptyString)), jit.Ptr(_SP, 0))
+    self.Sjmp("JMP", _LB_panic)
+    self.Link("_str_next_{n}")
+
+    /* openning quote, check for double quote */
+    if !doubleQuote {
+        self.check_size_r(_AX, 2)   // SIZE $2
+        self.add_char('"')          // CHAR $'"'
+    } else {
+        self.check_size_r(_AX, 6)   // SIZE $6
+        self.add_long(_IM_open, 3)  // TEXT $`"\"`
+    }
+
+    /* quoting loop */
+    self.Emit("XORL", _AX, _AX)         // XORL AX, AX
+    self.Emit("MOVQ", _AX, _VAR_sp)     // MOVQ AX, sp
+    self.Link("_str_loop_{n}")          // _str_loop_{n}:
+    self.save_c()                       // SAVE $REG_ffi
+
+    /* load the output buffer first, and then input buffer,
+     * because the parameter registers collide with RP / RL / RC */
+    self.Emit("MOVQ", _RC, _CX)                         // MOVQ RC, CX
+    self.Emit("SUBQ", _RL, _CX)                         // SUBQ RL, CX
+    self.Emit("MOVQ", _CX, _VAR_dn)                     // MOVQ CX, dn
+    self.Emit("LEAQ", jit.Sib(_RP, _RL, 1, 0), _DX)     // LEAQ (RP)(RL), DX
+    self.Emit("LEAQ", _VAR_dn, _CX)                     // LEAQ dn, CX
+    self.Emit("MOVQ", _VAR_sp, _AX)                     // MOVQ sp, AX
+    self.Emit("MOVQ", jit.Ptr(_SP_p, 0), _DI)           // MOVQ (SP.p), DI
+    self.Emit("MOVQ", jit.Ptr(_SP_p, 8), _SI)           // MOVQ 8(SP.p), SI
+    self.Emit("ADDQ", _AX, _DI)                         // ADDQ AX, DI
+    self.Emit("SUBQ", _AX, _SI)                         // SUBQ AX, SI
+
+    /* set the flags based on `doubleQuote` */
+    if !doubleQuote {
+        self.Emit("XORL", _R8, _R8)                                 // XORL R8, R8
+    } else {
+        self.Emit("MOVL", jit.Imm(types.F_DOUBLE_UNQUOTE), _R8)     // MOVL ${types.F_DOUBLE_UNQUOTE}, R8
+    }
+
+    /* call the native quoter */
+    self.call_c(_F_quote)                   // CALL  quote
+    self.Emit("ADDQ" , _VAR_dn, _RL)        // ADDQ  dn, RL
+    self.Emit("TESTQ", _AX, _AX)            // TESTQ AX, AX
+    self.Sjmp("JS"   , "_str_space_{n}")    // JS    _str_space_{n}
+
+    /* close the string, check for double quote */
+    if !doubleQuote {
+        self.check_size(1)                  // SIZE $1
+        self.add_char('"')                  // CHAR $'"'
+        self.Sjmp("JMP", "_str_end_{n}")    // JMP  _str_end_{n}
+    } else {
+        self.check_size(3)                  // SIZE $3
+        self.add_text("\\\"\"")             // TEXT $'\""'
+        self.Sjmp("JMP", "_str_end_{n}")    // JMP  _str_end_{n}
+    }
+
+    /* not enough space to contain the quoted string */
+    self.Link("_str_space_{n}")                         // _str_space_{n}:
+    self.Emit("NOTQ", _AX)                              // NOTQ AX
+    self.Emit("ADDQ", _AX, _VAR_sp)                     // ADDQ AX, sp
+    self.Emit("LEAQ", jit.Sib(_RC, _RC, 1, 0), _AX)     // LEAQ (RC)(RC), AX
+    self.slice_grow_ax("_str_loop_{n}")                 // GROW _str_loop_{n}
+
+    /* empty string, check for double quote */
+    if !doubleQuote {
+        self.Link("_str_empty_{n}")     // _str_empty_{n}:
+        self.check_size(2)              // SIZE $2
+        self.add_text("\"\"")           // TEXT $'""'
+        self.Link("_str_end_{n}")       // _str_end_{n}:
+    } else {
+        self.Link("_str_empty_{n}")     // _str_empty_{n}:
+        self.check_size(6)              // SIZE $6
+        self.add_text("\"\\\"\\\"\"")   // TEXT $'"\"\""'
+        self.Link("_str_end_{n}")       // _str_end_{n}:
+    }
+}
+
+/** OpCode Assembler Functions **/
+
+var (
+    _T_json_Marshaler         = rt.UnpackType(jsonMarshalerType)
+    _T_encoding_TextMarshaler = rt.UnpackType(encodingTextMarshalerType)
+)
+
+var (
+    _F_f64toa    = jit.Imm(int64(native.S_f64toa))
+    _F_f32toa    = jit.Imm(int64(native.S_f32toa))
+    _F_i64toa    = jit.Imm(int64(native.S_i64toa))
+    _F_u64toa    = jit.Imm(int64(native.S_u64toa))
+    _F_b64encode = jit.Imm(int64(_subr__b64encode))
+)
+
+var (
+    _F_memmove       = jit.Func(memmove)
+    _F_error_number  = jit.Func(error_number)
+    _F_isValidNumber = jit.Func(isValidNumber)
+)
+
+var (
+    _F_iteratorStop  = jit.Func(iteratorStop)
+    _F_iteratorNext  = jit.Func(iteratorNext)
+    _F_iteratorStart = jit.Func(iteratorStart)
+)
+
+var (
+    _F_encodeTypedPointer  obj.Addr
+    _F_encodeJsonMarshaler obj.Addr
+    _F_encodeTextMarshaler obj.Addr
+)
+
+const (
+    _MODE_AVX2 = 1 << 2
+)
+
+func init() {
+    _F_encodeTypedPointer  = jit.Func(encodeTypedPointer)
+    _F_encodeJsonMarshaler = jit.Func(encodeJsonMarshaler)
+    _F_encodeTextMarshaler = jit.Func(encodeTextMarshaler)
+}
+
+func (self *_Assembler) _asm_OP_null(_ *_Instr) {
+    self.check_size(4)
+    self.Emit("MOVL", jit.Imm(_IM_null), jit.Sib(_RP, _RL, 1, 0))  // MOVL $'null', (RP)(RL*1)
+    self.Emit("ADDQ", jit.Imm(4), _RL)                             // ADDQ $4, RL
+}
+
+func (self *_Assembler) _asm_OP_empty_arr(_ *_Instr) {
+    self.Emit("BTQ", jit.Imm(int64(bitNoNullSliceOrMap)), _ARG_fv)
+    self.Sjmp("JC", "_empty_arr_{n}")
+    self._asm_OP_null(nil)
+    self.Sjmp("JMP", "_empty_arr_end_{n}")
+    self.Link("_empty_arr_{n}")
+    self.check_size(2)
+    self.Emit("MOVW", jit.Imm(_IM_array), jit.Sib(_RP, _RL, 1, 0)) 
+    self.Emit("ADDQ", jit.Imm(2), _RL)    
+    self.Link("_empty_arr_end_{n}")                  
+}
+
+func (self *_Assembler) _asm_OP_empty_obj(_ *_Instr) {
+    self.Emit("BTQ", jit.Imm(int64(bitNoNullSliceOrMap)), _ARG_fv)
+    self.Sjmp("JC", "_empty_obj_{n}")
+    self._asm_OP_null(nil)
+    self.Sjmp("JMP", "_empty_obj_end_{n}")
+    self.Link("_empty_obj_{n}")
+    self.check_size(2)
+    self.Emit("MOVW", jit.Imm(_IM_object), jit.Sib(_RP, _RL, 1, 0))  
+    self.Emit("ADDQ", jit.Imm(2), _RL) 
+    self.Link("_empty_obj_end_{n}")                                             
+}
+
+func (self *_Assembler) _asm_OP_bool(_ *_Instr) {
+    self.Emit("CMPB", jit.Ptr(_SP_p, 0), jit.Imm(0))                // CMPB (SP.p), $0
+    self.Sjmp("JE"  , "_false_{n}")                                 // JE   _false_{n}
+    self.check_size(4)                                              // SIZE $4
+    self.Emit("MOVL", jit.Imm(_IM_true), jit.Sib(_RP, _RL, 1, 0))   // MOVL $'true', (RP)(RL*1)
+    self.Emit("ADDQ", jit.Imm(4), _RL)                              // ADDQ $4, RL
+    self.Sjmp("JMP" , "_end_{n}")                                   // JMP  _end_{n}
+    self.Link("_false_{n}")                                         // _false_{n}:
+    self.check_size(5)                                              // SIZE $5
+    self.Emit("MOVL", jit.Imm(_IM_fals), jit.Sib(_RP, _RL, 1, 0))   // MOVL $'fals', (RP)(RL*1)
+    self.Emit("MOVB", jit.Imm('e'), jit.Sib(_RP, _RL, 1, 4))        // MOVB $'e', 4(RP)(RL*1)
+    self.Emit("ADDQ", jit.Imm(5), _RL)                              // ADDQ $5, RL
+    self.Link("_end_{n}")                                           // _end_{n}:
+}
+
+func (self *_Assembler) _asm_OP_i8(_ *_Instr) {
+    self.store_int(4, _F_i64toa, "MOVBQSX")
+}
+
+func (self *_Assembler) _asm_OP_i16(_ *_Instr) {
+    self.store_int(6, _F_i64toa, "MOVWQSX")
+}
+
+func (self *_Assembler) _asm_OP_i32(_ *_Instr) {
+    self.store_int(17, _F_i64toa, "MOVLQSX")
+}
+
+func (self *_Assembler) _asm_OP_i64(_ *_Instr) {
+    self.store_int(21, _F_i64toa, "MOVQ")
+}
+
+func (self *_Assembler) _asm_OP_u8(_ *_Instr) {
+    self.store_int(3, _F_u64toa, "MOVBQZX")
+}
+
+func (self *_Assembler) _asm_OP_u16(_ *_Instr) {
+    self.store_int(5, _F_u64toa, "MOVWQZX")
+}
+
+func (self *_Assembler) _asm_OP_u32(_ *_Instr) {
+    self.store_int(16, _F_u64toa, "MOVLQZX")
+}
+
+func (self *_Assembler) _asm_OP_u64(_ *_Instr) {
+    self.store_int(20, _F_u64toa, "MOVQ")
+}
+
+func (self *_Assembler) _asm_OP_f32(_ *_Instr) {
+    self.check_size(32)
+    self.Emit("MOVL"    , jit.Ptr(_SP_p, 0), _AX)       // MOVL     (SP.p), AX
+    self.Emit("ANDL"    , jit.Imm(_FM_exp32), _AX)      // ANDL     $_FM_exp32, AX
+    self.Emit("XORL"    , jit.Imm(_FM_exp32), _AX)      // XORL     $_FM_exp32, AX
+    self.Sjmp("JZ"      , _LB_error_nan_or_infinite)    // JZ       _error_nan_or_infinite
+    self.save_c()                                       // SAVE     $C_regs
+    self.rbuf_di()                                      // MOVQ     RP, DI
+    self.Emit("MOVSS"   , jit.Ptr(_SP_p, 0), _X0)       // MOVSS    (SP.p), X0
+    self.call_c(_F_f32toa)                              // CALL_C   f64toa
+    self.Emit("ADDQ"    , _AX, _RL)                     // ADDQ     AX, RL
+}
+
+func (self *_Assembler) _asm_OP_f64(_ *_Instr) {
+    self.check_size(32)
+    self.Emit("MOVQ"  , jit.Ptr(_SP_p, 0), _AX)     // MOVQ   (SP.p), AX
+    self.Emit("MOVQ"  , jit.Imm(_FM_exp64), _CX)    // MOVQ   $_FM_exp64, CX
+    self.Emit("ANDQ"  , _CX, _AX)                   // ANDQ   CX, AX
+    self.Emit("XORQ"  , _CX, _AX)                   // XORQ   CX, AX
+    self.Sjmp("JZ"    , _LB_error_nan_or_infinite)  // JZ     _error_nan_or_infinite
+    self.save_c()                                   // SAVE   $C_regs
+    self.rbuf_di()                                  // MOVQ   RP, DI
+    self.Emit("MOVSD" , jit.Ptr(_SP_p, 0), _X0)     // MOVSD  (SP.p), X0
+    self.call_c(_F_f64toa)                          // CALL_C f64toa
+    self.Emit("ADDQ"  , _AX, _RL)                   // ADDQ   AX, RL
+}
+
+func (self *_Assembler) _asm_OP_str(_ *_Instr) {
+    self.encode_string(false)
+}
+
+func (self *_Assembler) _asm_OP_bin(_ *_Instr) {
+    self.Emit("MOVQ", jit.Ptr(_SP_p, 8), _AX)           // MOVQ 8(SP.p), AX
+    self.Emit("ADDQ", jit.Imm(2), _AX)                  // ADDQ $2, AX
+    self.Emit("MOVQ", jit.Imm(_IM_mulv), _CX)           // MOVQ $_MF_mulv, CX
+    self.Emit("MOVQ", _DX, _R8)                         // MOVQ DX, R8
+    self.From("MULQ", _CX)                              // MULQ CX
+    self.Emit("LEAQ", jit.Sib(_DX, _DX, 1, 1), _AX)     // LEAQ 1(DX)(DX), AX
+    self.Emit("ORQ" , jit.Imm(2), _AX)                  // ORQ  $2, AX
+    self.Emit("MOVQ", _R8, _DX)                         // MOVQ R8, DX
+    self.check_size_r(_AX, 0)                           // SIZE AX
+    self.add_char('"')                                  // CHAR $'"'
+    self.save_c()                                       // SAVE $REG_ffi
+    self.prep_buffer_c()                                // MOVE {buf}, DI
+    self.Emit("MOVQ", _SP_p, _SI)                       // MOVQ SP.p, SI
+
+    /* check for AVX2 support */
+    if !cpu.HasAVX2 {
+        self.Emit("XORL", _DX, _DX)                     // XORL DX, DX
+    } else {
+        self.Emit("MOVL", jit.Imm(_MODE_AVX2), _DX)     // MOVL $_MODE_AVX2, DX
+    }
+
+    /* call the encoder */
+    self.call_c(_F_b64encode)   // CALL b64encode
+    self.load_buffer()          // LOAD {buf}
+    self.add_char('"')          // CHAR $'"'
+}
+
+func (self *_Assembler) _asm_OP_quote(_ *_Instr) {
+    self.encode_string(true)
+}
+
+func (self *_Assembler) _asm_OP_number(_ *_Instr) {
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 8), _CX)          // MOVQ    (SP.p), CX
+    self.Emit("TESTQ", _CX, _CX)                        // TESTQ   CX, CX
+    self.Sjmp("JZ"   , "_empty_{n}")                    // JZ      _empty_{n}
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 0), _AX)          // MOVQ    (SP.p), AX
+    self.Emit("TESTQ", _AX, _AX)                        // TESTQ   AX, AX
+    self.Sjmp("JNZ"   , "_number_next_{n}") 
+    self.Emit("MOVQ", jit.Imm(int64(panicNilPointerOfNonEmptyString)), jit.Ptr(_SP, 0))
+    self.Sjmp("JMP", _LB_panic)
+    self.Link("_number_next_{n}")
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 0))            // MOVQ    AX, (SP)
+    self.Emit("MOVQ" , _CX, jit.Ptr(_SP, 8))            // MOVQ    CX, 8(SP)
+    self.call_go(_F_isValidNumber)                      // CALL_GO isValidNumber
+    self.Emit("CMPB" , jit.Ptr(_SP, 16), jit.Imm(0))    // CMPB    16(SP), $0
+    self.Sjmp("JE"   , _LB_error_invalid_number)        // JE      _error_invalid_number
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 8), _AX)          // MOVQ    8(SP.p), AX
+    self.check_size_r(_AX, 0)                           // SIZE    AX
+    self.Emit("LEAQ" , jit.Sib(_RP, _RL, 1, 0), _AX)    // LEAQ    (RP)(RL), AX
+    self.Emit("ADDQ" , jit.Ptr(_SP_p, 8), _RL)          // ADDQ    8(SP.p), RL
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 0))            // MOVQ    AX, (SP)
+    self.Emit("MOVOU", jit.Ptr(_SP_p, 0), _X0)          // MOVOU   (SP.p), X0
+    self.Emit("MOVOU", _X0, jit.Ptr(_SP, 8))            // MOVOU   X0, 8(SP)
+    self.call_go(_F_memmove)                            // CALL_GO memmove
+    self.Sjmp("JMP"  , "_done_{n}")                     // JMP     _done_{n}
+    self.Link("_empty_{n}")                             // _empty_{n}:
+    self.check_size(1)                                  // SIZE    $1
+    self.add_char('0')                                  // CHAR    $'0'
+    self.Link("_done_{n}")                              // _done_{n}:
+}
+
+func (self *_Assembler) _asm_OP_eface(_ *_Instr) {
+    self.prep_buffer()                          // MOVE  {buf}, (SP)s
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 0), _AX)  // MOVQ  (SP.p), AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 8))    // MOVQ  AX, 8(SP)
+    self.Emit("LEAQ" , jit.Ptr(_SP_p, 8), _AX)  // LEAQ  8(SP.p), AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 16))   // MOVQ  AX, 16(SP)
+    self.Emit("MOVQ" , _ST, jit.Ptr(_SP, 24))   // MOVQ  ST, 24(SP)
+    self.Emit("MOVQ" , _ARG_fv, _AX)            // MOVQ  fv, AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 32))   // MOVQ  AX, 32(SP)
+    self.call_encoder(_F_encodeTypedPointer)    // CALL  encodeTypedPointer
+    self.Emit("MOVQ" , jit.Ptr(_SP, 40), _ET)   // MOVQ  40(SP), ET
+    self.Emit("MOVQ" , jit.Ptr(_SP, 48), _EP)   // MOVQ  48(SP), EP
+    self.Emit("TESTQ", _ET, _ET)                // TESTQ ET, ET
+    self.Sjmp("JNZ"  , _LB_error)               // JNZ   _error
+}
+
+func (self *_Assembler) _asm_OP_iface(_ *_Instr) {
+    self.prep_buffer()                          // MOVE  {buf}, (SP)
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 0), _AX)  // MOVQ  (SP.p), AX
+    self.Emit("MOVQ" , jit.Ptr(_AX, 8), _AX)    // MOVQ  8(AX), AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 8))    // MOVQ  AX, 8(SP)
+    self.Emit("LEAQ" , jit.Ptr(_SP_p, 8), _AX)  // LEAQ  8(SP.p), AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 16))   // MOVQ  AX, 16(SP)
+    self.Emit("MOVQ" , _ST, jit.Ptr(_SP, 24))   // MOVQ  ST, 24(SP)
+    self.Emit("MOVQ" , _ARG_fv, _AX)            // MOVQ  fv, AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 32))   // MOVQ  AX, 32(SP)
+    self.call_encoder(_F_encodeTypedPointer)    // CALL  encodeTypedPointer
+    self.Emit("MOVQ" , jit.Ptr(_SP, 40), _ET)   // MOVQ  40(SP), ET
+    self.Emit("MOVQ" , jit.Ptr(_SP, 48), _EP)   // MOVQ  48(SP), EP
+    self.Emit("TESTQ", _ET, _ET)                // TESTQ ET, ET
+    self.Sjmp("JNZ"  , _LB_error)               // JNZ   _error
+}
+
+func (self *_Assembler) _asm_OP_byte(p *_Instr) {
+    self.check_size(1)
+    self.Emit("MOVB", jit.Imm(p.i64()), jit.Sib(_RP, _RL, 1, 0))    // MOVL p.vi(), (RP)(RL*1)
+    self.Emit("ADDQ", jit.Imm(1), _RL)                              // ADDQ $1, RL
+}
+
+func (self *_Assembler) _asm_OP_text(p *_Instr) {
+    self.check_size(len(p.vs()))    // SIZE ${len(p.vs())}
+    self.add_text(p.vs())           // TEXT ${p.vs()}
+}
+
+func (self *_Assembler) _asm_OP_deref(_ *_Instr) {
+    self.Emit("MOVQ", jit.Ptr(_SP_p, 0), _SP_p)     // MOVQ (SP.p), SP.p
+}
+
+func (self *_Assembler) _asm_OP_index(p *_Instr) {
+    self.Emit("MOVQ", jit.Imm(p.i64()), _AX)    // MOVQ $p.vi(), AX
+    self.Emit("ADDQ", _AX, _SP_p)               // ADDQ AX, SP.p
+}
+
+func (self *_Assembler) _asm_OP_load(_ *_Instr) {
+    self.Emit("MOVQ", jit.Ptr(_ST, 0), _AX)                 // MOVQ (ST), AX
+    self.Emit("MOVQ", jit.Sib(_ST, _AX, 1, -24), _SP_x)     // MOVQ -24(ST)(AX), SP.x
+    self.Emit("MOVQ", jit.Sib(_ST, _AX, 1, -8), _SP_p)      // MOVQ -8(ST)(AX), SP.p
+    self.Emit("MOVQ", jit.Sib(_ST, _AX, 1, 0), _SP_q)       // MOVQ (ST)(AX), SP.q
+}
+
+func (self *_Assembler) _asm_OP_save(_ *_Instr) {
+    self.save_state()
+}
+
+func (self *_Assembler) _asm_OP_drop(_ *_Instr) {
+    self.drop_state(_StateSize)
+}
+
+func (self *_Assembler) _asm_OP_drop_2(_ *_Instr) {
+    self.drop_state(_StateSize * 2)                     // DROP  $(_StateSize * 2)
+    self.Emit("MOVOU", _X0, jit.Sib(_ST, _AX, 1, 56))   // MOVOU X0, 56(ST)(AX)
+}
+
+func (self *_Assembler) _asm_OP_recurse(p *_Instr) {
+    self.prep_buffer()                          // MOVE {buf}, (SP)
+    vt, pv := p.vp()
+    self.Emit("MOVQ", jit.Type(vt), _AX)    // MOVQ $(type(p.vt())), AX
+    self.Emit("MOVQ", _AX, jit.Ptr(_SP, 8))     // MOVQ AX, 8(SP)
+
+    /* check for indirection */
+    if !rt.UnpackType(vt).Indirect() {
+        self.Emit("MOVQ", _SP_p, _AX)               // MOVQ SP.p, AX
+    } else {
+        self.Emit("MOVQ", _SP_p, _VAR_vp)  // MOVQ SP.p, 48(SP)
+        self.Emit("LEAQ", _VAR_vp, _AX)    // LEAQ 48(SP), AX
+    }
+
+    /* call the encoder */
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 16))   // MOVQ  AX, 16(SP)
+    self.Emit("MOVQ" , _ST, jit.Ptr(_SP, 24))   // MOVQ  ST, 24(SP)
+    self.Emit("MOVQ" , _ARG_fv, _AX)            // MOVQ  fv, AX
+    if pv {
+        self.Emit("BTCQ", jit.Imm(bitPointerValue), _AX)  // BTCQ $1, AX
+    }
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 32))   // MOVQ  AX, 32(SP)
+    self.call_encoder(_F_encodeTypedPointer)    // CALL  encodeTypedPointer
+    self.Emit("MOVQ" , jit.Ptr(_SP, 40), _ET)   // MOVQ  40(SP), ET
+    self.Emit("MOVQ" , jit.Ptr(_SP, 48), _EP)   // MOVQ  48(SP), EP
+    self.Emit("TESTQ", _ET, _ET)                // TESTQ ET, ET
+    self.Sjmp("JNZ"  , _LB_error)               // JNZ   _error
+}
+
+func (self *_Assembler) _asm_OP_is_nil(p *_Instr) {
+    self.Emit("CMPQ", jit.Ptr(_SP_p, 0), jit.Imm(0))    // CMPQ (SP.p), $0
+    self.Xjmp("JE"  , p.vi())                           // JE   p.vi()
+}
+
+func (self *_Assembler) _asm_OP_is_nil_p1(p *_Instr) {
+    self.Emit("CMPQ", jit.Ptr(_SP_p, 8), jit.Imm(0))    // CMPQ 8(SP.p), $0
+    self.Xjmp("JE"  , p.vi())                           // JE   p.vi()
+}
+
+func (self *_Assembler) _asm_OP_is_zero_1(p *_Instr) {
+    self.Emit("CMPB", jit.Ptr(_SP_p, 0), jit.Imm(0))    // CMPB (SP.p), $0
+    self.Xjmp("JE"  , p.vi())                           // JE   p.vi()
+}
+
+func (self *_Assembler) _asm_OP_is_zero_2(p *_Instr) {
+    self.Emit("CMPW", jit.Ptr(_SP_p, 0), jit.Imm(0))    // CMPW (SP.p), $0
+    self.Xjmp("JE"  , p.vi())                           // JE   p.vi()
+}
+
+func (self *_Assembler) _asm_OP_is_zero_4(p *_Instr) {
+    self.Emit("CMPL", jit.Ptr(_SP_p, 0), jit.Imm(0))    // CMPL (SP.p), $0
+    self.Xjmp("JE"  , p.vi())                           // JE   p.vi()
+}
+
+func (self *_Assembler) _asm_OP_is_zero_8(p *_Instr) {
+    self.Emit("CMPQ", jit.Ptr(_SP_p, 0), jit.Imm(0))    // CMPQ (SP.p), $0
+    self.Xjmp("JE"  , p.vi())                           // JE   p.vi()
+}
+
+func (self *_Assembler) _asm_OP_is_zero_map(p *_Instr) {
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 0), _AX)          // MOVQ  (SP.p), AX
+    self.Emit("TESTQ", _AX, _AX)                        // TESTQ AX, AX
+    self.Xjmp("JZ"   , p.vi())                          // JZ    p.vi()
+    self.Emit("CMPQ" , jit.Ptr(_AX, 0), jit.Imm(0))     // CMPQ  (AX), $0
+    self.Xjmp("JE"   , p.vi())                          // JE    p.vi()
+}
+
+func (self *_Assembler) _asm_OP_goto(p *_Instr) {
+    self.Xjmp("JMP", p.vi())
+}
+
+func (self *_Assembler) _asm_OP_map_iter(p *_Instr) {
+    self.Emit("MOVQ" , jit.Type(p.vt()), _AX)       // MOVQ    $p.vt(), AX
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 0), _CX)      // MOVQ    (SP.p), CX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 0))        // MOVQ    AX, (SP)
+    self.Emit("MOVQ" , _CX, jit.Ptr(_SP, 8))        // MOVQ    CX, 8(SP)
+    self.Emit("MOVQ" , _ARG_fv, _AX)                // MOVQ    fv, AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_SP, 16))       // MOVQ    AX, 16(SP)
+    self.call_go(_F_iteratorStart)                  // CALL_GO iteratorStart
+    self.Emit("MOVQ" , jit.Ptr(_SP, 24), _SP_q)     // MOVQ    24(SP), SP.q
+    self.Emit("MOVQ" , jit.Ptr(_SP, 32), _ET)       // MOVQ    32(SP), ET
+    self.Emit("MOVQ" , jit.Ptr(_SP, 40), _EP)       // MOVQ    40(SP), EP
+    self.Emit("TESTQ", _ET, _ET)                    // TESTQ   ET, ET
+    self.Sjmp("JNZ"  , _LB_error)                   // JNZ     _error
+}
+
+func (self *_Assembler) _asm_OP_map_stop(_ *_Instr) {
+    self.Emit("MOVQ", _SP_q, jit.Ptr(_SP, 0))   // MOVQ    SP.q, 0(SP)
+    self.call_go(_F_iteratorStop)               // CALL_GO iteratorStop
+    self.Emit("XORL", _SP_q, _SP_q)             // XORL    SP.q, SP.q
+}
+
+func (self *_Assembler) _asm_OP_map_check_key(p *_Instr) {
+    self.Emit("MOVQ" , jit.Ptr(_SP_q, 0), _SP_p)    // MOVQ    (SP.q), SP.p
+    self.Emit("TESTQ", _SP_p, _SP_p)                // TESTQ   SP.p, SP.p
+    self.Xjmp("JZ"   , p.vi())                      // JNZ     p.vi()
+}
+
+func (self *_Assembler) _asm_OP_map_write_key(p *_Instr) {
+    self.Emit("BTQ", jit.Imm(bitSortMapKeys), _ARG_fv)      // BTQ ${SortMapKeys}, fv
+    self.Sjmp("JNC", "_unordered_key_{n}")                  // JNC _unordered_key_{n}
+    self.encode_string(false)                               // STR $false
+    self.Xjmp("JMP", p.vi())                                // JMP ${p.vi()}
+    self.Link("_unordered_key_{n}")                         // _unordered_key_{n}:
+}
+
+func (self *_Assembler) _asm_OP_map_value_next(_ *_Instr) {
+    self.Emit("MOVQ", jit.Ptr(_SP_q, 8), _SP_p)     // MOVQ    8(SP.q), SP.p
+    self.Emit("MOVQ", _SP_q, jit.Ptr(_SP, 0))       // MOVQ    SP.q, (SP)
+    self.call_go(_F_iteratorNext)                   // CALL_GO iteratorNext
+}
+
+func (self *_Assembler) _asm_OP_slice_len(_ *_Instr) {
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 8), _SP_x)        // MOVQ  8(SP.p), SP.x
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 0), _SP_p)        // MOVQ  (SP.p), SP.p
+    self.Emit("ORQ"  , jit.Imm(1 << _S_init), _SP_f)    // ORQ   $(1<<_S_init), SP.f
+}
+
+func (self *_Assembler) _asm_OP_slice_next(p *_Instr) {
+    self.Emit("TESTQ"  , _SP_x, _SP_x)                          // TESTQ   SP.x, SP.x
+    self.Xjmp("JZ"     , p.vi())                                // JZ      p.vi()
+    self.Emit("SUBQ"   , jit.Imm(1), _SP_x)                     // SUBQ    $1, SP.x
+    self.Emit("BTRQ"   , jit.Imm(_S_init), _SP_f)               // BTRQ    $_S_init, SP.f
+    self.Emit("LEAQ"   , jit.Ptr(_SP_p, int64(p.vlen())), _AX)  // LEAQ    $(p.vlen())(SP.p), AX
+    self.Emit("CMOVQCC", _AX, _SP_p)                            // CMOVQNC AX, SP.p
+}
+
+func (self *_Assembler) _asm_OP_marshal(p *_Instr) {
+    self.call_marshaler(_F_encodeJsonMarshaler, _T_json_Marshaler, p.vt())
+}
+
+func (self *_Assembler) _asm_OP_marshal_p(p *_Instr) {
+    if p.vk() != reflect.Ptr {
+        panic("marshal_p: invalid type")
+    } else {
+        self.call_marshaler_v(_F_encodeJsonMarshaler, _T_json_Marshaler, p.vt(), false)
+    }
+}
+
+func (self *_Assembler) _asm_OP_marshal_text(p *_Instr) {
+    self.call_marshaler(_F_encodeTextMarshaler, _T_encoding_TextMarshaler, p.vt())
+}
+
+func (self *_Assembler) _asm_OP_marshal_text_p(p *_Instr) {
+    if p.vk() != reflect.Ptr {
+        panic("marshal_text_p: invalid type")
+    } else {
+        self.call_marshaler_v(_F_encodeTextMarshaler, _T_encoding_TextMarshaler, p.vt(), false)
+    }
+}
+
+func (self *_Assembler) _asm_OP_cond_set(_ *_Instr) {
+    self.Emit("ORQ", jit.Imm(1 << _S_cond), _SP_f)  // ORQ $(1<<_S_cond), SP.f
+}
+
+func (self *_Assembler) _asm_OP_cond_testc(p *_Instr) {
+    self.Emit("BTRQ", jit.Imm(_S_cond), _SP_f)      // BTRQ $_S_cond, SP.f
+    self.Xjmp("JC"  , p.vi())
+}
+
+func (self *_Assembler) print_gc(i int, p1 *_Instr, p2 *_Instr) {
+    self.Emit("MOVQ", jit.Imm(int64(p2.op())),  jit.Ptr(_SP, 16))// MOVQ $(p2.op()), 16(SP)
+    self.Emit("MOVQ", jit.Imm(int64(p1.op())),  jit.Ptr(_SP, 8)) // MOVQ $(p1.op()), 8(SP)
+    self.Emit("MOVQ", jit.Imm(int64(i)),  jit.Ptr(_SP, 0))       // MOVQ $(i), (SP)
+    self.call_go(_F_println)
+}
+
+var (
+    _V_writeBarrier = jit.Imm(int64(_runtime_writeBarrier))
+
+    _F_gcWriteBarrierAX = jit.Func(gcWriteBarrierAX)
+)
+
+func (self *_Assembler) WriteRecNotAX(i int, ptr obj.Addr, rec obj.Addr) {
+    if rec.Reg == x86.REG_AX || rec.Index == x86.REG_AX {
+        panic("rec contains AX!")
+    }
+    self.Emit("MOVQ", _V_writeBarrier, _R10)
+    self.Emit("CMPL", jit.Ptr(_R10, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, _AX)
+    self.xsave(_DI)
+    self.Emit("LEAQ", rec, _DI)
+    self.Emit("MOVQ", _F_gcWriteBarrierAX, _R10)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _R10)  
+    self.xload(_DI)  
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/encoder/assembler_amd64_go117.go b/vendor/github.com/bytedance/sonic/encoder/assembler_amd64_go117.go
new file mode 100644
index 000000000..8cd83e868
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/assembler_amd64_go117.go
@@ -0,0 +1,1201 @@
+//go:build go1.17 && !go1.21
+// +build go1.17,!go1.21
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `fmt`
+    `reflect`
+    `strconv`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/cpu`
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/twitchyliquid64/golang-asm/obj`
+    `github.com/twitchyliquid64/golang-asm/obj/x86`
+
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+/** Register Allocations
+ *
+ *  State Registers:
+ *
+ *      %rbx : stack base
+ *      %rdi : result pointer
+ *      %rsi : result length
+ *      %rdx : result capacity
+ *      %r12 : sp->p
+ *      %r13 : sp->q
+ *      %r14 : sp->x
+ *      %r15 : sp->f
+ *
+ *  Error Registers:
+ *
+ *      %r10 : error type register
+ *      %r11 : error pointer register
+ */
+
+/** Function Prototype & Stack Map
+ *
+ *  func (buf *[]byte, p unsafe.Pointer, sb *_Stack, fv uint64) (err error)
+ *
+ *  buf    :   (FP)
+ *  p      :  8(FP)
+ *  sb     : 16(FP)
+ *  fv     : 24(FP)
+ *  err.vt : 32(FP)
+ *  err.vp : 40(FP)
+ */
+
+const (
+    _S_cond = iota
+    _S_init
+)
+
+const (
+    _FP_args   = 32     // 32 bytes for spill registers of arguments
+    _FP_fargs  = 40     // 40 bytes for passing arguments to other Go functions
+    _FP_saves  = 64     // 64 bytes for saving the registers before CALL instructions
+    _FP_locals = 24     // 24 bytes for local variables
+)
+
+const (
+    _FP_loffs = _FP_fargs + _FP_saves
+    _FP_offs  = _FP_loffs + _FP_locals
+    // _FP_offs  = _FP_loffs + _FP_locals + _FP_debug
+    _FP_size  = _FP_offs + 8     // 8 bytes for the parent frame pointer
+    _FP_base  = _FP_size + 8     // 8 bytes for the return address
+)
+
+const (
+    _FM_exp32 = 0x7f800000
+    _FM_exp64 = 0x7ff0000000000000
+)
+
+const (
+    _IM_null   = 0x6c6c756e           // 'null'
+    _IM_true   = 0x65757274           // 'true'
+    _IM_fals   = 0x736c6166           // 'fals' ('false' without the 'e')
+    _IM_open   = 0x00225c22           // '"\"∅'
+    _IM_array  = 0x5d5b               // '[]'
+    _IM_object = 0x7d7b               // '{}'
+    _IM_mulv   = -0x5555555555555555
+)
+
+const (
+    _LB_more_space        = "_more_space"
+    _LB_more_space_return = "_more_space_return_"
+)
+
+const (
+    _LB_error                 = "_error"
+    _LB_error_too_deep        = "_error_too_deep"
+    _LB_error_invalid_number  = "_error_invalid_number"
+    _LB_error_nan_or_infinite = "_error_nan_or_infinite"
+    _LB_panic = "_panic"
+)
+
+var (
+    _AX = jit.Reg("AX")
+    _BX = jit.Reg("BX")
+    _CX = jit.Reg("CX")
+    _DX = jit.Reg("DX")
+    _DI = jit.Reg("DI")
+    _SI = jit.Reg("SI")
+    _BP = jit.Reg("BP")
+    _SP = jit.Reg("SP")
+    _R8 = jit.Reg("R8")
+    _R9 = jit.Reg("R9")
+)
+
+var (
+    _X0 = jit.Reg("X0")
+    _Y0 = jit.Reg("Y0")
+)
+
+var (
+    _ST = jit.Reg("R15")     // can't use R14 since it's always scratched by Go...
+    _RP = jit.Reg("DI")
+    _RL = jit.Reg("SI")
+    _RC = jit.Reg("DX")
+)
+
+var (
+    _LR = jit.Reg("R9")
+    _ET = jit.Reg("AX")
+    _EP = jit.Reg("BX")
+)
+
+var (
+    _SP_p = jit.Reg("R10") // saved on BX when call_c
+    _SP_q = jit.Reg("R11") // saved on BP when call_c
+    _SP_x = jit.Reg("R12")
+    _SP_f = jit.Reg("R13") 
+)
+
+var (
+    _ARG_rb = jit.Ptr(_SP, _FP_base)
+    _ARG_vp = jit.Ptr(_SP, _FP_base + 8)
+    _ARG_sb = jit.Ptr(_SP, _FP_base + 16)
+    _ARG_fv = jit.Ptr(_SP, _FP_base + 24)
+)
+
+var (
+    _RET_et = _ET
+    _RET_ep = _EP
+)
+
+var (
+    _VAR_sp = jit.Ptr(_SP, _FP_fargs + _FP_saves)
+    _VAR_dn = jit.Ptr(_SP, _FP_fargs + _FP_saves + 8)
+    _VAR_vp = jit.Ptr(_SP, _FP_fargs + _FP_saves + 16)
+)
+
+var (
+    _REG_ffi = []obj.Addr{ _RP, _RL, _RC}
+    _REG_b64 = []obj.Addr{_SP_p, _SP_q}
+
+    _REG_all = []obj.Addr{_ST, _SP_x, _SP_f, _SP_p, _SP_q, _RP, _RL, _RC}
+    _REG_ms  = []obj.Addr{_ST, _SP_x, _SP_f, _SP_p, _SP_q, _LR}
+    _REG_enc = []obj.Addr{_ST, _SP_x, _SP_f, _SP_p, _SP_q, _RL}
+)
+
+type _Assembler struct {
+    jit.BaseAssembler
+    p _Program
+    x int
+    name string
+}
+
+func newAssembler(p _Program) *_Assembler {
+    return new(_Assembler).Init(p)
+}
+
+/** Assembler Interface **/
+
+func (self *_Assembler) Load() _Encoder {
+    return ptoenc(self.BaseAssembler.Load("encode_"+self.name, _FP_size, _FP_args, argPtrs, localPtrs))
+}
+
+func (self *_Assembler) Init(p _Program) *_Assembler {
+    self.p = p
+    self.BaseAssembler.Init(self.compile)
+    return self
+}
+
+func (self *_Assembler) compile() {
+    self.prologue()
+    self.instrs()
+    self.epilogue()
+    self.builtins()
+}
+
+/** Assembler Stages **/
+
+var _OpFuncTab = [256]func(*_Assembler, *_Instr) {
+    _OP_null           : (*_Assembler)._asm_OP_null,
+    _OP_empty_arr      : (*_Assembler)._asm_OP_empty_arr,
+    _OP_empty_obj      : (*_Assembler)._asm_OP_empty_obj, 
+    _OP_bool           : (*_Assembler)._asm_OP_bool,
+    _OP_i8             : (*_Assembler)._asm_OP_i8,
+    _OP_i16            : (*_Assembler)._asm_OP_i16,
+    _OP_i32            : (*_Assembler)._asm_OP_i32,
+    _OP_i64            : (*_Assembler)._asm_OP_i64,
+    _OP_u8             : (*_Assembler)._asm_OP_u8,
+    _OP_u16            : (*_Assembler)._asm_OP_u16,
+    _OP_u32            : (*_Assembler)._asm_OP_u32,
+    _OP_u64            : (*_Assembler)._asm_OP_u64,
+    _OP_f32            : (*_Assembler)._asm_OP_f32,
+    _OP_f64            : (*_Assembler)._asm_OP_f64,
+    _OP_str            : (*_Assembler)._asm_OP_str,
+    _OP_bin            : (*_Assembler)._asm_OP_bin,
+    _OP_quote          : (*_Assembler)._asm_OP_quote,
+    _OP_number         : (*_Assembler)._asm_OP_number,
+    _OP_eface          : (*_Assembler)._asm_OP_eface,
+    _OP_iface          : (*_Assembler)._asm_OP_iface,
+    _OP_byte           : (*_Assembler)._asm_OP_byte,
+    _OP_text           : (*_Assembler)._asm_OP_text,
+    _OP_deref          : (*_Assembler)._asm_OP_deref,
+    _OP_index          : (*_Assembler)._asm_OP_index,
+    _OP_load           : (*_Assembler)._asm_OP_load,
+    _OP_save           : (*_Assembler)._asm_OP_save,
+    _OP_drop           : (*_Assembler)._asm_OP_drop,
+    _OP_drop_2         : (*_Assembler)._asm_OP_drop_2,
+    _OP_recurse        : (*_Assembler)._asm_OP_recurse,
+    _OP_is_nil         : (*_Assembler)._asm_OP_is_nil,
+    _OP_is_nil_p1      : (*_Assembler)._asm_OP_is_nil_p1,
+    _OP_is_zero_1      : (*_Assembler)._asm_OP_is_zero_1,
+    _OP_is_zero_2      : (*_Assembler)._asm_OP_is_zero_2,
+    _OP_is_zero_4      : (*_Assembler)._asm_OP_is_zero_4,
+    _OP_is_zero_8      : (*_Assembler)._asm_OP_is_zero_8,
+    _OP_is_zero_map    : (*_Assembler)._asm_OP_is_zero_map,
+    _OP_goto           : (*_Assembler)._asm_OP_goto,
+    _OP_map_iter       : (*_Assembler)._asm_OP_map_iter,
+    _OP_map_stop       : (*_Assembler)._asm_OP_map_stop,
+    _OP_map_check_key  : (*_Assembler)._asm_OP_map_check_key,
+    _OP_map_write_key  : (*_Assembler)._asm_OP_map_write_key,
+    _OP_map_value_next : (*_Assembler)._asm_OP_map_value_next,
+    _OP_slice_len      : (*_Assembler)._asm_OP_slice_len,
+    _OP_slice_next     : (*_Assembler)._asm_OP_slice_next,
+    _OP_marshal        : (*_Assembler)._asm_OP_marshal,
+    _OP_marshal_p      : (*_Assembler)._asm_OP_marshal_p,
+    _OP_marshal_text   : (*_Assembler)._asm_OP_marshal_text,
+    _OP_marshal_text_p : (*_Assembler)._asm_OP_marshal_text_p,
+    _OP_cond_set       : (*_Assembler)._asm_OP_cond_set,
+    _OP_cond_testc     : (*_Assembler)._asm_OP_cond_testc,
+}
+
+func (self *_Assembler) instr(v *_Instr) {
+    if fn := _OpFuncTab[v.op()]; fn != nil {
+        fn(self, v)
+    } else {
+        panic(fmt.Sprintf("invalid opcode: %d", v.op()))
+    }
+}
+
+func (self *_Assembler) instrs() {
+    for i, v := range self.p {
+        self.Mark(i)
+        self.instr(&v)
+        self.debug_instr(i, &v)
+    }
+}
+
+func (self *_Assembler) builtins() {
+    self.more_space()
+    self.error_too_deep()
+    self.error_invalid_number()
+    self.error_nan_or_infinite()
+    self.go_panic()
+}
+
+func (self *_Assembler) epilogue() {
+    self.Mark(len(self.p))
+    self.Emit("XORL", _ET, _ET)
+    self.Emit("XORL", _EP, _EP)
+    self.Link(_LB_error)
+    self.Emit("MOVQ", _ARG_rb, _CX)                 // MOVQ rb<>+0(FP), CX
+    self.Emit("MOVQ", _RL, jit.Ptr(_CX, 8))         // MOVQ RL, 8(CX)
+    self.Emit("MOVQ", jit.Imm(0), _ARG_rb)          // MOVQ AX, rb<>+0(FP)
+    self.Emit("MOVQ", jit.Imm(0), _ARG_vp)          // MOVQ BX, vp<>+8(FP)
+    self.Emit("MOVQ", jit.Imm(0), _ARG_sb)          // MOVQ CX, sb<>+16(FP)
+    self.Emit("MOVQ", jit.Ptr(_SP, _FP_offs), _BP)  // MOVQ _FP_offs(SP), BP
+    self.Emit("ADDQ", jit.Imm(_FP_size), _SP)       // ADDQ $_FP_size, SP
+    self.Emit("RET")                                // RET
+}
+
+func (self *_Assembler) prologue() {
+    self.Emit("SUBQ", jit.Imm(_FP_size), _SP)       // SUBQ $_FP_size, SP
+    self.Emit("MOVQ", _BP, jit.Ptr(_SP, _FP_offs))  // MOVQ BP, _FP_offs(SP)
+    self.Emit("LEAQ", jit.Ptr(_SP, _FP_offs), _BP)  // LEAQ _FP_offs(SP), BP
+    self.Emit("MOVQ", _AX, _ARG_rb)                 // MOVQ AX, rb<>+0(FP)
+    self.Emit("MOVQ", _BX, _ARG_vp)                 // MOVQ BX, vp<>+8(FP)
+    self.Emit("MOVQ", _CX, _ARG_sb)                 // MOVQ CX, sb<>+16(FP)
+    self.Emit("MOVQ", _DI, _ARG_fv)                 // MOVQ DI, rb<>+24(FP)
+    self.Emit("MOVQ", jit.Ptr(_AX,  0), _RP)        // MOVQ (AX)  , DI
+    self.Emit("MOVQ", jit.Ptr(_AX,  8), _RL)        // MOVQ 8(AX) , SI
+    self.Emit("MOVQ", jit.Ptr(_AX, 16), _RC)        // MOVQ 16(AX), DX
+    self.Emit("MOVQ", _BX, _SP_p)                   // MOVQ BX, R10
+    self.Emit("MOVQ", _CX, _ST)                     // MOVQ CX, R8
+    self.Emit("XORL", _SP_x, _SP_x)                 // XORL R10, R12
+    self.Emit("XORL", _SP_f, _SP_f)                 // XORL R11, R13
+    self.Emit("XORL", _SP_q, _SP_q)                 // XORL R13, R11
+}
+
+/** Assembler Inline Functions **/
+
+func (self *_Assembler) xsave(reg ...obj.Addr) {
+    for i, v := range reg {
+        if i > _FP_saves / 8 - 1 {
+            panic("too many registers to save")
+        } else {
+            self.Emit("MOVQ", v, jit.Ptr(_SP, _FP_fargs + int64(i) * 8))
+        }
+    }
+}
+
+func (self *_Assembler) xload(reg ...obj.Addr) {
+    for i, v := range reg {
+        if i > _FP_saves / 8 - 1 {
+            panic("too many registers to load")
+        } else {
+            self.Emit("MOVQ", jit.Ptr(_SP, _FP_fargs + int64(i) * 8), v)
+        }
+    }
+}
+
+func (self *_Assembler) rbuf_di() {
+    if _RP.Reg != x86.REG_DI {
+        panic("register allocation messed up: RP != DI")
+    } else {
+        self.Emit("ADDQ", _RL, _RP)
+    }
+}
+
+func (self *_Assembler) store_int(nd int, fn obj.Addr, ins string) {
+    self.check_size(nd)
+    self.save_c()                           // SAVE   $C_regs
+    self.rbuf_di()                          // MOVQ   RP, DI
+    self.Emit(ins, jit.Ptr(_SP_p, 0), _SI)  // $ins   (SP.p), SI
+    self.call_c(fn)                         // CALL_C $fn
+    self.Emit("ADDQ", _AX, _RL)             // ADDQ   AX, RL
+}
+
+func (self *_Assembler) store_str(s string) {
+    i := 0
+    m := rt.Str2Mem(s)
+
+    /* 8-byte stores */
+    for i <= len(m) - 8 {
+        self.Emit("MOVQ", jit.Imm(rt.Get64(m[i:])), _AX)        // MOVQ $s[i:], AX
+        self.Emit("MOVQ", _AX, jit.Sib(_RP, _RL, 1, int64(i)))  // MOVQ AX, i(RP)(RL)
+        i += 8
+    }
+
+    /* 4-byte stores */
+    if i <= len(m) - 4 {
+        self.Emit("MOVL", jit.Imm(int64(rt.Get32(m[i:]))), jit.Sib(_RP, _RL, 1, int64(i)))  // MOVL $s[i:], i(RP)(RL)
+        i += 4
+    }
+
+    /* 2-byte stores */
+    if i <= len(m) - 2 {
+        self.Emit("MOVW", jit.Imm(int64(rt.Get16(m[i:]))), jit.Sib(_RP, _RL, 1, int64(i)))  // MOVW $s[i:], i(RP)(RL)
+        i += 2
+    }
+
+    /* last byte */
+    if i < len(m) {
+        self.Emit("MOVB", jit.Imm(int64(m[i])), jit.Sib(_RP, _RL, 1, int64(i)))     // MOVB $s[i:], i(RP)(RL)
+    }
+}
+
+func (self *_Assembler) check_size(n int) {
+    self.check_size_rl(jit.Ptr(_RL, int64(n)))
+}
+
+func (self *_Assembler) check_size_r(r obj.Addr, d int) {
+    self.check_size_rl(jit.Sib(_RL, r, 1, int64(d)))
+}
+
+func (self *_Assembler) check_size_rl(v obj.Addr) {
+    idx := self.x
+    key := _LB_more_space_return + strconv.Itoa(idx)
+
+    /* the following code relies on LR == R9 to work */
+    if _LR.Reg != x86.REG_R9 {
+        panic("register allocation messed up: LR != R9")
+    }
+
+    /* check for buffer capacity */
+    self.x++
+    self.Emit("LEAQ", v, _AX)       // LEAQ $v, AX
+    self.Emit("CMPQ", _AX, _RC)     // CMPQ AX, RC
+    self.Sjmp("JBE" , key)          // JBE  _more_space_return_{n}
+    self.slice_grow_ax(key)         // GROW $key
+    self.Link(key)                  // _more_space_return_{n}:
+}
+
+func (self *_Assembler) slice_grow_ax(ret string) {
+    self.Byte(0x4c, 0x8d, 0x0d)         // LEAQ ?(PC), R9
+    self.Sref(ret, 4)                   // .... &ret
+    self.Sjmp("JMP" , _LB_more_space)   // JMP  _more_space
+}
+
+/** State Stack Helpers **/
+
+const (
+    _StateSize  = int64(unsafe.Sizeof(_State{}))
+    _StackLimit = _MaxStack * _StateSize
+)
+
+func (self *_Assembler) save_state() {
+    self.Emit("MOVQ", jit.Ptr(_ST, 0), _CX)             // MOVQ (ST), CX
+    self.Emit("LEAQ", jit.Ptr(_CX, _StateSize), _R9)    // LEAQ _StateSize(CX), R9
+    self.Emit("CMPQ", _R9, jit.Imm(_StackLimit))        // CMPQ R9, $_StackLimit
+    self.Sjmp("JAE" , _LB_error_too_deep)               // JA   _error_too_deep
+    self.Emit("MOVQ", _SP_x, jit.Sib(_ST, _CX, 1, 8))   // MOVQ SP.x, 8(ST)(CX)
+    self.Emit("MOVQ", _SP_f, jit.Sib(_ST, _CX, 1, 16))  // MOVQ SP.f, 16(ST)(CX)
+    self.WriteRecNotAX(0, _SP_p, jit.Sib(_ST, _CX, 1, 24))  // MOVQ SP.p, 24(ST)(CX)
+    self.WriteRecNotAX(1, _SP_q, jit.Sib(_ST, _CX, 1, 32))  // MOVQ SP.q, 32(ST)(CX)
+    self.Emit("MOVQ", _R9, jit.Ptr(_ST, 0))             // MOVQ R9, (ST)
+}
+
+func (self *_Assembler) drop_state(decr int64) {
+    self.Emit("MOVQ" , jit.Ptr(_ST, 0), _AX)                // MOVQ  (ST), AX
+    self.Emit("SUBQ" , jit.Imm(decr), _AX)                  // SUBQ  $decr, AX
+    self.Emit("MOVQ" , _AX, jit.Ptr(_ST, 0))                // MOVQ  AX, (ST)
+    self.Emit("MOVQ" , jit.Sib(_ST, _AX, 1, 8), _SP_x)      // MOVQ  8(ST)(AX), SP.x
+    self.Emit("MOVQ" , jit.Sib(_ST, _AX, 1, 16), _SP_f)     // MOVQ  16(ST)(AX), SP.f
+    self.Emit("MOVQ" , jit.Sib(_ST, _AX, 1, 24), _SP_p)     // MOVQ  24(ST)(AX), SP.p
+    self.Emit("MOVQ" , jit.Sib(_ST, _AX, 1, 32), _SP_q)     // MOVQ  32(ST)(AX), SP.q
+    self.Emit("PXOR" , _X0, _X0)                            // PXOR  X0, X0
+    self.Emit("MOVOU", _X0, jit.Sib(_ST, _AX, 1, 8))        // MOVOU X0, 8(ST)(AX)
+    self.Emit("MOVOU", _X0, jit.Sib(_ST, _AX, 1, 24))       // MOVOU X0, 24(ST)(AX)
+}
+
+/** Buffer Helpers **/
+
+func (self *_Assembler) add_char(ch byte) {
+    self.Emit("MOVB", jit.Imm(int64(ch)), jit.Sib(_RP, _RL, 1, 0))  // MOVB $ch, (RP)(RL)
+    self.Emit("ADDQ", jit.Imm(1), _RL)                              // ADDQ $1, RL
+}
+
+func (self *_Assembler) add_long(ch uint32, n int64) {
+    self.Emit("MOVL", jit.Imm(int64(ch)), jit.Sib(_RP, _RL, 1, 0))  // MOVL $ch, (RP)(RL)
+    self.Emit("ADDQ", jit.Imm(n), _RL)                              // ADDQ $n, RL
+}
+
+func (self *_Assembler) add_text(ss string) {
+    self.store_str(ss)                                  // TEXT $ss
+    self.Emit("ADDQ", jit.Imm(int64(len(ss))), _RL)     // ADDQ ${len(ss)}, RL
+}
+
+// get *buf at AX
+func (self *_Assembler) prep_buffer_AX() {
+    self.Emit("MOVQ", _ARG_rb, _AX)             // MOVQ rb<>+0(FP), AX
+    self.Emit("MOVQ", _RL, jit.Ptr(_AX, 8))     // MOVQ RL, 8(AX)
+}
+
+func (self *_Assembler) save_buffer() {
+    self.Emit("MOVQ", _ARG_rb, _CX)             // MOVQ rb<>+0(FP), CX
+    self.Emit("MOVQ", _RP, jit.Ptr(_CX,  0))    // MOVQ RP, (CX)
+    self.Emit("MOVQ", _RL, jit.Ptr(_CX,  8))    // MOVQ RL, 8(CX)
+    self.Emit("MOVQ", _RC, jit.Ptr(_CX, 16))    // MOVQ RC, 16(CX)
+}
+
+// get *buf at AX
+func (self *_Assembler) load_buffer_AX() {
+    self.Emit("MOVQ", _ARG_rb, _AX)             // MOVQ rb<>+0(FP), AX
+    self.Emit("MOVQ", jit.Ptr(_AX,  0), _RP)    // MOVQ (AX), RP
+    self.Emit("MOVQ", jit.Ptr(_AX,  8), _RL)    // MOVQ 8(AX), RL
+    self.Emit("MOVQ", jit.Ptr(_AX, 16), _RC)    // MOVQ 16(AX), RC
+}
+
+/** Function Interface Helpers **/
+
+func (self *_Assembler) call(pc obj.Addr) {
+    self.Emit("MOVQ", pc, _LR)  // MOVQ $pc, AX
+    self.Rjmp("CALL", _LR)      // CALL AX
+}
+
+func (self *_Assembler) save_c() {
+    self.xsave(_REG_ffi...)     // SAVE $REG_ffi
+}
+
+func (self *_Assembler) call_b64(pc obj.Addr) {
+    self.xsave(_REG_b64...)     // SAVE $REG_all
+    self.call(pc)               // CALL $pc
+    self.xload(_REG_b64...)     // LOAD $REG_ffi
+}
+
+func (self *_Assembler) call_c(pc obj.Addr) {
+    self.Emit("XCHGQ", _SP_p, _BX)
+    self.Emit("XCHGQ", _SP_q, _BP)
+    self.call(pc)               // CALL $pc
+    self.xload(_REG_ffi...)     // LOAD $REG_ffi
+    self.Emit("XCHGQ", _SP_p, _BX)
+    self.Emit("XCHGQ", _SP_q, _BP)
+}
+
+func (self *_Assembler) call_go(pc obj.Addr) {
+    self.xsave(_REG_all...)     // SAVE $REG_all
+    self.call(pc)               // CALL $pc
+    self.xload(_REG_all...)     // LOAD $REG_all
+}
+
+func (self *_Assembler) call_more_space(pc obj.Addr) {
+    self.xsave(_REG_ms...)     // SAVE $REG_all
+    self.call(pc)               // CALL $pc
+    self.xload(_REG_ms...)     // LOAD $REG_all
+}
+
+func (self *_Assembler) call_encoder(pc obj.Addr) {
+    self.xsave(_REG_enc...)     // SAVE $REG_all
+    self.call(pc)               // CALL $pc
+    self.xload(_REG_enc...)     // LOAD $REG_all
+}
+
+func (self *_Assembler) call_marshaler(fn obj.Addr, it *rt.GoType, vt reflect.Type) {
+    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)
+    }
+}
+
+func (self *_Assembler) call_marshaler_i(fn obj.Addr, it *rt.GoType) {
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 0), _AX)                      // MOVQ    (SP.p), AX
+    self.Emit("TESTQ", _AX, _AX)                                    // TESTQ   AX, AX
+    self.Sjmp("JZ"   , "_null_{n}")                                 // JZ      _null_{n}
+    self.Emit("MOVQ" , _AX, _BX)                                    // MOVQ    AX, BX
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 8), _CX)                      // MOVQ    8(SP.p), CX
+    self.Emit("MOVQ" , jit.Gtype(it), _AX)                          // MOVQ    $it, AX
+    self.call_go(_F_assertI2I)                                       // CALL_GO assertI2I
+    self.Emit("TESTQ", _AX, _AX)                                    // TESTQ   AX, AX
+    self.Sjmp("JZ"   , "_null_{n}")                                 // JZ      _null_{n}
+    self.Emit("MOVQ", _BX, _CX)                                     // MOVQ   BX, CX
+    self.Emit("MOVQ", _AX, _BX)                                     // MOVQ   AX, BX
+    self.prep_buffer_AX()
+    self.Emit("MOVQ", _ARG_fv, _DI)                                 // MOVQ   ARG.fv, DI
+    self.call_go(fn)                                                // CALL    $fn
+    self.Emit("TESTQ", _ET, _ET)                                    // TESTQ ET, ET
+    self.Sjmp("JNZ"  , _LB_error)                                   // JNZ   _error
+    self.load_buffer_AX()
+    self.Sjmp("JMP"  , "_done_{n}")                                 // JMP     _done_{n}
+    self.Link("_null_{n}")                                          // _null_{n}:
+    self.check_size(4)                                              // SIZE    $4
+    self.Emit("MOVL", jit.Imm(_IM_null), jit.Sib(_RP, _RL, 1, 0))   // MOVL    $'null', (RP)(RL*1)
+    self.Emit("ADDQ", jit.Imm(4), _RL)                              // ADDQ    $4, RL
+    self.Link("_done_{n}")                                          // _done_{n}:
+}
+
+func (self *_Assembler) call_marshaler_v(fn obj.Addr, it *rt.GoType, vt reflect.Type, deref bool) {
+    self.prep_buffer_AX()                          // MOVE {buf}, (SP)
+    self.Emit("MOVQ", jit.Itab(it, vt), _BX)       // MOVQ $(itab(it, vt)), BX
+
+    /* dereference the pointer if needed */
+    if !deref {
+        self.Emit("MOVQ", _SP_p, _CX)              // MOVQ SP.p, CX
+    } else {
+        self.Emit("MOVQ", jit.Ptr(_SP_p, 0), _CX)   // MOVQ 0(SP.p), CX
+    }
+
+    /* call the encoder, and perform error checks */
+    self.Emit("MOVQ", _ARG_fv, _DI)                 // MOVQ   ARG.fv, DI
+    self.call_go(fn)                                // CALL  $fn
+    self.Emit("TESTQ", _ET, _ET)                // TESTQ ET, ET
+    self.Sjmp("JNZ"  , _LB_error)               // JNZ   _error
+    self.load_buffer_AX()
+}
+
+/** Builtin: _more_space **/
+
+var (
+    _T_byte      = jit.Type(byteType)
+    _F_growslice = jit.Func(growslice)
+)
+
+// AX must saving n 
+func (self *_Assembler) more_space() {
+    self.Link(_LB_more_space)
+    self.Emit("MOVQ", _RP, _BX)        // MOVQ DI, BX
+    self.Emit("MOVQ", _RL, _CX)        // MOVQ SI, CX
+    self.Emit("MOVQ", _RC, _DI)        // MOVQ DX, DI
+    self.Emit("MOVQ", _AX, _SI)        // MOVQ AX, SI
+    self.Emit("MOVQ", _T_byte, _AX)    // MOVQ $_T_byte, AX
+    self.call_more_space(_F_growslice)            // CALL $pc    
+    self.Emit("MOVQ", _AX, _RP)        // MOVQ AX, DI
+    self.Emit("MOVQ", _BX, _RL)        // MOVQ BX, SI
+    self.Emit("MOVQ", _CX, _RC)        // MOVQ CX, DX
+    self.save_buffer()                 // SAVE {buf}
+    self.Rjmp("JMP" , _LR)             // JMP  LR
+}
+
+/** Builtin Errors **/
+
+var (
+    _V_ERR_too_deep               = jit.Imm(int64(uintptr(unsafe.Pointer(_ERR_too_deep))))
+    _V_ERR_nan_or_infinite        = jit.Imm(int64(uintptr(unsafe.Pointer(_ERR_nan_or_infinite))))
+    _I_json_UnsupportedValueError = jit.Itab(rt.UnpackType(errorType), jsonUnsupportedValueType)
+)
+
+func (self *_Assembler) error_too_deep() {
+    self.Link(_LB_error_too_deep)
+    self.Emit("MOVQ", _V_ERR_too_deep, _EP)                 // MOVQ $_V_ERR_too_deep, EP
+    self.Emit("MOVQ", _I_json_UnsupportedValueError, _ET)   // MOVQ $_I_json_UnsupportedValuError, ET
+    self.Sjmp("JMP" , _LB_error)                            // JMP  _error
+}
+
+func (self *_Assembler) error_invalid_number() {
+    self.Link(_LB_error_invalid_number)
+    self.Emit("MOVQ", jit.Ptr(_SP_p, 0), _AX)  // MOVQ    0(SP), AX
+    self.Emit("MOVQ", jit.Ptr(_SP_p, 8), _BX)  // MOVQ    8(SP), BX
+    self.call_go(_F_error_number)              // CALL_GO error_number
+    self.Sjmp("JMP" , _LB_error)               // JMP     _error
+}
+
+func (self *_Assembler) error_nan_or_infinite()  {
+    self.Link(_LB_error_nan_or_infinite)
+    self.Emit("MOVQ", _V_ERR_nan_or_infinite, _EP)          // MOVQ $_V_ERR_nan_or_infinite, EP
+    self.Emit("MOVQ", _I_json_UnsupportedValueError, _ET)   // MOVQ $_I_json_UnsupportedValuError, ET
+    self.Sjmp("JMP" , _LB_error)                            // JMP  _error
+}
+
+/** String Encoding Routine **/
+
+var (
+    _F_quote = jit.Imm(int64(native.S_quote))
+    _F_panic = jit.Func(goPanic)
+)
+
+func (self *_Assembler) go_panic() {
+    self.Link(_LB_panic)
+    self.Emit("MOVQ", _SP_p, _BX)
+    self.call_go(_F_panic)
+}
+
+func (self *_Assembler) encode_string(doubleQuote bool) {       
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 8), _AX)  // MOVQ  8(SP.p), AX
+    self.Emit("TESTQ", _AX, _AX)                // TESTQ AX, AX
+    self.Sjmp("JZ"   , "_str_empty_{n}")        // JZ    _str_empty_{n}
+    self.Emit("CMPQ", jit.Ptr(_SP_p, 0), jit.Imm(0))
+    self.Sjmp("JNE"   , "_str_next_{n}") 
+    self.Emit("MOVQ", jit.Imm(int64(panicNilPointerOfNonEmptyString)), _AX)
+    self.Sjmp("JMP", _LB_panic)
+    self.Link("_str_next_{n}")
+
+    /* openning quote, check for double quote */
+    if !doubleQuote {
+        self.check_size_r(_AX, 2)   // SIZE $2
+        self.add_char('"')          // CHAR $'"'
+    } else {
+        self.check_size_r(_AX, 6)   // SIZE $6
+        self.add_long(_IM_open, 3)  // TEXT $`"\"`
+    }
+
+    /* quoting loop */
+    self.Emit("XORL", _AX, _AX)         // XORL AX, AX
+    self.Emit("MOVQ", _AX, _VAR_sp)     // MOVQ AX, sp
+    self.Link("_str_loop_{n}")          // _str_loop_{n}:
+    self.save_c()                       // SAVE $REG_ffi
+
+    /* load the output buffer first, and then input buffer,
+     * because the parameter registers collide with RP / RL / RC */
+    self.Emit("MOVQ", _RC, _CX)                         // MOVQ RC, CX
+    self.Emit("SUBQ", _RL, _CX)                         // SUBQ RL, CX
+    self.Emit("MOVQ", _CX, _VAR_dn)                     // MOVQ CX, dn
+    self.Emit("LEAQ", jit.Sib(_RP, _RL, 1, 0), _DX)     // LEAQ (RP)(RL), DX
+    self.Emit("LEAQ", _VAR_dn, _CX)                     // LEAQ dn, CX
+    self.Emit("MOVQ", _VAR_sp, _AX)                     // MOVQ sp, AX
+    self.Emit("MOVQ", jit.Ptr(_SP_p, 0), _DI)           // MOVQ (SP.p), DI
+    self.Emit("MOVQ", jit.Ptr(_SP_p, 8), _SI)           // MOVQ 8(SP.p), SI
+    self.Emit("ADDQ", _AX, _DI)                         // ADDQ AX, DI
+    self.Emit("SUBQ", _AX, _SI)                         // SUBQ AX, SI
+
+    /* set the flags based on `doubleQuote` */
+    if !doubleQuote {
+        self.Emit("XORL", _R8, _R8)                                 // XORL R8, R8
+    } else {
+        self.Emit("MOVL", jit.Imm(types.F_DOUBLE_UNQUOTE), _R8)     // MOVL ${types.F_DOUBLE_UNQUOTE}, R8
+    }
+
+    /* call the native quoter */
+    self.call_c(_F_quote)                   // CALL  quote
+    self.Emit("ADDQ" , _VAR_dn, _RL)        // ADDQ  dn, RL
+
+    self.Emit("TESTQ", _AX, _AX)            // TESTQ AX, AX
+    self.Sjmp("JS"   , "_str_space_{n}")    // JS    _str_space_{n}
+
+    /* close the string, check for double quote */
+    if !doubleQuote {
+        self.check_size(1)                  // SIZE $1
+        self.add_char('"')                  // CHAR $'"'
+        self.Sjmp("JMP", "_str_end_{n}")    // JMP  _str_end_{n}
+    } else {
+        self.check_size(3)                  // SIZE $3
+        self.add_text("\\\"\"")             // TEXT $'\""'
+        self.Sjmp("JMP", "_str_end_{n}")    // JMP  _str_end_{n}
+    }
+
+    /* not enough space to contain the quoted string */
+    self.Link("_str_space_{n}")                         // _str_space_{n}:
+    self.Emit("NOTQ", _AX)                              // NOTQ AX
+    self.Emit("ADDQ", _AX, _VAR_sp)                     // ADDQ AX, sp
+    self.Emit("LEAQ", jit.Sib(_RC, _RC, 1, 0), _AX)     // LEAQ (RC)(RC), AX
+    self.slice_grow_ax("_str_loop_{n}")                 // GROW _str_loop_{n}
+
+    /* empty string, check for double quote */
+    if !doubleQuote {
+        self.Link("_str_empty_{n}")     // _str_empty_{n}:
+        self.check_size(2)              // SIZE $2
+        self.add_text("\"\"")           // TEXT $'""'
+        self.Link("_str_end_{n}")       // _str_end_{n}:
+    } else {
+        self.Link("_str_empty_{n}")     // _str_empty_{n}:
+        self.check_size(6)              // SIZE $6
+        self.add_text("\"\\\"\\\"\"")   // TEXT $'"\"\""'
+        self.Link("_str_end_{n}")       // _str_end_{n}:
+    }
+}
+
+/** OpCode Assembler Functions **/
+
+var (
+    _T_json_Marshaler         = rt.UnpackType(jsonMarshalerType)
+    _T_encoding_TextMarshaler = rt.UnpackType(encodingTextMarshalerType)
+)
+
+var (
+    _F_f64toa    = jit.Imm(int64(native.S_f64toa))
+    _F_f32toa    = jit.Imm(int64(native.S_f32toa))
+    _F_i64toa    = jit.Imm(int64(native.S_i64toa))
+    _F_u64toa    = jit.Imm(int64(native.S_u64toa))
+    _F_b64encode = jit.Imm(int64(_subr__b64encode))
+)
+
+var (
+    _F_memmove       = jit.Func(memmove)
+    _F_error_number  = jit.Func(error_number)
+    _F_isValidNumber = jit.Func(isValidNumber)
+)
+
+var (
+    _F_iteratorStop  = jit.Func(iteratorStop)
+    _F_iteratorNext  = jit.Func(iteratorNext)
+    _F_iteratorStart = jit.Func(iteratorStart)
+)
+
+var (
+    _F_encodeTypedPointer  obj.Addr
+    _F_encodeJsonMarshaler obj.Addr
+    _F_encodeTextMarshaler obj.Addr
+)
+
+const (
+    _MODE_AVX2 = 1 << 2
+)
+
+func init() {
+    _F_encodeTypedPointer  = jit.Func(encodeTypedPointer)
+    _F_encodeJsonMarshaler = jit.Func(encodeJsonMarshaler)
+    _F_encodeTextMarshaler = jit.Func(encodeTextMarshaler)
+}
+
+func (self *_Assembler) _asm_OP_null(_ *_Instr) {
+    self.check_size(4)
+    self.Emit("MOVL", jit.Imm(_IM_null), jit.Sib(_RP, _RL, 1, 0))  // MOVL $'null', (RP)(RL*1)
+    self.Emit("ADDQ", jit.Imm(4), _RL)                             // ADDQ $4, RL
+}
+
+func (self *_Assembler) _asm_OP_empty_arr(_ *_Instr) {
+    self.Emit("BTQ", jit.Imm(int64(bitNoNullSliceOrMap)), _ARG_fv)
+    self.Sjmp("JC", "_empty_arr_{n}")
+    self._asm_OP_null(nil)
+    self.Sjmp("JMP", "_empty_arr_end_{n}")
+    self.Link("_empty_arr_{n}")
+    self.check_size(2)
+    self.Emit("MOVW", jit.Imm(_IM_array), jit.Sib(_RP, _RL, 1, 0)) 
+    self.Emit("ADDQ", jit.Imm(2), _RL)    
+    self.Link("_empty_arr_end_{n}")                  
+}
+
+func (self *_Assembler) _asm_OP_empty_obj(_ *_Instr) {
+    self.Emit("BTQ", jit.Imm(int64(bitNoNullSliceOrMap)), _ARG_fv)
+    self.Sjmp("JC", "_empty_obj_{n}")
+    self._asm_OP_null(nil)
+    self.Sjmp("JMP", "_empty_obj_end_{n}")
+    self.Link("_empty_obj_{n}")
+    self.check_size(2)
+    self.Emit("MOVW", jit.Imm(_IM_object), jit.Sib(_RP, _RL, 1, 0))  
+    self.Emit("ADDQ", jit.Imm(2), _RL) 
+    self.Link("_empty_obj_end_{n}")                                             
+}
+
+func (self *_Assembler) _asm_OP_bool(_ *_Instr) {
+    self.Emit("CMPB", jit.Ptr(_SP_p, 0), jit.Imm(0))                // CMPB (SP.p), $0
+    self.Sjmp("JE"  , "_false_{n}")                                 // JE   _false_{n}
+    self.check_size(4)                                              // SIZE $4
+    self.Emit("MOVL", jit.Imm(_IM_true), jit.Sib(_RP, _RL, 1, 0))   // MOVL $'true', (RP)(RL*1)
+    self.Emit("ADDQ", jit.Imm(4), _RL)                              // ADDQ $4, RL
+    self.Sjmp("JMP" , "_end_{n}")                                   // JMP  _end_{n}
+    self.Link("_false_{n}")                                         // _false_{n}:
+    self.check_size(5)                                              // SIZE $5
+    self.Emit("MOVL", jit.Imm(_IM_fals), jit.Sib(_RP, _RL, 1, 0))   // MOVL $'fals', (RP)(RL*1)
+    self.Emit("MOVB", jit.Imm('e'), jit.Sib(_RP, _RL, 1, 4))        // MOVB $'e', 4(RP)(RL*1)
+    self.Emit("ADDQ", jit.Imm(5), _RL)                              // ADDQ $5, RL
+    self.Link("_end_{n}")                                           // _end_{n}:
+}
+
+func (self *_Assembler) _asm_OP_i8(_ *_Instr) {
+    self.store_int(4, _F_i64toa, "MOVBQSX")
+}
+
+func (self *_Assembler) _asm_OP_i16(_ *_Instr) {
+    self.store_int(6, _F_i64toa, "MOVWQSX")
+}
+
+func (self *_Assembler) _asm_OP_i32(_ *_Instr) {
+    self.store_int(17, _F_i64toa, "MOVLQSX")
+}
+
+func (self *_Assembler) _asm_OP_i64(_ *_Instr) {
+    self.store_int(21, _F_i64toa, "MOVQ")
+}
+
+func (self *_Assembler) _asm_OP_u8(_ *_Instr) {
+    self.store_int(3, _F_u64toa, "MOVBQZX")
+}
+
+func (self *_Assembler) _asm_OP_u16(_ *_Instr) {
+    self.store_int(5, _F_u64toa, "MOVWQZX")
+}
+
+func (self *_Assembler) _asm_OP_u32(_ *_Instr) {
+    self.store_int(16, _F_u64toa, "MOVLQZX")
+}
+
+func (self *_Assembler) _asm_OP_u64(_ *_Instr) {
+    self.store_int(20, _F_u64toa, "MOVQ")
+}
+
+func (self *_Assembler) _asm_OP_f32(_ *_Instr) {
+    self.check_size(32)
+    self.Emit("MOVL"    , jit.Ptr(_SP_p, 0), _AX)       // MOVL     (SP.p), AX
+    self.Emit("ANDL"    , jit.Imm(_FM_exp32), _AX)      // ANDL     $_FM_exp32, AX
+    self.Emit("XORL"    , jit.Imm(_FM_exp32), _AX)      // XORL     $_FM_exp32, AX
+    self.Sjmp("JZ"      , _LB_error_nan_or_infinite)    // JZ       _error_nan_or_infinite
+    self.save_c()                                       // SAVE     $C_regs
+    self.rbuf_di()                                      // MOVQ     RP, DI
+    self.Emit("MOVSS"   , jit.Ptr(_SP_p, 0), _X0)       // MOVSS    (SP.p), X0
+    self.call_c(_F_f32toa)                              // CALL_C   f64toa
+    self.Emit("ADDQ"    , _AX, _RL)                     // ADDQ     AX, RL
+}
+
+func (self *_Assembler) _asm_OP_f64(_ *_Instr) {
+    self.check_size(32)
+    self.Emit("MOVQ"  , jit.Ptr(_SP_p, 0), _AX)     // MOVQ   (SP.p), AX
+    self.Emit("MOVQ"  , jit.Imm(_FM_exp64), _CX)    // MOVQ   $_FM_exp64, CX
+    self.Emit("ANDQ"  , _CX, _AX)                   // ANDQ   CX, AX
+    self.Emit("XORQ"  , _CX, _AX)                   // XORQ   CX, AX
+    self.Sjmp("JZ"    , _LB_error_nan_or_infinite)  // JZ     _error_nan_or_infinite
+    self.save_c()                                   // SAVE   $C_regs
+    self.rbuf_di()                                  // MOVQ   RP, DI
+    self.Emit("MOVSD" , jit.Ptr(_SP_p, 0), _X0)     // MOVSD  (SP.p), X0
+    self.call_c(_F_f64toa)                          // CALL_C f64toa
+    self.Emit("ADDQ"  , _AX, _RL)                   // ADDQ   AX, RL
+}
+
+func (self *_Assembler) _asm_OP_str(_ *_Instr) {
+    self.encode_string(false)
+}
+
+func (self *_Assembler) _asm_OP_bin(_ *_Instr) {
+    self.Emit("MOVQ", jit.Ptr(_SP_p, 8), _AX)           // MOVQ 8(SP.p), AX
+    self.Emit("ADDQ", jit.Imm(2), _AX)                  // ADDQ $2, AX
+    self.Emit("MOVQ", jit.Imm(_IM_mulv), _CX)           // MOVQ $_MF_mulv, CX
+    self.Emit("MOVQ", _DX, _BX)                         // MOVQ DX, BX
+    self.From("MULQ", _CX)                              // MULQ CX
+    self.Emit("LEAQ", jit.Sib(_DX, _DX, 1, 1), _AX)     // LEAQ 1(DX)(DX), AX
+    self.Emit("ORQ" , jit.Imm(2), _AX)                  // ORQ  $2, AX
+    self.Emit("MOVQ", _BX, _DX)                         // MOVQ BX, DX
+    self.check_size_r(_AX, 0)                           // SIZE AX
+    self.add_char('"')                                  // CHAR $'"'
+    self.Emit("MOVQ", _ARG_rb, _DI)                     // MOVQ rb<>+0(FP), DI
+    self.Emit("MOVQ", _RL, jit.Ptr(_DI, 8))             // MOVQ SI, 8(DI)
+    self.Emit("MOVQ", _SP_p, _SI)                       // MOVQ SP.p, SI
+
+    /* check for AVX2 support */
+    if !cpu.HasAVX2 {
+        self.Emit("XORL", _DX, _DX)                     // XORL DX, DX
+    } else {
+        self.Emit("MOVL", jit.Imm(_MODE_AVX2), _DX)     // MOVL $_MODE_AVX2, DX
+    }
+
+    /* call the encoder */
+    self.call_b64(_F_b64encode)   // CALL b64encode
+    self.load_buffer_AX()       // LOAD {buf}
+    self.add_char('"')          // CHAR $'"'
+}
+
+func (self *_Assembler) _asm_OP_quote(_ *_Instr) {
+    self.encode_string(true)
+}
+
+func (self *_Assembler) _asm_OP_number(_ *_Instr) {
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 8), _BX)          // MOVQ    (SP.p), BX
+    self.Emit("TESTQ", _BX, _BX)                        // TESTQ   BX, BX
+    self.Sjmp("JZ"   , "_empty_{n}")
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 0), _AX)          // MOVQ    (SP.p), AX
+    self.Emit("TESTQ", _AX, _AX)                        // TESTQ   AX, AX
+    self.Sjmp("JNZ"   , "_number_next_{n}") 
+    self.Emit("MOVQ", jit.Imm(int64(panicNilPointerOfNonEmptyString)), _AX)
+    self.Sjmp("JMP", _LB_panic)
+    self.Link("_number_next_{n}")
+    self.call_go(_F_isValidNumber)                      // CALL_GO isValidNumber
+    self.Emit("CMPB" , _AX, jit.Imm(0))                 // CMPB    AX, $0
+    self.Sjmp("JE"   , _LB_error_invalid_number)        // JE      _error_invalid_number
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 8), _BX)          // MOVQ    (SP.p), BX
+    self.check_size_r(_BX, 0)                           // SIZE    BX
+    self.Emit("LEAQ" , jit.Sib(_RP, _RL, 1, 0), _AX)    // LEAQ    (RP)(RL), AX
+    self.Emit("ADDQ" , jit.Ptr(_SP_p, 8), _RL)          // ADDQ    8(SP.p), RL
+    self.Emit("MOVQ", jit.Ptr(_SP_p, 0), _BX)           // MOVOU   (SP.p), BX
+    self.Emit("MOVQ", jit.Ptr(_SP_p, 8), _CX)           // MOVOU   X0, 8(SP)
+    self.call_go(_F_memmove)                            // CALL_GO memmove
+    self.Emit("MOVQ", _ARG_rb, _AX)                     // MOVQ rb<>+0(FP), AX
+    self.Emit("MOVQ", _RL, jit.Ptr(_AX, 8))             // MOVQ RL, 8(AX)
+    self.Sjmp("JMP"  , "_done_{n}")                     // JMP     _done_{n}
+    self.Link("_empty_{n}")                             // _empty_{n}
+    self.check_size(1)                                  // SIZE    $1
+    self.add_char('0')                                  // CHAR    $'0'
+    self.Link("_done_{n}")                              // _done_{n}:
+}
+
+func (self *_Assembler) _asm_OP_eface(_ *_Instr) {
+    self.prep_buffer_AX()                       // MOVE  {buf}, AX
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 0), _BX)  // MOVQ  (SP.p), BX
+    self.Emit("LEAQ" , jit.Ptr(_SP_p, 8), _CX)  // LEAQ  8(SP.p), CX
+    self.Emit("MOVQ" , _ST, _DI)                // MOVQ  ST, DI
+    self.Emit("MOVQ" , _ARG_fv, _SI)            // MOVQ  fv, AX
+    self.call_encoder(_F_encodeTypedPointer)            // CALL  encodeTypedPointer
+    self.Emit("TESTQ", _ET, _ET)                // TESTQ ET, ET
+    self.Sjmp("JNZ"  , _LB_error)               // JNZ   _error
+    self.load_buffer_AX()
+}
+
+func (self *_Assembler) _asm_OP_iface(_ *_Instr) {
+    self.prep_buffer_AX()                       // MOVE  {buf}, AX
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 0), _CX)  // MOVQ  (SP.p), CX
+    self.Emit("MOVQ" , jit.Ptr(_CX, 8), _BX)    // MOVQ  8(CX), BX
+    self.Emit("LEAQ" , jit.Ptr(_SP_p, 8), _CX)  // LEAQ  8(SP.p), CX
+    self.Emit("MOVQ" , _ST, _DI)                // MOVQ  ST, DI
+    self.Emit("MOVQ" , _ARG_fv, _SI)            // MOVQ  fv, AX
+    self.call_encoder(_F_encodeTypedPointer)    // CALL  encodeTypedPointer
+    self.Emit("TESTQ", _ET, _ET)                // TESTQ ET, ET
+    self.Sjmp("JNZ"  , _LB_error)               // JNZ   _error
+    self.load_buffer_AX()
+}
+
+func (self *_Assembler) _asm_OP_byte(p *_Instr) {
+    self.check_size(1)
+    self.Emit("MOVB", jit.Imm(p.i64()), jit.Sib(_RP, _RL, 1, 0))    // MOVL p.vi(), (RP)(RL*1)
+    self.Emit("ADDQ", jit.Imm(1), _RL)                              // ADDQ $1, RL
+}
+
+func (self *_Assembler) _asm_OP_text(p *_Instr) {
+    self.check_size(len(p.vs()))    // SIZE ${len(p.vs())}
+    self.add_text(p.vs())           // TEXT ${p.vs()}
+}
+
+func (self *_Assembler) _asm_OP_deref(_ *_Instr) {
+    self.Emit("MOVQ", jit.Ptr(_SP_p, 0), _SP_p)     // MOVQ (SP.p), SP.p
+}
+
+func (self *_Assembler) _asm_OP_index(p *_Instr) {
+    self.Emit("MOVQ", jit.Imm(p.i64()), _AX)    // MOVQ $p.vi(), AX
+    self.Emit("ADDQ", _AX, _SP_p)               // ADDQ AX, SP.p
+}
+
+func (self *_Assembler) _asm_OP_load(_ *_Instr) {
+    self.Emit("MOVQ", jit.Ptr(_ST, 0), _AX)                 // MOVQ (ST), AX
+    self.Emit("MOVQ", jit.Sib(_ST, _AX, 1, -24), _SP_x)     // MOVQ -24(ST)(AX), SP.x
+    self.Emit("MOVQ", jit.Sib(_ST, _AX, 1, -8), _SP_p)      // MOVQ -8(ST)(AX), SP.p
+    self.Emit("MOVQ", jit.Sib(_ST, _AX, 1, 0), _SP_q)       // MOVQ (ST)(AX), SP.q
+}
+
+func (self *_Assembler) _asm_OP_save(_ *_Instr) {
+    self.save_state()
+}
+
+func (self *_Assembler) _asm_OP_drop(_ *_Instr) {
+    self.drop_state(_StateSize)
+}
+
+func (self *_Assembler) _asm_OP_drop_2(_ *_Instr) {
+    self.drop_state(_StateSize * 2)                     // DROP  $(_StateSize * 2)
+    self.Emit("MOVOU", _X0, jit.Sib(_ST, _AX, 1, 56))   // MOVOU X0, 56(ST)(AX)
+}
+
+func (self *_Assembler) _asm_OP_recurse(p *_Instr) {
+    self.prep_buffer_AX()                       // MOVE {buf}, (SP)
+    vt, pv := p.vp()
+    self.Emit("MOVQ", jit.Type(vt), _BX)    // MOVQ $(type(p.vt())), BX
+
+    /* check for indirection */
+    if !rt.UnpackType(vt).Indirect() {
+        self.Emit("MOVQ", _SP_p, _CX)           // MOVQ SP.p, CX
+    } else {
+        self.Emit("MOVQ", _SP_p, _VAR_vp)  // MOVQ SP.p, VAR.vp
+        self.Emit("LEAQ", _VAR_vp, _CX)    // LEAQ VAR.vp, CX
+    }
+
+    /* call the encoder */
+    self.Emit("MOVQ" , _ST, _DI)                // MOVQ  ST, DI
+    self.Emit("MOVQ" , _ARG_fv, _SI)            // MOVQ  $fv, SI
+    if pv {
+        self.Emit("BTCQ", jit.Imm(bitPointerValue), _SI)  // BTCQ $1, SI
+    }
+    self.call_encoder(_F_encodeTypedPointer)    // CALL  encodeTypedPointer
+    self.Emit("TESTQ", _ET, _ET)                // TESTQ ET, ET
+    self.Sjmp("JNZ"  , _LB_error)               // JNZ   _error
+    self.load_buffer_AX()
+}
+
+func (self *_Assembler) _asm_OP_is_nil(p *_Instr) {
+    self.Emit("CMPQ", jit.Ptr(_SP_p, 0), jit.Imm(0))    // CMPQ (SP.p), $0
+    self.Xjmp("JE"  , p.vi())                           // JE   p.vi()
+}
+
+func (self *_Assembler) _asm_OP_is_nil_p1(p *_Instr) {
+    self.Emit("CMPQ", jit.Ptr(_SP_p, 8), jit.Imm(0))    // CMPQ 8(SP.p), $0
+    self.Xjmp("JE"  , p.vi())                           // JE   p.vi()
+}
+
+func (self *_Assembler) _asm_OP_is_zero_1(p *_Instr) {
+    self.Emit("CMPB", jit.Ptr(_SP_p, 0), jit.Imm(0))    // CMPB (SP.p), $0
+    self.Xjmp("JE"  , p.vi())                           // JE   p.vi()
+}
+
+func (self *_Assembler) _asm_OP_is_zero_2(p *_Instr) {
+    self.Emit("CMPW", jit.Ptr(_SP_p, 0), jit.Imm(0))    // CMPW (SP.p), $0
+    self.Xjmp("JE"  , p.vi())                           // JE   p.vi()
+}
+
+func (self *_Assembler) _asm_OP_is_zero_4(p *_Instr) {
+    self.Emit("CMPL", jit.Ptr(_SP_p, 0), jit.Imm(0))    // CMPL (SP.p), $0
+    self.Xjmp("JE"  , p.vi())                           // JE   p.vi()
+}
+
+func (self *_Assembler) _asm_OP_is_zero_8(p *_Instr) {
+    self.Emit("CMPQ", jit.Ptr(_SP_p, 0), jit.Imm(0))    // CMPQ (SP.p), $0
+    self.Xjmp("JE"  , p.vi())                           // JE   p.vi()
+}
+
+func (self *_Assembler) _asm_OP_is_zero_map(p *_Instr) {
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 0), _AX)          // MOVQ  (SP.p), AX
+    self.Emit("TESTQ", _AX, _AX)                        // TESTQ AX, AX
+    self.Xjmp("JZ"   , p.vi())                          // JZ    p.vi()
+    self.Emit("CMPQ" , jit.Ptr(_AX, 0), jit.Imm(0))     // CMPQ  (AX), $0
+    self.Xjmp("JE"   , p.vi())                          // JE    p.vi()
+}
+
+func (self *_Assembler) _asm_OP_goto(p *_Instr) {
+    self.Xjmp("JMP", p.vi())
+}
+
+func (self *_Assembler) _asm_OP_map_iter(p *_Instr) {
+    self.Emit("MOVQ" , jit.Type(p.vt()), _AX)       // MOVQ    $p.vt(), AX
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 0), _BX)      // MOVQ    (SP.p), BX
+    self.Emit("MOVQ" , _ARG_fv, _CX)                // MOVQ    fv, CX
+    self.call_go(_F_iteratorStart)                  // CALL_GO iteratorStart
+    self.Emit("MOVQ" , _AX, _SP_q)                  // MOVQ    AX, SP.q
+    self.Emit("MOVQ" , _BX, _ET)                    // MOVQ    32(SP), ET
+    self.Emit("MOVQ" , _CX, _EP)                    // MOVQ    40(SP), EP
+    self.Emit("TESTQ", _ET, _ET)                    // TESTQ   ET, ET
+    self.Sjmp("JNZ"  , _LB_error)                   // JNZ     _error
+}
+
+func (self *_Assembler) _asm_OP_map_stop(_ *_Instr) {
+    self.Emit("MOVQ", _SP_q, _AX)               // MOVQ    SP.q, AX
+    self.call_go(_F_iteratorStop)               // CALL_GO iteratorStop
+    self.Emit("XORL", _SP_q, _SP_q)             // XORL    SP.q, SP.q
+}
+
+func (self *_Assembler) _asm_OP_map_check_key(p *_Instr) {
+    self.Emit("MOVQ" , jit.Ptr(_SP_q, 0), _SP_p)    // MOVQ    (SP.q), SP.p
+    self.Emit("TESTQ", _SP_p, _SP_p)                // TESTQ   SP.p, SP.p
+    self.Xjmp("JZ"   , p.vi())                      // JNZ     p.vi()
+}
+
+func (self *_Assembler) _asm_OP_map_write_key(p *_Instr) {
+    self.Emit("BTQ", jit.Imm(bitSortMapKeys), _ARG_fv)      // BTQ ${SortMapKeys}, fv
+    self.Sjmp("JNC", "_unordered_key_{n}")                  // JNC _unordered_key_{n}
+    self.encode_string(false)                               // STR $false
+    self.Xjmp("JMP", p.vi())                                // JMP ${p.vi()}
+    self.Link("_unordered_key_{n}")                         // _unordered_key_{n}:
+}
+
+func (self *_Assembler) _asm_OP_map_value_next(_ *_Instr) {
+    self.Emit("MOVQ", jit.Ptr(_SP_q, 8), _SP_p)     // MOVQ    8(SP.q), SP.p
+    self.Emit("MOVQ", _SP_q, _AX)                   // MOVQ    SP.q, AX
+    self.call_go(_F_iteratorNext)                   // CALL_GO iteratorNext
+}
+
+func (self *_Assembler) _asm_OP_slice_len(_ *_Instr) {
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 8), _SP_x)        // MOVQ  8(SP.p), SP.x
+    self.Emit("MOVQ" , jit.Ptr(_SP_p, 0), _SP_p)        // MOVQ  (SP.p), SP.p
+    self.Emit("ORQ"  , jit.Imm(1 << _S_init), _SP_f)    // ORQ   $(1<<_S_init), SP.f
+}
+
+func (self *_Assembler) _asm_OP_slice_next(p *_Instr) {
+    self.Emit("TESTQ"  , _SP_x, _SP_x)                          // TESTQ   SP.x, SP.x
+    self.Xjmp("JZ"     , p.vi())                                // JZ      p.vi()
+    self.Emit("SUBQ"   , jit.Imm(1), _SP_x)                     // SUBQ    $1, SP.x
+    self.Emit("BTRQ"   , jit.Imm(_S_init), _SP_f)               // BTRQ    $_S_init, SP.f
+    self.Emit("LEAQ"   , jit.Ptr(_SP_p, int64(p.vlen())), _AX)  // LEAQ    $(p.vlen())(SP.p), AX
+    self.Emit("CMOVQCC", _AX, _SP_p)                            // CMOVQNC AX, SP.p
+}
+
+func (self *_Assembler) _asm_OP_marshal(p *_Instr) {
+    self.call_marshaler(_F_encodeJsonMarshaler, _T_json_Marshaler, p.vt())
+}
+
+func (self *_Assembler) _asm_OP_marshal_p(p *_Instr) {
+    if p.vk() != reflect.Ptr {
+        panic("marshal_p: invalid type")
+    } else {
+        self.call_marshaler_v(_F_encodeJsonMarshaler, _T_json_Marshaler, p.vt(), false)
+    }
+}
+
+func (self *_Assembler) _asm_OP_marshal_text(p *_Instr) {
+    self.call_marshaler(_F_encodeTextMarshaler, _T_encoding_TextMarshaler, p.vt())
+}
+
+func (self *_Assembler) _asm_OP_marshal_text_p(p *_Instr) {
+    if p.vk() != reflect.Ptr {
+        panic("marshal_text_p: invalid type")
+    } else {
+        self.call_marshaler_v(_F_encodeTextMarshaler, _T_encoding_TextMarshaler, p.vt(), false)
+    }
+}
+
+func (self *_Assembler) _asm_OP_cond_set(_ *_Instr) {
+    self.Emit("ORQ", jit.Imm(1 << _S_cond), _SP_f)  // ORQ $(1<<_S_cond), SP.f
+}
+
+func (self *_Assembler) _asm_OP_cond_testc(p *_Instr) {
+    self.Emit("BTRQ", jit.Imm(_S_cond), _SP_f)      // BTRQ $_S_cond, SP.f
+    self.Xjmp("JC"  , p.vi())
+}
+
+func (self *_Assembler) print_gc(i int, p1 *_Instr, p2 *_Instr) {
+    self.Emit("MOVQ", jit.Imm(int64(p2.op())),  _CX) // MOVQ $(p2.op()), AX
+    self.Emit("MOVQ", jit.Imm(int64(p1.op())),  _BX) // MOVQ $(p1.op()), BX
+    self.Emit("MOVQ", jit.Imm(int64(i)),  _AX)       // MOVQ $(i), CX
+    self.call_go(_F_println)
+}
+
+var (
+    _V_writeBarrier = jit.Imm(int64(uintptr(unsafe.Pointer(&_runtime_writeBarrier))))
+
+    _F_gcWriteBarrierAX = jit.Func(gcWriteBarrierAX)
+)
+
+func (self *_Assembler) WriteRecNotAX(i int, ptr obj.Addr, rec obj.Addr) {
+    if rec.Reg == x86.REG_AX || rec.Index == x86.REG_AX {
+        panic("rec contains AX!")
+    }
+    self.Emit("MOVQ", _V_writeBarrier, _BX)
+    self.Emit("CMPL", jit.Ptr(_BX, 0), jit.Imm(0))
+    self.Sjmp("JE", "_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.xsave(_DI)
+    self.Emit("MOVQ", ptr, _AX)
+    self.Emit("LEAQ", rec, _DI)
+    self.Emit("MOVQ", _F_gcWriteBarrierAX, _BX)  // MOVQ ${fn}, AX
+    self.Rjmp("CALL", _BX)  
+    self.xload(_DI)  
+    self.Sjmp("JMP", "_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Link("_no_writeBarrier" + strconv.Itoa(i) + "_{n}")
+    self.Emit("MOVQ", ptr, rec)
+    self.Link("_end_writeBarrier" + strconv.Itoa(i) + "_{n}")
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/encoder/compiler.go b/vendor/github.com/bytedance/sonic/encoder/compiler.go
new file mode 100644
index 000000000..a949c90f7
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/compiler.go
@@ -0,0 +1,885 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `fmt`
+    `reflect`
+    `strconv`
+    `strings`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/resolver`
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/bytedance/sonic/option`
+)
+
+type _Op uint8
+
+const (
+    _OP_null _Op = iota + 1
+    _OP_empty_arr
+    _OP_empty_obj
+    _OP_bool
+    _OP_i8
+    _OP_i16
+    _OP_i32
+    _OP_i64
+    _OP_u8
+    _OP_u16
+    _OP_u32
+    _OP_u64
+    _OP_f32
+    _OP_f64
+    _OP_str
+    _OP_bin
+    _OP_quote
+    _OP_number
+    _OP_eface
+    _OP_iface
+    _OP_byte
+    _OP_text
+    _OP_deref
+    _OP_index
+    _OP_load
+    _OP_save
+    _OP_drop
+    _OP_drop_2
+    _OP_recurse
+    _OP_is_nil
+    _OP_is_nil_p1
+    _OP_is_zero_1
+    _OP_is_zero_2
+    _OP_is_zero_4
+    _OP_is_zero_8
+    _OP_is_zero_map
+    _OP_goto
+    _OP_map_iter
+    _OP_map_stop
+    _OP_map_check_key
+    _OP_map_write_key
+    _OP_map_value_next
+    _OP_slice_len
+    _OP_slice_next
+    _OP_marshal
+    _OP_marshal_p
+    _OP_marshal_text
+    _OP_marshal_text_p
+    _OP_cond_set
+    _OP_cond_testc
+)
+
+const (
+    _INT_SIZE = 32 << (^uint(0) >> 63)
+    _PTR_SIZE = 32 << (^uintptr(0) >> 63)
+    _PTR_BYTE = unsafe.Sizeof(uintptr(0))
+)
+
+const (
+    _MAX_ILBUF = 100000     // cutoff at 100k of IL instructions
+    _MAX_FIELDS = 50        // cutoff at 50 fields struct
+)
+
+var _OpNames = [256]string {
+    _OP_null           : "null",
+    _OP_empty_arr      : "empty_arr",
+    _OP_empty_obj      : "empty_obj",
+    _OP_bool           : "bool",
+    _OP_i8             : "i8",
+    _OP_i16            : "i16",
+    _OP_i32            : "i32",
+    _OP_i64            : "i64",
+    _OP_u8             : "u8",
+    _OP_u16            : "u16",
+    _OP_u32            : "u32",
+    _OP_u64            : "u64",
+    _OP_f32            : "f32",
+    _OP_f64            : "f64",
+    _OP_str            : "str",
+    _OP_bin            : "bin",
+    _OP_quote          : "quote",
+    _OP_number         : "number",
+    _OP_eface          : "eface",
+    _OP_iface          : "iface",
+    _OP_byte           : "byte",
+    _OP_text           : "text",
+    _OP_deref          : "deref",
+    _OP_index          : "index",
+    _OP_load           : "load",
+    _OP_save           : "save",
+    _OP_drop           : "drop",
+    _OP_drop_2         : "drop_2",
+    _OP_recurse        : "recurse",
+    _OP_is_nil         : "is_nil",
+    _OP_is_nil_p1      : "is_nil_p1",
+    _OP_is_zero_1      : "is_zero_1",
+    _OP_is_zero_2      : "is_zero_2",
+    _OP_is_zero_4      : "is_zero_4",
+    _OP_is_zero_8      : "is_zero_8",
+    _OP_is_zero_map    : "is_zero_map",
+    _OP_goto           : "goto",
+    _OP_map_iter       : "map_iter",
+    _OP_map_stop       : "map_stop",
+    _OP_map_check_key  : "map_check_key",
+    _OP_map_write_key  : "map_write_key",
+    _OP_map_value_next : "map_value_next",
+    _OP_slice_len      : "slice_len",
+    _OP_slice_next     : "slice_next",
+    _OP_marshal        : "marshal",
+    _OP_marshal_p      : "marshal_p",
+    _OP_marshal_text   : "marshal_text",
+    _OP_marshal_text_p : "marshal_text_p",
+    _OP_cond_set       : "cond_set",
+    _OP_cond_testc     : "cond_testc",
+}
+
+func (self _Op) String() string {
+    if ret := _OpNames[self]; ret != "" {
+        return ret
+    } else {
+        return "<invalid>"
+    }
+}
+
+func _OP_int() _Op {
+    switch _INT_SIZE {
+        case 32: return _OP_i32
+        case 64: return _OP_i64
+        default: panic("unsupported int size")
+    }
+}
+
+func _OP_uint() _Op {
+    switch _INT_SIZE {
+        case 32: return _OP_u32
+        case 64: return _OP_u64
+        default: panic("unsupported uint size")
+    }
+}
+
+func _OP_uintptr() _Op {
+    switch _PTR_SIZE {
+        case 32: return _OP_u32
+        case 64: return _OP_u64
+        default: panic("unsupported pointer size")
+    }
+}
+
+func _OP_is_zero_ints() _Op {
+    switch _INT_SIZE {
+        case 32: return _OP_is_zero_4
+        case 64: return _OP_is_zero_8
+        default: panic("unsupported integer size")
+    }
+}
+
+type _Instr struct {
+    u uint64            // union {op: 8, _: 8, vi: 48}, vi maybe int or len(str)
+    p unsafe.Pointer    // maybe GoString.Ptr, or *GoType
+}
+
+func packOp(op _Op) uint64 {
+    return uint64(op) << 56
+}
+
+func newInsOp(op _Op) _Instr {
+    return _Instr{u: packOp(op)}
+}
+
+func newInsVi(op _Op, vi int) _Instr {
+    return _Instr{u: packOp(op) | rt.PackInt(vi)}
+}
+
+func newInsVs(op _Op, vs string) _Instr {
+    return _Instr {
+        u: packOp(op) | rt.PackInt(len(vs)),
+        p: (*rt.GoString)(unsafe.Pointer(&vs)).Ptr,
+    }
+}
+
+func newInsVt(op _Op, vt reflect.Type) _Instr {
+    return _Instr {
+        u: packOp(op),
+        p: unsafe.Pointer(rt.UnpackType(vt)),
+    }
+}
+
+func newInsVp(op _Op, vt reflect.Type, pv bool) _Instr {
+    i := 0
+    if pv {
+        i = 1
+    }
+    return _Instr {
+        u: packOp(op) | rt.PackInt(i),
+        p: unsafe.Pointer(rt.UnpackType(vt)),
+    }
+}
+
+func (self _Instr) op() _Op {
+    return _Op(self.u >> 56)
+}
+
+func (self _Instr) vi() int {
+    return rt.UnpackInt(self.u)
+}
+
+func (self _Instr) vf() uint8 {
+    return (*rt.GoType)(self.p).KindFlags
+}
+
+func (self _Instr) vs() (v string) {
+    (*rt.GoString)(unsafe.Pointer(&v)).Ptr = self.p
+    (*rt.GoString)(unsafe.Pointer(&v)).Len = self.vi()
+    return
+}
+
+func (self _Instr) vk() reflect.Kind {
+    return (*rt.GoType)(self.p).Kind()
+}
+
+func (self _Instr) vt() reflect.Type {
+    return (*rt.GoType)(self.p).Pack()
+}
+
+func (self _Instr) vp() (vt reflect.Type, pv bool) {
+    return (*rt.GoType)(self.p).Pack(), rt.UnpackInt(self.u) == 1
+}
+
+func (self _Instr) i64() int64 {
+    return int64(self.vi())
+}
+
+func (self _Instr) vlen() int {
+    return int((*rt.GoType)(self.p).Size)
+}
+
+func (self _Instr) isBranch() bool {
+    switch self.op() {
+        case _OP_goto          : fallthrough
+        case _OP_is_nil        : fallthrough
+        case _OP_is_nil_p1     : fallthrough
+        case _OP_is_zero_1     : fallthrough
+        case _OP_is_zero_2     : fallthrough
+        case _OP_is_zero_4     : fallthrough
+        case _OP_is_zero_8     : fallthrough
+        case _OP_map_check_key : fallthrough
+        case _OP_map_write_key : fallthrough
+        case _OP_slice_next    : fallthrough
+        case _OP_cond_testc    : return true
+        default                : return false
+    }
+}
+
+func (self _Instr) disassemble() string {
+    switch self.op() {
+        case _OP_byte           : return fmt.Sprintf("%-18s%s", self.op().String(), strconv.QuoteRune(rune(self.vi())))
+        case _OP_text           : return fmt.Sprintf("%-18s%s", self.op().String(), strconv.Quote(self.vs()))
+        case _OP_index          : return fmt.Sprintf("%-18s%d", self.op().String(), self.vi())
+        case _OP_recurse        : fallthrough
+        case _OP_map_iter       : fallthrough
+        case _OP_marshal        : fallthrough
+        case _OP_marshal_p      : fallthrough
+        case _OP_marshal_text   : fallthrough
+        case _OP_marshal_text_p : return fmt.Sprintf("%-18s%s", self.op().String(), self.vt())
+        case _OP_goto           : fallthrough
+        case _OP_is_nil         : fallthrough
+        case _OP_is_nil_p1      : fallthrough
+        case _OP_is_zero_1      : fallthrough
+        case _OP_is_zero_2      : fallthrough
+        case _OP_is_zero_4      : fallthrough
+        case _OP_is_zero_8      : fallthrough
+        case _OP_is_zero_map    : fallthrough
+        case _OP_cond_testc     : fallthrough
+        case _OP_map_check_key  : fallthrough
+        case _OP_map_write_key  : return fmt.Sprintf("%-18sL_%d", self.op().String(), self.vi())
+        case _OP_slice_next     : return fmt.Sprintf("%-18sL_%d, %s", self.op().String(), self.vi(), self.vt())
+        default                 : return self.op().String()
+    }
+}
+
+type (
+	_Program []_Instr
+)
+
+func (self _Program) pc() int {
+    return len(self)
+}
+
+func (self _Program) tag(n int) {
+    if n >= _MaxStack {
+        panic("type nesting too deep")
+    }
+}
+
+func (self _Program) pin(i int) {
+    v := &self[i]
+    v.u &= 0xffff000000000000
+    v.u |= rt.PackInt(self.pc())
+}
+
+func (self _Program) rel(v []int) {
+    for _, i := range v {
+        self.pin(i)
+    }
+}
+
+func (self *_Program) add(op _Op) {
+    *self = append(*self, newInsOp(op))
+}
+
+func (self *_Program) key(op _Op) {
+    *self = append(*self,
+        newInsVi(_OP_byte, '"'),
+        newInsOp(op),
+        newInsVi(_OP_byte, '"'),
+    )
+}
+
+func (self *_Program) int(op _Op, vi int) {
+    *self = append(*self, newInsVi(op, vi))
+}
+
+func (self *_Program) str(op _Op, vs string) {
+    *self = append(*self, newInsVs(op, vs))
+}
+
+func (self *_Program) rtt(op _Op, vt reflect.Type) {
+    *self = append(*self, newInsVt(op, vt))
+}
+
+func (self *_Program) vp(op _Op, vt reflect.Type, pv bool) {
+    *self = append(*self, newInsVp(op, vt, pv))
+}
+
+func (self _Program) disassemble() string {
+    nb  := len(self)
+    tab := make([]bool, nb + 1)
+    ret := make([]string, 0, nb + 1)
+
+    /* prescan to get all the labels */
+    for _, ins := range self {
+        if ins.isBranch() {
+            tab[ins.vi()] = true
+        }
+    }
+
+    /* disassemble each instruction */
+    for i, ins := range self {
+        if !tab[i] {
+            ret = append(ret, "\t" + ins.disassemble())
+        } else {
+            ret = append(ret, fmt.Sprintf("L_%d:\n\t%s", i, ins.disassemble()))
+        }
+    }
+
+    /* add the last label, if needed */
+    if tab[nb] {
+        ret = append(ret, fmt.Sprintf("L_%d:", nb))
+    }
+
+    /* add an "end" indicator, and join all the strings */
+    return strings.Join(append(ret, "\tend"), "\n")
+}
+
+type _Compiler struct {
+    opts option.CompileOptions
+    pv   bool
+    tab  map[reflect.Type]bool
+    rec  map[reflect.Type]uint8
+}
+
+func newCompiler() *_Compiler {
+    return &_Compiler {
+        opts: option.DefaultCompileOptions(),
+        tab: map[reflect.Type]bool{},
+        rec: map[reflect.Type]uint8{},
+    }
+}
+
+func (self *_Compiler) apply(opts option.CompileOptions) *_Compiler {
+    self.opts = opts
+    if self.opts.RecursiveDepth > 0 {
+        self.rec = map[reflect.Type]uint8{}
+    }
+    return self
+}
+
+func (self *_Compiler) rescue(ep *error) {
+    if val := recover(); val != nil {
+        if err, ok := val.(error); ok {
+            *ep = err
+        } else {
+            panic(val)
+        }
+    }
+}
+
+func (self *_Compiler) compile(vt reflect.Type, pv bool) (ret _Program, err error) {
+    defer self.rescue(&err)
+    self.compileOne(&ret, 0, vt, pv)
+    return
+}
+
+func (self *_Compiler) compileOne(p *_Program, sp int, vt reflect.Type, pv bool) {
+    if self.tab[vt] {
+        p.vp(_OP_recurse, vt, pv)
+    } else {
+        self.compileRec(p, sp, vt, pv)
+    }
+}
+
+func (self *_Compiler) compileRec(p *_Program, sp int, vt reflect.Type, pv bool) {
+    pr := self.pv
+    pt := reflect.PtrTo(vt)
+
+    /* check for addressable `json.Marshaler` with pointer receiver */
+    if pv && pt.Implements(jsonMarshalerType) {
+        p.rtt(_OP_marshal_p, pt)
+        return
+    }
+
+    /* check for `json.Marshaler` */
+    if vt.Implements(jsonMarshalerType) {
+        self.compileMarshaler(p, _OP_marshal, vt, jsonMarshalerType)
+        return
+    }
+
+    /* check for addressable `encoding.TextMarshaler` with pointer receiver */
+    if pv && pt.Implements(encodingTextMarshalerType) {
+        p.rtt(_OP_marshal_text_p, pt)
+        return
+    }
+
+    /* check for `encoding.TextMarshaler` */
+    if vt.Implements(encodingTextMarshalerType) {
+        self.compileMarshaler(p, _OP_marshal_text, vt, encodingTextMarshalerType)
+        return
+    }
+
+    /* enter the recursion, and compile the type */
+    self.pv = pv
+    self.tab[vt] = true
+    self.compileOps(p, sp, vt)
+
+    /* exit the recursion */
+    self.pv = pr
+    delete(self.tab, vt)
+}
+
+func (self *_Compiler) compileOps(p *_Program, sp int, vt reflect.Type) {
+    switch vt.Kind() {
+        case reflect.Bool      : p.add(_OP_bool)
+        case reflect.Int       : p.add(_OP_int())
+        case reflect.Int8      : p.add(_OP_i8)
+        case reflect.Int16     : p.add(_OP_i16)
+        case reflect.Int32     : p.add(_OP_i32)
+        case reflect.Int64     : p.add(_OP_i64)
+        case reflect.Uint      : p.add(_OP_uint())
+        case reflect.Uint8     : p.add(_OP_u8)
+        case reflect.Uint16    : p.add(_OP_u16)
+        case reflect.Uint32    : p.add(_OP_u32)
+        case reflect.Uint64    : p.add(_OP_u64)
+        case reflect.Uintptr   : p.add(_OP_uintptr())
+        case reflect.Float32   : p.add(_OP_f32)
+        case reflect.Float64   : p.add(_OP_f64)
+        case reflect.String    : self.compileString    (p, vt)
+        case reflect.Array     : self.compileArray     (p, sp, vt.Elem(), vt.Len())
+        case reflect.Interface : self.compileInterface (p, vt)
+        case reflect.Map       : self.compileMap       (p, sp, vt)
+        case reflect.Ptr       : self.compilePtr       (p, sp, vt.Elem())
+        case reflect.Slice     : self.compileSlice     (p, sp, vt.Elem())
+        case reflect.Struct    : self.compileStruct    (p, sp, vt)
+        default                : panic                 (error_type(vt))
+    }
+}
+
+func (self *_Compiler) compileNil(p *_Program, sp int, vt reflect.Type, nil_op _Op, fn func(*_Program, int, reflect.Type)) {
+    x := p.pc()
+    p.add(_OP_is_nil)
+    fn(p, sp, vt)
+    e := p.pc()
+    p.add(_OP_goto)
+    p.pin(x)
+    p.add(nil_op)
+    p.pin(e)
+}
+
+func (self *_Compiler) compilePtr(p *_Program, sp int, vt reflect.Type) {
+    self.compileNil(p, sp, vt, _OP_null, self.compilePtrBody)
+}
+
+func (self *_Compiler) compilePtrBody(p *_Program, sp int, vt reflect.Type) {
+    p.tag(sp)
+    p.add(_OP_save)
+    p.add(_OP_deref)
+    self.compileOne(p, sp + 1, vt, true)
+    p.add(_OP_drop)
+}
+
+func (self *_Compiler) compileMap(p *_Program, sp int, vt reflect.Type) {
+    self.compileNil(p, sp, vt, _OP_empty_obj, self.compileMapBody)
+}
+
+func (self *_Compiler) compileMapBody(p *_Program, sp int, vt reflect.Type) {
+    p.tag(sp + 1)
+    p.int(_OP_byte, '{')
+    p.add(_OP_save)
+    p.rtt(_OP_map_iter, vt)
+    p.add(_OP_save)
+    i := p.pc()
+    p.add(_OP_map_check_key)
+    u := p.pc()
+    p.add(_OP_map_write_key)
+    self.compileMapBodyKey(p, vt.Key())
+    p.pin(u)
+    p.int(_OP_byte, ':')
+    p.add(_OP_map_value_next)
+    self.compileOne(p, sp + 2, vt.Elem(), false)
+    j := p.pc()
+    p.add(_OP_map_check_key)
+    p.int(_OP_byte, ',')
+    v := p.pc()
+    p.add(_OP_map_write_key)
+    self.compileMapBodyKey(p, vt.Key())
+    p.pin(v)
+    p.int(_OP_byte, ':')
+    p.add(_OP_map_value_next)
+    self.compileOne(p, sp + 2, vt.Elem(), false)
+    p.int(_OP_goto, j)
+    p.pin(i)
+    p.pin(j)
+    p.add(_OP_map_stop)
+    p.add(_OP_drop_2)
+    p.int(_OP_byte, '}')
+}
+
+func (self *_Compiler) compileMapBodyKey(p *_Program, vk reflect.Type) {
+    if !vk.Implements(encodingTextMarshalerType) {
+        self.compileMapBodyTextKey(p, vk)
+    } else {
+        self.compileMapBodyUtextKey(p, vk)
+    }
+}
+
+func (self *_Compiler) compileMapBodyTextKey(p *_Program, vk reflect.Type) {
+    switch vk.Kind() {
+        case reflect.Invalid : panic("map key is nil")
+        case reflect.Bool    : p.key(_OP_bool)
+        case reflect.Int     : p.key(_OP_int())
+        case reflect.Int8    : p.key(_OP_i8)
+        case reflect.Int16   : p.key(_OP_i16)
+        case reflect.Int32   : p.key(_OP_i32)
+        case reflect.Int64   : p.key(_OP_i64)
+        case reflect.Uint    : p.key(_OP_uint())
+        case reflect.Uint8   : p.key(_OP_u8)
+        case reflect.Uint16  : p.key(_OP_u16)
+        case reflect.Uint32  : p.key(_OP_u32)
+        case reflect.Uint64  : p.key(_OP_u64)
+        case reflect.Uintptr : p.key(_OP_uintptr())
+        case reflect.Float32 : p.key(_OP_f32)
+        case reflect.Float64 : p.key(_OP_f64)
+        case reflect.String  : self.compileString(p, vk)
+        default              : panic(error_type(vk))
+    }
+}
+
+func (self *_Compiler) compileMapBodyUtextKey(p *_Program, vk reflect.Type) {
+    if vk.Kind() != reflect.Ptr {
+        p.rtt(_OP_marshal_text, vk)
+    } else {
+        self.compileMapBodyUtextPtr(p, vk)
+    }
+}
+
+func (self *_Compiler) compileMapBodyUtextPtr(p *_Program, vk reflect.Type) {
+    i := p.pc()
+    p.add(_OP_is_nil)
+    p.rtt(_OP_marshal_text, vk)
+    j := p.pc()
+    p.add(_OP_goto)
+    p.pin(i)
+    p.str(_OP_text, "\"\"")
+    p.pin(j)
+}
+
+func (self *_Compiler) compileSlice(p *_Program, sp int, vt reflect.Type) {
+    self.compileNil(p, sp, vt, _OP_empty_arr, self.compileSliceBody)
+}
+
+func (self *_Compiler) compileSliceBody(p *_Program, sp int, vt reflect.Type) {
+    if isSimpleByte(vt) {
+        p.add(_OP_bin)
+    } else {
+        self.compileSliceArray(p, sp, vt)
+    }
+}
+
+func (self *_Compiler) compileSliceArray(p *_Program, sp int, vt reflect.Type) {
+    p.tag(sp)
+    p.int(_OP_byte, '[')
+    p.add(_OP_save)
+    p.add(_OP_slice_len)
+    i := p.pc()
+    p.rtt(_OP_slice_next, vt)
+    self.compileOne(p, sp + 1, vt, true)
+    j := p.pc()
+    p.rtt(_OP_slice_next, vt)
+    p.int(_OP_byte, ',')
+    self.compileOne(p, sp + 1, vt, true)
+    p.int(_OP_goto, j)
+    p.pin(i)
+    p.pin(j)
+    p.add(_OP_drop)
+    p.int(_OP_byte, ']')
+}
+
+func (self *_Compiler) compileArray(p *_Program, sp int, vt reflect.Type, nb int) {
+    p.tag(sp)
+    p.int(_OP_byte, '[')
+    p.add(_OP_save)
+
+    /* first item */
+    if nb != 0 {
+        self.compileOne(p, sp + 1, vt, self.pv)
+        p.add(_OP_load)
+    }
+
+    /* remaining items */
+    for i := 1; i < nb; i++ {
+        p.int(_OP_byte, ',')
+        p.int(_OP_index, i * int(vt.Size()))
+        self.compileOne(p, sp + 1, vt, self.pv)
+        p.add(_OP_load)
+    }
+
+    /* end of array */
+    p.add(_OP_drop)
+    p.int(_OP_byte, ']')
+}
+
+func (self *_Compiler) compileString(p *_Program, vt reflect.Type) {
+    if vt != jsonNumberType {
+        p.add(_OP_str)
+    } else {
+        p.add(_OP_number)
+    }
+}
+
+func (self *_Compiler) compileStruct(p *_Program, sp int, vt reflect.Type) {
+    if sp >= self.opts.MaxInlineDepth || p.pc() >= _MAX_ILBUF || (sp > 0 && vt.NumField() >= _MAX_FIELDS) {
+        p.vp(_OP_recurse, vt, self.pv)
+        if self.opts.RecursiveDepth > 0 {
+            if self.pv {
+                self.rec[vt] = 1
+            } else {
+                self.rec[vt] = 0
+            }
+        }
+    } else {
+        self.compileStructBody(p, sp, vt)
+    }
+}
+
+func (self *_Compiler) compileStructBody(p *_Program, sp int, vt reflect.Type) {
+    p.tag(sp)
+    p.int(_OP_byte, '{')
+    p.add(_OP_save)
+    p.add(_OP_cond_set)
+
+    /* compile each field */
+    for _, fv := range resolver.ResolveStruct(vt) {
+        var s []int
+        var o resolver.Offset
+
+        /* "omitempty" for arrays */
+        if fv.Type.Kind() == reflect.Array {
+            if fv.Type.Len() == 0 && (fv.Opts & resolver.F_omitempty) != 0 {
+                continue
+            }
+        }
+
+        /* index to the field */
+        for _, o = range fv.Path {
+            if p.int(_OP_index, int(o.Size)); o.Kind == resolver.F_deref {
+                s = append(s, p.pc())
+                p.add(_OP_is_nil)
+                p.add(_OP_deref)
+            }
+        }
+
+        /* check for "omitempty" option */
+        if fv.Type.Kind() != reflect.Struct && fv.Type.Kind() != reflect.Array && (fv.Opts & resolver.F_omitempty) != 0 {
+            s = append(s, p.pc())
+            self.compileStructFieldZero(p, fv.Type)
+        }
+
+        /* add the comma if not the first element */
+        i := p.pc()
+        p.add(_OP_cond_testc)
+        p.int(_OP_byte, ',')
+        p.pin(i)
+
+        /* compile the key and value */
+        ft := fv.Type
+        p.str(_OP_text, Quote(fv.Name) + ":")
+
+        /* check for "stringnize" option */
+        if (fv.Opts & resolver.F_stringize) == 0 {
+            self.compileOne(p, sp + 1, ft, self.pv)
+        } else {
+            self.compileStructFieldStr(p, sp + 1, ft)
+        }
+
+        /* patch the skipping jumps and reload the struct pointer */
+        p.rel(s)
+        p.add(_OP_load)
+    }
+
+    /* end of object */
+    p.add(_OP_drop)
+    p.int(_OP_byte, '}')
+}
+
+func (self *_Compiler) compileStructFieldStr(p *_Program, sp int, vt reflect.Type) {
+    pc := -1
+    ft := vt
+    sv := false
+
+    /* dereference the pointer if needed */
+    if ft.Kind() == reflect.Ptr {
+        ft = ft.Elem()
+    }
+
+    /* check if it can be stringized */
+    switch ft.Kind() {
+        case reflect.Bool    : sv = true
+        case reflect.Int     : sv = true
+        case reflect.Int8    : sv = true
+        case reflect.Int16   : sv = true
+        case reflect.Int32   : sv = true
+        case reflect.Int64   : sv = true
+        case reflect.Uint    : sv = true
+        case reflect.Uint8   : sv = true
+        case reflect.Uint16  : sv = true
+        case reflect.Uint32  : sv = true
+        case reflect.Uint64  : sv = true
+        case reflect.Uintptr : sv = true
+        case reflect.Float32 : sv = true
+        case reflect.Float64 : sv = true
+        case reflect.String  : sv = true
+    }
+
+    /* if it's not, ignore the "string" and follow the regular path */
+    if !sv {
+        self.compileOne(p, sp, vt, self.pv)
+        return
+    }
+
+    /* dereference the pointer */
+    if vt.Kind() == reflect.Ptr {
+        pc = p.pc()
+        vt = vt.Elem()
+        p.add(_OP_is_nil)
+        p.add(_OP_deref)
+    }
+
+    /* special case of a double-quoted string */
+    if ft != jsonNumberType && ft.Kind() == reflect.String {
+        p.add(_OP_quote)
+    } else {
+        self.compileStructFieldQuoted(p, sp, vt)
+    }
+
+    /* the "null" case of the pointer */
+    if pc != -1 {
+        e := p.pc()
+        p.add(_OP_goto)
+        p.pin(pc)
+        p.add(_OP_null)
+        p.pin(e)
+    }
+}
+
+func (self *_Compiler) compileStructFieldZero(p *_Program, vt reflect.Type) {
+    switch vt.Kind() {
+        case reflect.Bool      : p.add(_OP_is_zero_1)
+        case reflect.Int       : p.add(_OP_is_zero_ints())
+        case reflect.Int8      : p.add(_OP_is_zero_1)
+        case reflect.Int16     : p.add(_OP_is_zero_2)
+        case reflect.Int32     : p.add(_OP_is_zero_4)
+        case reflect.Int64     : p.add(_OP_is_zero_8)
+        case reflect.Uint      : p.add(_OP_is_zero_ints())
+        case reflect.Uint8     : p.add(_OP_is_zero_1)
+        case reflect.Uint16    : p.add(_OP_is_zero_2)
+        case reflect.Uint32    : p.add(_OP_is_zero_4)
+        case reflect.Uint64    : p.add(_OP_is_zero_8)
+        case reflect.Uintptr   : p.add(_OP_is_nil)
+        case reflect.Float32   : p.add(_OP_is_zero_4)
+        case reflect.Float64   : p.add(_OP_is_zero_8)
+        case reflect.String    : p.add(_OP_is_nil_p1)
+        case reflect.Interface : p.add(_OP_is_nil_p1)
+        case reflect.Map       : p.add(_OP_is_zero_map)
+        case reflect.Ptr       : p.add(_OP_is_nil)
+        case reflect.Slice     : p.add(_OP_is_nil_p1)
+        default                : panic(error_type(vt))
+    }
+}
+
+func (self *_Compiler) compileStructFieldQuoted(p *_Program, sp int, vt reflect.Type) {
+    p.int(_OP_byte, '"')
+    self.compileOne(p, sp, vt, self.pv)
+    p.int(_OP_byte, '"')
+}
+
+func (self *_Compiler) compileInterface(p *_Program, vt reflect.Type) {
+    x := p.pc()
+    p.add(_OP_is_nil_p1)
+
+    /* iface and efaces are different */
+    if vt.NumMethod() == 0 {
+        p.add(_OP_eface)
+    } else {
+        p.add(_OP_iface)
+    }
+
+    /* the "null" value */
+    e := p.pc()
+    p.add(_OP_goto)
+    p.pin(x)
+    p.add(_OP_null)
+    p.pin(e)
+}
+
+func (self *_Compiler) compileMarshaler(p *_Program, op _Op, vt reflect.Type, mt reflect.Type) {
+    pc := p.pc()
+    vk := vt.Kind()
+
+    /* direct receiver */
+    if vk != reflect.Ptr {
+        p.rtt(op, vt)
+        return
+    }
+
+    /* value receiver with a pointer type, check for nil before calling the marshaler */
+    p.add(_OP_is_nil)
+    p.rtt(op, vt)
+    i := p.pc()
+    p.add(_OP_goto)
+    p.pin(pc)
+    p.add(_OP_null)
+    p.pin(i)
+}
diff --git a/vendor/github.com/bytedance/sonic/encoder/debug_go116.go b/vendor/github.com/bytedance/sonic/encoder/debug_go116.go
new file mode 100644
index 000000000..4bc9c15c1
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/debug_go116.go
@@ -0,0 +1,66 @@
+// +build go1.15,!go1.17
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `os`
+    `strings`
+    `runtime`
+    `runtime/debug`
+
+    `github.com/bytedance/sonic/internal/jit`
+)
+
+var (
+    debugSyncGC  = os.Getenv("SONIC_SYNC_GC") != ""
+    debugAsyncGC = os.Getenv("SONIC_NO_ASYNC_GC") == ""
+)
+
+var (
+    _Instr_End _Instr = newInsOp(_OP_null)
+
+    _F_gc       = jit.Func(runtime.GC)
+    _F_force_gc = jit.Func(debug.FreeOSMemory)
+    _F_println  = jit.Func(println_wrapper)
+)
+
+func println_wrapper(i int, op1 int, op2 int){
+    println(i, " Intrs ", op1, _OpNames[op1], "next: ", op2, _OpNames[op2])
+}
+
+func (self *_Assembler) force_gc() {
+    self.call_go(_F_gc)
+    self.call_go(_F_force_gc)
+}
+
+func (self *_Assembler) debug_instr(i int, v *_Instr) {
+    if debugSyncGC {
+        if (i+1 == len(self.p)) {
+            self.print_gc(i, v, &_Instr_End) 
+        } else {
+            next := &(self.p[i+1])
+            self.print_gc(i, v, next)
+            name := _OpNames[next.op()]
+            if strings.Contains(name, "save") {
+                return
+            }
+        }
+        self.force_gc()
+    }
+}
diff --git a/vendor/github.com/bytedance/sonic/encoder/debug_go117.go b/vendor/github.com/bytedance/sonic/encoder/debug_go117.go
new file mode 100644
index 000000000..e1016de32
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/debug_go117.go
@@ -0,0 +1,205 @@
+// +build go1.17,!go1.21
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `fmt`
+    `os`
+    `runtime`
+    `strings`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/twitchyliquid64/golang-asm/obj`
+)
+
+const _FP_debug = 128
+
+var (
+    debugSyncGC  = os.Getenv("SONIC_SYNC_GC") != ""
+    debugAsyncGC = os.Getenv("SONIC_NO_ASYNC_GC") == ""
+    debugCheckPtr = os.Getenv("SONIC_CHECK_POINTER") != ""
+)
+
+var (
+    _Instr_End = newInsOp(_OP_is_nil)
+
+    _F_gc       = jit.Func(gc)
+    _F_println  = jit.Func(println_wrapper)
+    _F_print    = jit.Func(print)
+)
+
+func (self *_Assembler) dsave(r ...obj.Addr) {
+    for i, v := range r {
+        if i > _FP_debug / 8 - 1 {
+            panic("too many registers to save")
+        } else {
+            self.Emit("MOVQ", v, jit.Ptr(_SP, _FP_fargs + _FP_saves + _FP_locals + int64(i) * 8))
+        }
+    }
+}
+
+func (self *_Assembler) dload(r ...obj.Addr) {
+    for i, v := range r {
+        if i > _FP_debug / 8 - 1 {
+            panic("too many registers to load")
+        } else {
+            self.Emit("MOVQ", jit.Ptr(_SP, _FP_fargs + _FP_saves + _FP_locals + int64(i) * 8), v)
+        }
+    }
+}
+
+func println_wrapper(i int, op1 int, op2 int){
+    println(i, " Intrs ", op1, _OpNames[op1], "next: ", op2, _OpNames[op2])
+}
+
+func print(i int){
+    println(i)
+}
+
+func gc() {
+    if !debugSyncGC {
+        return
+    }
+    runtime.GC()
+    // debug.FreeOSMemory()
+}
+
+func (self *_Assembler) dcall(fn obj.Addr) {
+    self.Emit("MOVQ", fn, _R10)  // MOVQ ${fn}, R10
+    self.Rjmp("CALL", _R10)       // CALL R10
+}
+
+func (self *_Assembler) debug_gc() {
+    if !debugSyncGC {
+        return
+    }
+    self.dsave(_REG_debug...)
+    self.dcall(_F_gc)
+    self.dload(_REG_debug...)
+}
+
+func (self *_Assembler) debug_instr(i int, v *_Instr) {
+    if debugSyncGC {
+        if i+1 == len(self.p) {
+            self.print_gc(i, v, &_Instr_End)
+        } else {
+            next := &(self.p[i+1])
+            self.print_gc(i, v, next)
+            name := _OpNames[next.op()]
+            if strings.Contains(name, "save") {
+                return
+            }
+        }
+        // self.debug_gc()
+    }
+}
+
+//go:noescape
+//go:linkname checkptrBase runtime.checkptrBase
+func checkptrBase(p unsafe.Pointer) uintptr
+
+//go:noescape
+//go:linkname findObject runtime.findObject
+func findObject(p, refBase, refOff uintptr) (base uintptr, s unsafe.Pointer, objIndex uintptr)
+
+var (
+    _F_checkptr = jit.Func(checkptr)
+    _F_printptr = jit.Func(printptr)
+)
+
+var (
+    _R10 = jit.Reg("R10")
+)
+var _REG_debug = []obj.Addr {
+    jit.Reg("AX"),
+    jit.Reg("BX"),
+    jit.Reg("CX"),
+    jit.Reg("DX"),
+    jit.Reg("DI"),
+    jit.Reg("SI"),
+    jit.Reg("BP"),
+    jit.Reg("SP"),
+    jit.Reg("R8"),
+    jit.Reg("R9"),
+    jit.Reg("R10"),
+    jit.Reg("R11"),
+    jit.Reg("R12"),
+    jit.Reg("R13"),
+    jit.Reg("R14"),
+    jit.Reg("R15"),
+}
+
+func checkptr(ptr uintptr) {
+    if ptr == 0 {
+        return
+    }
+    fmt.Printf("pointer: %x\n", ptr)
+    f := checkptrBase(unsafe.Pointer(uintptr(ptr)))
+    if f == 0 {
+        fmt.Printf("! unknown-based pointer: %x\n", ptr)
+    } else if f == 1 {
+        fmt.Printf("! stack pointer: %x\n", ptr)
+    } else {
+        fmt.Printf("base: %x\n", f)
+    }
+    findobj(ptr)
+}
+
+func findobj(ptr uintptr) {
+    base, s, objIndex := findObject(ptr, 0, 0)
+    if s != nil && base == 0 {
+        fmt.Printf("! invalid pointer: %x\n", ptr)
+    }
+    fmt.Printf("objIndex: %d\n", objIndex)
+}
+
+func (self *_Assembler) check_ptr(ptr obj.Addr, lea bool) {
+    if !debugCheckPtr {
+        return
+    }
+
+    self.dsave(_REG_debug...)
+    if lea {
+        self.Emit("LEAQ", ptr, _R10)
+    } else {
+        self.Emit("MOVQ", ptr, _R10)
+    }
+    self.Emit("MOVQ", _R10, jit.Ptr(_SP, 0))
+    self.dcall(_F_checkptr)
+    self.dload(_REG_debug...)
+}
+
+func printptr(i int, ptr uintptr) {
+    fmt.Printf("[%d] ptr: %x\n", i, ptr)
+}
+
+func (self *_Assembler) print_ptr(i int, ptr obj.Addr, lea bool) {
+    self.dsave(_REG_debug...)
+    if lea {
+        self.Emit("LEAQ", ptr, _R10)
+    } else {
+        self.Emit("MOVQ", ptr, _R10)
+    }
+
+    self.Emit("MOVQ", jit.Imm(int64(i)), _AX)
+    self.Emit("MOVQ", _R10, _BX)
+    self.dcall(_F_printptr)
+    self.dload(_REG_debug...)
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/encoder/encoder.go b/vendor/github.com/bytedance/sonic/encoder/encoder.go
new file mode 100644
index 000000000..7a1330166
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/encoder.go
@@ -0,0 +1,311 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `bytes`
+    `encoding/json`
+    `reflect`
+    `runtime`
+
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/bytedance/sonic/utf8`
+    `github.com/bytedance/sonic/option`
+)
+
+// Options is a set of encoding options.
+type Options uint64
+
+const (
+    bitSortMapKeys          = iota
+    bitEscapeHTML          
+    bitCompactMarshaler
+    bitNoQuoteTextMarshaler
+    bitNoNullSliceOrMap
+    bitValidateString
+
+    // 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 {
+    var n int
+    var p []byte
+
+    /* check for empty string */
+    if s == "" {
+        return `""`
+    }
+
+    /* allocate space for result */
+    n = len(s) + 2
+    p = make([]byte, 0, n)
+
+    /* call the encoder */
+    _ = encodeString(&p, s)
+    return rt.Mem2Str(p)
+}
+
+// Encode returns the JSON encoding of val, encoded with opts.
+func Encode(val interface{}, opts Options) ([]byte, error) {
+    buf := newBytes()
+    err := EncodeInto(&buf, val, opts)
+
+    /* check for errors */
+    if err != nil {
+        freeBytes(buf)
+        return nil, err
+    }
+
+    if opts & EscapeHTML != 0 || opts & ValidateString != 0  {
+        return buf, nil
+    }
+
+    /* make a copy of the result */
+    ret := make([]byte, len(buf))
+    copy(ret, buf)
+
+    freeBytes(buf)
+    /* return the buffer into pool */
+    return ret, nil
+}
+
+// EncodeInto is like Encode but uses a user-supplied buffer instead of allocating
+// a new one.
+func EncodeInto(buf *[]byte, val interface{}, opts Options) error {
+    stk := newStack()
+    efv := rt.UnpackEface(val)
+    err := encodeTypedPointer(buf, efv.Type, &efv.Value, stk, uint64(opts))
+
+    /* return the stack into pool */
+    if err != nil {
+        resetStack(stk)
+    }
+    freeStack(stk)
+
+    /* 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
+}
+
+var typeByte = rt.UnpackType(reflect.TypeOf(byte(0)))
+
+// HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029
+// characters inside string literals changed to \u003c, \u003e, \u0026, \u2028, \u2029
+// so that the JSON will be safe to embed inside HTML <script> tags.
+// For historical reasons, web browsers don't honor standard HTML
+// escaping within <script> tags, so an alternative JSON encoding must
+// be used.
+func HTMLEscape(dst []byte, src []byte) []byte {
+    return htmlEscape(dst, src)
+}
+
+// EncodeIndented is like Encode but applies Indent to format the output.
+// Each JSON element in the output will begin on a new line beginning with prefix
+// followed by one or more copies of indent according to the indentation nesting.
+func EncodeIndented(val interface{}, prefix string, indent string, opts Options) ([]byte, error) {
+    var err error
+    var out []byte
+    var buf *bytes.Buffer
+
+    /* encode into the buffer */
+    out = newBytes()
+    err = EncodeInto(&out, val, opts)
+
+    /* check for errors */
+    if err != nil {
+        freeBytes(out)
+        return nil, err
+    }
+
+    /* indent the JSON */
+    buf = newBuffer()
+    err = json.Indent(buf, out, prefix, indent)
+
+    /* check for errors */
+    if err != nil {
+        freeBytes(out)
+        freeBuffer(buf)
+        return nil, err
+    }
+
+    /* copy to the result buffer */
+    ret := make([]byte, buf.Len())
+    copy(ret, buf.Bytes())
+
+    /* return the buffers into pool */
+    freeBytes(out)
+    freeBuffer(buf)
+    return ret, nil
+}
+
+// Pretouch compiles vt ahead-of-time to avoid JIT compilation on-the-fly, in
+// order to reduce the first-hit latency.
+//
+// Opts are the compile options, for example, "option.WithCompileRecursiveDepth" is
+// a compile option to set the depth of recursive compile for the nested struct type.
+func Pretouch(vt reflect.Type, opts ...option.CompileOption) error {
+    cfg := option.DefaultCompileOptions()
+    for _, opt := range opts {
+        opt(&cfg)
+        break
+    }
+    return pretouchRec(map[reflect.Type]uint8{vt: 0}, cfg)
+}
+
+// Valid validates json and returns first non-blank character position,
+// if it is only one valid json value.
+// Otherwise returns invalid character position using start.
+//
+// Note: it does not check for the invalid UTF-8 characters.
+func Valid(data []byte) (ok bool, start int) {
+    n := len(data)
+    if n == 0 {
+        return false, -1
+    }
+    s := rt.Mem2Str(data)
+    p := 0
+    m := types.NewStateMachine()
+    ret := native.ValidateOne(&s, &p, m)
+    types.FreeStateMachine(m)
+
+    if ret < 0 {
+        return false, p-1
+    }
+
+    /* check for trailing spaces */
+    for ;p < n; p++ {
+        if (types.SPACE_MASK & (1 << data[p])) == 0 {
+            return false, p
+        }
+    }
+
+    return true, ret
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/encoder/errors.go b/vendor/github.com/bytedance/sonic/encoder/errors.go
new file mode 100644
index 000000000..ac6848a5b
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/errors.go
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `encoding/json`
+    `fmt`
+    `reflect`
+    `strconv`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var _ERR_too_deep = &json.UnsupportedValueError {
+    Str   : "Value nesting too deep",
+    Value : reflect.ValueOf("..."),
+}
+
+var _ERR_nan_or_infinite = &json.UnsupportedValueError {
+    Str   : "NaN or ±Infinite",
+    Value : reflect.ValueOf("NaN or ±Infinite"),
+}
+
+func error_type(vtype reflect.Type) error {
+    return &json.UnsupportedTypeError{Type: vtype}
+}
+
+func error_number(number json.Number) error {
+    return &json.UnsupportedValueError {
+        Str   : "invalid number literal: " + strconv.Quote(string(number)),
+        Value : reflect.ValueOf(number),
+    }
+}
+
+func error_marshaler(ret []byte, pos int) error {
+    return fmt.Errorf("invalid Marshaler output json syntax at %d: %q", pos, ret)
+}
+
+const (
+    panicNilPointerOfNonEmptyString int = 1 + iota
+)
+
+func goPanic(code int, val unsafe.Pointer) {
+    switch(code){
+    case panicNilPointerOfNonEmptyString:
+        panic(fmt.Sprintf("val: %#v has nil pointer while its length is not zero!", (*rt.GoString)(val)))
+    default:
+        panic("encoder error!")
+    }
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/encoder/mapiter.go b/vendor/github.com/bytedance/sonic/encoder/mapiter.go
new file mode 100644
index 000000000..8a322b3af
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/mapiter.go
@@ -0,0 +1,199 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+	"encoding"
+	"reflect"
+	"sync"
+	"unsafe"
+
+	"github.com/bytedance/sonic/internal/native"
+	"github.com/bytedance/sonic/internal/rt"
+)
+
+type _MapPair struct {
+    k string  // when the map key is integer, k is pointed to m
+    v unsafe.Pointer
+    m [32]byte
+}
+
+type _MapIterator struct {
+    it rt.GoMapIterator     // must be the first field
+    kv rt.GoSlice           // slice of _MapPair
+    ki int
+}
+
+var (
+    iteratorPool = sync.Pool{}
+    iteratorPair = rt.UnpackType(reflect.TypeOf(_MapPair{}))
+)
+
+func init() {
+    if unsafe.Offsetof(_MapIterator{}.it) != 0 {
+        panic("_MapIterator.it is not the first field")
+    }
+}
+
+
+func newIterator() *_MapIterator {
+    if v := iteratorPool.Get(); v == nil {
+        return new(_MapIterator)
+    } else {
+        return resetIterator(v.(*_MapIterator))
+    }
+}
+
+func resetIterator(p *_MapIterator) *_MapIterator {
+    p.ki = 0
+    p.it = rt.GoMapIterator{}
+    p.kv.Len = 0
+    return p
+}
+
+func (self *_MapIterator) at(i int) *_MapPair {
+    return (*_MapPair)(unsafe.Pointer(uintptr(self.kv.Ptr) + uintptr(i) * unsafe.Sizeof(_MapPair{})))
+}
+
+func (self *_MapIterator) add() (p *_MapPair) {
+    p = self.at(self.kv.Len)
+    self.kv.Len++
+    return
+}
+
+func (self *_MapIterator) data() (p []_MapPair) {
+    *(*rt.GoSlice)(unsafe.Pointer(&p)) = self.kv
+    return
+}
+
+func (self *_MapIterator) append(t *rt.GoType, k unsafe.Pointer, v unsafe.Pointer) (err error) {
+    p := self.add()
+    p.v = v
+
+    /* check for strings */
+    if tk := t.Kind(); tk != reflect.String {
+        return self.appendGeneric(p, t, tk, k)
+    }
+
+    /* fast path for strings */
+    p.k = *(*string)(k)
+    return nil
+}
+
+func (self *_MapIterator) appendGeneric(p *_MapPair, t *rt.GoType, v reflect.Kind, k unsafe.Pointer) error {
+    switch v {
+        case reflect.Int       : p.k = rt.Mem2Str(p.m[:native.I64toa(&p.m[0], int64(*(*int)(k)))])      ; return nil
+        case reflect.Int8      : p.k = rt.Mem2Str(p.m[:native.I64toa(&p.m[0], int64(*(*int8)(k)))])     ; return nil
+        case reflect.Int16     : p.k = rt.Mem2Str(p.m[:native.I64toa(&p.m[0], int64(*(*int16)(k)))])    ; return nil
+        case reflect.Int32     : p.k = rt.Mem2Str(p.m[:native.I64toa(&p.m[0], int64(*(*int32)(k)))])    ; return nil
+        case reflect.Int64     : p.k = rt.Mem2Str(p.m[:native.I64toa(&p.m[0], *(*int64)(k))])           ; return nil
+        case reflect.Uint      : p.k = rt.Mem2Str(p.m[:native.U64toa(&p.m[0], uint64(*(*uint)(k)))])    ; return nil
+        case reflect.Uint8     : p.k = rt.Mem2Str(p.m[:native.U64toa(&p.m[0], uint64(*(*uint8)(k)))])   ; return nil
+        case reflect.Uint16    : p.k = rt.Mem2Str(p.m[:native.U64toa(&p.m[0], uint64(*(*uint16)(k)))])  ; return nil
+        case reflect.Uint32    : p.k = rt.Mem2Str(p.m[:native.U64toa(&p.m[0], uint64(*(*uint32)(k)))])  ; return nil
+        case reflect.Uint64    : p.k = rt.Mem2Str(p.m[:native.U64toa(&p.m[0], *(*uint64)(k))])          ; return nil
+        case reflect.Uintptr   : p.k = rt.Mem2Str(p.m[:native.U64toa(&p.m[0], uint64(*(*uintptr)(k)))]) ; return nil
+        case reflect.Interface : return self.appendInterface(p, t, k)
+        case reflect.Struct, reflect.Ptr : return self.appendConcrete(p, t, k)
+        default                : panic("unexpected map key type")
+    }
+}
+
+func (self *_MapIterator) appendConcrete(p *_MapPair, t *rt.GoType, k unsafe.Pointer) (err error) {
+    // compiler has already checked that the type implements the encoding.MarshalText interface
+    if !t.Indirect() {
+        k = *(*unsafe.Pointer)(k)
+    }
+    eface := rt.GoEface{Value: k, Type: t}.Pack()
+    out, err := eface.(encoding.TextMarshaler).MarshalText()
+    if err != nil {
+        return err
+    }
+    p.k = rt.Mem2Str(out)
+    return
+}
+
+func (self *_MapIterator) appendInterface(p *_MapPair, t *rt.GoType, k unsafe.Pointer) (err error) {
+    if len(rt.IfaceType(t).Methods) == 0 {
+        panic("unexpected map key type")
+    } else if p.k, err = asText(k); err == nil {
+        return nil
+    } else {
+        return
+    }
+}
+
+func iteratorStop(p *_MapIterator) {
+    iteratorPool.Put(p)
+}
+
+func iteratorNext(p *_MapIterator) {
+    i := p.ki
+    t := &p.it
+
+    /* check for unordered iteration */
+    if i < 0 {
+        mapiternext(t)
+        return
+    }
+
+    /* check for end of iteration */
+    if p.ki >= p.kv.Len {
+        t.K = nil
+        t.V = nil
+        return
+    }
+
+    /* update the key-value pair, and increase the pointer */
+    t.K = unsafe.Pointer(&p.at(p.ki).k)
+    t.V = p.at(p.ki).v
+    p.ki++
+}
+
+func iteratorStart(t *rt.GoMapType, m *rt.GoMap, fv uint64) (*_MapIterator, error) {
+    it := newIterator()
+    mapiterinit(t, m, &it.it)
+
+    /* check for key-sorting, empty map don't need sorting */
+    if m.Count == 0 || (fv & uint64(SortMapKeys)) == 0 {
+        it.ki = -1
+        return it, nil
+    }
+
+    /* pre-allocate space if needed */
+    if m.Count > it.kv.Cap {
+        it.kv = growslice(iteratorPair, it.kv, m.Count)
+    }
+
+    /* dump all the key-value pairs */
+    for ; it.it.K != nil; mapiternext(&it.it) {
+        if err := it.append(t.Key, it.it.K, it.it.V); err != nil {
+            iteratorStop(it)
+            return nil, err
+        }
+    }
+
+    /* sort the keys, map with only 1 item don't need sorting */
+    if it.ki = 1; m.Count > 1 {
+        radixQsort(it.data(), 0, maxDepth(it.kv.Len))
+    }
+
+    /* load the first pair into iterator */
+    it.it.V = it.at(0).v
+    it.it.K = unsafe.Pointer(&it.at(0).k)
+    return it, nil
+}
diff --git a/vendor/github.com/bytedance/sonic/encoder/pools.go b/vendor/github.com/bytedance/sonic/encoder/pools.go
new file mode 100644
index 000000000..600605d7c
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/pools.go
@@ -0,0 +1,194 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `bytes`
+    `sync`
+    `unsafe`
+    `errors`
+    `reflect`
+
+    `github.com/bytedance/sonic/internal/caching`
+    `github.com/bytedance/sonic/option`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+const (
+    _MaxStack  = 4096      // 4k states
+    _MaxBuffer = 1048576    // 1MB buffer size
+
+    _StackSize = unsafe.Sizeof(_Stack{})
+)
+
+var (
+    bytesPool    = sync.Pool{}
+    stackPool    = sync.Pool{}
+    bufferPool   = sync.Pool{}
+    programCache = caching.CreateProgramCache()
+)
+
+type _State struct {
+    x int
+    f uint64
+    p unsafe.Pointer
+    q unsafe.Pointer
+}
+
+type _Stack struct {
+    sp uint64
+    sb [_MaxStack]_State
+}
+
+type _Encoder func(
+    rb *[]byte,
+    vp unsafe.Pointer,
+    sb *_Stack,
+    fv uint64,
+) error
+
+var _KeepAlive struct {
+    rb *[]byte
+    vp unsafe.Pointer
+    sb *_Stack
+    fv uint64
+    err error
+    frame [_FP_offs]byte
+}
+
+var errCallShadow = errors.New("DON'T CALL THIS!")
+
+// Faker func of _Encoder, used to export its stackmap as _Encoder's
+func _Encoder_Shadow(rb *[]byte, vp unsafe.Pointer, sb *_Stack, fv uint64) (err error) {
+    // align to assembler_amd64.go: _FP_offs
+    var frame [_FP_offs]byte
+
+    // must keep all args and frames noticeable to GC
+    _KeepAlive.rb = rb
+    _KeepAlive.vp = vp
+    _KeepAlive.sb = sb
+    _KeepAlive.fv = fv
+    _KeepAlive.err = err
+    _KeepAlive.frame = frame
+
+    return errCallShadow
+}
+
+func newBytes() []byte {
+    if ret := bytesPool.Get(); ret != nil {
+        return ret.([]byte)
+    } else {
+        return make([]byte, 0, _MaxBuffer)
+    }
+}
+
+func newStack() *_Stack {
+    if ret := stackPool.Get(); ret == nil {
+        return new(_Stack)
+    } else {
+        return ret.(*_Stack)
+    }
+}
+
+func resetStack(p *_Stack) {
+    memclrNoHeapPointers(unsafe.Pointer(p), _StackSize)
+}
+
+func newBuffer() *bytes.Buffer {
+    if ret := bufferPool.Get(); ret != nil {
+        return ret.(*bytes.Buffer)
+    } else {
+        return bytes.NewBuffer(make([]byte, 0, _MaxBuffer))
+    }
+}
+
+func freeBytes(p []byte) {
+    p = p[:0]
+    bytesPool.Put(p)
+}
+
+func freeStack(p *_Stack) {
+    p.sp = 0
+    stackPool.Put(p)
+}
+
+func freeBuffer(p *bytes.Buffer) {
+    p.Reset()
+    bufferPool.Put(p)
+}
+
+func makeEncoder(vt *rt.GoType, ex ...interface{}) (interface{}, error) {
+    if pp, err := newCompiler().compile(vt.Pack(), ex[0].(bool)); err != nil {
+        return nil, err
+    } else {
+        as := newAssembler(pp)
+        as.name = vt.String()
+        return as.Load(), nil
+    }
+}
+
+func findOrCompile(vt *rt.GoType, pv bool) (_Encoder, error) {
+    if val := programCache.Get(vt); val != nil {
+        return val.(_Encoder), nil
+    } else if ret, err := programCache.Compute(vt, makeEncoder, pv); err == nil {
+        return ret.(_Encoder), nil
+    } else {
+        return nil, err
+    }
+}
+
+func pretouchType(_vt reflect.Type, opts option.CompileOptions, v uint8) (map[reflect.Type]uint8, error) {
+    /* compile function */
+    compiler := newCompiler().apply(opts)
+    encoder := func(vt *rt.GoType, ex ...interface{}) (interface{}, error) {
+        if pp, err := compiler.compile(_vt, ex[0].(bool)); err != nil {
+            return nil, err
+        } else {
+            as := newAssembler(pp)
+            as.name = vt.String()
+            return as.Load(), nil
+        }
+    }
+
+    /* find or compile */
+    vt := rt.UnpackType(_vt)
+    if val := programCache.Get(vt); val != nil {
+        return nil, nil
+    } else if _, err := programCache.Compute(vt, encoder, v == 1); err == nil {
+        return compiler.rec, nil
+    } else {
+        return nil, err
+    }
+}
+
+func pretouchRec(vtm map[reflect.Type]uint8, opts option.CompileOptions) error {
+    if opts.RecursiveDepth < 0 || len(vtm) == 0 {
+        return nil
+    }
+    next := make(map[reflect.Type]uint8)
+    for vt, v := range vtm {
+        sub, err := pretouchType(vt, opts, v)
+        if err != nil {
+            return err
+        }
+        for svt, v := range sub {
+            next[svt] = v
+        }
+    }
+    opts.RecursiveDepth -= 1
+    return pretouchRec(next, opts)
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/encoder/primitives.go b/vendor/github.com/bytedance/sonic/encoder/primitives.go
new file mode 100644
index 000000000..78fb29ff6
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/primitives.go
@@ -0,0 +1,168 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `encoding`
+    `encoding/json`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/jit`
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+/** Encoder Primitives **/
+
+func encodeNil(rb *[]byte) error {
+    *rb = append(*rb, 'n', 'u', 'l', 'l')
+    return nil
+}
+
+func encodeString(buf *[]byte, val string) error {
+    var sidx int
+    var pbuf *rt.GoSlice
+    var pstr *rt.GoString
+
+    /* opening quote */
+    *buf = append(*buf, '"')
+    pbuf = (*rt.GoSlice)(unsafe.Pointer(buf))
+    pstr = (*rt.GoString)(unsafe.Pointer(&val))
+
+    /* encode with native library */
+    for sidx < pstr.Len {
+        sn := pstr.Len - sidx
+        dn := pbuf.Cap - pbuf.Len
+        sp := padd(pstr.Ptr, sidx)
+        dp := padd(pbuf.Ptr, pbuf.Len)
+        nb := native.Quote(sp, sn, dp, &dn, 0)
+
+        /* check for errors */
+        if pbuf.Len += dn; nb >= 0 {
+            break
+        }
+
+        /* not enough space, grow the slice and try again */
+        sidx += ^nb
+        *pbuf = growslice(rt.UnpackType(byteType), *pbuf, pbuf.Cap * 2)
+    }
+
+    /* closing quote */
+    *buf = append(*buf, '"')
+    return nil
+}
+
+func encodeTypedPointer(buf *[]byte, vt *rt.GoType, vp *unsafe.Pointer, sb *_Stack, fv uint64) error {
+    if vt == nil {
+        return encodeNil(buf)
+    } else if fn, err := findOrCompile(vt, (fv&(1<<bitPointerValue)) != 0); err != nil {
+        return err
+    } else if vt.Indirect() {
+        rt.MoreStack(_FP_size + native.MaxFrameSize)
+        rt.StopProf()
+        err := fn(buf, *vp, sb, fv)
+        rt.StartProf()
+        return err
+    } else {
+        rt.MoreStack(_FP_size + native.MaxFrameSize)
+        rt.StopProf()
+        err := fn(buf, unsafe.Pointer(vp), sb, fv)
+        rt.StartProf()
+        return err
+    }
+}
+
+func encodeJsonMarshaler(buf *[]byte, val json.Marshaler, opt Options) error {
+    if ret, err := val.MarshalJSON(); err != nil {
+        return err
+    } else {
+        if opt & CompactMarshaler != 0 {
+            return compact(buf, ret)
+        }
+        if ok, s := Valid(ret); !ok {
+            return error_marshaler(ret, s)
+        }
+        *buf = append(*buf, ret...)
+        return nil
+    }
+}
+
+func encodeTextMarshaler(buf *[]byte, val encoding.TextMarshaler, opt Options) error {
+    if ret, err := val.MarshalText(); err != nil {
+        return err
+    } else {
+        if opt & NoQuoteTextMarshaler != 0 {
+            *buf = append(*buf, ret...)
+            return nil
+        }
+        return encodeString(buf, rt.Mem2Str(ret) )
+    }
+}
+
+func htmlEscape(dst []byte, src []byte) []byte {
+    var sidx int
+
+    dst  = append(dst, src[:0]...) // avoid check nil dst
+    sbuf := (*rt.GoSlice)(unsafe.Pointer(&src))
+    dbuf := (*rt.GoSlice)(unsafe.Pointer(&dst))
+
+    /* grow dst if it is shorter */
+    if cap(dst) - len(dst) < len(src) + native.BufPaddingSize {
+        cap :=  len(src) * 3 / 2 + native.BufPaddingSize
+        *dbuf = growslice(typeByte, *dbuf, cap)
+    }
+
+    for sidx < sbuf.Len {
+        sp := padd(sbuf.Ptr, sidx)
+        dp := padd(dbuf.Ptr, dbuf.Len)
+
+        sn := sbuf.Len - sidx
+        dn := dbuf.Cap - dbuf.Len
+        nb := native.HTMLEscape(sp, sn, dp, &dn)
+
+        /* check for errors */
+        if dbuf.Len += dn; nb >= 0 {
+            break
+        }
+
+        /* not enough space, grow the slice and try again */
+        sidx += ^nb
+        *dbuf = growslice(typeByte, *dbuf, dbuf.Cap * 2)
+    }
+    return dst
+}
+
+var (
+    argPtrs   = []bool { true, true, true, false }
+    localPtrs = []bool{}
+)
+
+var (
+    _F_assertI2I = jit.Func(assertI2I)
+)
+
+func asText(v unsafe.Pointer) (string, error) {
+    text := assertI2I(_T_encoding_TextMarshaler, *(*rt.GoIface)(v))
+    r, e := (*(*encoding.TextMarshaler)(unsafe.Pointer(&text))).MarshalText()
+    return rt.Mem2Str(r), e
+}
+
+func asJson(v unsafe.Pointer) (string, error) {
+    text := assertI2I(_T_json_Marshaler, *(*rt.GoIface)(v))
+    r, e := (*(*json.Marshaler)(unsafe.Pointer(&text))).MarshalJSON()
+    return rt.Mem2Str(r), e
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/encoder/sort.go b/vendor/github.com/bytedance/sonic/encoder/sort.go
new file mode 100644
index 000000000..b1a67598b
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/sort.go
@@ -0,0 +1,206 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+// Algorithm 3-way Radix Quicksort, d means the radix.
+// Reference: https://algs4.cs.princeton.edu/51radix/Quick3string.java.html
+func radixQsort(kvs []_MapPair, d, maxDepth int) {
+    for len(kvs) > 11 {
+        // To avoid the worst case of quickSort (time: O(n^2)), use introsort here.
+        // Reference: https://en.wikipedia.org/wiki/Introsort and
+        // https://github.com/golang/go/issues/467
+        if maxDepth == 0 {
+            heapSort(kvs, 0, len(kvs))
+            return
+        }
+        maxDepth--
+
+        p := pivot(kvs, d)
+        lt, i, gt := 0, 0, len(kvs)
+        for i < gt {
+            c := byteAt(kvs[i].k, d)
+            if c < p {
+                swap(kvs, lt, i)
+                i++
+                lt++
+            } else if c > p {
+                gt--
+                swap(kvs, i, gt)
+            } else {
+                i++
+            }
+        }
+
+        // kvs[0:lt] < v = kvs[lt:gt] < kvs[gt:len(kvs)]
+        // Native implemention:
+        //     radixQsort(kvs[:lt], d, maxDepth)
+        //     if p > -1 {
+        //         radixQsort(kvs[lt:gt], d+1, maxDepth)
+        //     }
+        //     radixQsort(kvs[gt:], d, maxDepth)
+        // Optimize as follows: make recursive calls only for the smaller parts.
+        // Reference: https://www.geeksforgeeks.org/quicksort-tail-call-optimization-reducing-worst-case-space-log-n/
+        if p == -1 {
+            if lt > len(kvs) - gt {
+                radixQsort(kvs[gt:], d, maxDepth)
+                kvs = kvs[:lt]
+            } else {
+                radixQsort(kvs[:lt], d, maxDepth)
+                kvs = kvs[gt:]
+            }
+        } else {
+            ml := maxThree(lt, gt-lt, len(kvs)-gt)
+            if ml == lt {
+                radixQsort(kvs[lt:gt], d+1, maxDepth)
+                radixQsort(kvs[gt:], d, maxDepth)
+                kvs = kvs[:lt]
+            } else if ml == gt-lt {
+                radixQsort(kvs[:lt], d, maxDepth)
+                radixQsort(kvs[gt:], d, maxDepth)
+                kvs = kvs[lt:gt]
+                d += 1
+            } else {
+                radixQsort(kvs[:lt], d, maxDepth)
+                radixQsort(kvs[lt:gt], d+1, maxDepth)
+                kvs = kvs[gt:] 
+            }
+        }
+    }
+    insertRadixSort(kvs, d)
+}
+
+func insertRadixSort(kvs []_MapPair, d int) {
+    for i := 1; i < len(kvs); i++ {
+        for j := i; j > 0 && lessFrom(kvs[j].k, kvs[j-1].k, d); j-- {
+            swap(kvs, j, j-1)
+        }
+    }
+}
+
+func pivot(kvs []_MapPair, d int) int {
+    m := len(kvs) >> 1
+    if len(kvs) > 40 {
+        // Tukey's ``Ninther,'' median of three mediankvs of three.
+        t := len(kvs) / 8
+        return medianThree(
+            medianThree(byteAt(kvs[0].k, d), byteAt(kvs[t].k, d), byteAt(kvs[2*t].k, d)),
+            medianThree(byteAt(kvs[m].k, d), byteAt(kvs[m-t].k, d), byteAt(kvs[m+t].k, d)),
+            medianThree(byteAt(kvs[len(kvs)-1].k, d),
+                byteAt(kvs[len(kvs)-1-t].k, d),
+                byteAt(kvs[len(kvs)-1-2*t].k, d)))
+    }
+    return medianThree(byteAt(kvs[0].k, d), byteAt(kvs[m].k, d), byteAt(kvs[len(kvs)-1].k, d))
+}
+
+func medianThree(i, j, k int) int {
+    if i > j {
+        i, j = j, i
+    } // i < j
+    if k < i {
+        return i
+    }
+    if k > j {
+        return j
+    }
+    return k
+}
+
+func maxThree(i, j, k int) int {
+    max := i
+    if max < j {
+        max = j
+    }
+    if max < k {
+        max = k
+    }
+    return max
+}
+
+// maxDepth returns a threshold at which quicksort should switch
+// to heapsort. It returnkvs 2*ceil(lg(n+1)).
+func maxDepth(n int) int {
+    var depth int
+    for i := n; i > 0; i >>= 1 {
+        depth++
+    }
+    return depth * 2
+}
+
+// siftDown implements the heap property on kvs[lo:hi].
+// first is an offset into the array where the root of the heap lies.
+func siftDown(kvs []_MapPair, lo, hi, first int) {
+    root := lo
+    for {
+        child := 2*root + 1
+        if child >= hi {
+            break
+        }
+        if child+1 < hi && kvs[first+child].k < kvs[first+child+1].k {
+            child++
+        }
+        if kvs[first+root].k >= kvs[first+child].k {
+            return
+        }
+        swap(kvs, first+root, first+child)
+        root = child
+    }
+}
+
+func heapSort(kvs []_MapPair, a, b int) {
+    first := a
+    lo := 0
+    hi := b - a
+
+    // Build heap with the greatest element at top.
+    for i := (hi - 1) / 2; i >= 0; i-- {
+        siftDown(kvs, i, hi, first)
+    }
+
+    // Pop elements, the largest first, into end of kvs.
+    for i := hi - 1; i >= 0; i-- {
+        swap(kvs, first, first+i)
+        siftDown(kvs, lo, i, first)
+    }
+}
+
+// Note that _MapPair.k is NOT pointed to _MapPair.m when map key is integer after swap
+func swap(kvs []_MapPair, a, b int) {
+    kvs[a].k, kvs[b].k = kvs[b].k, kvs[a].k
+    kvs[a].v, kvs[b].v = kvs[b].v, kvs[a].v
+}
+
+// Compare two strings from the pos d.
+func lessFrom(a, b string, d int) bool {
+    l := len(a)
+    if l > len(b) {
+        l = len(b)
+    }
+    for i := d; i < l; i++ {
+        if a[i] == b[i] {
+            continue
+        }
+        return a[i] < b[i]
+    }
+    return len(a) < len(b)
+}
+
+func byteAt(b string, p int) int {
+    if p < len(b) {
+        return int(b[p])
+    }
+    return -1
+}
diff --git a/vendor/github.com/bytedance/sonic/encoder/stream.go b/vendor/github.com/bytedance/sonic/encoder/stream.go
new file mode 100644
index 000000000..205232c71
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/stream.go
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `encoding/json`
+    `io`
+)
+
+// StreamEncoder uses io.Writer as 
+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) {
+    out := newBytes()
+
+    /* encode into the buffer */
+    err = EncodeInto(&out, val, enc.Opts)
+    if err != nil {
+        goto free_bytes
+    }
+
+    if enc.indent != "" || enc.prefix != "" {
+        /* indent the JSON */
+        buf := newBuffer()
+        err = json.Indent(buf, out, enc.prefix, enc.indent)
+        if err != nil {
+            freeBuffer(buf)
+            goto free_bytes
+        }
+
+        // according to standard library, terminate each value with a newline...
+        buf.WriteByte('\n')
+
+        /* copy into io.Writer */
+        _, err = io.Copy(enc.w, buf)
+        if err != nil {
+            freeBuffer(buf)
+            goto free_bytes
+        }
+
+    } else {
+        /* copy into io.Writer */
+        var n int
+        for len(out) > 0 {
+            n, err = enc.w.Write(out)
+            out = out[n:]
+            if err != nil {
+                goto free_bytes
+            }
+        }
+
+        // according to standard library, terminate each value with a newline...
+        enc.w.Write([]byte{'\n'})
+    }
+
+free_bytes:
+    freeBytes(out)
+    return err
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/encoder/stubs_go116.go b/vendor/github.com/bytedance/sonic/encoder/stubs_go116.go
new file mode 100644
index 000000000..40d06f4af
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/stubs_go116.go
@@ -0,0 +1,65 @@
+// +build go1.15,!go1.17
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `unsafe`
+
+    _ `github.com/chenzhuoyu/base64x`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+//go:linkname _subr__b64encode github.com/chenzhuoyu/base64x._subr__b64encode
+var _subr__b64encode uintptr
+
+//go:noescape
+//go:linkname memmove runtime.memmove
+//goland:noinspection GoUnusedParameter
+func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
+
+//go:linkname growslice runtime.growslice
+//goland:noinspection GoUnusedParameter
+func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
+
+//go:linkname assertI2I runtime.assertI2I
+//goland:noinspection GoUnusedParameter
+func assertI2I(inter *rt.GoType, i rt.GoIface) rt.GoIface
+
+//go:linkname mapiternext runtime.mapiternext
+//goland:noinspection GoUnusedParameter
+func mapiternext(it *rt.GoMapIterator)
+
+//go:linkname mapiterinit runtime.mapiterinit
+//goland:noinspection GoUnusedParameter
+func mapiterinit(t *rt.GoMapType, m *rt.GoMap, it *rt.GoMapIterator)
+
+//go:linkname isValidNumber encoding/json.isValidNumber
+//goland:noinspection GoUnusedParameter
+func isValidNumber(s string) bool
+
+//go:noescape
+//go:linkname memclrNoHeapPointers runtime.memclrNoHeapPointers
+//goland:noinspection GoUnusedParameter
+func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
+
+var _runtime_writeBarrier uintptr = rt.GcwbAddr()
+
+//go:linkname gcWriteBarrierAX runtime.gcWriteBarrier
+func gcWriteBarrierAX()
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/encoder/stubs_go117.go b/vendor/github.com/bytedance/sonic/encoder/stubs_go117.go
new file mode 100644
index 000000000..6c8c6ec75
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/stubs_go117.go
@@ -0,0 +1,66 @@
+// +build go1.17,!go1.20
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `unsafe`
+
+    _ `github.com/chenzhuoyu/base64x`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+//go:linkname _subr__b64encode github.com/chenzhuoyu/base64x._subr__b64encode
+var _subr__b64encode uintptr
+
+//go:noescape
+//go:linkname memmove runtime.memmove
+//goland:noinspection GoUnusedParameter
+func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
+
+//go:linkname growslice runtime.growslice
+//goland:noinspection GoUnusedParameter
+func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
+
+//go:linkname assertI2I runtime.assertI2I2
+//goland:noinspection GoUnusedParameter
+func assertI2I(inter *rt.GoType, i rt.GoIface) rt.GoIface
+
+//go:linkname mapiternext runtime.mapiternext
+//goland:noinspection GoUnusedParameter
+func mapiternext(it *rt.GoMapIterator)
+
+//go:linkname mapiterinit runtime.mapiterinit
+//goland:noinspection GoUnusedParameter
+func mapiterinit(t *rt.GoMapType, m *rt.GoMap, it *rt.GoMapIterator)
+
+//go:linkname isValidNumber encoding/json.isValidNumber
+//goland:noinspection GoUnusedParameter
+func isValidNumber(s string) bool
+
+//go:noescape
+//go:linkname memclrNoHeapPointers runtime.memclrNoHeapPointers
+//goland:noinspection GoUnusedParameter
+func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
+
+//go:linkname _runtime_writeBarrier runtime.writeBarrier
+var _runtime_writeBarrier uintptr
+
+//go:linkname gcWriteBarrierAX runtime.gcWriteBarrier
+func gcWriteBarrierAX()
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/encoder/stubs_go120.go b/vendor/github.com/bytedance/sonic/encoder/stubs_go120.go
new file mode 100644
index 000000000..f1a7d10c7
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/stubs_go120.go
@@ -0,0 +1,66 @@
+// +build go1.20
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `unsafe`
+
+    _ `github.com/chenzhuoyu/base64x`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+//go:linkname _subr__b64encode github.com/chenzhuoyu/base64x._subr__b64encode
+var _subr__b64encode uintptr
+
+//go:noescape
+//go:linkname memmove runtime.memmove
+//goland:noinspection GoUnusedParameter
+func memmove(to unsafe.Pointer, from unsafe.Pointer, n uintptr)
+
+//go:linkname growslice reflect.growslice
+//goland:noinspection GoUnusedParameter
+func growslice(et *rt.GoType, old rt.GoSlice, cap int) rt.GoSlice
+
+//go:linkname assertI2I runtime.assertI2I2
+//goland:noinspection GoUnusedParameter
+func assertI2I(inter *rt.GoType, i rt.GoIface) rt.GoIface
+
+//go:linkname mapiternext runtime.mapiternext
+//goland:noinspection GoUnusedParameter
+func mapiternext(it *rt.GoMapIterator)
+
+//go:linkname mapiterinit runtime.mapiterinit
+//goland:noinspection GoUnusedParameter
+func mapiterinit(t *rt.GoMapType, m *rt.GoMap, it *rt.GoMapIterator)
+
+//go:linkname isValidNumber encoding/json.isValidNumber
+//goland:noinspection GoUnusedParameter
+func isValidNumber(s string) bool
+
+//go:noescape
+//go:linkname memclrNoHeapPointers runtime.memclrNoHeapPointers
+//goland:noinspection GoUnusedParameter
+func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
+
+//go:linkname _runtime_writeBarrier runtime.writeBarrier
+var _runtime_writeBarrier uintptr
+
+//go:linkname gcWriteBarrierAX runtime.gcWriteBarrier
+func gcWriteBarrierAX()
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/encoder/types.go b/vendor/github.com/bytedance/sonic/encoder/types.go
new file mode 100644
index 000000000..3d4a00668
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/types.go
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `encoding`
+    `encoding/json`
+    `reflect`
+)
+
+var (
+    byteType                 = reflect.TypeOf(byte(0))
+    jsonNumberType           = reflect.TypeOf(json.Number(""))
+    jsonUnsupportedValueType = reflect.TypeOf(new(json.UnsupportedValueError))
+)
+
+var (
+    errorType                 = reflect.TypeOf((*error)(nil)).Elem()
+    jsonMarshalerType         = reflect.TypeOf((*json.Marshaler)(nil)).Elem()
+    encodingTextMarshalerType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
+)
+
+func isSimpleByte(vt reflect.Type) bool {
+    if vt.Kind() != byteType.Kind() {
+        return false
+    } else {
+        return !isEitherMarshaler(vt) && !isEitherMarshaler(reflect.PtrTo(vt))
+    }
+}
+
+func isEitherMarshaler(vt reflect.Type) bool {
+    return vt.Implements(jsonMarshalerType) || vt.Implements(encodingTextMarshalerType)
+}
diff --git a/vendor/github.com/bytedance/sonic/encoder/utils.go b/vendor/github.com/bytedance/sonic/encoder/utils.go
new file mode 100644
index 000000000..510596fda
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/encoder/utils.go
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package encoder
+
+import (
+    `encoding/json`
+    `unsafe`
+
+    `github.com/bytedance/sonic/loader`
+)
+
+//go:nosplit
+func padd(p unsafe.Pointer, v int) unsafe.Pointer {
+    return unsafe.Pointer(uintptr(p) + uintptr(v))
+}
+
+//go:nosplit
+func ptoenc(p loader.Function) _Encoder {
+    return *(*_Encoder)(unsafe.Pointer(&p))
+}
+
+func compact(p *[]byte, v []byte) error {
+    buf := newBuffer()
+    err := json.Compact(buf, v)
+
+    /* check for errors */
+    if err != nil {
+        return err
+    }
+
+    /* add to result */
+    v = buf.Bytes()
+    *p = append(*p, v...)
+
+    /* return the buffer into pool */
+    freeBuffer(buf)
+    return nil
+}
diff --git a/vendor/github.com/bytedance/sonic/go.work b/vendor/github.com/bytedance/sonic/go.work
new file mode 100644
index 000000000..e21d6f872
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/go.work
@@ -0,0 +1,8 @@
+go 1.18
+
+use (
+	.
+	./generic_test
+	./fuzz
+	./external_jsonlib_test
+)
diff --git a/vendor/github.com/bytedance/sonic/internal/caching/asm.s b/vendor/github.com/bytedance/sonic/internal/caching/asm.s
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/caching/asm.s
diff --git a/vendor/github.com/bytedance/sonic/internal/caching/fcache.go b/vendor/github.com/bytedance/sonic/internal/caching/fcache.go
new file mode 100644
index 000000000..8cf62ff44
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/caching/fcache.go
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package caching
+
+import (
+    `strings`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+type FieldMap struct {
+    N uint64
+    b unsafe.Pointer
+    m map[string]int
+}
+
+type FieldEntry struct {
+    ID   int
+    Name string
+    Hash uint64
+}
+
+const (
+    FieldMap_N     = int64(unsafe.Offsetof(FieldMap{}.N))
+    FieldMap_b     = int64(unsafe.Offsetof(FieldMap{}.b))
+	FieldEntrySize = int64(unsafe.Sizeof(FieldEntry{}))
+)
+
+func newBucket(n int) unsafe.Pointer {
+    v := make([]FieldEntry, n)
+    return (*rt.GoSlice)(unsafe.Pointer(&v)).Ptr
+}
+
+func CreateFieldMap(n int) *FieldMap {
+    return &FieldMap {
+        N: uint64(n * 2),
+        b: newBucket(n * 2),    // LoadFactor = 0.5
+        m: make(map[string]int, n * 2),
+    }
+}
+
+func (self *FieldMap) At(p uint64) *FieldEntry {
+    off := uintptr(p) * uintptr(FieldEntrySize)
+    return (*FieldEntry)(unsafe.Pointer(uintptr(self.b) + off))
+}
+
+// Get searches FieldMap by name. JIT generated assembly does NOT call this
+// function, rather it implements its own version directly in assembly. So
+// we must ensure this function stays in sync with the JIT generated one.
+func (self *FieldMap) Get(name string) int {
+    h := StrHash(name)
+    p := h % self.N
+    s := self.At(p)
+
+    /* find the element;
+     * the hash map is never full, so the loop will always terminate */
+    for s.Hash != 0 {
+        if s.Hash == h && s.Name == name {
+            return s.ID
+        } else {
+            p = (p + 1) % self.N
+            s = self.At(p)
+        }
+    }
+
+    /* not found */
+    return -1
+}
+
+func (self *FieldMap) Set(name string, i int) {
+    h := StrHash(name)
+    p := h % self.N
+    s := self.At(p)
+
+    /* searching for an empty slot;
+     * the hash map is never full, so the loop will always terminate */
+    for s.Hash != 0 {
+        p = (p + 1) % self.N
+        s = self.At(p)
+    }
+
+    /* set the value */
+    s.ID   = i
+    s.Hash = h
+    s.Name = name
+
+    /* add the case-insensitive version, prefer the one with smaller field ID */
+    key := strings.ToLower(name)
+    if v, ok := self.m[key]; !ok || i < v {
+        self.m[key] = i
+    }
+}
+
+func (self *FieldMap) GetCaseInsensitive(name string) int {
+    if i, ok := self.m[strings.ToLower(name)]; ok {
+        return i
+    } else {
+        return -1
+    }
+}
diff --git a/vendor/github.com/bytedance/sonic/internal/caching/hashing.go b/vendor/github.com/bytedance/sonic/internal/caching/hashing.go
new file mode 100644
index 000000000..b8876a410
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/caching/hashing.go
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package caching
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+var (
+    V_strhash = rt.UnpackEface(strhash)
+    S_strhash = *(*uintptr)(V_strhash.Value)
+)
+
+//go:noescape
+//go:linkname strhash runtime.strhash
+func strhash(_ unsafe.Pointer, _ uintptr) uintptr
+
+func StrHash(s string) uint64 {
+    if v := strhash(unsafe.Pointer(&s), 0); v == 0 {
+        return 1
+    } else {
+        return uint64(v)
+    }
+}
diff --git a/vendor/github.com/bytedance/sonic/internal/caching/pcache.go b/vendor/github.com/bytedance/sonic/internal/caching/pcache.go
new file mode 100644
index 000000000..8c1224d9c
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/caching/pcache.go
@@ -0,0 +1,173 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package caching
+
+import (
+    `sync`
+    `sync/atomic`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+/** Program Map **/
+
+const (
+    _LoadFactor   = 0.5
+    _InitCapacity = 4096    // must be a power of 2
+)
+
+type _ProgramMap struct {
+    n uint64
+    m uint32
+    b []_ProgramEntry
+}
+
+type _ProgramEntry struct {
+    vt *rt.GoType
+    fn interface{}
+}
+
+func newProgramMap() *_ProgramMap {
+    return &_ProgramMap {
+        n: 0,
+        m: _InitCapacity - 1,
+        b: make([]_ProgramEntry, _InitCapacity),
+    }
+}
+
+func (self *_ProgramMap) copy() *_ProgramMap {
+    fork := &_ProgramMap{
+        n: self.n,
+        m: self.m,
+        b: make([]_ProgramEntry, len(self.b)),
+    }
+    for i, f := range self.b {
+        fork.b[i] = f
+    }
+    return fork
+}
+
+func (self *_ProgramMap) get(vt *rt.GoType) interface{} {
+    i := self.m + 1
+    p := vt.Hash & self.m
+
+    /* linear probing */
+    for ; i > 0; i-- {
+        if b := self.b[p]; b.vt == vt {
+            return b.fn
+        } else if b.vt == nil {
+            break
+        } else {
+            p = (p + 1) & self.m
+        }
+    }
+
+    /* not found */
+    return nil
+}
+
+func (self *_ProgramMap) add(vt *rt.GoType, fn interface{}) *_ProgramMap {
+    p := self.copy()
+    f := float64(atomic.LoadUint64(&p.n) + 1) / float64(p.m + 1)
+
+    /* check for load factor */
+    if f > _LoadFactor {
+        p = p.rehash()
+    }
+
+    /* insert the value */
+    p.insert(vt, fn)
+    return p
+}
+
+func (self *_ProgramMap) rehash() *_ProgramMap {
+    c := (self.m + 1) << 1
+    r := &_ProgramMap{m: c - 1, b: make([]_ProgramEntry, int(c))}
+
+    /* rehash every entry */
+    for i := uint32(0); i <= self.m; i++ {
+        if b := self.b[i]; b.vt != nil {
+            r.insert(b.vt, b.fn)
+        }
+    }
+
+    /* rebuild successful */
+    return r
+}
+
+func (self *_ProgramMap) insert(vt *rt.GoType, fn interface{}) {
+    h := vt.Hash
+    p := h & self.m
+
+    /* linear probing */
+    for i := uint32(0); i <= self.m; i++ {
+        if b := &self.b[p]; b.vt != nil {
+            p += 1
+            p &= self.m
+        } else {
+            b.vt = vt
+            b.fn = fn
+            atomic.AddUint64(&self.n, 1)
+            return
+        }
+    }
+
+    /* should never happens */
+    panic("no available slots")
+}
+
+/** RCU Program Cache **/
+
+type ProgramCache struct {
+    m sync.Mutex
+    p unsafe.Pointer
+}
+
+func CreateProgramCache() *ProgramCache {
+    return &ProgramCache {
+        m: sync.Mutex{},
+        p: unsafe.Pointer(newProgramMap()),
+    }
+}
+
+func (self *ProgramCache) Get(vt *rt.GoType) interface{} {
+    return (*_ProgramMap)(atomic.LoadPointer(&self.p)).get(vt)
+}
+
+func (self *ProgramCache) Compute(vt *rt.GoType, compute func(*rt.GoType, ... interface{}) (interface{}, error), ex ...interface{}) (interface{}, error) {
+    var err error
+    var val interface{}
+
+    /* use defer to prevent inlining of this function */
+    self.m.Lock()
+    defer self.m.Unlock()
+
+    /* double check with write lock held */
+    if val = self.Get(vt); val != nil {
+        return val, nil
+    }
+
+    /* compute the value */
+    if val, err = compute(vt, ex...); err != nil {
+        return nil, err
+    }
+
+    /* update the RCU cache */
+    atomic.StorePointer(&self.p, unsafe.Pointer((*_ProgramMap)(atomic.LoadPointer(&self.p)).add(vt, val)))
+    return val, nil
+}
diff --git a/vendor/github.com/bytedance/sonic/internal/cpu/features.go b/vendor/github.com/bytedance/sonic/internal/cpu/features.go
new file mode 100644
index 000000000..f9ee3b8f3
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/cpu/features.go
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package cpu
+
+import (
+    `fmt`
+    `os`
+
+    `github.com/klauspost/cpuid/v2`
+)
+
+var (
+    HasAVX  = cpuid.CPU.Has(cpuid.AVX)
+    HasAVX2 = cpuid.CPU.Has(cpuid.AVX2)
+    HasSSE = cpuid.CPU.Has(cpuid.SSE)
+)
+
+func init() {
+    switch v := os.Getenv("SONIC_MODE"); v {
+        case ""       : break
+        case "auto"   : break
+        case "noavx"  : HasAVX = false; fallthrough
+        case "noavx2" : HasAVX2 = false
+        default       : panic(fmt.Sprintf("invalid mode: '%s', should be one of 'auto', 'noavx', 'noavx2'", v))
+    }
+}
diff --git a/vendor/github.com/bytedance/sonic/internal/jit/arch_amd64.go b/vendor/github.com/bytedance/sonic/internal/jit/arch_amd64.go
new file mode 100644
index 000000000..7405052d6
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/jit/arch_amd64.go
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package jit
+
+import (
+    `github.com/twitchyliquid64/golang-asm/asm/arch`
+    `github.com/twitchyliquid64/golang-asm/obj`
+)
+
+var (
+    _AC = arch.Set("amd64")
+)
+
+func As(op string) obj.As {
+    if ret, ok := _AC.Instructions[op]; ok {
+        return ret
+    } else {
+        panic("invalid instruction: " + op)
+    }
+}
+
+func Imm(imm int64) obj.Addr {
+    return obj.Addr {
+        Type   : obj.TYPE_CONST,
+        Offset : imm,
+    }
+}
+
+func Reg(reg string) obj.Addr {
+    if ret, ok := _AC.Register[reg]; ok {
+        return obj.Addr{Reg: ret, Type: obj.TYPE_REG}
+    } else {
+        panic("invalid register name: " + reg)
+    }
+}
+
+func Ptr(reg obj.Addr, offs int64) obj.Addr {
+    return obj.Addr {
+        Reg    : reg.Reg,
+        Type   : obj.TYPE_MEM,
+        Offset : offs,
+    }
+}
+
+func Sib(reg obj.Addr, idx obj.Addr, scale int16, offs int64) obj.Addr {
+    return obj.Addr {
+        Reg    : reg.Reg,
+        Index  : idx.Reg,
+        Scale  : scale,
+        Type   : obj.TYPE_MEM,
+        Offset : offs,
+    }
+}
diff --git a/vendor/github.com/bytedance/sonic/internal/jit/asm.s b/vendor/github.com/bytedance/sonic/internal/jit/asm.s
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/jit/asm.s
diff --git a/vendor/github.com/bytedance/sonic/internal/jit/assembler_amd64.go b/vendor/github.com/bytedance/sonic/internal/jit/assembler_amd64.go
new file mode 100644
index 000000000..00e6009db
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/jit/assembler_amd64.go
@@ -0,0 +1,269 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package jit
+
+import (
+    `encoding/binary`
+    `strconv`
+    `strings`
+    `sync`
+
+    `github.com/bytedance/sonic/loader`
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/twitchyliquid64/golang-asm/obj`
+    `github.com/twitchyliquid64/golang-asm/obj/x86`
+)
+
+const (
+    _LB_jump_pc = "_jump_pc_"
+)
+
+type BaseAssembler struct {
+    i        int
+    f        func()
+    c        []byte
+    o        sync.Once
+    pb       *Backend
+    xrefs    map[string][]*obj.Prog
+    labels   map[string]*obj.Prog
+    pendings map[string][]*obj.Prog
+}
+
+/** Instruction Encoders **/
+
+var _NOPS = [][16]byte {
+    {0x90},                                                     // NOP
+    {0x66, 0x90},                                               // 66 NOP
+    {0x0f, 0x1f, 0x00},                                         // NOP DWORD ptr [EAX]
+    {0x0f, 0x1f, 0x40, 0x00},                                   // NOP DWORD ptr [EAX + 00H]
+    {0x0f, 0x1f, 0x44, 0x00, 0x00},                             // NOP DWORD ptr [EAX + EAX*1 + 00H]
+    {0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00},                       // 66 NOP DWORD ptr [EAX + EAX*1 + 00H]
+    {0x0f, 0x1f, 0x80, 0x00, 0x00, 0x00, 0x00},                 // NOP DWORD ptr [EAX + 00000000H]
+    {0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00},           // NOP DWORD ptr [EAX + EAX*1 + 00000000H]
+    {0x66, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00},     // 66 NOP DWORD ptr [EAX + EAX*1 + 00000000H]
+}
+
+func (self *BaseAssembler) NOP() *obj.Prog {
+    p := self.pb.New()
+    p.As = obj.ANOP
+    self.pb.Append(p)
+    return p
+}
+
+func (self *BaseAssembler) NOPn(n int) {
+    for i := len(_NOPS); i > 0 && n > 0; i-- {
+        for ; n >= i; n -= i {
+            self.Byte(_NOPS[i - 1][:i]...)
+        }
+    }
+}
+
+func (self *BaseAssembler) Byte(v ...byte) {
+    for ; len(v) >= 8; v = v[8:] { self.From("QUAD", Imm(rt.Get64(v))) }
+    for ; len(v) >= 4; v = v[4:] { self.From("LONG", Imm(int64(rt.Get32(v)))) }
+    for ; len(v) >= 2; v = v[2:] { self.From("WORD", Imm(int64(rt.Get16(v)))) }
+    for ; len(v) >= 1; v = v[1:] { self.From("BYTE", Imm(int64(v[0]))) }
+}
+
+func (self *BaseAssembler) Mark(pc int) {
+    self.i++
+    self.Link(_LB_jump_pc + strconv.Itoa(pc))
+}
+
+func (self *BaseAssembler) Link(to string) {
+    var p *obj.Prog
+    var v []*obj.Prog
+
+    /* placeholder substitution */
+    if strings.Contains(to, "{n}") {
+        to = strings.ReplaceAll(to, "{n}", strconv.Itoa(self.i))
+    }
+
+    /* check for duplications */
+    if _, ok := self.labels[to]; ok {
+        panic("label " + to + " has already been linked")
+    }
+
+    /* get the pending links */
+    p = self.NOP()
+    v = self.pendings[to]
+
+    /* patch all the pending jumps */
+    for _, q := range v {
+        q.To.Val = p
+    }
+
+    /* mark the label as resolved */
+    self.labels[to] = p
+    delete(self.pendings, to)
+}
+
+func (self *BaseAssembler) Xref(pc int, d int64) {
+    self.Sref(_LB_jump_pc + strconv.Itoa(pc), d)
+}
+
+func (self *BaseAssembler) Sref(to string, d int64) {
+    p := self.pb.New()
+    p.As = x86.ALONG
+    p.From = Imm(-d)
+
+    /* placeholder substitution */
+    if strings.Contains(to, "{n}") {
+        to = strings.ReplaceAll(to, "{n}", strconv.Itoa(self.i))
+    }
+
+    /* record the patch point */
+    self.pb.Append(p)
+    self.xrefs[to] = append(self.xrefs[to], p)
+}
+
+func (self *BaseAssembler) Xjmp(op string, to int) {
+    self.Sjmp(op, _LB_jump_pc + strconv.Itoa(to))
+}
+
+func (self *BaseAssembler) Sjmp(op string, to string) {
+    p := self.pb.New()
+    p.As = As(op)
+
+    /* placeholder substitution */
+    if strings.Contains(to, "{n}") {
+        to = strings.ReplaceAll(to, "{n}", strconv.Itoa(self.i))
+    }
+
+    /* check for backward jumps */
+    if v, ok := self.labels[to]; ok {
+        p.To.Val = v
+    } else {
+        self.pendings[to] = append(self.pendings[to], p)
+    }
+
+    /* mark as a branch, and add to instruction buffer */
+    p.To.Type = obj.TYPE_BRANCH
+    self.pb.Append(p)
+}
+
+func (self *BaseAssembler) Rjmp(op string, to obj.Addr) {
+    p := self.pb.New()
+    p.To = to
+    p.As = As(op)
+    self.pb.Append(p)
+}
+
+func (self *BaseAssembler) From(op string, val obj.Addr) {
+    p := self.pb.New()
+    p.As = As(op)
+    p.From = val
+    self.pb.Append(p)
+}
+
+func (self *BaseAssembler) Emit(op string, args ...obj.Addr) {
+    p := self.pb.New()
+    p.As = As(op)
+    self.assignOperands(p, args)
+    self.pb.Append(p)
+}
+
+func (self *BaseAssembler) assignOperands(p *obj.Prog, args []obj.Addr) {
+    switch len(args) {
+        case 0  :
+        case 1  : p.To                     = args[0]
+        case 2  : p.To, p.From             = args[1], args[0]
+        case 3  : p.To, p.From, p.RestArgs = args[2], args[0], args[1:2]
+        case 4  : p.To, p.From, p.RestArgs = args[2], args[3], args[:2]
+        default : panic("invalid operands")
+    }
+}
+
+/** Assembler Helpers **/
+
+func (self *BaseAssembler) Size() int {
+    self.build()
+    return len(self.c)
+}
+
+func (self *BaseAssembler) Init(f func()) {
+    self.i = 0
+    self.f = f
+    self.c = nil
+    self.o = sync.Once{}
+}
+
+var jitLoader = loader.Loader{
+    Name: "sonic.jit.",
+    File: "github.com/bytedance/sonic/jit.go",
+    Options: loader.Options{
+        NoPreempt: true,
+    },
+}
+
+func (self *BaseAssembler) Load(name string, frameSize int, argSize int, argStackmap []bool, localStackmap []bool) loader.Function {
+    self.build()
+    return jitLoader.LoadOne(self.c, name, frameSize, argSize, argStackmap, localStackmap)
+}
+
+/** Assembler Stages **/
+
+func (self *BaseAssembler) init() {
+    self.pb       = newBackend("amd64")
+    self.xrefs    = map[string][]*obj.Prog{}
+    self.labels   = map[string]*obj.Prog{}
+    self.pendings = map[string][]*obj.Prog{}
+}
+
+func (self *BaseAssembler) build() {
+    self.o.Do(func() {
+        self.init()
+        self.f()
+        self.validate()
+        self.assemble()
+        self.resolve()
+        self.release()
+    })
+}
+
+func (self *BaseAssembler) release() {
+    self.pb.Release()
+    self.pb = nil
+    self.xrefs = nil
+    self.labels = nil
+    self.pendings = nil
+}
+
+func (self *BaseAssembler) resolve() {
+    for s, v := range self.xrefs {
+        for _, prog := range v {
+            if prog.As != x86.ALONG {
+                panic("invalid RIP relative reference")
+            } else if p, ok := self.labels[s]; !ok {
+                panic("links are not fully resolved: " + s)
+            } else {
+                off := prog.From.Offset + p.Pc - prog.Pc
+                binary.LittleEndian.PutUint32(self.c[prog.Pc:], uint32(off))
+            }
+        }
+    }
+}
+
+func (self *BaseAssembler) validate() {
+    for key := range self.pendings {
+        panic("links are not fully resolved: " + key)
+    }
+}
+
+func (self *BaseAssembler) assemble() {
+    self.c = self.pb.Assemble()
+}
diff --git a/vendor/github.com/bytedance/sonic/internal/jit/backend.go b/vendor/github.com/bytedance/sonic/internal/jit/backend.go
new file mode 100644
index 000000000..75e180415
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/jit/backend.go
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package jit
+
+import (
+    `fmt`
+    `sync`
+    _ `unsafe`
+
+    `github.com/twitchyliquid64/golang-asm/asm/arch`
+    `github.com/twitchyliquid64/golang-asm/obj`
+    `github.com/twitchyliquid64/golang-asm/objabi`
+)
+
+type Backend struct {
+    Ctxt *obj.Link
+    Arch *arch.Arch
+    Head *obj.Prog
+    Tail *obj.Prog
+    Prog []*obj.Prog
+}
+
+var (
+    _progPool sync.Pool
+)
+
+//go:nosplit
+//go:linkname throw runtime.throw
+func throw(_ string)
+
+func newProg() *obj.Prog {
+    if val := _progPool.Get(); val == nil {
+        return new(obj.Prog)
+    } else {
+        return remProg(val.(*obj.Prog))
+    }
+}
+
+func remProg(p *obj.Prog) *obj.Prog {
+    *p = obj.Prog{}
+    return p
+}
+
+func newBackend(name string) (ret *Backend) {
+    ret      = new(Backend)
+    ret.Arch = arch.Set(name)
+    ret.Ctxt = newLinkContext(ret.Arch.LinkArch)
+    ret.Arch.Init(ret.Ctxt)
+    return
+}
+
+func newLinkContext(arch *obj.LinkArch) (ret *obj.Link) {
+    ret          = obj.Linknew(arch)
+    ret.Headtype = objabi.Hlinux
+    ret.DiagFunc = diagLinkContext
+    return
+}
+
+func diagLinkContext(str string, args ...interface{}) {
+    throw(fmt.Sprintf(str, args...))
+}
+
+func (self *Backend) New() (ret *obj.Prog) {
+    ret = newProg()
+    ret.Ctxt = self.Ctxt
+    self.Prog = append(self.Prog, ret)
+    return
+}
+
+func (self *Backend) Append(p *obj.Prog) {
+    if self.Head == nil {
+        self.Head = p
+        self.Tail = p
+    } else {
+        self.Tail.Link = p
+        self.Tail = p
+    }
+}
+
+func (self *Backend) Release() {
+    self.Arch = nil
+    self.Ctxt = nil
+
+    /* return all the progs into pool */
+    for _, p := range self.Prog {
+        _progPool.Put(p)
+    }
+
+    /* clear all the references */
+    self.Head = nil
+    self.Tail = nil
+    self.Prog = nil
+}
+
+func (self *Backend) Assemble() []byte {
+    var sym obj.LSym
+    var fnv obj.FuncInfo
+
+    /* construct the function */
+    sym.Func = &fnv
+    fnv.Text = self.Head
+
+    /* call the assembler */
+    self.Arch.Assemble(self.Ctxt, &sym, self.New)
+    return sym.P
+}
diff --git a/vendor/github.com/bytedance/sonic/internal/jit/runtime.go b/vendor/github.com/bytedance/sonic/internal/jit/runtime.go
new file mode 100644
index 000000000..ec69d067a
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/jit/runtime.go
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package jit
+
+import (
+    `reflect`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/twitchyliquid64/golang-asm/obj`
+)
+
+//go:noescape
+//go:linkname getitab runtime.getitab
+//goland:noinspection ALL
+func getitab(inter *rt.GoType, typ *rt.GoType, canfail bool) *rt.GoItab
+
+func Func(f interface{}) obj.Addr {
+    if p := rt.UnpackEface(f); p.Type.Kind() != reflect.Func {
+        panic("f is not a function")
+    } else {
+        return Imm(*(*int64)(p.Value))
+    }
+}
+
+func Type(t reflect.Type) obj.Addr {
+    return Gtype(rt.UnpackType(t))
+}
+
+func Itab(i *rt.GoType, t reflect.Type) obj.Addr {
+    return Imm(int64(uintptr(unsafe.Pointer(getitab(i, rt.UnpackType(t), false)))))
+}
+
+func Gitab(i *rt.GoItab) obj.Addr {
+    return Imm(int64(uintptr(unsafe.Pointer(i))))
+}
+
+func Gtype(t *rt.GoType) obj.Addr {
+    return Imm(int64(uintptr(unsafe.Pointer(t))))
+}
diff --git a/vendor/github.com/bytedance/sonic/internal/loader/asm.s b/vendor/github.com/bytedance/sonic/internal/loader/asm.s
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/loader/asm.s
diff --git a/vendor/github.com/bytedance/sonic/internal/loader/funcdata.go b/vendor/github.com/bytedance/sonic/internal/loader/funcdata.go
new file mode 100644
index 000000000..59a3cb349
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/loader/funcdata.go
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package loader
+
+import (
+    `reflect`
+    `sync`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+//go:linkname lastmoduledatap runtime.lastmoduledatap
+//goland:noinspection GoUnusedGlobalVariable
+var lastmoduledatap *_ModuleData
+
+//go:linkname moduledataverify1 runtime.moduledataverify1
+func moduledataverify1(_ *_ModuleData)
+
+// PCDATA and FUNCDATA table indexes.
+//
+// See funcdata.h and $GROOT/src/cmd/internal/objabi/funcdata.go.
+const (
+    _FUNCDATA_ArgsPointerMaps = 0
+    _FUNCDATA_LocalsPointerMaps = 1
+)
+
+type funcInfo struct {
+    *_Func
+    datap *_ModuleData
+}
+
+//go:linkname findfunc runtime.findfunc
+func findfunc(pc uintptr) funcInfo
+
+//go:linkname funcdata runtime.funcdata
+func funcdata(f funcInfo, i uint8) unsafe.Pointer
+
+var (
+    modLock sync.Mutex
+    modList []*_ModuleData
+)
+
+var emptyByte byte
+
+func encodeVariant(v int) []byte {
+    var u int
+    var r []byte
+
+    /* split every 7 bits */
+    for v > 127 {
+        u = v & 0x7f
+        v = v >> 7
+        r = append(r, byte(u) | 0x80)
+    }
+
+    /* check for last one */
+    if v == 0 {
+        return r
+    }
+
+    /* add the last one */
+    r = append(r, byte(v))
+    return r
+}
+
+func registerModule(mod *_ModuleData) {
+    modLock.Lock()
+    modList = append(modList, mod)
+    lastmoduledatap.next = mod
+    lastmoduledatap = mod
+    modLock.Unlock()
+}
+
+func stackMap(f interface{}) (args uintptr, locals uintptr) {
+    fv := reflect.ValueOf(f)
+    if fv.Kind() != reflect.Func {
+        panic("f must be reflect.Func kind!")
+    }
+    fi := findfunc(fv.Pointer())
+    return uintptr(funcdata(fi, uint8(_FUNCDATA_ArgsPointerMaps))), uintptr(funcdata(fi, uint8(_FUNCDATA_LocalsPointerMaps)))
+}
+
+var moduleCache = struct{
+    m map[*_ModuleData][]byte
+    l sync.Mutex
+}{
+    m : make(map[*_ModuleData][]byte),
+}
+
+func cacheStackmap(argPtrs []bool, localPtrs []bool, mod *_ModuleData) (argptrs uintptr, localptrs uintptr) {
+    as := rt.StackMapBuilder{}
+    for _, b := range argPtrs {
+        as.AddField(b)
+    }
+    ab, _ := as.Build().MarshalBinary()
+    ls := rt.StackMapBuilder{}
+    for _, b := range localPtrs {
+        ls.AddField(b)
+    }
+    lb, _ := ls.Build().MarshalBinary()
+    cache := make([]byte, len(ab) + len(lb))
+    copy(cache, ab)
+    copy(cache[len(ab):], lb)
+    moduleCache.l.Lock()
+    moduleCache.m[mod] = cache
+    moduleCache.l.Unlock()
+    return uintptr(rt.IndexByte(cache, 0)), uintptr(rt.IndexByte(cache, len(ab)))
+
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go115.go b/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go115.go
new file mode 100644
index 000000000..b0d2d6c65
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go115.go
@@ -0,0 +1,169 @@
+// +build go1.15,!go1.16
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package loader
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+type _Func struct {
+    entry       uintptr // start pc
+    nameoff     int32   // function name
+    args        int32   // in/out args size
+    deferreturn uint32  // offset of start of a deferreturn call instruction from entry, if any.
+    pcsp        int32
+    pcfile      int32
+    pcln        int32
+    npcdata     int32
+    funcID      uint8   // set for certain special runtime functions
+    _           [2]int8 // unused
+    nfuncdata   uint8   // must be last
+    argptrs     uintptr
+    localptrs   uintptr
+}
+
+type _FuncTab struct {
+    entry   uintptr
+    funcoff uintptr
+}
+
+type _BitVector struct {
+    n        int32 // # of bits
+    bytedata *uint8
+}
+
+type _PtabEntry struct {
+    name int32
+    typ  int32
+}
+
+type _TextSection struct {
+    vaddr    uintptr // prelinked section vaddr
+    length   uintptr // section length
+    baseaddr uintptr // relocated section address
+}
+
+type _ModuleData struct {
+    pclntable             []byte
+    ftab                  []_FuncTab
+    filetab               []uint32
+    findfunctab           *_FindFuncBucket
+    minpc, maxpc          uintptr
+    text, etext           uintptr
+    noptrdata, enoptrdata uintptr
+    data, edata           uintptr
+    bss, ebss             uintptr
+    noptrbss, enoptrbss   uintptr
+    end, gcdata, gcbss    uintptr
+    types, etypes         uintptr
+    textsectmap           []_TextSection
+    typelinks             []int32 // offsets from types
+    itablinks             []*rt.GoItab
+    ptab                  []_PtabEntry
+    pluginpath            string
+    pkghashes             []byte
+    modulename            string
+    modulehashes          []byte
+    hasmain               uint8 // 1 if module contains the main function, 0 otherwise
+    gcdatamask, gcbssmask _BitVector
+    typemap               map[int32]*rt.GoType // offset to *_rtype in previous module
+    bad                   bool                 // module failed to load and should be ignored
+    next                  *_ModuleData
+}
+
+type _FindFuncBucket struct {
+    idx        uint32
+    subbuckets [16]byte
+}
+
+var findFuncTab = &_FindFuncBucket {
+    idx: 1,
+}
+
+func registerFunction(name string, pc uintptr, textSize uintptr, fp int, args int, size uintptr, argPtrs []bool, localPtrs []bool) {
+    mod := new(_ModuleData)
+    minpc := pc
+    maxpc := pc + size
+
+    /* build the PC & line table */
+    pclnt := []byte {
+        0xfb, 0xff, 0xff, 0xff,     // magic   : 0xfffffffb
+        0,                          // pad1    : 0
+        0,                          // pad2    : 0
+        1,                          // minLC   : 1
+        4 << (^uintptr(0) >> 63),   // ptrSize : 4 << (^uintptr(0) >> 63)
+    }
+
+    // cache arg and local stackmap
+    argptrs, localptrs := cacheStackmap(argPtrs, localPtrs, mod)
+
+    /* add the function name */
+    noff := len(pclnt)
+    pclnt = append(append(pclnt, name...), 0)
+
+    /* add PCDATA */
+    pcsp := len(pclnt)
+    pclnt = append(pclnt, encodeVariant((fp + 1) << 1)...)
+    pclnt = append(pclnt, encodeVariant(int(size))...)
+
+    /* function entry */
+    fnv := _Func {
+        entry     : pc,
+        nameoff   : int32(noff),
+        args      : int32(args),
+        pcsp      : int32(pcsp),
+        nfuncdata : 2,
+        argptrs   : uintptr(argptrs),
+        localptrs : uintptr(localptrs),
+    }
+
+    /* align the func to 8 bytes */
+    if p := len(pclnt) % 8; p != 0 {
+        pclnt = append(pclnt, make([]byte, 8 - p)...)
+    }
+
+    /* add the function descriptor */
+    foff := len(pclnt)
+    pclnt = append(pclnt, (*(*[unsafe.Sizeof(_Func{})]byte)(unsafe.Pointer(&fnv)))[:]...)
+
+    /* function table */
+    tab := []_FuncTab {
+        {entry: pc, funcoff: uintptr(foff)},
+        {entry: pc, funcoff: uintptr(foff)},
+        {entry: maxpc},
+    }
+
+    /* module data */
+    *mod = _ModuleData {
+        pclntable   : pclnt,
+        ftab        : tab,
+        findfunctab : findFuncTab,
+        minpc       : minpc,
+        maxpc       : maxpc,
+        modulename  : name,
+        gcdata: uintptr(unsafe.Pointer(&emptyByte)),
+        gcbss: uintptr(unsafe.Pointer(&emptyByte)),
+    }
+
+    /* verify and register the new module */
+    moduledataverify1(mod)
+    registerModule(mod)
+}
diff --git a/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go116.go b/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go116.go
new file mode 100644
index 000000000..f01747f93
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go116.go
@@ -0,0 +1,175 @@
+//go:build go1.16 && !go1.18
+// +build go1.16,!go1.18
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package loader
+
+import (
+    `unsafe`
+)
+
+type _Func struct {
+    entry       uintptr // start pc
+    nameoff     int32   // function name
+    args        int32   // in/out args size
+    deferreturn uint32  // offset of start of a deferreturn call instruction from entry, if any.
+    pcsp        uint32
+    pcfile      uint32
+    pcln        uint32
+    npcdata     uint32
+    cuOffset    uint32  // runtime.cutab offset of this function's CU
+    funcID      uint8   // set for certain special runtime functions
+    _           [2]byte // pad
+    nfuncdata   uint8   // must be last
+    argptrs     uintptr
+    localptrs   uintptr
+}
+
+type _FuncTab struct {
+    entry   uintptr
+    funcoff uintptr
+}
+
+type _PCHeader struct {
+    magic          uint32  // 0xFFFFFFFA
+    pad1, pad2     uint8   // 0,0
+    minLC          uint8   // min instruction size
+    ptrSize        uint8   // size of a ptr in bytes
+    nfunc          int     // number of functions in the module
+    nfiles         uint    // number of entries in the file tab.
+    funcnameOffset uintptr // offset to the funcnametab variable from _PCHeader
+    cuOffset       uintptr // offset to the cutab variable from _PCHeader
+    filetabOffset  uintptr // offset to the filetab variable from _PCHeader
+    pctabOffset    uintptr // offset to the pctab varible from _PCHeader
+    pclnOffset     uintptr // offset to the pclntab variable from _PCHeader
+}
+
+type _BitVector struct {
+    n        int32 // # of bits
+    bytedata *uint8
+}
+
+type _PtabEntry struct {
+    name int32
+    typ  int32
+}
+
+type _TextSection struct {
+    vaddr    uintptr // prelinked section vaddr
+    length   uintptr // section length
+    baseaddr uintptr // relocated section address
+}
+
+type _ModuleData struct {
+    pcHeader              *_PCHeader
+    funcnametab           []byte
+    cutab                 []uint32
+    filetab               []byte
+    pctab                 []byte
+    pclntable             []_Func
+    ftab                  []_FuncTab
+    findfunctab           *_FindFuncBucket
+    minpc, maxpc          uintptr
+    text, etext           uintptr
+    noptrdata, enoptrdata uintptr
+    data, edata           uintptr
+    bss, ebss             uintptr
+    noptrbss, enoptrbss   uintptr
+    end, gcdata, gcbss    uintptr
+    types, etypes         uintptr
+    textsectmap           []_TextSection
+    typelinks             []int32
+    itablinks             []unsafe.Pointer
+    ptab                  []_PtabEntry
+    pluginpath            string
+    pkghashes             []struct{}
+    modulename            string
+    modulehashes          []struct{}
+    hasmain               uint8
+    gcdatamask, gcbssmask _BitVector
+    typemap               map[int32]unsafe.Pointer
+    bad                   bool
+    next                  *_ModuleData
+}
+
+type _FindFuncBucket struct {
+    idx        uint32
+    subbuckets [16]byte
+}
+
+var modHeader = &_PCHeader {
+    magic   : 0xfffffffa,
+    minLC   : 1,
+    nfunc   : 1,
+    ptrSize : 4 << (^uintptr(0) >> 63),
+}
+
+var findFuncTab = &_FindFuncBucket {
+    idx: 1,
+}
+
+func makePCtab(fp int) []byte {
+    return append([]byte{0}, encodeVariant((fp + 1) << 1)...)
+}
+
+func registerFunction(name string, pc uintptr, textSize uintptr, fp int, args int, size uintptr, argPtrs []bool, localPtrs []bool) {
+    mod := new(_ModuleData)
+    
+    minpc := pc
+    maxpc := pc + size
+
+    // cache arg and local stackmap
+    argptrs, localptrs := cacheStackmap(argPtrs, localPtrs, mod)
+
+    /* function entry */
+    lnt := []_Func {{
+        entry     : pc,
+        nameoff   : 1,
+        args      : int32(args),
+        pcsp      : 1,
+        nfuncdata : 2,
+        argptrs   : uintptr(argptrs),
+        localptrs : uintptr(localptrs),
+    }}
+
+    /* function table */
+    tab := []_FuncTab {
+        {entry: pc},
+        {entry: pc},
+        {entry: maxpc},
+    }
+
+    /* module data */
+    *mod = _ModuleData {
+        pcHeader    : modHeader,
+        funcnametab : append(append([]byte{0}, name...), 0),
+        pctab       : append(makePCtab(fp), encodeVariant(int(size))...),
+        pclntable   : lnt,
+        ftab        : tab,
+        findfunctab : findFuncTab,
+        minpc       : minpc,
+        maxpc       : maxpc,
+        modulename  : name,
+        gcdata: uintptr(unsafe.Pointer(&emptyByte)),
+        gcbss: uintptr(unsafe.Pointer(&emptyByte)),
+    }
+
+    /* verify and register the new module */
+    moduledataverify1(mod)
+    registerModule(mod)
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go118.go b/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go118.go
new file mode 100644
index 000000000..f1d585d97
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go118.go
@@ -0,0 +1,201 @@
+// +build go1.18,!go1.20
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package loader
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+// A FuncFlag holds bits about a function.
+// This list must match the list in cmd/internal/objabi/funcid.go.
+type funcFlag uint8
+
+type _Func struct {
+    entryOff    uint32 // start pc
+    nameoff     int32   // function name
+    args        int32   // in/out args size
+    deferreturn uint32  // offset of start of a deferreturn call instruction from entry, if any.
+    pcsp        uint32
+    pcfile      uint32
+    pcln        uint32
+    npcdata     uint32
+    cuOffset    uint32  // runtime.cutab offset of this function's CU
+    funcID      uint8   // set for certain special runtime functions
+    flag        funcFlag
+    _           [1]byte // pad
+    nfuncdata   uint8   // must be last
+    argptrs     uint32
+    localptrs   uint32
+}
+
+type _FuncTab struct {
+    entry   uint32
+    funcoff uint32
+}
+
+type _PCHeader struct {
+    magic          uint32  // 0xFFFFFFF0
+    pad1, pad2     uint8   // 0,0
+    minLC          uint8   // min instruction size
+    ptrSize        uint8   // size of a ptr in bytes
+    nfunc          int     // number of functions in the module
+    nfiles         uint    // number of entries in the file tab
+    textStart      uintptr // base for function entry PC offsets in this module, equal to moduledata.text
+    funcnameOffset uintptr // offset to the funcnametab variable from pcHeader
+    cuOffset       uintptr // offset to the cutab variable from pcHeader
+    filetabOffset  uintptr // offset to the filetab variable from pcHeader
+    pctabOffset    uintptr // offset to the pctab variable from pcHeader
+    pclnOffset     uintptr // offset to the pclntab variable from pcHeader
+}
+
+type _BitVector struct {
+    n        int32 // # of bits
+    bytedata *uint8
+}
+
+type _PtabEntry struct {
+    name int32
+    typ  int32
+}
+
+type _TextSection struct {
+    vaddr    uintptr // prelinked section vaddr
+    length   uintptr // section length
+    baseaddr uintptr // relocated section address
+}
+
+type _ModuleData struct {
+    pcHeader              *_PCHeader
+    funcnametab           []byte
+    cutab                 []uint32
+    filetab               []byte
+    pctab                 []byte
+    pclntable             []byte
+    ftab                  []_FuncTab
+    findfunctab           *_FindFuncBucket
+    minpc, maxpc          uintptr
+    text, etext           uintptr
+    noptrdata, enoptrdata uintptr
+    data, edata           uintptr
+    bss, ebss             uintptr
+    noptrbss, enoptrbss   uintptr
+    end, gcdata, gcbss    uintptr
+    types, etypes         uintptr
+    rodata                uintptr
+    gofunc                uintptr 
+    textsectmap           []_TextSection
+    typelinks             []int32
+    itablinks             []unsafe.Pointer
+    ptab                  []_PtabEntry
+    pluginpath            string
+    pkghashes             []struct{}
+    modulename            string
+    modulehashes          []struct{}
+    hasmain               uint8
+    gcdatamask, gcbssmask _BitVector
+    typemap               map[int32]unsafe.Pointer
+    bad                   bool
+    next                  *_ModuleData
+}
+
+
+type _FindFuncBucket struct {
+    idx        uint32
+    subbuckets [16]byte
+}
+
+
+
+func makePCtab(fp int) []byte {
+    return append([]byte{0}, encodeVariant((fp + 1) << 1)...)
+}
+
+func registerFunction(name string, pc uintptr, textSize uintptr, fp int, args int, size uintptr, argPtrs []bool, localPtrs []bool) {
+    mod := new(_ModuleData)
+
+    minpc := pc
+    maxpc := pc + size
+
+    findFuncTab := make([]_FindFuncBucket, textSize/4096 + 1)
+
+    modHeader := &_PCHeader {
+        magic   : 0xfffffff0,
+        minLC   : 1,
+        nfunc   : 1,
+        ptrSize : 4 << (^uintptr(0) >> 63),
+        textStart: minpc,
+    }
+
+    // cache arg and local stackmap
+    argptrs, localptrs := cacheStackmap(argPtrs, localPtrs, mod)
+
+    base := argptrs
+    if argptrs > localptrs {
+        base = localptrs
+    }
+
+    /* function entry */
+    lnt := []_Func {{
+        entryOff  : 0,
+        nameoff   : 1,
+        args      : int32(args),
+        pcsp      : 1,
+        nfuncdata : 2,
+        argptrs: uint32(argptrs - base),
+        localptrs: uint32(localptrs - base),
+    }}
+    nlnt := len(lnt)*int(unsafe.Sizeof(_Func{}))
+    plnt := unsafe.Pointer(&lnt[0])
+
+    /* function table */
+    ftab := []_FuncTab {
+        {entry   : 0, funcoff : 16},    
+        {entry   : uint32(size)},
+    }
+    nftab := len(ftab)*int(unsafe.Sizeof(_FuncTab{}))
+    pftab := unsafe.Pointer(&ftab[0])
+
+    pclntab := make([]byte, 0, nftab + nlnt)
+    pclntab = append(pclntab, rt.BytesFrom(pftab, nftab, nftab)...)
+    pclntab = append(pclntab, rt.BytesFrom(plnt, nlnt, nlnt)...)
+
+    /* module data */
+    *mod = _ModuleData {
+        pcHeader    : modHeader,
+        funcnametab : append(append([]byte{0}, name...), 0),
+        pctab       : append(makePCtab(fp), encodeVariant(int(size))...),
+        pclntable   : pclntab,
+        ftab        : ftab,
+        text        : minpc,
+        etext       : pc + textSize,
+        findfunctab : &findFuncTab[0],
+        minpc       : minpc,
+        maxpc       : maxpc,
+        modulename  : name,
+        gcdata: uintptr(unsafe.Pointer(&emptyByte)),
+        gcbss: uintptr(unsafe.Pointer(&emptyByte)),
+        gofunc: base,
+    }
+
+    /* verify and register the new module */
+    moduledataverify1(mod)
+    registerModule(mod)
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go120.go b/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go120.go
new file mode 100644
index 000000000..c12f8a73c
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/loader/funcdata_go120.go
@@ -0,0 +1,201 @@
+// +build go1.20
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package loader
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+// A FuncFlag holds bits about a function.
+// This list must match the list in cmd/internal/objabi/funcid.go.
+type funcFlag uint8
+
+type _Func struct {
+    entryOff    uint32 // start pc
+    nameoff     int32   // function name
+    args        int32   // in/out args size
+    deferreturn uint32  // offset of start of a deferreturn call instruction from entry, if any.
+    pcsp        uint32
+    pcfile      uint32
+    pcln        uint32
+    npcdata     uint32
+    cuOffset    uint32  // runtime.cutab offset of this function's CU
+    funcID      uint8   // set for certain special runtime functions
+    flag        funcFlag
+    _           [1]byte // pad
+    nfuncdata   uint8   // must be last
+    argptrs     uint32
+    localptrs   uint32
+}
+
+type _FuncTab struct {
+    entry   uint32
+    funcoff uint32
+}
+
+type _PCHeader struct {
+    magic          uint32  // 0xFFFFFFF0
+    pad1, pad2     uint8   // 0,0
+    minLC          uint8   // min instruction size
+    ptrSize        uint8   // size of a ptr in bytes
+    nfunc          int     // number of functions in the module
+    nfiles         uint    // number of entries in the file tab
+    textStart      uintptr // base for function entry PC offsets in this module, equal to moduledata.text
+    funcnameOffset uintptr // offset to the funcnametab variable from pcHeader
+    cuOffset       uintptr // offset to the cutab variable from pcHeader
+    filetabOffset  uintptr // offset to the filetab variable from pcHeader
+    pctabOffset    uintptr // offset to the pctab variable from pcHeader
+    pclnOffset     uintptr // offset to the pclntab variable from pcHeader
+}
+
+type _BitVector struct {
+    n        int32 // # of bits
+    bytedata *uint8
+}
+
+type _PtabEntry struct {
+    name int32
+    typ  int32
+}
+
+type _TextSection struct {
+    vaddr    uintptr // prelinked section vaddr
+    length   uintptr // section length
+    baseaddr uintptr // relocated section address
+}
+
+type _ModuleData struct {
+    pcHeader              *_PCHeader
+    funcnametab           []byte
+    cutab                 []uint32
+    filetab               []byte
+    pctab                 []byte
+    pclntable             []byte
+    ftab                  []_FuncTab
+    findfunctab           *_FindFuncBucket
+    minpc, maxpc          uintptr
+    text, etext           uintptr
+    noptrdata, enoptrdata uintptr
+    data, edata           uintptr
+    bss, ebss             uintptr
+    noptrbss, enoptrbss   uintptr
+    end, gcdata, gcbss    uintptr
+    types, etypes         uintptr
+    rodata                uintptr
+    gofunc                uintptr 
+    textsectmap           []_TextSection
+    typelinks             []int32
+    itablinks             []unsafe.Pointer
+    ptab                  []_PtabEntry
+    pluginpath            string
+    pkghashes             []struct{}
+    modulename            string
+    modulehashes          []struct{}
+    hasmain               uint8
+    gcdatamask, gcbssmask _BitVector
+    typemap               map[int32]unsafe.Pointer
+    bad                   bool
+    next                  *_ModuleData
+}
+
+
+type _FindFuncBucket struct {
+    idx        uint32
+    subbuckets [16]byte
+}
+
+
+
+func makePCtab(fp int) []byte {
+    return append([]byte{0}, encodeVariant((fp + 1) << 1)...)
+}
+
+func registerFunction(name string, pc uintptr, textSize uintptr, fp int, args int, size uintptr, argPtrs []bool, localPtrs []bool) {
+    mod := new(_ModuleData)
+
+    minpc := pc
+    maxpc := pc + size
+
+    findFuncTab := make([]_FindFuncBucket, textSize/4096 + 1)
+
+    modHeader := &_PCHeader {
+        magic   : 0xfffffff0,
+        minLC   : 1,
+        nfunc   : 1,
+        ptrSize : 4 << (^uintptr(0) >> 63),
+        textStart: minpc,
+    }
+
+    // cache arg and local stackmap
+    argptrs, localptrs := cacheStackmap(argPtrs, localPtrs, mod)
+
+    base := argptrs
+    if argptrs > localptrs {
+        base = localptrs
+    }
+
+    /* function entry */
+    lnt := []_Func {{
+        entryOff  : 0,
+        nameoff   : 1,
+        args      : int32(args),
+        pcsp      : 1,
+        nfuncdata : 2,
+        argptrs: uint32(argptrs - base),
+        localptrs: uint32(localptrs - base),
+    }}
+    nlnt := len(lnt)*int(unsafe.Sizeof(_Func{}))
+    plnt := unsafe.Pointer(&lnt[0])
+
+    /* function table */
+    ftab := []_FuncTab {
+        {entry   : 0, funcoff : 16},    
+        {entry   : uint32(size)},
+    }
+    nftab := len(ftab)*int(unsafe.Sizeof(_FuncTab{}))
+    pftab := unsafe.Pointer(&ftab[0])
+
+    pclntab := make([]byte, 0, nftab + nlnt)
+    pclntab = append(pclntab, rt.BytesFrom(pftab, nftab, nftab)...)
+    pclntab = append(pclntab, rt.BytesFrom(plnt, nlnt, nlnt)...)
+
+    /* module data */
+    *mod = _ModuleData {
+        pcHeader    : modHeader,
+        funcnametab : append(append([]byte{0}, name...), 0),
+        pctab       : append(makePCtab(fp), encodeVariant(int(size))...),
+        pclntable   : pclntab,
+        ftab        : ftab,
+        text        : minpc,
+        etext       : pc + textSize,
+        findfunctab : &findFuncTab[0],
+        minpc       : minpc,
+        maxpc       : maxpc,
+        modulename  : name,
+        gcdata: uintptr(unsafe.Pointer(&emptyByte)),
+        gcbss: uintptr(unsafe.Pointer(&emptyByte)),
+        gofunc: base,
+    }
+
+    /* verify and register the new module */
+    moduledataverify1(mod)
+    registerModule(mod)
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/internal/loader/loader.go b/vendor/github.com/bytedance/sonic/internal/loader/loader.go
new file mode 100644
index 000000000..6446a5f07
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/loader/loader.go
@@ -0,0 +1,74 @@
+//go:build darwin || linux
+// +build darwin linux
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package loader
+
+import (
+    `fmt`
+    `os`
+    `reflect`
+    `syscall`
+    `unsafe`
+)
+
+const (
+    _AP = syscall.MAP_ANON  | syscall.MAP_PRIVATE
+    _RX = syscall.PROT_READ | syscall.PROT_EXEC
+    _RW = syscall.PROT_READ | syscall.PROT_WRITE
+)
+
+type Loader   []byte
+type Function unsafe.Pointer
+
+func (self Loader) Load(fn string, fp int, args int, argPtrs []bool, localPtrs []bool) (f Function) {
+    p := os.Getpagesize()
+    n := (((len(self) - 1) / p) + 1) * p
+
+    /* register the function */
+    m := mmap(n)
+    v := fmt.Sprintf("runtime.__%s_%x", fn, m)
+    
+    registerFunction(v, m, uintptr(n), fp, args, uintptr(len(self)), argPtrs, localPtrs)
+
+    /* reference as a slice */
+    s := *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader {
+        Data : m,
+        Cap  : n,
+        Len  : len(self),
+    }))
+
+    /* copy the machine code, and make it executable */
+    copy(s, self)
+    mprotect(m, n)
+    return Function(&m)
+}
+
+func mmap(nb int) uintptr {
+    if m, _, e := syscall.RawSyscall6(syscall.SYS_MMAP, 0, uintptr(nb), _RW, _AP, 0, 0); e != 0 {
+        panic(e)
+    } else {
+        return m
+    }
+}
+
+func mprotect(p uintptr, nb int) {
+    if _, _, err := syscall.RawSyscall(syscall.SYS_MPROTECT, p, uintptr(nb), _RX); err != 0 {
+        panic(err)
+    }
+}
diff --git a/vendor/github.com/bytedance/sonic/internal/loader/loader_windows.go b/vendor/github.com/bytedance/sonic/internal/loader/loader_windows.go
new file mode 100644
index 000000000..4053ee9bb
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/loader/loader_windows.go
@@ -0,0 +1,111 @@
+//go:build windows
+// +build windows
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package loader
+
+import (
+    `fmt`
+    `os`
+    `reflect`
+    `syscall`
+    `unsafe`
+)
+
+const (
+    MEM_COMMIT  = 0x00001000
+    MEM_RESERVE = 0x00002000
+)
+
+var (
+    libKernel32                = syscall.NewLazyDLL("KERNEL32.DLL")
+    libKernel32_VirtualAlloc   = libKernel32.NewProc("VirtualAlloc")
+    libKernel32_VirtualProtect = libKernel32.NewProc("VirtualProtect")
+)
+
+type Loader   []byte
+type Function unsafe.Pointer
+
+func (self Loader) Load(fn string, fp int, args int, argPtrs []bool, localPtrs []bool) (f Function) {
+    p := os.Getpagesize()
+    n := (((len(self) - 1) / p) + 1) * p
+
+    /* register the function */
+    m := mmap(n)
+    v := fmt.Sprintf("runtime.__%s_%x", fn, m)
+    
+    registerFunction(v, m, uintptr(n), fp, args, uintptr(len(self)), argPtrs, localPtrs)
+
+    /* reference as a slice */
+    s := *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader {
+        Data : m,
+        Cap  : n,
+        Len  : len(self),
+    }))
+
+    /* copy the machine code, and make it executable */
+    copy(s, self)
+    mprotect(m, n)
+    return Function(&m)
+}
+
+func mmap(nb int) uintptr {
+    addr, err := winapi_VirtualAlloc(0, nb, MEM_COMMIT|MEM_RESERVE, syscall.PAGE_READWRITE)
+    if err != nil {
+        panic(err)
+    }
+    return addr
+}
+
+func mprotect(p uintptr, nb int) (oldProtect int) {
+    err := winapi_VirtualProtect(p, nb, syscall.PAGE_EXECUTE_READ, &oldProtect)
+    if err != nil {
+        panic(err)
+    }
+    return
+}
+
+// winapi_VirtualAlloc allocate memory
+// Doc: https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc
+func winapi_VirtualAlloc(lpAddr uintptr, dwSize int, flAllocationType int, flProtect int) (uintptr, error) {
+    r1, _, err := libKernel32_VirtualAlloc.Call(
+        lpAddr,
+        uintptr(dwSize),
+        uintptr(flAllocationType),
+        uintptr(flProtect),
+    )
+    if r1 == 0 {
+        return 0, err
+    }
+    return r1, nil
+}
+
+// winapi_VirtualProtect change memory protection
+// Doc: https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualprotect
+func winapi_VirtualProtect(lpAddr uintptr, dwSize int, flNewProtect int, lpflOldProtect *int) error {
+    r1, _, err := libKernel32_VirtualProtect.Call(
+        lpAddr,
+        uintptr(dwSize),
+        uintptr(flNewProtect),
+        uintptr(unsafe.Pointer(lpflOldProtect)),
+    )
+    if r1 == 0 {
+        return err
+    }
+    return nil
+}
diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.go
new file mode 100644
index 000000000..8a42449b8
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.go
@@ -0,0 +1,135 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native/types`
+)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __i64toa(out *byte, val int64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __u64toa(out *byte, val uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __f64toa(out *byte, val float64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __f32toa(out *byte, val float32) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __lspace(sp unsafe.Pointer, nb int, off int) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __vstring(s *string, p *int, v *types.JsonState, flags uint64)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __vnumber(s *string, p *int, v *types.JsonState)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __vsigned(s *string, p *int, v *types.JsonState)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __vunsigned(s *string, p *int, v *types.JsonState)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_one_fast(s *string, p *int) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_number(s *string, p *int) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __validate_one(s *string, p *int, m *types.StateMachine) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __get_by_path(s *string, p *int, path *[]interface{}) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __validate_utf8(s *string, p *int, m *types.StateMachine) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __validate_utf8_fast(s *string)  (ret int)
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.s b/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.s
new file mode 100644
index 000000000..3b5304093
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/avx/native_amd64.s
@@ -0,0 +1,15286 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+#include "go_asm.h"
+#include "funcdata.h"
+#include "textflag.h"
+
+TEXT ·__native_entry__(SB), NOSPLIT, $0
+	NO_LOCAL_POINTERS
+	LONG $0xf9058d48; WORD $0xffff; BYTE $0xff // leaq         $-7(%rip), %rax
+	LONG $0x24448948; BYTE $0x08               // movq         %rax, $8(%rsp)
+	BYTE $0xc3                                 // retq
+	WORD $0x0000; BYTE $0x00                   // .p2align 4, 0x00
+
+LCPI0_0:
+	QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, '                '
+
+LCPI0_1:
+	QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'
+
+LCPI0_2:
+	QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n'
+
+LCPI0_3:
+	QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r'
+
+	// .p2align 4, 0x90
+_lspace:
+	BYTE $0x55                                         // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                           // movq         %rsp, %rbp
+	WORD $0x8948; BYTE $0xd0                           // movq         %rdx, %rax
+	LONG $0x17148d4c                                   // leaq         (%rdi,%rdx), %r10
+	WORD $0x8948; BYTE $0xf2                           // movq         %rsi, %rdx
+	WORD $0x2948; BYTE $0xc2                           // subq         %rax, %rdx
+	LONG $0x0066840f; WORD $0x0000                     // je           LBB0_7, $102(%rip)
+	WORD $0x8944; BYTE $0xd1                           // movl         %r10d, %ecx
+	WORD $0xe183; BYTE $0x0f                           // andl         $15, %ecx
+	LONG $0x005a840f; WORD $0x0000                     // je           LBB0_7, $90(%rip)
+	LONG $0x014f8d4c                                   // leaq         $1(%rdi), %r9
+	LONG $0xff4e8d48                                   // leaq         $-1(%rsi), %rcx
+	QUAD $0x000100002600b849; WORD $0x0000             // movabsq      $4294977024, %r8
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB0_3:
+	LONG $0x0714be0f               // movsbl       (%rdi,%rax), %edx
+	WORD $0xfa83; BYTE $0x20       // cmpl         $32, %edx
+	LONG $0x00f0870f; WORD $0x0000 // ja           LBB0_22, $240(%rip)
+	LONG $0xd0a30f49               // btq          %rdx, %r8
+	LONG $0x00e6830f; WORD $0x0000 // jae          LBB0_22, $230(%rip)
+	LONG $0x01508d48               // leaq         $1(%rax), %rdx
+	WORD $0x3948; BYTE $0xc1       // cmpq         %rax, %rcx
+	LONG $0x000f840f; WORD $0x0000 // je           LBB0_6, $15(%rip)
+	WORD $0x0144; BYTE $0xc8       // addl         %r9d, %eax
+	WORD $0xe083; BYTE $0x0f       // andl         $15, %eax
+	WORD $0x8948; BYTE $0xd0       // movq         %rdx, %rax
+	LONG $0xffcd850f; WORD $0xffff // jne          LBB0_3, $-51(%rip)
+
+LBB0_6:
+	LONG $0x17148d4c         // leaq         (%rdi,%rdx), %r10
+	WORD $0x2948; BYTE $0xd6 // subq         %rdx, %rsi
+	WORD $0x8948; BYTE $0xf2 // movq         %rsi, %rdx
+
+LBB0_7:
+	LONG $0x10fa8348               // cmpq         $16, %rdx
+	LONG $0x006e820f; WORD $0x0000 // jb           LBB0_13, $110(%rip)
+	WORD $0x8948; BYTE $0xfe       // movq         %rdi, %rsi
+	WORD $0x294c; BYTE $0xd6       // subq         %r10, %rsi
+	QUAD $0xffffff2b056ff9c5       // vmovdqa      $-213(%rip), %xmm0  /* LCPI0_0(%rip) */
+	QUAD $0xffffff330d6ff9c5       // vmovdqa      $-205(%rip), %xmm1  /* LCPI0_1(%rip) */
+	QUAD $0xffffff3b156ff9c5       // vmovdqa      $-197(%rip), %xmm2  /* LCPI0_2(%rip) */
+	QUAD $0xffffff431d6ff9c5       // vmovdqa      $-189(%rip), %xmm3  /* LCPI0_3(%rip) */
+	WORD $0x9090; BYTE $0x90       // .p2align 4, 0x90
+
+LBB0_9:
+	LONG $0x6f79c1c4; BYTE $0x22   // vmovdqa      (%r10), %xmm4
+	LONG $0xe874d9c5               // vpcmpeqb     %xmm0, %xmm4, %xmm5
+	LONG $0xf174d9c5               // vpcmpeqb     %xmm1, %xmm4, %xmm6
+	LONG $0xeeebd1c5               // vpor         %xmm6, %xmm5, %xmm5
+	LONG $0xf274d9c5               // vpcmpeqb     %xmm2, %xmm4, %xmm6
+	LONG $0xe374d9c5               // vpcmpeqb     %xmm3, %xmm4, %xmm4
+	LONG $0xe6ebd9c5               // vpor         %xmm6, %xmm4, %xmm4
+	LONG $0xe5ebd9c5               // vpor         %xmm5, %xmm4, %xmm4
+	LONG $0xc4d7f9c5               // vpmovmskb    %xmm4, %eax
+	LONG $0xfff88366               // cmpw         $-1, %ax
+	LONG $0x0060850f; WORD $0x0000 // jne          LBB0_10, $96(%rip)
+	LONG $0x10c28349               // addq         $16, %r10
+	LONG $0xf0c28348               // addq         $-16, %rdx
+	LONG $0xf0c68348               // addq         $-16, %rsi
+	LONG $0x0ffa8348               // cmpq         $15, %rdx
+	LONG $0xffbb870f; WORD $0xffff // ja           LBB0_9, $-69(%rip)
+
+LBB0_13:
+	WORD $0x8548; BYTE $0xd2               // testq        %rdx, %rdx
+	LONG $0x0039840f; WORD $0x0000         // je           LBB0_20, $57(%rip)
+	LONG $0x12048d4d                       // leaq         (%r10,%rdx), %r8
+	WORD $0xc031                           // xorl         %eax, %eax
+	QUAD $0x000100002600b949; WORD $0x0000 // movabsq      $4294977024, %r9
+	WORD $0x9090                           // .p2align 4, 0x90
+
+LBB0_15:
+	LONG $0x34be0f41; BYTE $0x02   // movsbl       (%r10,%rax), %esi
+	WORD $0xfe83; BYTE $0x20       // cmpl         $32, %esi
+	LONG $0x002e870f; WORD $0x0000 // ja           LBB0_17, $46(%rip)
+	LONG $0xf1a30f49               // btq          %rsi, %r9
+	LONG $0x0024830f; WORD $0x0000 // jae          LBB0_17, $36(%rip)
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3948; BYTE $0xc2       // cmpq         %rax, %rdx
+	LONG $0xffdc850f; WORD $0xffff // jne          LBB0_15, $-36(%rip)
+	WORD $0x894d; BYTE $0xc2       // movq         %r8, %r10
+
+LBB0_20:
+	WORD $0x2949; BYTE $0xfa // subq         %rdi, %r10
+
+LBB0_21:
+	WORD $0x894c; BYTE $0xd0 // movq         %r10, %rax
+
+LBB0_22:
+	BYTE $0x5d // popq         %rbp
+	BYTE $0xc3 // retq
+
+LBB0_10:
+	WORD $0xb70f; BYTE $0xc0 // movzwl       %ax, %eax
+	WORD $0xd0f7             // notl         %eax
+	WORD $0xbc0f; BYTE $0xc0 // bsfl         %eax, %eax
+	WORD $0x2948; BYTE $0xf0 // subq         %rsi, %rax
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB0_17:
+	WORD $0x2949; BYTE $0xfa                                                                 // subq         %rdi, %r10
+	WORD $0x0149; BYTE $0xc2                                                                 // addq         %rax, %r10
+	LONG $0xffffe3e9; BYTE $0xff                                                             // jmp          LBB0_21, $-29(%rip)
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000; QUAD $0x0000000000000000; BYTE $0x00 // .p2align 5, 0x00
+
+LCPI1_0:
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+
+	// .p2align 4, 0x00
+LCPI1_1:
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+
+	// .p2align 4, 0x90
+_f64toa:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	BYTE $0x50                                 // pushq        %rax
+	LONG $0x7ef9e1c4; BYTE $0xc2               // vmovq        %xmm0, %rdx
+	WORD $0x8948; BYTE $0xd0                   // movq         %rdx, %rax
+	LONG $0x34e8c148                           // shrq         $52, %rax
+	LONG $0x0007ff25; BYTE $0x00               // andl         $2047, %eax
+	LONG $0x0007ff3d; BYTE $0x00               // cmpl         $2047, %eax
+	LONG $0x0c1e840f; WORD $0x0000             // je           LBB1_1, $3102(%rip)
+	WORD $0x8948; BYTE $0xfe                   // movq         %rdi, %rsi
+	WORD $0x07c6; BYTE $0x2d                   // movb         $45, (%rdi)
+	WORD $0x8949; BYTE $0xd5                   // movq         %rdx, %r13
+	LONG $0x3fedc149                           // shrq         $63, %r13
+	LONG $0x2f3c8d4e                           // leaq         (%rdi,%r13), %r15
+	QUAD $0x00000000550c8d48                   // leaq         (,%rdx,2), %rcx
+	WORD $0x8548; BYTE $0xc9                   // testq        %rcx, %rcx
+	LONG $0x01f5840f; WORD $0x0000             // je           LBB1_3, $501(%rip)
+	QUAD $0xffffffffffffbf48; WORD $0x000f     // movabsq      $4503599627370495, %rdi
+	WORD $0x2148; BYTE $0xfa                   // andq         %rdi, %rdx
+	WORD $0xc085                               // testl        %eax, %eax
+	LONG $0xd0758948                           // movq         %rsi, $-48(%rbp)
+	LONG $0x0bea840f; WORD $0x0000             // je           LBB1_5, $3050(%rip)
+	WORD $0xff48; BYTE $0xc7                   // incq         %rdi
+	WORD $0x0948; BYTE $0xd7                   // orq          %rdx, %rdi
+	LONG $0xfbcdb08d; WORD $0xffff             // leal         $-1075(%rax), %esi
+	LONG $0xfc01888d; WORD $0xffff             // leal         $-1023(%rax), %ecx
+	WORD $0xf983; BYTE $0x34                   // cmpl         $52, %ecx
+	LONG $0x001d870f; WORD $0x0000             // ja           LBB1_6, $29(%rip)
+	LONG $0x000433b9; BYTE $0x00               // movl         $1075, %ecx
+	WORD $0xc129                               // subl         %eax, %ecx
+	LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rbx
+	WORD $0xd348; BYTE $0xe3                   // shlq         %cl, %rbx
+	WORD $0xf748; BYTE $0xd3                   // notq         %rbx
+	WORD $0x8548; BYTE $0xdf                   // testq        %rbx, %rdi
+	LONG $0x0421840f; WORD $0x0000             // je           LBB1_11, $1057(%rip)
+
+LBB1_6:
+	WORD $0x8548; BYTE $0xd2                   // testq        %rdx, %rdx
+	WORD $0x940f; BYTE $0xc1                   // sete         %cl
+	WORD $0xf883; BYTE $0x02                   // cmpl         $2, %eax
+	WORD $0x930f; BYTE $0xc0                   // setae        %al
+	WORD $0xc820                               // andb         %cl, %al
+	QUAD $0x00000000bd0c8d4c                   // leaq         (,%rdi,4), %r9
+	WORD $0xb60f; BYTE $0xc0                   // movzbl       %al, %eax
+	LONG $0xb81c8d48                           // leaq         (%rax,%rdi,4), %rbx
+	LONG $0xfec38348                           // addq         $-2, %rbx
+	LONG $0x4413ce69; WORD $0x0013             // imull        $1262611, %esi, %ecx
+	LONG $0x01918d44; WORD $0xf801; BYTE $0xff // leal         $-524031(%rcx), %r10d
+	WORD $0xc084                               // testb        %al, %al
+	LONG $0xd1440f44                           // cmovel       %ecx, %r10d
+	QUAD $0x00000002bd048d4c                   // leaq         $2(,%rdi,4), %r8
+	LONG $0x16fac141                           // sarl         $22, %r10d
+	LONG $0xb1ca6941; WORD $0xe56c; BYTE $0xff // imull        $-1741647, %r10d, %ecx
+	WORD $0xe9c1; BYTE $0x13                   // shrl         $19, %ecx
+	WORD $0xf101                               // addl         %esi, %ecx
+	LONG $0x000124b8; BYTE $0x00               // movl         $292, %eax
+	WORD $0x2944; BYTE $0xd0                   // subl         %r10d, %eax
+	LONG $0x04e0c148                           // shlq         $4, %rax
+	LONG $0x34158d48; WORD $0x00b8; BYTE $0x00 // leaq         $47156(%rip), %rdx  /* _pow10_ceil_sig.g(%rip) */
+	LONG $0x101c8b4c                           // movq         (%rax,%rdx), %r11
+	LONG $0x10748b4c; BYTE $0x08               // movq         $8(%rax,%rdx), %r14
+	WORD $0xc1fe                               // incb         %cl
+	WORD $0xd348; BYTE $0xe3                   // shlq         %cl, %rbx
+	WORD $0x8948; BYTE $0xd8                   // movq         %rbx, %rax
+	WORD $0xf749; BYTE $0xe6                   // mulq         %r14
+	WORD $0x8948; BYTE $0xd6                   // movq         %rdx, %rsi
+	WORD $0x8948; BYTE $0xd8                   // movq         %rbx, %rax
+	WORD $0xf749; BYTE $0xe3                   // mulq         %r11
+	WORD $0x0148; BYTE $0xf0                   // addq         %rsi, %rax
+	LONG $0x00d28348                           // adcq         $0, %rdx
+	WORD $0xf631                               // xorl         %esi, %esi
+	LONG $0xfffea948; WORD $0xffff             // testq        $-2, %rax
+	LONG $0xc6950f40                           // setne        %sil
+	WORD $0x0948; BYTE $0xd6                   // orq          %rdx, %rsi
+	WORD $0xd349; BYTE $0xe1                   // shlq         %cl, %r9
+	WORD $0x894c; BYTE $0xc8                   // movq         %r9, %rax
+	WORD $0xf749; BYTE $0xe6                   // mulq         %r14
+	WORD $0x8948; BYTE $0xd3                   // movq         %rdx, %rbx
+	WORD $0x894c; BYTE $0xc8                   // movq         %r9, %rax
+	WORD $0xf749; BYTE $0xe3                   // mulq         %r11
+	WORD $0x8949; BYTE $0xd1                   // movq         %rdx, %r9
+	WORD $0x0148; BYTE $0xd8                   // addq         %rbx, %rax
+	LONG $0x00d18349                           // adcq         $0, %r9
+	WORD $0xdb31                               // xorl         %ebx, %ebx
+	LONG $0xfffea948; WORD $0xffff             // testq        $-2, %rax
+	WORD $0x950f; BYTE $0xc3                   // setne        %bl
+	WORD $0x094c; BYTE $0xcb                   // orq          %r9, %rbx
+	WORD $0xd349; BYTE $0xe0                   // shlq         %cl, %r8
+	WORD $0x894c; BYTE $0xc0                   // movq         %r8, %rax
+	WORD $0xf749; BYTE $0xe6                   // mulq         %r14
+	WORD $0x8948; BYTE $0xd1                   // movq         %rdx, %rcx
+	WORD $0x894c; BYTE $0xc0                   // movq         %r8, %rax
+	WORD $0xf749; BYTE $0xe3                   // mulq         %r11
+	WORD $0x0148; BYTE $0xc8                   // addq         %rcx, %rax
+	LONG $0x00d28348                           // adcq         $0, %rdx
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0xfffea948; WORD $0xffff             // testq        $-2, %rax
+	WORD $0x950f; BYTE $0xc1                   // setne        %cl
+	WORD $0x0948; BYTE $0xd1                   // orq          %rdx, %rcx
+	WORD $0xe783; BYTE $0x01                   // andl         $1, %edi
+	WORD $0x0148; BYTE $0xfe                   // addq         %rdi, %rsi
+	WORD $0x2948; BYTE $0xf9                   // subq         %rdi, %rcx
+	LONG $0x28fb8348                           // cmpq         $40, %rbx
+	LONG $0x0043820f; WORD $0x0000             // jb           LBB1_28, $67(%rip)
+	QUAD $0xcccccccccccdba48; WORD $0xcccc     // movabsq      $-3689348814741910323, %rdx
+	WORD $0x894c; BYTE $0xc8                   // movq         %r9, %rax
+	WORD $0xf748; BYTE $0xe2                   // mulq         %rdx
+	WORD $0x8948; BYTE $0xd7                   // movq         %rdx, %rdi
+	LONG $0x05efc148                           // shrq         $5, %rdi
+	QUAD $0x00000000fd048d48                   // leaq         (,%rdi,8), %rax
+	LONG $0x80148d48                           // leaq         (%rax,%rax,4), %rdx
+	WORD $0x3948; BYTE $0xd6                   // cmpq         %rdx, %rsi
+	LONG $0xc0970f41                           // seta         %r8b
+	LONG $0x80148d48                           // leaq         (%rax,%rax,4), %rdx
+	LONG $0x28c28348                           // addq         $40, %rdx
+	WORD $0xc031                               // xorl         %eax, %eax
+	WORD $0x3948; BYTE $0xca                   // cmpq         %rcx, %rdx
+	WORD $0x960f; BYTE $0xc2                   // setbe        %dl
+	WORD $0x3841; BYTE $0xd0                   // cmpb         %dl, %r8b
+	LONG $0x0134840f; WORD $0x0000             // je           LBB1_8, $308(%rip)
+
+LBB1_28:
+	WORD $0x894d; BYTE $0xc8       // movq         %r9, %r8
+	LONG $0x02e8c149               // shrq         $2, %r8
+	WORD $0x894c; BYTE $0xca       // movq         %r9, %rdx
+	LONG $0xfce28348               // andq         $-4, %rdx
+	WORD $0x3948; BYTE $0xd6       // cmpq         %rdx, %rsi
+	LONG $0xc7970f40               // seta         %dil
+	LONG $0x04728d48               // leaq         $4(%rdx), %rsi
+	WORD $0x3948; BYTE $0xce       // cmpq         %rcx, %rsi
+	WORD $0x960f; BYTE $0xc0       // setbe        %al
+	WORD $0x3040; BYTE $0xf8       // xorb         %dil, %al
+	LONG $0x0055840f; WORD $0x0000 // je           LBB1_29, $85(%rip)
+	LONG $0x02ca8348               // orq          $2, %rdx
+	LONG $0x000001bf; BYTE $0x00   // movl         $1, %edi
+	WORD $0x3948; BYTE $0xd3       // cmpq         %rdx, %rbx
+	LONG $0x000e870f; WORD $0x0000 // ja           LBB1_32, $14(%rip)
+	WORD $0x940f; BYTE $0xc0       // sete         %al
+	LONG $0x02e9c041               // shrb         $2, %r9b
+	WORD $0x2041; BYTE $0xc1       // andb         %al, %r9b
+	LONG $0xf9b60f41               // movzbl       %r9b, %edi
+
+LBB1_32:
+	WORD $0x014c; BYTE $0xc7               // addq         %r8, %rdi
+	QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq      $8589934464, %r12
+	QUAD $0x540be47f24848d49               // leaq         $1410065535(%r12), %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x003c870f; WORD $0x0000         // ja           LBB1_34, $60(%rip)
+	LONG $0x0000ece9; BYTE $0x00           // jmp          LBB1_40, $236(%rip)
+
+LBB1_3:
+	LONG $0x3007c641             // movb         $48, (%r15)
+	WORD $0x2941; BYTE $0xf7     // subl         %esi, %r15d
+	WORD $0xff41; BYTE $0xc7     // incl         %r15d
+	WORD $0x8944; BYTE $0xfb     // movl         %r15d, %ebx
+	LONG $0x0009e1e9; BYTE $0x00 // jmp          LBB1_123, $2529(%rip)
+
+LBB1_29:
+	WORD $0x3948; BYTE $0xf1               // cmpq         %rsi, %rcx
+	LONG $0xffd88349                       // sbbq         $-1, %r8
+	WORD $0x894c; BYTE $0xc7               // movq         %r8, %rdi
+	QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq      $8589934464, %r12
+	QUAD $0x540be47f24848d49               // leaq         $1410065535(%r12), %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x00b5860f; WORD $0x0000         // jbe          LBB1_40, $181(%rip)
+
+LBB1_34:
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0be8c148                       // shrq         $11, %rax
+	LONG $0x00000bba; BYTE $0x00           // movl         $11, %edx
+	LONG $0x0edd3d48; WORD $0x02e9         // cmpq         $48828125, %rax
+	LONG $0x0136820f; WORD $0x0000         // jb           LBB1_49, $310(%rip)
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0ce8c148                       // shrq         $12, %rax
+	LONG $0x00000cba; BYTE $0x00           // movl         $12, %edx
+	LONG $0x4a513d48; WORD $0x0e8d         // cmpq         $244140625, %rax
+	LONG $0x011e820f; WORD $0x0000         // jb           LBB1_49, $286(%rip)
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0de8c148                       // shrq         $13, %rax
+	LONG $0x00000dba; BYTE $0x00           // movl         $13, %edx
+	LONG $0x73953d48; WORD $0x48c2         // cmpq         $1220703125, %rax
+	LONG $0x0106820f; WORD $0x0000         // jb           LBB1_49, $262(%rip)
+	LONG $0x00000eba; BYTE $0x00           // movl         $14, %edx
+	QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq      $100000000000000, %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x00ee820f; WORD $0x0000         // jb           LBB1_49, $238(%rip)
+	LONG $0x00000fba; BYTE $0x00           // movl         $15, %edx
+	QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq      $1000000000000000, %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x00d6820f; WORD $0x0000         // jb           LBB1_49, $214(%rip)
+	QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq      $10000000000000000, %rax
+	WORD $0xd231                           // xorl         %edx, %edx
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	WORD $0x920f; BYTE $0xc2               // setb         %dl
+	WORD $0xf283; BYTE $0x11               // xorl         $17, %edx
+	LONG $0x0000bce9; BYTE $0x00           // jmp          LBB1_49, $188(%rip)
+
+LBB1_8:
+	WORD $0xd088                           // movb         %dl, %al
+	WORD $0x0148; BYTE $0xc7               // addq         %rax, %rdi
+	WORD $0xff41; BYTE $0xc2               // incl         %r10d
+	QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq      $8589934464, %r12
+	QUAD $0x540be47f24848d49               // leaq         $1410065535(%r12), %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0xff4b870f; WORD $0xffff         // ja           LBB1_34, $-181(%rip)
+
+LBB1_40:
+	LONG $0x000001ba; BYTE $0x00               // movl         $1, %edx
+	LONG $0x0aff8348                           // cmpq         $10, %rdi
+	LONG $0x008a820f; WORD $0x0000             // jb           LBB1_49, $138(%rip)
+	LONG $0x000002ba; BYTE $0x00               // movl         $2, %edx
+	LONG $0x64ff8348                           // cmpq         $100, %rdi
+	LONG $0x007b820f; WORD $0x0000             // jb           LBB1_49, $123(%rip)
+	LONG $0x000003ba; BYTE $0x00               // movl         $3, %edx
+	LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq         $1000, %rdi
+	LONG $0x0069820f; WORD $0x0000             // jb           LBB1_49, $105(%rip)
+	LONG $0x000004ba; BYTE $0x00               // movl         $4, %edx
+	LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq         $10000, %rdi
+	LONG $0x0057820f; WORD $0x0000             // jb           LBB1_49, $87(%rip)
+	LONG $0x000005ba; BYTE $0x00               // movl         $5, %edx
+	LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq         $100000, %rdi
+	LONG $0x0045820f; WORD $0x0000             // jb           LBB1_49, $69(%rip)
+	LONG $0x000006ba; BYTE $0x00               // movl         $6, %edx
+	LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq         $1000000, %rdi
+	LONG $0x0033820f; WORD $0x0000             // jb           LBB1_49, $51(%rip)
+	LONG $0x000007ba; BYTE $0x00               // movl         $7, %edx
+	LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq         $10000000, %rdi
+	LONG $0x0021820f; WORD $0x0000             // jb           LBB1_49, $33(%rip)
+	LONG $0x000008ba; BYTE $0x00               // movl         $8, %edx
+	LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq         $100000000, %rdi
+	LONG $0x000f820f; WORD $0x0000             // jb           LBB1_49, $15(%rip)
+	LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq         $1000000000, %rdi
+	LONG $0x00000aba; BYTE $0x00               // movl         $10, %edx
+	WORD $0xda83; BYTE $0x00                   // sbbl         $0, %edx
+
+LBB1_49:
+	LONG $0x12348d46                                       // leal         (%rdx,%r10), %r14d
+	LONG $0x12048d42                                       // leal         (%rdx,%r10), %eax
+	WORD $0xc083; BYTE $0xea                               // addl         $-22, %eax
+	WORD $0xf883; BYTE $0xe4                               // cmpl         $-28, %eax
+	LONG $0x00a4870f; WORD $0x0000                         // ja           LBB1_62, $164(%rip)
+	LONG $0x01678d4d                                       // leaq         $1(%r15), %r12
+	WORD $0x894c; BYTE $0xe6                               // movq         %r12, %rsi
+	LONG $0x007c8ae8; BYTE $0x00                           // callq        _format_significand, $31882(%rip)
+	WORD $0x8948; BYTE $0xc3                               // movq         %rax, %rbx
+	LONG $0xd0558b4c                                       // movq         $-48(%rbp), %r10
+	WORD $0x294c; BYTE $0xd0                               // subq         %r10, %rax
+	WORD $0x294c; BYTE $0xe8                               // subq         %r13, %rax
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB1_51:
+	WORD $0xff48; BYTE $0xc8       // decq         %rax
+	LONG $0x30ff7b80               // cmpb         $48, $-1(%rbx)
+	LONG $0xff5b8d48               // leaq         $-1(%rbx), %rbx
+	LONG $0xffef840f; WORD $0xffff // je           LBB1_51, $-17(%rip)
+	LONG $0x4fb60f41; BYTE $0x01   // movzbl       $1(%r15), %ecx
+	WORD $0x8841; BYTE $0x0f       // movb         %cl, (%r15)
+	LONG $0x02f88348               // cmpq         $2, %rax
+	LONG $0x00088c0f; WORD $0x0000 // jl           LBB1_54, $8(%rip)
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	LONG $0x2404c641; BYTE $0x2e   // movb         $46, (%r12)
+
+LBB1_54:
+	WORD $0x03c6; BYTE $0x65       // movb         $101, (%rbx)
+	WORD $0x8545; BYTE $0xf6       // testl        %r14d, %r14d
+	LONG $0x011d8e0f; WORD $0x0000 // jle          LBB1_55, $285(%rip)
+	WORD $0xff41; BYTE $0xce       // decl         %r14d
+	LONG $0x2b0143c6               // movb         $43, $1(%rbx)
+	WORD $0x8944; BYTE $0xf0       // movl         %r14d, %eax
+	WORD $0xf883; BYTE $0x64       // cmpl         $100, %eax
+	LONG $0x011f820f; WORD $0x0000 // jb           LBB1_59, $287(%rip)
+
+LBB1_58:
+	WORD $0xc189                               // movl         %eax, %ecx
+	LONG $0xcccccdba; BYTE $0xcc               // movl         $3435973837, %edx
+	LONG $0xd1af0f48                           // imulq        %rcx, %rdx
+	LONG $0x23eac148                           // shrq         $35, %rdx
+	WORD $0x0c8d; BYTE $0x12                   // leal         (%rdx,%rdx), %ecx
+	WORD $0x0c8d; BYTE $0x89                   // leal         (%rcx,%rcx,4), %ecx
+	WORD $0xc829                               // subl         %ecx, %eax
+	LONG $0xf80d8d48; WORD $0x00b3; BYTE $0x00 // leaq         $46072(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x510cb70f                           // movzwl       (%rcx,%rdx,2), %ecx
+	LONG $0x024b8966                           // movw         %cx, $2(%rbx)
+	WORD $0x300c                               // orb          $48, %al
+	WORD $0x4388; BYTE $0x04                   // movb         %al, $4(%rbx)
+	LONG $0x05c38348                           // addq         $5, %rbx
+	LONG $0x0007b3e9; BYTE $0x00               // jmp          LBB1_122, $1971(%rip)
+
+LBB1_62:
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0x0105880f; WORD $0x0000 // js           LBB1_63, $261(%rip)
+	WORD $0x8945; BYTE $0xf6       // movl         %r14d, %r14d
+	LONG $0x371c8d4b               // leaq         (%r15,%r14), %rbx
+	WORD $0x894c; BYTE $0xfe       // movq         %r15, %rsi
+	LONG $0x0007dae8; BYTE $0x00   // callq        _format_integer, $2010(%rip)
+	WORD $0x3948; BYTE $0xd8       // cmpq         %rbx, %rax
+	LONG $0x0154830f; WORD $0x0000 // jae          LBB1_103, $340(%rip)
+	LONG $0xd0558b4c               // movq         $-48(%rbp), %r10
+	WORD $0x014d; BYTE $0xd5       // addq         %r10, %r13
+	WORD $0x014d; BYTE $0xf5       // addq         %r14, %r13
+	WORD $0x2949; BYTE $0xc5       // subq         %rax, %r13
+	LONG $0x10fd8349               // cmpq         $16, %r13
+	LONG $0x01f1830f; WORD $0x0000 // jae          LBB1_105, $497(%rip)
+
+LBB1_120:
+	WORD $0x8948; BYTE $0xc2     // movq         %rax, %rdx
+	LONG $0x000372e9; BYTE $0x00 // jmp          LBB1_121, $882(%rip)
+
+LBB1_11:
+	WORD $0xd348; BYTE $0xef               // shrq         %cl, %rdi
+	QUAD $0x0001ffffff80b848; WORD $0x0000 // movabsq      $8589934464, %rax
+	LONG $0xe47f0548; WORD $0x540b         // addq         $1410065535, %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x0130860f; WORD $0x0000         // jbe          LBB1_17, $304(%rip)
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0be8c148                       // shrq         $11, %rax
+	LONG $0x00000bba; BYTE $0x00           // movl         $11, %edx
+	LONG $0x0edd3d48; WORD $0x02e9         // cmpq         $48828125, %rax
+	LONG $0x01a2820f; WORD $0x0000         // jb           LBB1_27, $418(%rip)
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0ce8c148                       // shrq         $12, %rax
+	LONG $0x00000cba; BYTE $0x00           // movl         $12, %edx
+	LONG $0x4a513d48; WORD $0x0e8d         // cmpq         $244140625, %rax
+	LONG $0x018a820f; WORD $0x0000         // jb           LBB1_27, $394(%rip)
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0de8c148                       // shrq         $13, %rax
+	LONG $0x00000dba; BYTE $0x00           // movl         $13, %edx
+	LONG $0x73953d48; WORD $0x48c2         // cmpq         $1220703125, %rax
+	LONG $0x0172820f; WORD $0x0000         // jb           LBB1_27, $370(%rip)
+	LONG $0x00000eba; BYTE $0x00           // movl         $14, %edx
+	QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq      $100000000000000, %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x015a820f; WORD $0x0000         // jb           LBB1_27, $346(%rip)
+	QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq      $1000000000000000, %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x000010ba; BYTE $0x00           // movl         $16, %edx
+
+LBB1_26:
+	WORD $0xda83; BYTE $0x00     // sbbl         $0, %edx
+	LONG $0x000140e9; BYTE $0x00 // jmp          LBB1_27, $320(%rip)
+
+LBB1_55:
+	LONG $0x2d0143c6               // movb         $45, $1(%rbx)
+	LONG $0x000001b8; BYTE $0x00   // movl         $1, %eax
+	WORD $0x2944; BYTE $0xf0       // subl         %r14d, %eax
+	WORD $0xf883; BYTE $0x64       // cmpl         $100, %eax
+	LONG $0xfee1830f; WORD $0xffff // jae          LBB1_58, $-287(%rip)
+
+LBB1_59:
+	WORD $0xf883; BYTE $0x0a                   // cmpl         $10, %eax
+	LONG $0x008a820f; WORD $0x0000             // jb           LBB1_61, $138(%rip)
+	WORD $0xc089                               // movl         %eax, %eax
+	LONG $0xe50d8d48; WORD $0x00b2; BYTE $0x00 // leaq         $45797(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	LONG $0x02438966                           // movw         %ax, $2(%rbx)
+	LONG $0x04c38348                           // addq         $4, %rbx
+	LONG $0x0006a5e9; BYTE $0x00               // jmp          LBB1_122, $1701(%rip)
+
+LBB1_63:
+	WORD $0x8545; BYTE $0xf6                   // testl        %r14d, %r14d
+	LONG $0x03ca8f0f; WORD $0x0000             // jg           LBB1_76, $970(%rip)
+	LONG $0x07c74166; WORD $0x2e30             // movw         $11824, (%r15)
+	LONG $0x02c78349                           // addq         $2, %r15
+	WORD $0x8545; BYTE $0xf6                   // testl        %r14d, %r14d
+	LONG $0x03b7890f; WORD $0x0000             // jns          LBB1_76, $951(%rip)
+	WORD $0x8941; BYTE $0xd0                   // movl         %edx, %r8d
+	WORD $0xf741; BYTE $0xd0                   // notl         %r8d
+	WORD $0x2945; BYTE $0xd0                   // subl         %r10d, %r8d
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0x7ff88341                           // cmpl         $127, %r8d
+	LONG $0x038e820f; WORD $0x0000             // jb           LBB1_74, $910(%rip)
+	WORD $0xff49; BYTE $0xc0                   // incq         %r8
+	WORD $0x894c; BYTE $0xc0                   // movq         %r8, %rax
+	WORD $0x214c; BYTE $0xe0                   // andq         %r12, %rax
+	LONG $0x80488d48                           // leaq         $-128(%rax), %rcx
+	WORD $0x8948; BYTE $0xce                   // movq         %rcx, %rsi
+	LONG $0x07eec148                           // shrq         $7, %rsi
+	WORD $0xff48; BYTE $0xc6                   // incq         %rsi
+	WORD $0x8941; BYTE $0xf1                   // movl         %esi, %r9d
+	LONG $0x03e18341                           // andl         $3, %r9d
+	LONG $0x80f98148; WORD $0x0001; BYTE $0x00 // cmpq         $384, %rcx
+	LONG $0x0264830f; WORD $0x0000             // jae          LBB1_68, $612(%rip)
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0xd0558b4c                           // movq         $-48(%rbp), %r10
+	LONG $0x000307e9; BYTE $0x00               // jmp          LBB1_70, $775(%rip)
+
+LBB1_103:
+	LONG $0xd0558b4c             // movq         $-48(%rbp), %r10
+	LONG $0x000635e9; BYTE $0x00 // jmp          LBB1_122, $1589(%rip)
+
+LBB1_61:
+	WORD $0x3004                 // addb         $48, %al
+	WORD $0x4388; BYTE $0x02     // movb         %al, $2(%rbx)
+	LONG $0x03c38348             // addq         $3, %rbx
+	LONG $0x000627e9; BYTE $0x00 // jmp          LBB1_122, $1575(%rip)
+
+LBB1_17:
+	LONG $0x000001ba; BYTE $0x00               // movl         $1, %edx
+	LONG $0x0aff8348                           // cmpq         $10, %rdi
+	LONG $0x007b820f; WORD $0x0000             // jb           LBB1_27, $123(%rip)
+	LONG $0x000002ba; BYTE $0x00               // movl         $2, %edx
+	LONG $0x64ff8348                           // cmpq         $100, %rdi
+	LONG $0x006c820f; WORD $0x0000             // jb           LBB1_27, $108(%rip)
+	LONG $0x000003ba; BYTE $0x00               // movl         $3, %edx
+	LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq         $1000, %rdi
+	LONG $0x005a820f; WORD $0x0000             // jb           LBB1_27, $90(%rip)
+	LONG $0x000004ba; BYTE $0x00               // movl         $4, %edx
+	LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq         $10000, %rdi
+	LONG $0x0048820f; WORD $0x0000             // jb           LBB1_27, $72(%rip)
+	LONG $0x000005ba; BYTE $0x00               // movl         $5, %edx
+	LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq         $100000, %rdi
+	LONG $0x0036820f; WORD $0x0000             // jb           LBB1_27, $54(%rip)
+	LONG $0x000006ba; BYTE $0x00               // movl         $6, %edx
+	LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq         $1000000, %rdi
+	LONG $0x0024820f; WORD $0x0000             // jb           LBB1_27, $36(%rip)
+	LONG $0x000007ba; BYTE $0x00               // movl         $7, %edx
+	LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq         $10000000, %rdi
+	LONG $0x0012820f; WORD $0x0000             // jb           LBB1_27, $18(%rip)
+	LONG $0x000008ba; BYTE $0x00               // movl         $8, %edx
+	LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq         $100000000, %rdi
+	LONG $0x05c8830f; WORD $0x0000             // jae          LBB1_25, $1480(%rip)
+
+LBB1_27:
+	WORD $0x894c; BYTE $0xfe     // movq         %r15, %rsi
+	LONG $0x0005d4e8; BYTE $0x00 // callq        _format_integer, $1492(%rip)
+	WORD $0x8948; BYTE $0xc3     // movq         %rax, %rbx
+	WORD $0x5d2b; BYTE $0xd0     // subl         $-48(%rbp), %ebx
+	LONG $0x00058de9; BYTE $0x00 // jmp          LBB1_123, $1421(%rip)
+
+LBB1_105:
+	LONG $0x80fd8149; WORD $0x0000; BYTE $0x00 // cmpq         $128, %r13
+	LONG $0x0007830f; WORD $0x0000             // jae          LBB1_110, $7(%rip)
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0x00013ce9; BYTE $0x00               // jmp          LBB1_107, $316(%rip)
+
+LBB1_110:
+	WORD $0x894c; BYTE $0xe9                   // movq         %r13, %rcx
+	LONG $0x80e18348                           // andq         $-128, %rcx
+	LONG $0x80798d48                           // leaq         $-128(%rcx), %rdi
+	WORD $0x8948; BYTE $0xfe                   // movq         %rdi, %rsi
+	LONG $0x07eec148                           // shrq         $7, %rsi
+	WORD $0xff48; BYTE $0xc6                   // incq         %rsi
+	WORD $0xf289                               // movl         %esi, %edx
+	WORD $0xe283; BYTE $0x03                   // andl         $3, %edx
+	LONG $0x80ff8148; WORD $0x0001; BYTE $0x00 // cmpq         $384, %rdi
+	LONG $0x0007830f; WORD $0x0000             // jae          LBB1_112, $7(%rip)
+	WORD $0xff31                               // xorl         %edi, %edi
+	LONG $0x0000abe9; BYTE $0x00               // jmp          LBB1_114, $171(%rip)
+
+LBB1_112:
+	LONG $0xfce68348                     // andq         $-4, %rsi
+	WORD $0xff31                         // xorl         %edi, %edi
+	QUAD $0xfffff8d9056ffdc5             // vmovdqa      $-1831(%rip), %ymm0  /* LCPI1_0(%rip) */
+	QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB1_113:
+	LONG $0x047ffec5; BYTE $0x38               // vmovdqu      %ymm0, (%rax,%rdi)
+	LONG $0x447ffec5; WORD $0x2038             // vmovdqu      %ymm0, $32(%rax,%rdi)
+	LONG $0x447ffec5; WORD $0x4038             // vmovdqu      %ymm0, $64(%rax,%rdi)
+	LONG $0x447ffec5; WORD $0x6038             // vmovdqu      %ymm0, $96(%rax,%rdi)
+	QUAD $0x00008038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $128(%rax,%rdi)
+	QUAD $0x0000a038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $160(%rax,%rdi)
+	QUAD $0x0000c038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $192(%rax,%rdi)
+	QUAD $0x0000e038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $224(%rax,%rdi)
+	QUAD $0x00010038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $256(%rax,%rdi)
+	QUAD $0x00012038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $288(%rax,%rdi)
+	QUAD $0x00014038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $320(%rax,%rdi)
+	QUAD $0x00016038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $352(%rax,%rdi)
+	QUAD $0x00018038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $384(%rax,%rdi)
+	QUAD $0x0001a038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $416(%rax,%rdi)
+	QUAD $0x0001c038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $448(%rax,%rdi)
+	QUAD $0x0001e038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $480(%rax,%rdi)
+	LONG $0x00c78148; WORD $0x0002; BYTE $0x00 // addq         $512, %rdi
+	LONG $0xfcc68348                           // addq         $-4, %rsi
+	LONG $0xff6c850f; WORD $0xffff             // jne          LBB1_113, $-148(%rip)
+
+LBB1_114:
+	WORD $0x8548; BYTE $0xd2                               // testq        %rdx, %rdx
+	LONG $0x0047840f; WORD $0x0000                         // je           LBB1_117, $71(%rip)
+	LONG $0x07348d48                                       // leaq         (%rdi,%rax), %rsi
+	LONG $0x60c68348                                       // addq         $96, %rsi
+	LONG $0x07e2c148                                       // shlq         $7, %rdx
+	WORD $0xff31                                           // xorl         %edi, %edi
+	QUAD $0xfffff81d056ffdc5                               // vmovdqa      $-2019(%rip), %ymm0  /* LCPI1_0(%rip) */
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB1_116:
+	LONG $0x447ffec5; WORD $0xa03e // vmovdqu      %ymm0, $-96(%rsi,%rdi)
+	LONG $0x447ffec5; WORD $0xc03e // vmovdqu      %ymm0, $-64(%rsi,%rdi)
+	LONG $0x447ffec5; WORD $0xe03e // vmovdqu      %ymm0, $-32(%rsi,%rdi)
+	LONG $0x047ffec5; BYTE $0x3e   // vmovdqu      %ymm0, (%rsi,%rdi)
+	LONG $0x80ef8348               // subq         $-128, %rdi
+	WORD $0x3948; BYTE $0xfa       // cmpq         %rdi, %rdx
+	LONG $0xffdc850f; WORD $0xffff // jne          LBB1_116, $-36(%rip)
+
+LBB1_117:
+	WORD $0x3949; BYTE $0xcd       // cmpq         %rcx, %r13
+	LONG $0x0444840f; WORD $0x0000 // je           LBB1_122, $1092(%rip)
+	LONG $0x70c5f641               // testb        $112, %r13b
+	LONG $0x004d840f; WORD $0x0000 // je           LBB1_119, $77(%rip)
+
+LBB1_107:
+	WORD $0x894c; BYTE $0xee // movq         %r13, %rsi
+	LONG $0xf0e68348         // andq         $-16, %rsi
+	WORD $0x8948; BYTE $0xc2 // movq         %rax, %rdx
+	WORD $0x0148; BYTE $0xf2 // addq         %rsi, %rdx
+	QUAD $0xfffff7e4056ff9c5 // vmovdqa      $-2076(%rip), %xmm0  /* LCPI1_1(%rip) */
+	LONG $0x90909090         // .p2align 4, 0x90
+
+LBB1_108:
+	LONG $0x047ffac5; BYTE $0x08   // vmovdqu      %xmm0, (%rax,%rcx)
+	LONG $0x10c18348               // addq         $16, %rcx
+	WORD $0x3948; BYTE $0xce       // cmpq         %rcx, %rsi
+	LONG $0xffee850f; WORD $0xffff // jne          LBB1_108, $-18(%rip)
+	WORD $0x3949; BYTE $0xf5       // cmpq         %rsi, %r13
+	LONG $0x0406840f; WORD $0x0000 // je           LBB1_122, $1030(%rip)
+	LONG $0x90909090; BYTE $0x90   // .p2align 4, 0x90
+
+LBB1_121:
+	WORD $0x02c6; BYTE $0x30       // movb         $48, (%rdx)
+	WORD $0xff48; BYTE $0xc2       // incq         %rdx
+	WORD $0x3948; BYTE $0xda       // cmpq         %rbx, %rdx
+	LONG $0xfff1820f; WORD $0xffff // jb           LBB1_121, $-15(%rip)
+	LONG $0x0003ede9; BYTE $0x00   // jmp          LBB1_122, $1005(%rip)
+
+LBB1_119:
+	WORD $0x0148; BYTE $0xc8     // addq         %rcx, %rax
+	LONG $0xfffc6ae9; BYTE $0xff // jmp          LBB1_120, $-918(%rip)
+
+LBB1_68:
+	LONG $0xfce68348                           // andq         $-4, %rsi
+	LONG $0xd0558b4c                           // movq         $-48(%rbp), %r10
+	LONG $0x2a1c8d4b                           // leaq         (%r10,%r13), %rbx
+	LONG $0xe2c38148; WORD $0x0001; BYTE $0x00 // addq         $482, %rbx
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	QUAD $0xfffff767056ffdc5                   // vmovdqa      $-2201(%rip), %ymm0  /* LCPI1_0(%rip) */
+
+LBB1_69:
+	QUAD $0xfffe200b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-480(%rbx,%rcx)
+	QUAD $0xfffe400b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-448(%rbx,%rcx)
+	QUAD $0xfffe600b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-416(%rbx,%rcx)
+	QUAD $0xfffe800b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-384(%rbx,%rcx)
+	QUAD $0xfffea00b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-352(%rbx,%rcx)
+	QUAD $0xfffec00b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-320(%rbx,%rcx)
+	QUAD $0xfffee00b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-288(%rbx,%rcx)
+	QUAD $0xffff000b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-256(%rbx,%rcx)
+	QUAD $0xffff200b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-224(%rbx,%rcx)
+	QUAD $0xffff400b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-192(%rbx,%rcx)
+	QUAD $0xffff600b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-160(%rbx,%rcx)
+	LONG $0x447ffec5; WORD $0x800b             // vmovdqu      %ymm0, $-128(%rbx,%rcx)
+	LONG $0x447ffec5; WORD $0xa00b             // vmovdqu      %ymm0, $-96(%rbx,%rcx)
+	LONG $0x447ffec5; WORD $0xc00b             // vmovdqu      %ymm0, $-64(%rbx,%rcx)
+	LONG $0x447ffec5; WORD $0xe00b             // vmovdqu      %ymm0, $-32(%rbx,%rcx)
+	LONG $0x047ffec5; BYTE $0x0b               // vmovdqu      %ymm0, (%rbx,%rcx)
+	LONG $0x00c18148; WORD $0x0002; BYTE $0x00 // addq         $512, %rcx
+	LONG $0xfcc68348                           // addq         $-4, %rsi
+	LONG $0xff6f850f; WORD $0xffff             // jne          LBB1_69, $-145(%rip)
+
+LBB1_70:
+	WORD $0x854d; BYTE $0xc9       // testq        %r9, %r9
+	LONG $0x003c840f; WORD $0x0000 // je           LBB1_73, $60(%rip)
+	WORD $0x014c; BYTE $0xe9       // addq         %r13, %rcx
+	WORD $0x014c; BYTE $0xd1       // addq         %r10, %rcx
+	LONG $0x62c18348               // addq         $98, %rcx
+	LONG $0x07e1c149               // shlq         $7, %r9
+	WORD $0xf631                   // xorl         %esi, %esi
+	QUAD $0xfffff6b5056ffdc5       // vmovdqa      $-2379(%rip), %ymm0  /* LCPI1_0(%rip) */
+
+LBB1_72:
+	LONG $0x447ffec5; WORD $0xa031 // vmovdqu      %ymm0, $-96(%rcx,%rsi)
+	LONG $0x447ffec5; WORD $0xc031 // vmovdqu      %ymm0, $-64(%rcx,%rsi)
+	LONG $0x447ffec5; WORD $0xe031 // vmovdqu      %ymm0, $-32(%rcx,%rsi)
+	LONG $0x047ffec5; BYTE $0x31   // vmovdqu      %ymm0, (%rcx,%rsi)
+	LONG $0x80ee8348               // subq         $-128, %rsi
+	WORD $0x3949; BYTE $0xf1       // cmpq         %rsi, %r9
+	LONG $0xffdc850f; WORD $0xffff // jne          LBB1_72, $-36(%rip)
+
+LBB1_73:
+	WORD $0x0149; BYTE $0xc7       // addq         %rax, %r15
+	WORD $0x3949; BYTE $0xc0       // cmpq         %rax, %r8
+	LONG $0x0014840f; WORD $0x0000 // je           LBB1_76, $20(%rip)
+
+LBB1_74:
+	WORD $0x0144; BYTE $0xf0 // addl         %r14d, %eax
+	WORD $0xd8f7             // negl         %eax
+
+	// .p2align 4, 0x90
+LBB1_75:
+	LONG $0x3007c641               // movb         $48, (%r15)
+	WORD $0xff49; BYTE $0xc7       // incq         %r15
+	WORD $0xc8ff                   // decl         %eax
+	LONG $0xfff1850f; WORD $0xffff // jne          LBB1_75, $-15(%rip)
+
+LBB1_76:
+	WORD $0x894c; BYTE $0xfe                               // movq         %r15, %rsi
+	WORD $0xf8c5; BYTE $0x77                               // vzeroupper
+	LONG $0x007706e8; BYTE $0x00                           // callq        _format_significand, $30470(%rip)
+	WORD $0xc389                                           // movl         %eax, %ebx
+	WORD $0x2844; BYTE $0xfb                               // subb         %r15b, %bl
+	WORD $0x2844; BYTE $0xf3                               // subb         %r14b, %bl
+	LONG $0x3e2c8d47                                       // leal         (%r14,%r15), %r13d
+	WORD $0x2941; BYTE $0xc5                               // subl         %eax, %r13d
+	LONG $0xff458d45                                       // leal         $-1(%r13), %r8d
+	LONG $0xfe7d8d41                                       // leal         $-2(%r13), %edi
+	WORD $0xc931                                           // xorl         %ecx, %ecx
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB1_77:
+	WORD $0xda89                   // movl         %ebx, %edx
+	WORD $0x5a8d; BYTE $0x03       // leal         $3(%rdx), %ebx
+	WORD $0xc7ff                   // incl         %edi
+	LONG $0xff087c80; BYTE $0x30   // cmpb         $48, $-1(%rax,%rcx)
+	LONG $0xff498d48               // leaq         $-1(%rcx), %rcx
+	LONG $0xffea840f; WORD $0xffff // je           LBB1_77, $-22(%rip)
+	LONG $0x081c8d48               // leaq         (%rax,%rcx), %rbx
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	WORD $0x8545; BYTE $0xf6       // testl        %r14d, %r14d
+	LONG $0xd0558b4c               // movq         $-48(%rbp), %r10
+	LONG $0x02778e0f; WORD $0x0000 // jle          LBB1_122, $631(%rip)
+	WORD $0xc689                   // movl         %eax, %esi
+	WORD $0x2944; BYTE $0xfe       // subl         %r15d, %esi
+	WORD $0xce01                   // addl         %ecx, %esi
+	WORD $0xc6ff                   // incl         %esi
+	WORD $0x3941; BYTE $0xf6       // cmpl         %esi, %r14d
+	LONG $0x00308d0f; WORD $0x0000 // jge          LBB1_80, $48(%rip)
+	WORD $0x8941; BYTE $0xc1       // movl         %eax, %r9d
+	WORD $0x2945; BYTE $0xf1       // subl         %r14d, %r9d
+	WORD $0x2945; BYTE $0xf9       // subl         %r15d, %r9d
+	WORD $0xff41; BYTE $0xc1       // incl         %r9d
+	LONG $0x093c8d49               // leaq         (%r9,%rcx), %rdi
+	WORD $0xff85                   // testl        %edi, %edi
+	LONG $0x00e48e0f; WORD $0x0000 // jle          LBB1_99, $228(%rip)
+	WORD $0x8941; BYTE $0xf8       // movl         %edi, %r8d
+	LONG $0xff588d49               // leaq         $-1(%r8), %rbx
+	LONG $0x03fb8348               // cmpq         $3, %rbx
+	LONG $0x006c830f; WORD $0x0000 // jae          LBB1_100, $108(%rip)
+	WORD $0xdb31                   // xorl         %ebx, %ebx
+	LONG $0x000090e9; BYTE $0x00   // jmp          LBB1_96, $144(%rip)
+
+LBB1_80:
+	WORD $0x8945; BYTE $0xc3                   // movl         %r8d, %r11d
+	WORD $0x2949; BYTE $0xcb                   // subq         %rcx, %r11
+	WORD $0x8545; BYTE $0xdb                   // testl        %r11d, %r11d
+	LONG $0x02268e0f; WORD $0x0000             // jle          LBB1_122, $550(%rip)
+	WORD $0x0145; BYTE $0xfe                   // addl         %r15d, %r14d
+	WORD $0x2941; BYTE $0xc6                   // subl         %eax, %r14d
+	LONG $0xfec68341                           // addl         $-2, %r14d
+	WORD $0x2949; BYTE $0xce                   // subq         %rcx, %r14
+	WORD $0xd231                               // xorl         %edx, %edx
+	LONG $0x7ffe8341                           // cmpl         $127, %r14d
+	LONG $0x01fc820f; WORD $0x0000             // jb           LBB1_91, $508(%rip)
+	LONG $0xfec58341                           // addl         $-2, %r13d
+	WORD $0x2949; BYTE $0xcd                   // subq         %rcx, %r13
+	WORD $0x8945; BYTE $0xf0                   // movl         %r14d, %r8d
+	WORD $0xff49; BYTE $0xc0                   // incq         %r8
+	WORD $0x214d; BYTE $0xc4                   // andq         %r8, %r12
+	WORD $0x8941; BYTE $0xf9                   // movl         %edi, %r9d
+	WORD $0xff49; BYTE $0xc1                   // incq         %r9
+	LONG $0x80e18349                           // andq         $-128, %r9
+	LONG $0x24548d49; BYTE $0x80               // leaq         $-128(%r12), %rdx
+	WORD $0x8949; BYTE $0xd2                   // movq         %rdx, %r10
+	LONG $0x07eac149                           // shrq         $7, %r10
+	WORD $0xff49; BYTE $0xc2                   // incq         %r10
+	LONG $0x80fa8148; WORD $0x0001; BYTE $0x00 // cmpq         $384, %rdx
+	LONG $0x0083830f; WORD $0x0000             // jae          LBB1_84, $131(%rip)
+	WORD $0xff31                               // xorl         %edi, %edi
+	LONG $0x000138e9; BYTE $0x00               // jmp          LBB1_86, $312(%rip)
+
+LBB1_100:
+	WORD $0x0149; BYTE $0xc9 // addq         %rcx, %r9
+	LONG $0xfce18341         // andl         $-4, %r9d
+	WORD $0xf749; BYTE $0xd9 // negq         %r9
+	WORD $0xdb31             // xorl         %ebx, %ebx
+	WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB1_101:
+	LONG $0x183c8d48               // leaq         (%rax,%rbx), %rdi
+	LONG $0xfd39748b               // movl         $-3(%rcx,%rdi), %esi
+	LONG $0xfe397489               // movl         %esi, $-2(%rcx,%rdi)
+	LONG $0xfcc38348               // addq         $-4, %rbx
+	WORD $0x3949; BYTE $0xd9       // cmpq         %rbx, %r9
+	LONG $0xffe7850f; WORD $0xffff // jne          LBB1_101, $-25(%rip)
+	WORD $0xf748; BYTE $0xdb       // negq         %rbx
+
+LBB1_96:
+	LONG $0x03c0f641                           // testb        $3, %r8b
+	LONG $0x0032840f; WORD $0x0000             // je           LBB1_99, $50(%rip)
+	LONG $0xc2b60f44                           // movzbl       %dl, %r8d
+	LONG $0x03e08341                           // andl         $3, %r8d
+	WORD $0xf749; BYTE $0xd8                   // negq         %r8
+	WORD $0x8948; BYTE $0xc6                   // movq         %rax, %rsi
+	WORD $0x2948; BYTE $0xde                   // subq         %rbx, %rsi
+	WORD $0xff31                               // xorl         %edi, %edi
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB1_98:
+	LONG $0x3e1c8d48               // leaq         (%rsi,%rdi), %rbx
+	LONG $0x1914b60f               // movzbl       (%rcx,%rbx), %edx
+	LONG $0x01195488               // movb         %dl, $1(%rcx,%rbx)
+	WORD $0xff48; BYTE $0xcf       // decq         %rdi
+	WORD $0x3949; BYTE $0xf8       // cmpq         %rdi, %r8
+	LONG $0xffe8850f; WORD $0xffff // jne          LBB1_98, $-24(%rip)
+
+LBB1_99:
+	WORD $0x8944; BYTE $0xf2     // movl         %r14d, %edx
+	LONG $0x1704c641; BYTE $0x2e // movb         $46, (%r15,%rdx)
+	LONG $0x081c8d48             // leaq         (%rax,%rcx), %rbx
+	LONG $0x02c38348             // addq         $2, %rbx
+	LONG $0x000154e9; BYTE $0x00 // jmp          LBB1_122, $340(%rip)
+
+LBB1_84:
+	WORD $0x8944; BYTE $0xeb // movl         %r13d, %ebx
+	WORD $0xff48; BYTE $0xc3 // incq         %rbx
+	LONG $0x80e38348         // andq         $-128, %rbx
+	LONG $0x80c38348         // addq         $-128, %rbx
+	LONG $0x07ebc148         // shrq         $7, %rbx
+	WORD $0xff48; BYTE $0xc3 // incq         %rbx
+	LONG $0xfce38348         // andq         $-4, %rbx
+	WORD $0xff31             // xorl         %edi, %edi
+	QUAD $0xfffff4d0056ffdc5 // vmovdqa      $-2864(%rip), %ymm0  /* LCPI1_0(%rip) */
+
+LBB1_85:
+	LONG $0x38148d48                           // leaq         (%rax,%rdi), %rdx
+	LONG $0x447ffec5; WORD $0x0111             // vmovdqu      %ymm0, $1(%rcx,%rdx)
+	LONG $0x447ffec5; WORD $0x2111             // vmovdqu      %ymm0, $33(%rcx,%rdx)
+	LONG $0x447ffec5; WORD $0x4111             // vmovdqu      %ymm0, $65(%rcx,%rdx)
+	LONG $0x447ffec5; WORD $0x6111             // vmovdqu      %ymm0, $97(%rcx,%rdx)
+	QUAD $0x00008111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $129(%rcx,%rdx)
+	QUAD $0x0000a111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $161(%rcx,%rdx)
+	QUAD $0x0000c111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $193(%rcx,%rdx)
+	QUAD $0x0000e111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $225(%rcx,%rdx)
+	QUAD $0x00010111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $257(%rcx,%rdx)
+	QUAD $0x00012111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $289(%rcx,%rdx)
+	QUAD $0x00014111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $321(%rcx,%rdx)
+	QUAD $0x00016111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $353(%rcx,%rdx)
+	QUAD $0x00018111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $385(%rcx,%rdx)
+	QUAD $0x0001a111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $417(%rcx,%rdx)
+	QUAD $0x0001c111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $449(%rcx,%rdx)
+	QUAD $0x0001e111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $481(%rcx,%rdx)
+	LONG $0x00c78148; WORD $0x0002; BYTE $0x00 // addq         $512, %rdi
+	LONG $0xfcc38348                           // addq         $-4, %rbx
+	LONG $0xff67850f; WORD $0xffff             // jne          LBB1_85, $-153(%rip)
+
+LBB1_86:
+	WORD $0x0149; BYTE $0xc1                   // addq         %rax, %r9
+	LONG $0x03c2f641                           // testb        $3, %r10b
+	LONG $0x0059840f; WORD $0x0000             // je           LBB1_89, $89(%rip)
+	WORD $0xff41; BYTE $0xc5                   // incl         %r13d
+	LONG $0x80e58141; WORD $0x0001; BYTE $0x00 // andl         $384, %r13d
+	LONG $0x80c58341                           // addl         $-128, %r13d
+	LONG $0x07edc141                           // shrl         $7, %r13d
+	WORD $0xfe41; BYTE $0xc5                   // incb         %r13b
+	LONG $0xd5b60f41                           // movzbl       %r13b, %edx
+	WORD $0xe283; BYTE $0x03                   // andl         $3, %edx
+	LONG $0x07e2c148                           // shlq         $7, %rdx
+	WORD $0x0148; BYTE $0xf8                   // addq         %rdi, %rax
+	LONG $0x61c08348                           // addq         $97, %rax
+	WORD $0xf631                               // xorl         %esi, %esi
+	QUAD $0xfffff3f9056ffdc5                   // vmovdqa      $-3079(%rip), %ymm0  /* LCPI1_0(%rip) */
+
+LBB1_88:
+	LONG $0x303c8d48               // leaq         (%rax,%rsi), %rdi
+	LONG $0x447ffec5; WORD $0xa039 // vmovdqu      %ymm0, $-96(%rcx,%rdi)
+	LONG $0x447ffec5; WORD $0xc039 // vmovdqu      %ymm0, $-64(%rcx,%rdi)
+	LONG $0x447ffec5; WORD $0xe039 // vmovdqu      %ymm0, $-32(%rcx,%rdi)
+	LONG $0x047ffec5; BYTE $0x39   // vmovdqu      %ymm0, (%rcx,%rdi)
+	LONG $0x80ee8348               // subq         $-128, %rsi
+	WORD $0x3948; BYTE $0xf2       // cmpq         %rsi, %rdx
+	LONG $0xffd8850f; WORD $0xffff // jne          LBB1_88, $-40(%rip)
+
+LBB1_89:
+	LONG $0x091c8d4a                       // leaq         (%rcx,%r9), %rbx
+	WORD $0xff48; BYTE $0xc3               // incq         %rbx
+	WORD $0x394d; BYTE $0xe0               // cmpq         %r12, %r8
+	LONG $0xd0558b4c                       // movq         $-48(%rbp), %r10
+	LONG $0x001e840f; WORD $0x0000         // je           LBB1_122, $30(%rip)
+	WORD $0x8944; BYTE $0xe2               // movl         %r12d, %edx
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB1_91:
+	WORD $0x03c6; BYTE $0x30       // movb         $48, (%rbx)
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	WORD $0xc2ff                   // incl         %edx
+	WORD $0x3944; BYTE $0xda       // cmpl         %r11d, %edx
+	LONG $0xffef8c0f; WORD $0xffff // jl           LBB1_91, $-17(%rip)
+
+LBB1_122:
+	WORD $0x2944; BYTE $0xd3 // subl         %r10d, %ebx
+
+LBB1_123:
+	WORD $0xd889             // movl         %ebx, %eax
+	LONG $0x08c48348         // addq         $8, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	BYTE $0xc3               // retq
+
+LBB1_1:
+	WORD $0xdb31                 // xorl         %ebx, %ebx
+	LONG $0xffffe5e9; BYTE $0xff // jmp          LBB1_123, $-27(%rip)
+
+LBB1_5:
+	LONG $0xfffbcebe; BYTE $0xff // movl         $-1074, %esi
+	WORD $0x8948; BYTE $0xd7     // movq         %rdx, %rdi
+	LONG $0xfff441e9; BYTE $0xff // jmp          LBB1_6, $-3007(%rip)
+
+LBB1_25:
+	LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq         $1000000000, %rdi
+	LONG $0x00000aba; BYTE $0x00               // movl         $10, %edx
+	LONG $0xfff8dfe9; BYTE $0xff               // jmp          LBB1_26, $-1825(%rip)
+	WORD $0x9090; BYTE $0x90                   // .p2align 4, 0x90
+
+_format_integer:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	BYTE $0x53                     // pushq        %rbx
+	WORD $0x8941; BYTE $0xd0       // movl         %edx, %r8d
+	WORD $0x0149; BYTE $0xf0       // addq         %rsi, %r8
+	WORD $0x8948; BYTE $0xf8       // movq         %rdi, %rax
+	LONG $0x20e8c148               // shrq         $32, %rax
+	LONG $0x0016850f; WORD $0x0000 // jne          LBB2_2, $22(%rip)
+	WORD $0x894d; BYTE $0xc3       // movq         %r8, %r11
+	LONG $0x2710ff81; WORD $0x0000 // cmpl         $10000, %edi
+	LONG $0x00c3830f; WORD $0x0000 // jae          LBB2_5, $195(%rip)
+
+LBB2_4:
+	WORD $0xfa89                 // movl         %edi, %edx
+	LONG $0x00011ae9; BYTE $0x00 // jmp          LBB2_7, $282(%rip)
+
+LBB2_2:
+	QUAD $0x77118461cefdb948; WORD $0xabcc     // movabsq      $-6067343680855748867, %rcx
+	WORD $0x8948; BYTE $0xf8                   // movq         %rdi, %rax
+	WORD $0xf748; BYTE $0xe1                   // mulq         %rcx
+	LONG $0x1aeac148                           // shrq         $26, %rdx
+	LONG $0x1f00ca69; WORD $0xfa0a             // imull        $-100000000, %edx, %ecx
+	WORD $0xf901                               // addl         %edi, %ecx
+	LONG $0x1759b941; WORD $0xd1b7             // movl         $3518437209, %r9d
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	LONG $0xc1af0f49                           // imulq        %r9, %rax
+	LONG $0x2de8c148                           // shrq         $45, %rax
+	LONG $0x2710f869; WORD $0x0000             // imull        $10000, %eax, %edi
+	WORD $0xf929                               // subl         %edi, %ecx
+	WORD $0x8948; BYTE $0xc7                   // movq         %rax, %rdi
+	LONG $0xf9af0f49                           // imulq        %r9, %rdi
+	LONG $0x2defc148                           // shrq         $45, %rdi
+	LONG $0x2710ff69; WORD $0x0000             // imull        $10000, %edi, %edi
+	WORD $0xf829                               // subl         %edi, %eax
+	WORD $0xb70f; BYTE $0xf9                   // movzwl       %cx, %edi
+	WORD $0xefc1; BYTE $0x02                   // shrl         $2, %edi
+	LONG $0x7bcf6944; WORD $0x0014; BYTE $0x00 // imull        $5243, %edi, %r9d
+	LONG $0x11e9c141                           // shrl         $17, %r9d
+	LONG $0x64f96b41                           // imull        $100, %r9d, %edi
+	WORD $0xf929                               // subl         %edi, %ecx
+	LONG $0xd1b70f44                           // movzwl       %cx, %r10d
+	WORD $0xb70f; BYTE $0xf8                   // movzwl       %ax, %edi
+	WORD $0xefc1; BYTE $0x02                   // shrl         $2, %edi
+	LONG $0x147bff69; WORD $0x0000             // imull        $5243, %edi, %edi
+	WORD $0xefc1; BYTE $0x11                   // shrl         $17, %edi
+	WORD $0xcf6b; BYTE $0x64                   // imull        $100, %edi, %ecx
+	WORD $0xc829                               // subl         %ecx, %eax
+	LONG $0xd8b70f44                           // movzwl       %ax, %r11d
+	LONG $0x400d8d48; WORD $0x00ab; BYTE $0x00 // leaq         $43840(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x04b70f42; BYTE $0x51               // movzwl       (%rcx,%r10,2), %eax
+	LONG $0x40894166; BYTE $0xfe               // movw         %ax, $-2(%r8)
+	LONG $0x04b70f42; BYTE $0x49               // movzwl       (%rcx,%r9,2), %eax
+	LONG $0x40894166; BYTE $0xfc               // movw         %ax, $-4(%r8)
+	LONG $0x04b70f42; BYTE $0x59               // movzwl       (%rcx,%r11,2), %eax
+	LONG $0x40894166; BYTE $0xfa               // movw         %ax, $-6(%r8)
+	LONG $0xf8588d4d                           // leaq         $-8(%r8), %r11
+	LONG $0x790cb70f                           // movzwl       (%rcx,%rdi,2), %ecx
+	LONG $0x48894166; BYTE $0xf8               // movw         %cx, $-8(%r8)
+	WORD $0x8948; BYTE $0xd7                   // movq         %rdx, %rdi
+	LONG $0x2710ff81; WORD $0x0000             // cmpl         $10000, %edi
+	LONG $0xff3d820f; WORD $0xffff             // jb           LBB2_4, $-195(%rip)
+
+LBB2_5:
+	LONG $0x1759b941; WORD $0xd1b7             // movl         $3518437209, %r9d
+	LONG $0xf9158d4c; WORD $0x00aa; BYTE $0x00 // leaq         $43769(%rip), %r10  /* _Digits(%rip) */
+	QUAD $0x9090909090909090; BYTE $0x90       // .p2align 4, 0x90
+
+LBB2_6:
+	WORD $0xfa89                               // movl         %edi, %edx
+	LONG $0xd1af0f49                           // imulq        %r9, %rdx
+	LONG $0x2deac148                           // shrq         $45, %rdx
+	LONG $0xd8f0ca69; WORD $0xffff             // imull        $-10000, %edx, %ecx
+	WORD $0xf901                               // addl         %edi, %ecx
+	LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rcx, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xd86b; BYTE $0x64                   // imull        $100, %eax, %ebx
+	WORD $0xd929                               // subl         %ebx, %ecx
+	LONG $0x0cb70f41; BYTE $0x4a               // movzwl       (%r10,%rcx,2), %ecx
+	LONG $0x4b894166; BYTE $0xfe               // movw         %cx, $-2(%r11)
+	LONG $0x04b70f41; BYTE $0x42               // movzwl       (%r10,%rax,2), %eax
+	LONG $0x43894166; BYTE $0xfc               // movw         %ax, $-4(%r11)
+	LONG $0xfcc38349                           // addq         $-4, %r11
+	LONG $0xe0ffff81; WORD $0x05f5             // cmpl         $99999999, %edi
+	WORD $0xd789                               // movl         %edx, %edi
+	LONG $0xffb8870f; WORD $0xffff             // ja           LBB2_6, $-72(%rip)
+
+LBB2_7:
+	WORD $0xfa83; BYTE $0x64                   // cmpl         $100, %edx
+	LONG $0x002d820f; WORD $0x0000             // jb           LBB2_9, $45(%rip)
+	WORD $0xb70f; BYTE $0xc2                   // movzwl       %dx, %eax
+	WORD $0xe8c1; BYTE $0x02                   // shrl         $2, %eax
+	LONG $0x147bc069; WORD $0x0000             // imull        $5243, %eax, %eax
+	WORD $0xe8c1; BYTE $0x11                   // shrl         $17, %eax
+	WORD $0xc86b; BYTE $0x64                   // imull        $100, %eax, %ecx
+	WORD $0xca29                               // subl         %ecx, %edx
+	WORD $0xb70f; BYTE $0xca                   // movzwl       %dx, %ecx
+	LONG $0x81158d48; WORD $0x00aa; BYTE $0x00 // leaq         $43649(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x4a0cb70f                           // movzwl       (%rdx,%rcx,2), %ecx
+	LONG $0x4b894166; BYTE $0xfe               // movw         %cx, $-2(%r11)
+	LONG $0xfec38349                           // addq         $-2, %r11
+	WORD $0xc289                               // movl         %eax, %edx
+
+LBB2_9:
+	WORD $0xfa83; BYTE $0x0a                   // cmpl         $10, %edx
+	LONG $0x0018820f; WORD $0x0000             // jb           LBB2_11, $24(%rip)
+	WORD $0xd089                               // movl         %edx, %eax
+	LONG $0x600d8d48; WORD $0x00aa; BYTE $0x00 // leaq         $43616(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	LONG $0x43894166; BYTE $0xfe               // movw         %ax, $-2(%r11)
+	WORD $0x894c; BYTE $0xc0                   // movq         %r8, %rax
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB2_11:
+	WORD $0xc280; BYTE $0x30       // addb         $48, %dl
+	WORD $0x1688                   // movb         %dl, (%rsi)
+	WORD $0x894c; BYTE $0xc0       // movq         %r8, %rax
+	BYTE $0x5b                     // popq         %rbx
+	BYTE $0x5d                     // popq         %rbp
+	BYTE $0xc3                     // retq
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+_i64toa:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x8548; BYTE $0xf6                   // testq        %rsi, %rsi
+	LONG $0x00b1880f; WORD $0x0000             // js           LBB3_12, $177(%rip)
+	LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq         $9999, %rsi
+	LONG $0x00b6870f; WORD $0x0000             // ja           LBB3_9, $182(%rip)
+	WORD $0xb70f; BYTE $0xc6                   // movzwl       %si, %eax
+	WORD $0xe8c1; BYTE $0x02                   // shrl         $2, %eax
+	LONG $0x147bc069; WORD $0x0000             // imull        $5243, %eax, %eax
+	WORD $0xe8c1; BYTE $0x11                   // shrl         $17, %eax
+	LONG $0x00148d48                           // leaq         (%rax,%rax), %rdx
+	WORD $0xc06b; BYTE $0x64                   // imull        $100, %eax, %eax
+	WORD $0xf189                               // movl         %esi, %ecx
+	WORD $0xc129                               // subl         %eax, %ecx
+	WORD $0xb70f; BYTE $0xc9                   // movzwl       %cx, %ecx
+	WORD $0x0148; BYTE $0xc9                   // addq         %rcx, %rcx
+	LONG $0x03e8fe81; WORD $0x0000             // cmpl         $1000, %esi
+	LONG $0x0017820f; WORD $0x0000             // jb           LBB3_4, $23(%rip)
+	LONG $0xf3058d48; WORD $0x00a9; BYTE $0x00 // leaq         $43507(%rip), %rax  /* _Digits(%rip) */
+	LONG $0x0204b60f                           // movzbl       (%rdx,%rax), %eax
+	WORD $0x0788                               // movb         %al, (%rdi)
+	LONG $0x000001b8; BYTE $0x00               // movl         $1, %eax
+	LONG $0x00000be9; BYTE $0x00               // jmp          LBB3_5, $11(%rip)
+
+LBB3_4:
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xfe83; BYTE $0x64       // cmpl         $100, %esi
+	LONG $0x0046820f; WORD $0x0000 // jb           LBB3_6, $70(%rip)
+
+LBB3_5:
+	WORD $0xb70f; BYTE $0xd2                   // movzwl       %dx, %edx
+	LONG $0x01ca8348                           // orq          $1, %rdx
+	LONG $0xca358d48; WORD $0x00a9; BYTE $0x00 // leaq         $43466(%rip), %rsi  /* _Digits(%rip) */
+	LONG $0x3214b60f                           // movzbl       (%rdx,%rsi), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB3_7:
+	LONG $0xb8158d48; WORD $0x00a9; BYTE $0x00 // leaq         $43448(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x1114b60f                           // movzbl       (%rcx,%rdx), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB3_8:
+	WORD $0xb70f; BYTE $0xc9                   // movzwl       %cx, %ecx
+	LONG $0x01c98348                           // orq          $1, %rcx
+	LONG $0x9f158d48; WORD $0x00a9; BYTE $0x00 // leaq         $43423(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x110cb60f                           // movzbl       (%rcx,%rdx), %ecx
+	WORD $0xc289                               // movl         %eax, %edx
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x0c88; BYTE $0x17                   // movb         %cl, (%rdi,%rdx)
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB3_6:
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xfe83; BYTE $0x0a       // cmpl         $10, %esi
+	LONG $0xffc8830f; WORD $0xffff // jae          LBB3_7, $-56(%rip)
+	LONG $0xffffd5e9; BYTE $0xff   // jmp          LBB3_8, $-43(%rip)
+
+LBB3_12:
+	WORD $0x07c6; BYTE $0x2d     // movb         $45, (%rdi)
+	WORD $0xff48; BYTE $0xc7     // incq         %rdi
+	WORD $0xf748; BYTE $0xde     // negq         %rsi
+	LONG $0x000044e8; BYTE $0x00 // callq        _u64toa, $68(%rip)
+	WORD $0xc0ff                 // incl         %eax
+	BYTE $0x5d                   // popq         %rbp
+	BYTE $0xc3                   // retq
+
+LBB3_9:
+	LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq         $99999999, %rsi
+	LONG $0x0006870f; WORD $0x0000             // ja           LBB3_10, $6(%rip)
+	BYTE $0x5d                                 // popq         %rbp
+	LONG $0x00011de9; BYTE $0x00               // jmp          _u32toa_medium, $285(%rip)
+
+LBB3_10:
+	QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq      $9999999999999999, %rax
+	WORD $0x3948; BYTE $0xc6               // cmpq         %rax, %rsi
+	LONG $0x0006870f; WORD $0x0000         // ja           LBB3_11, $6(%rip)
+	BYTE $0x5d                             // popq         %rbp
+	LONG $0x000244e9; BYTE $0x00           // jmp          _u64toa_large_sse2, $580(%rip)
+
+LBB3_11:
+	BYTE $0x5d                                               // popq         %rbp
+	LONG $0x00038ee9; BYTE $0x00                             // jmp          _u64toa_xlarge_sse2, $910(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+_u64toa:
+	LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq         $9999, %rsi
+	LONG $0x00a8870f; WORD $0x0000             // ja           LBB4_8, $168(%rip)
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0xb70f; BYTE $0xc6                   // movzwl       %si, %eax
+	WORD $0xe8c1; BYTE $0x02                   // shrl         $2, %eax
+	LONG $0x147bc069; WORD $0x0000             // imull        $5243, %eax, %eax
+	WORD $0xe8c1; BYTE $0x11                   // shrl         $17, %eax
+	LONG $0x00148d48                           // leaq         (%rax,%rax), %rdx
+	WORD $0xc06b; BYTE $0x64                   // imull        $100, %eax, %eax
+	WORD $0xf189                               // movl         %esi, %ecx
+	WORD $0xc129                               // subl         %eax, %ecx
+	WORD $0xb70f; BYTE $0xc9                   // movzwl       %cx, %ecx
+	WORD $0x0148; BYTE $0xc9                   // addq         %rcx, %rcx
+	LONG $0x03e8fe81; WORD $0x0000             // cmpl         $1000, %esi
+	LONG $0x0017820f; WORD $0x0000             // jb           LBB4_3, $23(%rip)
+	LONG $0xec058d48; WORD $0x00a8; BYTE $0x00 // leaq         $43244(%rip), %rax  /* _Digits(%rip) */
+	LONG $0x0204b60f                           // movzbl       (%rdx,%rax), %eax
+	WORD $0x0788                               // movb         %al, (%rdi)
+	LONG $0x000001b8; BYTE $0x00               // movl         $1, %eax
+	LONG $0x00000be9; BYTE $0x00               // jmp          LBB4_4, $11(%rip)
+
+LBB4_3:
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xfe83; BYTE $0x64       // cmpl         $100, %esi
+	LONG $0x0046820f; WORD $0x0000 // jb           LBB4_5, $70(%rip)
+
+LBB4_4:
+	WORD $0xb70f; BYTE $0xd2                   // movzwl       %dx, %edx
+	LONG $0x01ca8348                           // orq          $1, %rdx
+	LONG $0xc3358d48; WORD $0x00a8; BYTE $0x00 // leaq         $43203(%rip), %rsi  /* _Digits(%rip) */
+	LONG $0x3214b60f                           // movzbl       (%rdx,%rsi), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB4_6:
+	LONG $0xb1158d48; WORD $0x00a8; BYTE $0x00 // leaq         $43185(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x1114b60f                           // movzbl       (%rcx,%rdx), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB4_7:
+	WORD $0xb70f; BYTE $0xc9                   // movzwl       %cx, %ecx
+	LONG $0x01c98348                           // orq          $1, %rcx
+	LONG $0x98158d48; WORD $0x00a8; BYTE $0x00 // leaq         $43160(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x110cb60f                           // movzbl       (%rcx,%rdx), %ecx
+	WORD $0xc289                               // movl         %eax, %edx
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x0c88; BYTE $0x17                   // movb         %cl, (%rdi,%rdx)
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB4_5:
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xfe83; BYTE $0x0a       // cmpl         $10, %esi
+	LONG $0xffc8830f; WORD $0xffff // jae          LBB4_6, $-56(%rip)
+	LONG $0xffffd5e9; BYTE $0xff   // jmp          LBB4_7, $-43(%rip)
+
+LBB4_8:
+	LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq         $99999999, %rsi
+	LONG $0x0005870f; WORD $0x0000             // ja           LBB4_9, $5(%rip)
+	LONG $0x000029e9; BYTE $0x00               // jmp          _u32toa_medium, $41(%rip)
+
+LBB4_9:
+	QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq      $9999999999999999, %rax
+	WORD $0x3948; BYTE $0xc6               // cmpq         %rax, %rsi
+	LONG $0x0005870f; WORD $0x0000         // ja           LBB4_10, $5(%rip)
+	LONG $0x000151e9; BYTE $0x00           // jmp          _u64toa_large_sse2, $337(%rip)
+
+LBB4_10:
+	LONG $0x00029ce9; BYTE $0x00               // jmp          _u64toa_xlarge_sse2, $668(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+_u32toa_medium:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0xf089                               // movl         %esi, %eax
+	LONG $0xb71759b9; BYTE $0xd1               // movl         $3518437209, %ecx
+	LONG $0xc8af0f48                           // imulq        %rax, %rcx
+	LONG $0x2de9c148                           // shrq         $45, %rcx
+	LONG $0x2710d169; WORD $0x0000             // imull        $10000, %ecx, %edx
+	WORD $0x8941; BYTE $0xf0                   // movl         %esi, %r8d
+	WORD $0x2941; BYTE $0xd0                   // subl         %edx, %r8d
+	LONG $0x83d06948; WORD $0x1bde; BYTE $0x43 // imulq        $1125899907, %rax, %rdx
+	LONG $0x31eac148                           // shrq         $49, %rdx
+	WORD $0xe283; BYTE $0xfe                   // andl         $-2, %edx
+	LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rcx, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xc06b; BYTE $0x64                   // imull        $100, %eax, %eax
+	WORD $0xc129                               // subl         %eax, %ecx
+	WORD $0x0148; BYTE $0xc9                   // addq         %rcx, %rcx
+	LONG $0x9680fe81; WORD $0x0098             // cmpl         $10000000, %esi
+	LONG $0x0017820f; WORD $0x0000             // jb           LBB5_2, $23(%rip)
+	LONG $0xed058d48; WORD $0x00a7; BYTE $0x00 // leaq         $42989(%rip), %rax  /* _Digits(%rip) */
+	LONG $0x0204b60f                           // movzbl       (%rdx,%rax), %eax
+	WORD $0x0788                               // movb         %al, (%rdi)
+	LONG $0x000001b8; BYTE $0x00               // movl         $1, %eax
+	LONG $0x00000ee9; BYTE $0x00               // jmp          LBB5_3, $14(%rip)
+
+LBB5_2:
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x4240fe81; WORD $0x000f // cmpl         $1000000, %esi
+	LONG $0x0074820f; WORD $0x0000 // jb           LBB5_4, $116(%rip)
+
+LBB5_3:
+	WORD $0xd289                               // movl         %edx, %edx
+	LONG $0x01ca8348                           // orq          $1, %rdx
+	LONG $0xc2358d48; WORD $0x00a7; BYTE $0x00 // leaq         $42946(%rip), %rsi  /* _Digits(%rip) */
+	LONG $0x3214b60f                           // movzbl       (%rdx,%rsi), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB5_5:
+	LONG $0xb0158d48; WORD $0x00a7; BYTE $0x00 // leaq         $42928(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x1114b60f                           // movzbl       (%rcx,%rdx), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB5_6:
+	LONG $0xd0b70f41                           // movzwl       %r8w, %edx
+	WORD $0xeac1; BYTE $0x02                   // shrl         $2, %edx
+	LONG $0x147bd269; WORD $0x0000             // imull        $5243, %edx, %edx
+	WORD $0xeac1; BYTE $0x11                   // shrl         $17, %edx
+	WORD $0xf26b; BYTE $0x64                   // imull        $100, %edx, %esi
+	WORD $0x2941; BYTE $0xf0                   // subl         %esi, %r8d
+	LONG $0xc0b70f45                           // movzwl       %r8w, %r8d
+	WORD $0xc989                               // movl         %ecx, %ecx
+	LONG $0x01c98348                           // orq          $1, %rcx
+	LONG $0x7e0d8d4c; WORD $0x00a7; BYTE $0x00 // leaq         $42878(%rip), %r9  /* _Digits(%rip) */
+	LONG $0x0cb60f42; BYTE $0x09               // movzbl       (%rcx,%r9), %ecx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0x0c88; BYTE $0x37                   // movb         %cl, (%rdi,%rsi)
+	LONG $0x0cb70f41; BYTE $0x51               // movzwl       (%r9,%rdx,2), %ecx
+	LONG $0x374c8966; BYTE $0x01               // movw         %cx, $1(%rdi,%rsi)
+	LONG $0x0cb70f43; BYTE $0x41               // movzwl       (%r9,%r8,2), %ecx
+	LONG $0x374c8966; BYTE $0x03               // movw         %cx, $3(%rdi,%rsi)
+	WORD $0xc083; BYTE $0x05                   // addl         $5, %eax
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB5_4:
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x86a0fe81; WORD $0x0001 // cmpl         $100000, %esi
+	LONG $0xff96830f; WORD $0xffff // jae          LBB5_5, $-106(%rip)
+	LONG $0xffffa3e9; BYTE $0xff   // jmp          LBB5_6, $-93(%rip)
+	QUAD $0x0000000000000000       // .p2align 4, 0x00
+
+LCPI6_0:
+	QUAD $0x00000000d1b71759 // .quad 3518437209
+	QUAD $0x00000000d1b71759 // .quad 3518437209
+
+LCPI6_3:
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+
+LCPI6_4:
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+
+	// .p2align 3, 0x00
+LCPI6_1:
+	QUAD $0x80003334147b20c5 // .quad -9223315738079846203
+
+LCPI6_2:
+	QUAD $0x8000200008000080 // .quad -9223336852348469120
+
+	// .p2align 4, 0x90
+_u64toa_large_sse2:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	QUAD $0x77118461cefdb948; WORD $0xabcc     // movabsq      $-6067343680855748867, %rcx
+	WORD $0x8948; BYTE $0xf0                   // movq         %rsi, %rax
+	WORD $0xf748; BYTE $0xe1                   // mulq         %rcx
+	LONG $0x1aeac148                           // shrq         $26, %rdx
+	LONG $0xe100c269; WORD $0x05f5             // imull        $100000000, %edx, %eax
+	WORD $0xc629                               // subl         %eax, %esi
+	LONG $0xc26ef9c5                           // vmovd        %edx, %xmm0
+	QUAD $0xffffff940d6ff9c5                   // vmovdqa      $-108(%rip), %xmm1  /* LCPI6_0(%rip) */
+	LONG $0xd1f4f9c5                           // vpmuludq     %xmm1, %xmm0, %xmm2
+	LONG $0xd273e9c5; BYTE $0x2d               // vpsrlq       $45, %xmm2, %xmm2
+	LONG $0x002710b8; BYTE $0x00               // movl         $10000, %eax
+	LONG $0x6ef9e1c4; BYTE $0xd8               // vmovq        %rax, %xmm3
+	LONG $0xe3f4e9c5                           // vpmuludq     %xmm3, %xmm2, %xmm4
+	LONG $0xc4faf9c5                           // vpsubd       %xmm4, %xmm0, %xmm0
+	LONG $0xc061e9c5                           // vpunpcklwd   %xmm0, %xmm2, %xmm0
+	LONG $0xf073f9c5; BYTE $0x02               // vpsllq       $2, %xmm0, %xmm0
+	LONG $0xc070fbc5; BYTE $0x50               // vpshuflw     $80, %xmm0, %xmm0
+	LONG $0xc070f9c5; BYTE $0x50               // vpshufd      $80, %xmm0, %xmm0
+	QUAD $0xffffff8e1512fbc5                   // vmovddup     $-114(%rip), %xmm2  /* LCPI6_1(%rip) */
+	LONG $0xc2e4f9c5                           // vpmulhuw     %xmm2, %xmm0, %xmm0
+	QUAD $0xffffff8a2512fbc5                   // vmovddup     $-118(%rip), %xmm4  /* LCPI6_2(%rip) */
+	LONG $0xc4e4f9c5                           // vpmulhuw     %xmm4, %xmm0, %xmm0
+	QUAD $0xffffff562d6ff9c5                   // vmovdqa      $-170(%rip), %xmm5  /* LCPI6_3(%rip) */
+	LONG $0xf5d5f9c5                           // vpmullw      %xmm5, %xmm0, %xmm6
+	LONG $0xf673c9c5; BYTE $0x10               // vpsllq       $16, %xmm6, %xmm6
+	LONG $0xc6f9f9c5                           // vpsubw       %xmm6, %xmm0, %xmm0
+	LONG $0xf66ef9c5                           // vmovd        %esi, %xmm6
+	LONG $0xc9f4c9c5                           // vpmuludq     %xmm1, %xmm6, %xmm1
+	LONG $0xd173f1c5; BYTE $0x2d               // vpsrlq       $45, %xmm1, %xmm1
+	LONG $0xdbf4f1c5                           // vpmuludq     %xmm3, %xmm1, %xmm3
+	LONG $0xdbfac9c5                           // vpsubd       %xmm3, %xmm6, %xmm3
+	LONG $0xcb61f1c5                           // vpunpcklwd   %xmm3, %xmm1, %xmm1
+	LONG $0xf173f1c5; BYTE $0x02               // vpsllq       $2, %xmm1, %xmm1
+	LONG $0xc970fbc5; BYTE $0x50               // vpshuflw     $80, %xmm1, %xmm1
+	LONG $0xc970f9c5; BYTE $0x50               // vpshufd      $80, %xmm1, %xmm1
+	LONG $0xcae4f1c5                           // vpmulhuw     %xmm2, %xmm1, %xmm1
+	LONG $0xcce4f1c5                           // vpmulhuw     %xmm4, %xmm1, %xmm1
+	LONG $0xd5d5f1c5                           // vpmullw      %xmm5, %xmm1, %xmm2
+	LONG $0xf273e9c5; BYTE $0x10               // vpsllq       $16, %xmm2, %xmm2
+	LONG $0xcaf9f1c5                           // vpsubw       %xmm2, %xmm1, %xmm1
+	LONG $0xc167f9c5                           // vpackuswb    %xmm1, %xmm0, %xmm0
+	QUAD $0xffffff100dfcf9c5                   // vpaddb       $-240(%rip), %xmm0, %xmm1  /* LCPI6_4(%rip) */
+	LONG $0xd2efe9c5                           // vpxor        %xmm2, %xmm2, %xmm2
+	LONG $0xc274f9c5                           // vpcmpeqb     %xmm2, %xmm0, %xmm0
+	LONG $0xc0d7f9c5                           // vpmovmskb    %xmm0, %eax
+	WORD $0xd0f7                               // notl         %eax
+	LONG $0x0080000d; BYTE $0x00               // orl          $32768, %eax
+	WORD $0xbc0f; BYTE $0xc8                   // bsfl         %eax, %ecx
+	LONG $0x000010b8; BYTE $0x00               // movl         $16, %eax
+	WORD $0xc829                               // subl         %ecx, %eax
+	LONG $0x04e1c148                           // shlq         $4, %rcx
+	LONG $0x68158d48; WORD $0x00cd; BYTE $0x00 // leaq         $52584(%rip), %rdx  /* _VecShiftShuffles(%rip) */
+	LONG $0x0071e2c4; WORD $0x1104             // vpshufb      (%rcx,%rdx), %xmm1, %xmm0
+	LONG $0x077ffac5                           // vmovdqu      %xmm0, (%rdi)
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+	QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00
+
+LCPI7_0:
+	QUAD $0x00000000d1b71759 // .quad 3518437209
+	QUAD $0x00000000d1b71759 // .quad 3518437209
+
+LCPI7_3:
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+
+LCPI7_4:
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+
+	// .p2align 3, 0x00
+LCPI7_1:
+	QUAD $0x80003334147b20c5 // .quad -9223315738079846203
+
+LCPI7_2:
+	QUAD $0x8000200008000080 // .quad -9223336852348469120
+
+	// .p2align 4, 0x90
+_u64toa_xlarge_sse2:
+	BYTE $0x55                             // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5               // movq         %rsp, %rbp
+	QUAD $0x652fb1137857b948; WORD $0x39a5 // movabsq      $4153837486827862103, %rcx
+	WORD $0x8948; BYTE $0xf0               // movq         %rsi, %rax
+	WORD $0xf748; BYTE $0xe1               // mulq         %rcx
+	LONG $0x33eac148                       // shrq         $51, %rdx
+	QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq      $10000000000000000, %rax
+	LONG $0xc2af0f48                       // imulq        %rdx, %rax
+	WORD $0x2948; BYTE $0xc6               // subq         %rax, %rsi
+	WORD $0xfa83; BYTE $0x09               // cmpl         $9, %edx
+	LONG $0x000f870f; WORD $0x0000         // ja           LBB7_2, $15(%rip)
+	WORD $0xc280; BYTE $0x30               // addb         $48, %dl
+	WORD $0x1788                           // movb         %dl, (%rdi)
+	LONG $0x000001b9; BYTE $0x00           // movl         $1, %ecx
+	LONG $0x0000a7e9; BYTE $0x00           // jmp          LBB7_7, $167(%rip)
+
+LBB7_2:
+	WORD $0xfa83; BYTE $0x63                   // cmpl         $99, %edx
+	LONG $0x001a870f; WORD $0x0000             // ja           LBB7_4, $26(%rip)
+	WORD $0xd089                               // movl         %edx, %eax
+	LONG $0x5d0d8d48; WORD $0x00a5; BYTE $0x00 // leaq         $42333(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	WORD $0x8966; BYTE $0x07                   // movw         %ax, (%rdi)
+	LONG $0x000002b9; BYTE $0x00               // movl         $2, %ecx
+	LONG $0x000084e9; BYTE $0x00               // jmp          LBB7_7, $132(%rip)
+
+LBB7_4:
+	WORD $0xd089                               // movl         %edx, %eax
+	WORD $0xe8c1; BYTE $0x02                   // shrl         $2, %eax
+	LONG $0x147bc069; WORD $0x0000             // imull        $5243, %eax, %eax
+	WORD $0xe8c1; BYTE $0x11                   // shrl         $17, %eax
+	LONG $0x03e7fa81; WORD $0x0000             // cmpl         $999, %edx
+	LONG $0x0037870f; WORD $0x0000             // ja           LBB7_6, $55(%rip)
+	WORD $0xc083; BYTE $0x30                   // addl         $48, %eax
+	WORD $0x0788                               // movb         %al, (%rdi)
+	WORD $0xb70f; BYTE $0xc2                   // movzwl       %dx, %eax
+	WORD $0xc189                               // movl         %eax, %ecx
+	WORD $0xe9c1; BYTE $0x02                   // shrl         $2, %ecx
+	LONG $0x147bc969; WORD $0x0000             // imull        $5243, %ecx, %ecx
+	WORD $0xe9c1; BYTE $0x11                   // shrl         $17, %ecx
+	WORD $0xc96b; BYTE $0x64                   // imull        $100, %ecx, %ecx
+	WORD $0xc829                               // subl         %ecx, %eax
+	WORD $0xb70f; BYTE $0xc0                   // movzwl       %ax, %eax
+	LONG $0x0d0d8d48; WORD $0x00a5; BYTE $0x00 // leaq         $42253(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	LONG $0x01478966                           // movw         %ax, $1(%rdi)
+	LONG $0x000003b9; BYTE $0x00               // movl         $3, %ecx
+	LONG $0x000033e9; BYTE $0x00               // jmp          LBB7_7, $51(%rip)
+
+LBB7_6:
+	WORD $0xc86b; BYTE $0x64                   // imull        $100, %eax, %ecx
+	WORD $0xca29                               // subl         %ecx, %edx
+	WORD $0xb70f; BYTE $0xc0                   // movzwl       %ax, %eax
+	LONG $0xec0d8d48; WORD $0x00a4; BYTE $0x00 // leaq         $42220(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	WORD $0x8966; BYTE $0x07                   // movw         %ax, (%rdi)
+	WORD $0xb70f; BYTE $0xc2                   // movzwl       %dx, %eax
+	LONG $0x4114b60f                           // movzbl       (%rcx,%rax,2), %edx
+	WORD $0x0148; BYTE $0xc0                   // addq         %rax, %rax
+	WORD $0x5788; BYTE $0x02                   // movb         %dl, $2(%rdi)
+	WORD $0xb70f; BYTE $0xc0                   // movzwl       %ax, %eax
+	LONG $0x0844b60f; BYTE $0x01               // movzbl       $1(%rax,%rcx), %eax
+	WORD $0x4788; BYTE $0x03                   // movb         %al, $3(%rdi)
+	LONG $0x000004b9; BYTE $0x00               // movl         $4, %ecx
+
+LBB7_7:
+	QUAD $0x77118461cefdba48; WORD $0xabcc                   // movabsq      $-6067343680855748867, %rdx
+	WORD $0x8948; BYTE $0xf0                                 // movq         %rsi, %rax
+	WORD $0xf748; BYTE $0xe2                                 // mulq         %rdx
+	LONG $0x1aeac148                                         // shrq         $26, %rdx
+	LONG $0xc26ef9c5                                         // vmovd        %edx, %xmm0
+	QUAD $0xfffffeb80d6ff9c5                                 // vmovdqa      $-328(%rip), %xmm1  /* LCPI7_0(%rip) */
+	LONG $0xd1f4f9c5                                         // vpmuludq     %xmm1, %xmm0, %xmm2
+	LONG $0xd273e9c5; BYTE $0x2d                             // vpsrlq       $45, %xmm2, %xmm2
+	LONG $0x002710b8; BYTE $0x00                             // movl         $10000, %eax
+	LONG $0x6ef9e1c4; BYTE $0xd8                             // vmovq        %rax, %xmm3
+	LONG $0xe3f4e9c5                                         // vpmuludq     %xmm3, %xmm2, %xmm4
+	LONG $0xc4faf9c5                                         // vpsubd       %xmm4, %xmm0, %xmm0
+	LONG $0xc061e9c5                                         // vpunpcklwd   %xmm0, %xmm2, %xmm0
+	LONG $0xf073f9c5; BYTE $0x02                             // vpsllq       $2, %xmm0, %xmm0
+	LONG $0xc070fbc5; BYTE $0x50                             // vpshuflw     $80, %xmm0, %xmm0
+	LONG $0xc070f9c5; BYTE $0x50                             // vpshufd      $80, %xmm0, %xmm0
+	QUAD $0xfffffeb21512fbc5                                 // vmovddup     $-334(%rip), %xmm2  /* LCPI7_1(%rip) */
+	LONG $0xc2e4f9c5                                         // vpmulhuw     %xmm2, %xmm0, %xmm0
+	QUAD $0xfffffeae2512fbc5                                 // vmovddup     $-338(%rip), %xmm4  /* LCPI7_2(%rip) */
+	LONG $0xc4e4f9c5                                         // vpmulhuw     %xmm4, %xmm0, %xmm0
+	QUAD $0xfffffe7a2d6ff9c5                                 // vmovdqa      $-390(%rip), %xmm5  /* LCPI7_3(%rip) */
+	LONG $0xf5d5f9c5                                         // vpmullw      %xmm5, %xmm0, %xmm6
+	LONG $0xf673c9c5; BYTE $0x10                             // vpsllq       $16, %xmm6, %xmm6
+	LONG $0xc6f9f9c5                                         // vpsubw       %xmm6, %xmm0, %xmm0
+	LONG $0xe100c269; WORD $0x05f5                           // imull        $100000000, %edx, %eax
+	WORD $0xc629                                             // subl         %eax, %esi
+	LONG $0xf66ef9c5                                         // vmovd        %esi, %xmm6
+	LONG $0xc9f4c9c5                                         // vpmuludq     %xmm1, %xmm6, %xmm1
+	LONG $0xd173f1c5; BYTE $0x2d                             // vpsrlq       $45, %xmm1, %xmm1
+	LONG $0xdbf4f1c5                                         // vpmuludq     %xmm3, %xmm1, %xmm3
+	LONG $0xdbfac9c5                                         // vpsubd       %xmm3, %xmm6, %xmm3
+	LONG $0xcb61f1c5                                         // vpunpcklwd   %xmm3, %xmm1, %xmm1
+	LONG $0xf173f1c5; BYTE $0x02                             // vpsllq       $2, %xmm1, %xmm1
+	LONG $0xc970fbc5; BYTE $0x50                             // vpshuflw     $80, %xmm1, %xmm1
+	LONG $0xc970f9c5; BYTE $0x50                             // vpshufd      $80, %xmm1, %xmm1
+	LONG $0xcae4f1c5                                         // vpmulhuw     %xmm2, %xmm1, %xmm1
+	LONG $0xcce4f1c5                                         // vpmulhuw     %xmm4, %xmm1, %xmm1
+	LONG $0xd5d5f1c5                                         // vpmullw      %xmm5, %xmm1, %xmm2
+	LONG $0xf273e9c5; BYTE $0x10                             // vpsllq       $16, %xmm2, %xmm2
+	LONG $0xcaf9f1c5                                         // vpsubw       %xmm2, %xmm1, %xmm1
+	LONG $0xc167f9c5                                         // vpackuswb    %xmm1, %xmm0, %xmm0
+	QUAD $0xfffffe2c05fcf9c5                                 // vpaddb       $-468(%rip), %xmm0, %xmm0  /* LCPI7_4(%rip) */
+	WORD $0xc889                                             // movl         %ecx, %eax
+	LONG $0x047ffac5; BYTE $0x07                             // vmovdqu      %xmm0, (%rdi,%rax)
+	WORD $0xc983; BYTE $0x10                                 // orl          $16, %ecx
+	WORD $0xc889                                             // movl         %ecx, %eax
+	BYTE $0x5d                                               // popq         %rbp
+	BYTE $0xc3                                               // retq
+	QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00
+
+LCPI8_0:
+	QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
+
+LCPI8_1:
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+
+LCPI8_2:
+	QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f'
+
+	// .p2align 4, 0x90
+_quote:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x20ec8348                           // subq         $32, %rsp
+	WORD $0x8949; BYTE $0xcb                   // movq         %rcx, %r11
+	WORD $0x8949; BYTE $0xd7                   // movq         %rdx, %r15
+	WORD $0x8b4c; BYTE $0x11                   // movq         (%rcx), %r10
+	LONG $0x01c0f641                           // testb        $1, %r8b
+	WORD $0x8948; BYTE $0xf0                   // movq         %rsi, %rax
+	LONG $0x780d8d48; WORD $0x00cb; BYTE $0x00 // leaq         $52088(%rip), %rcx  /* __SingleQuoteTab(%rip) */
+	LONG $0x71258d4c; WORD $0x00db; BYTE $0x00 // leaq         $56177(%rip), %r12  /* __DoubleQuoteTab(%rip) */
+	LONG $0xe1440f4c                           // cmoveq       %rcx, %r12
+	QUAD $0x00000000f50c8d48                   // leaq         (,%rsi,8), %rcx
+	WORD $0x3949; BYTE $0xca                   // cmpq         %rcx, %r10
+	LONG $0x03ec8d0f; WORD $0x0000             // jge          LBB8_56, $1004(%rip)
+	WORD $0x894d; BYTE $0xfe                   // movq         %r15, %r14
+	WORD $0x8949; BYTE $0xf9                   // movq         %rdi, %r9
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0x03cc840f; WORD $0x0000             // je           LBB8_79, $972(%rip)
+	LONG $0xc85d894c                           // movq         %r11, $-56(%rbp)
+	QUAD $0xffffff71056ff9c5                   // vmovdqa      $-143(%rip), %xmm0  /* LCPI8_0(%rip) */
+	QUAD $0xffffff790d6ff9c5                   // vmovdqa      $-135(%rip), %xmm1  /* LCPI8_1(%rip) */
+	QUAD $0xffffff81156ff9c5                   // vmovdqa      $-127(%rip), %xmm2  /* LCPI8_2(%rip) */
+	WORD $0x8948; BYTE $0xf9                   // movq         %rdi, %rcx
+	LONG $0xd07d894c                           // movq         %r15, $-48(%rbp)
+	WORD $0x894d; BYTE $0xfe                   // movq         %r15, %r14
+	LONG $0xc065894c                           // movq         %r12, $-64(%rbp)
+
+LBB8_3:
+	WORD $0x8949; BYTE $0xc9       // movq         %rcx, %r9
+	LONG $0x10f88348               // cmpq         $16, %rax
+	WORD $0x9d0f; BYTE $0xc3       // setge        %bl
+	WORD $0x894d; BYTE $0xd4       // movq         %r10, %r12
+	WORD $0x894d; BYTE $0xf7       // movq         %r14, %r15
+	WORD $0x8949; BYTE $0xc3       // movq         %rax, %r11
+	WORD $0x8949; BYTE $0xcd       // movq         %rcx, %r13
+	LONG $0x10fa8349               // cmpq         $16, %r10
+	LONG $0x00738c0f; WORD $0x0000 // jl           LBB8_10, $115(%rip)
+	LONG $0x10f88348               // cmpq         $16, %rax
+	LONG $0x00698c0f; WORD $0x0000 // jl           LBB8_10, $105(%rip)
+	WORD $0x3145; BYTE $0xff       // xorl         %r15d, %r15d
+	WORD $0x8948; BYTE $0xc2       // movq         %rax, %rdx
+	WORD $0x894c; BYTE $0xd1       // movq         %r10, %rcx
+
+	// .p2align 4, 0x90
+LBB8_6:
+	LONG $0x6f7a81c4; WORD $0x391c // vmovdqu      (%r9,%r15), %xmm3
+	LONG $0xe074e1c5               // vpcmpeqb     %xmm0, %xmm3, %xmm4
+	LONG $0xe974e1c5               // vpcmpeqb     %xmm1, %xmm3, %xmm5
+	LONG $0xe4ebd1c5               // vpor         %xmm4, %xmm5, %xmm4
+	LONG $0x7f7a81c4; WORD $0x3e1c // vmovdqu      %xmm3, (%r14,%r15)
+	LONG $0xeadae1c5               // vpminub      %xmm2, %xmm3, %xmm5
+	LONG $0xdd74e1c5               // vpcmpeqb     %xmm5, %xmm3, %xmm3
+	LONG $0xdbebd9c5               // vpor         %xmm3, %xmm4, %xmm3
+	LONG $0xf3d7f9c5               // vpmovmskb    %xmm3, %esi
+	WORD $0xf685                   // testl        %esi, %esi
+	LONG $0x012a850f; WORD $0x0000 // jne          LBB8_23, $298(%rip)
+	LONG $0xf05a8d4c               // leaq         $-16(%rdx), %r11
+	LONG $0xf0618d4c               // leaq         $-16(%rcx), %r12
+	LONG $0x10c78349               // addq         $16, %r15
+	LONG $0x20fa8348               // cmpq         $32, %rdx
+	WORD $0x9d0f; BYTE $0xc3       // setge        %bl
+	LONG $0x00108c0f; WORD $0x0000 // jl           LBB8_9, $16(%rip)
+	WORD $0x894c; BYTE $0xda       // movq         %r11, %rdx
+	LONG $0x1ff98348               // cmpq         $31, %rcx
+	WORD $0x894c; BYTE $0xe1       // movq         %r12, %rcx
+	LONG $0xffa78f0f; WORD $0xffff // jg           LBB8_6, $-89(%rip)
+
+LBB8_9:
+	LONG $0x392c8d4f         // leaq         (%r9,%r15), %r13
+	WORD $0x014d; BYTE $0xf7 // addq         %r14, %r15
+
+LBB8_10:
+	WORD $0xdb84                   // testb        %bl, %bl
+	LONG $0x0063840f; WORD $0x0000 // je           LBB8_14, $99(%rip)
+	LONG $0x6f7ac1c4; WORD $0x005d // vmovdqu      (%r13), %xmm3
+	LONG $0xe074e1c5               // vpcmpeqb     %xmm0, %xmm3, %xmm4
+	LONG $0xe974e1c5               // vpcmpeqb     %xmm1, %xmm3, %xmm5
+	LONG $0xe4ebd1c5               // vpor         %xmm4, %xmm5, %xmm4
+	LONG $0xeadae1c5               // vpminub      %xmm2, %xmm3, %xmm5
+	LONG $0xed74e1c5               // vpcmpeqb     %xmm5, %xmm3, %xmm5
+	LONG $0xe5ebd9c5               // vpor         %xmm5, %xmm4, %xmm4
+	LONG $0xccd7f9c5               // vpmovmskb    %xmm4, %ecx
+	LONG $0x0000c981; WORD $0x0001 // orl          $65536, %ecx
+	LONG $0xd9bc0f44               // bsfl         %ecx, %r11d
+	LONG $0x7ef9e1c4; BYTE $0xd9   // vmovq        %xmm3, %rcx
+	WORD $0x394d; BYTE $0xdc       // cmpq         %r11, %r12
+	LONG $0x00c88d0f; WORD $0x0000 // jge          LBB8_24, $200(%rip)
+	LONG $0x08fc8349               // cmpq         $8, %r12
+	LONG $0x00fd820f; WORD $0x0000 // jb           LBB8_28, $253(%rip)
+	WORD $0x8949; BYTE $0x0f       // movq         %rcx, (%r15)
+	LONG $0x085d8d4d               // leaq         $8(%r13), %r11
+	LONG $0x08c78349               // addq         $8, %r15
+	LONG $0x245c8d49; BYTE $0xf8   // leaq         $-8(%r12), %rbx
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x00f38d0f; WORD $0x0000 // jge          LBB8_29, $243(%rip)
+	LONG $0x000100e9; BYTE $0x00   // jmp          LBB8_30, $256(%rip)
+
+LBB8_14:
+	WORD $0x854d; BYTE $0xdb               // testq        %r11, %r11
+	LONG $0x006e8e0f; WORD $0x0000         // jle          LBB8_21, $110(%rip)
+	WORD $0x854d; BYTE $0xe4               // testq        %r12, %r12
+	LONG $0x00658e0f; WORD $0x0000         // jle          LBB8_21, $101(%rip)
+	LONG $0xb84d894c                       // movq         %r9, $-72(%rbp)
+	WORD $0x3145; BYTE $0xc9               // xorl         %r9d, %r9d
+	WORD $0xc931                           // xorl         %ecx, %ecx
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB8_17:
+	LONG $0x74b60f43; WORD $0x000d             // movzbl       (%r13,%r9), %esi
+	WORD $0x8948; BYTE $0xf3                   // movq         %rsi, %rbx
+	LONG $0x04e3c148                           // shlq         $4, %rbx
+	LONG $0xec158d48; WORD $0x00c9; BYTE $0x00 // leaq         $51692(%rip), %rdx  /* __SingleQuoteTab(%rip) */
+	LONG $0x133c8348; BYTE $0x00               // cmpq         $0, (%rbx,%rdx)
+	LONG $0x008b850f; WORD $0x0000             // jne          LBB8_27, $139(%rip)
+	LONG $0x0b048d4d                           // leaq         (%r11,%rcx), %r8
+	LONG $0x0f348843                           // movb         %sil, (%r15,%r9)
+	LONG $0xff598d48                           // leaq         $-1(%rcx), %rbx
+	LONG $0x02f88349                           // cmpq         $2, %r8
+	LONG $0x00138c0f; WORD $0x0000             // jl           LBB8_20, $19(%rip)
+	WORD $0x014c; BYTE $0xe1                   // addq         %r12, %rcx
+	WORD $0xff49; BYTE $0xc1                   // incq         %r9
+	LONG $0x01f98348                           // cmpq         $1, %rcx
+	WORD $0x8948; BYTE $0xd9                   // movq         %rbx, %rcx
+	LONG $0xffb88f0f; WORD $0xffff             // jg           LBB8_17, $-72(%rip)
+
+LBB8_20:
+	WORD $0x2949; BYTE $0xdd // subq         %rbx, %r13
+	WORD $0x0149; BYTE $0xdb // addq         %rbx, %r11
+	LONG $0xb84d8b4c         // movq         $-72(%rbp), %r9
+
+LBB8_21:
+	WORD $0x854d; BYTE $0xdb       // testq        %r11, %r11
+	LONG $0xc0658b4c               // movq         $-64(%rbp), %r12
+	LONG $0x0043840f; WORD $0x0000 // je           LBB8_26, $67(%rip)
+	WORD $0xf749; BYTE $0xd5       // notq         %r13
+	WORD $0x014d; BYTE $0xcd       // addq         %r9, %r13
+	LONG $0x000129e9; BYTE $0x00   // jmp          LBB8_41, $297(%rip)
+
+LBB8_23:
+	LONG $0xcebc0f66             // bsfw         %si, %cx
+	LONG $0xe9b70f44             // movzwl       %cx, %r13d
+	WORD $0x014d; BYTE $0xfd     // addq         %r15, %r13
+	LONG $0x000115e9; BYTE $0x00 // jmp          LBB8_40, $277(%rip)
+
+LBB8_24:
+	LONG $0x08fb8341               // cmpl         $8, %r11d
+	LONG $0x00a4820f; WORD $0x0000 // jb           LBB8_34, $164(%rip)
+	WORD $0x8949; BYTE $0x0f       // movq         %rcx, (%r15)
+	LONG $0x08658d4d               // leaq         $8(%r13), %r12
+	LONG $0x08c78349               // addq         $8, %r15
+	LONG $0xf85b8d49               // leaq         $-8(%r11), %rbx
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x009b830f; WORD $0x0000 // jae          LBB8_35, $155(%rip)
+	LONG $0x0000a9e9; BYTE $0x00   // jmp          LBB8_36, $169(%rip)
+
+LBB8_26:
+	WORD $0x294d; BYTE $0xcd     // subq         %r9, %r13
+	LONG $0x0000e9e9; BYTE $0x00 // jmp          LBB8_41, $233(%rip)
+
+LBB8_27:
+	LONG $0xb84d8b4c             // movq         $-72(%rbp), %r9
+	WORD $0x294d; BYTE $0xcd     // subq         %r9, %r13
+	WORD $0x2949; BYTE $0xcd     // subq         %rcx, %r13
+	LONG $0x0000d6e9; BYTE $0x00 // jmp          LBB8_40, $214(%rip)
+
+LBB8_28:
+	WORD $0x894d; BYTE $0xeb       // movq         %r13, %r11
+	WORD $0x894c; BYTE $0xe3       // movq         %r12, %rbx
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x00128c0f; WORD $0x0000 // jl           LBB8_30, $18(%rip)
+
+LBB8_29:
+	WORD $0x8b41; BYTE $0x0b // movl         (%r11), %ecx
+	WORD $0x8941; BYTE $0x0f // movl         %ecx, (%r15)
+	LONG $0x04c38349         // addq         $4, %r11
+	LONG $0x04c78349         // addq         $4, %r15
+	LONG $0xfcc38348         // addq         $-4, %rbx
+
+LBB8_30:
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0x0022820f; WORD $0x0000 // jb           LBB8_31, $34(%rip)
+	LONG $0x0bb70f41               // movzwl       (%r11), %ecx
+	LONG $0x0f894166               // movw         %cx, (%r15)
+	LONG $0x02c38349               // addq         $2, %r11
+	LONG $0x02c78349               // addq         $2, %r15
+	LONG $0xfec38348               // addq         $-2, %rbx
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x000e850f; WORD $0x0000 // jne          LBB8_32, $14(%rip)
+	LONG $0x000010e9; BYTE $0x00   // jmp          LBB8_33, $16(%rip)
+
+LBB8_31:
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0007840f; WORD $0x0000 // je           LBB8_33, $7(%rip)
+
+LBB8_32:
+	LONG $0x0bb60f41         // movzbl       (%r11), %ecx
+	WORD $0x8841; BYTE $0x0f // movb         %cl, (%r15)
+
+LBB8_33:
+	WORD $0x014d; BYTE $0xec     // addq         %r13, %r12
+	WORD $0xf749; BYTE $0xd4     // notq         %r12
+	WORD $0x014d; BYTE $0xcc     // addq         %r9, %r12
+	WORD $0x894d; BYTE $0xe5     // movq         %r12, %r13
+	LONG $0x000067e9; BYTE $0x00 // jmp          LBB8_40, $103(%rip)
+
+LBB8_34:
+	WORD $0x894d; BYTE $0xec       // movq         %r13, %r12
+	WORD $0x894c; BYTE $0xdb       // movq         %r11, %rbx
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x0013820f; WORD $0x0000 // jb           LBB8_36, $19(%rip)
+
+LBB8_35:
+	LONG $0x240c8b41         // movl         (%r12), %ecx
+	WORD $0x8941; BYTE $0x0f // movl         %ecx, (%r15)
+	LONG $0x04c48349         // addq         $4, %r12
+	LONG $0x04c78349         // addq         $4, %r15
+	LONG $0xfcc38348         // addq         $-4, %rbx
+
+LBB8_36:
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0x0023820f; WORD $0x0000 // jb           LBB8_37, $35(%rip)
+	LONG $0x0cb70f41; BYTE $0x24   // movzwl       (%r12), %ecx
+	LONG $0x0f894166               // movw         %cx, (%r15)
+	LONG $0x02c48349               // addq         $2, %r12
+	LONG $0x02c78349               // addq         $2, %r15
+	LONG $0xfec38348               // addq         $-2, %rbx
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x000e850f; WORD $0x0000 // jne          LBB8_38, $14(%rip)
+	LONG $0x000011e9; BYTE $0x00   // jmp          LBB8_39, $17(%rip)
+
+LBB8_37:
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0008840f; WORD $0x0000 // je           LBB8_39, $8(%rip)
+
+LBB8_38:
+	LONG $0x0cb60f41; BYTE $0x24 // movzbl       (%r12), %ecx
+	WORD $0x8841; BYTE $0x0f     // movb         %cl, (%r15)
+
+LBB8_39:
+	WORD $0x294d; BYTE $0xcd // subq         %r9, %r13
+	WORD $0x014d; BYTE $0xdd // addq         %r11, %r13
+
+LBB8_40:
+	LONG $0xc0658b4c // movq         $-64(%rbp), %r12
+
+LBB8_41:
+	QUAD $0x000300000001bb49; WORD $0x0000 // movabsq      $12884901889, %r11
+	WORD $0x854d; BYTE $0xed               // testq        %r13, %r13
+	LONG $0x0313880f; WORD $0x0000         // js           LBB8_82, $787(%rip)
+	WORD $0x014d; BYTE $0xee               // addq         %r13, %r14
+	WORD $0x394c; BYTE $0xe8               // cmpq         %r13, %rax
+	LONG $0x00c2840f; WORD $0x0000         // je           LBB8_78, $194(%rip)
+	WORD $0x294d; BYTE $0xea               // subq         %r13, %r10
+	LONG $0x000015e9; BYTE $0x00           // jmp          LBB8_45, $21(%rip)
+	LONG $0x90909090; WORD $0x9090         // .p2align 4, 0x90
+
+LBB8_44:
+	WORD $0x0149; BYTE $0xf6       // addq         %rsi, %r14
+	WORD $0xff49; BYTE $0xc5       // incq         %r13
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	LONG $0x00a5840f; WORD $0x0000 // je           LBB8_78, $165(%rip)
+
+LBB8_45:
+	LONG $0x0cb60f43; BYTE $0x29           // movzbl       (%r9,%r13), %ecx
+	LONG $0x04e1c148                       // shlq         $4, %rcx
+	LONG $0x0c148b41                       // movl         (%r12,%rcx), %edx
+	WORD $0x8548; BYTE $0xd2               // testq        %rdx, %rdx
+	LONG $0x0082840f; WORD $0x0000         // je           LBB8_53, $130(%rip)
+	WORD $0x6348; BYTE $0xf2               // movslq       %edx, %rsi
+	WORD $0x2949; BYTE $0xf2               // subq         %rsi, %r10
+	LONG $0x02a28c0f; WORD $0x0000         // jl           LBB8_80, $674(%rip)
+	LONG $0x20e2c148                       // shlq         $32, %rdx
+	LONG $0x0c1c8d49                       // leaq         (%r12,%rcx), %rbx
+	LONG $0x08c38348                       // addq         $8, %rbx
+	WORD $0x394c; BYTE $0xda               // cmpq         %r11, %rdx
+	LONG $0x002a8c0f; WORD $0x0000         // jl           LBB8_49, $42(%rip)
+	WORD $0x0b8b                           // movl         (%rbx), %ecx
+	WORD $0x8941; BYTE $0x0e               // movl         %ecx, (%r14)
+	LONG $0x04c38348                       // addq         $4, %rbx
+	LONG $0x04468d4d                       // leaq         $4(%r14), %r8
+	LONG $0xfc4e8d48                       // leaq         $-4(%rsi), %rcx
+	LONG $0x02f98348                       // cmpq         $2, %rcx
+	LONG $0x001f830f; WORD $0x0000         // jae          LBB8_50, $31(%rip)
+	LONG $0x00002de9; BYTE $0x00           // jmp          LBB8_51, $45(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB8_49:
+	WORD $0x894d; BYTE $0xf0       // movq         %r14, %r8
+	WORD $0x8948; BYTE $0xf1       // movq         %rsi, %rcx
+	LONG $0x02f98348               // cmpq         $2, %rcx
+	LONG $0x0013820f; WORD $0x0000 // jb           LBB8_51, $19(%rip)
+
+LBB8_50:
+	WORD $0xb70f; BYTE $0x13 // movzwl       (%rbx), %edx
+	LONG $0x10894166         // movw         %dx, (%r8)
+	LONG $0x02c38348         // addq         $2, %rbx
+	LONG $0x02c08349         // addq         $2, %r8
+	LONG $0xfec18348         // addq         $-2, %rcx
+
+LBB8_51:
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0xff64840f; WORD $0xffff // je           LBB8_44, $-156(%rip)
+	WORD $0xb60f; BYTE $0x0b       // movzbl       (%rbx), %ecx
+	WORD $0x8841; BYTE $0x08       // movb         %cl, (%r8)
+	LONG $0xffff59e9; BYTE $0xff   // jmp          LBB8_44, $-167(%rip)
+
+LBB8_53:
+	LONG $0x290c8d4b               // leaq         (%r9,%r13), %rcx
+	WORD $0x294c; BYTE $0xe8       // subq         %r13, %rax
+	LONG $0xfc69850f; WORD $0xffff // jne          LBB8_3, $-919(%rip)
+
+LBB8_78:
+	WORD $0x014d; BYTE $0xe9 // addq         %r13, %r9
+	LONG $0xc85d8b4c         // movq         $-56(%rbp), %r11
+	LONG $0xd07d8b4c         // movq         $-48(%rbp), %r15
+
+LBB8_79:
+	WORD $0x294d; BYTE $0xfe     // subq         %r15, %r14
+	WORD $0x894d; BYTE $0x33     // movq         %r14, (%r11)
+	WORD $0x2949; BYTE $0xf9     // subq         %rdi, %r9
+	WORD $0x894c; BYTE $0xc8     // movq         %r9, %rax
+	LONG $0x00021ae9; BYTE $0x00 // jmp          LBB8_81, $538(%rip)
+
+LBB8_56:
+	QUAD $0xfffffb98056ff9c5                   // vmovdqa      $-1128(%rip), %xmm0  /* LCPI8_0(%rip) */
+	QUAD $0xfffffba00d6ff9c5                   // vmovdqa      $-1120(%rip), %xmm1  /* LCPI8_1(%rip) */
+	QUAD $0xfffffba8156ff9c5                   // vmovdqa      $-1112(%rip), %xmm2  /* LCPI8_2(%rip) */
+	LONG $0x510d8d4c; WORD $0x00e7; BYTE $0x00 // leaq         $59217(%rip), %r9  /* __EscTab(%rip) */
+	WORD $0x894c; BYTE $0xfe                   // movq         %r15, %rsi
+	WORD $0x8948; BYTE $0xc3                   // movq         %rax, %rbx
+
+LBB8_57:
+	LONG $0x10fb8348               // cmpq         $16, %rbx
+	LONG $0x00438c0f; WORD $0x0000 // jl           LBB8_60, $67(%rip)
+	BYTE $0x90                     // .p2align 4, 0x90
+
+LBB8_58:
+	LONG $0x1f6ffac5               // vmovdqu      (%rdi), %xmm3
+	LONG $0xe074e1c5               // vpcmpeqb     %xmm0, %xmm3, %xmm4
+	LONG $0xe974e1c5               // vpcmpeqb     %xmm1, %xmm3, %xmm5
+	LONG $0xe4ebd1c5               // vpor         %xmm4, %xmm5, %xmm4
+	LONG $0x1e7ffac5               // vmovdqu      %xmm3, (%rsi)
+	LONG $0xeadae1c5               // vpminub      %xmm2, %xmm3, %xmm5
+	LONG $0xdd74e1c5               // vpcmpeqb     %xmm5, %xmm3, %xmm3
+	LONG $0xdbebd9c5               // vpor         %xmm3, %xmm4, %xmm3
+	LONG $0xcbd7f9c5               // vpmovmskb    %xmm3, %ecx
+	WORD $0xc985                   // testl        %ecx, %ecx
+	LONG $0x0120850f; WORD $0x0000 // jne          LBB8_70, $288(%rip)
+	LONG $0x10c78348               // addq         $16, %rdi
+	LONG $0x10c68348               // addq         $16, %rsi
+	LONG $0xf0c38348               // addq         $-16, %rbx
+	LONG $0x10fb8348               // cmpq         $16, %rbx
+	LONG $0xffbe830f; WORD $0xffff // jae          LBB8_58, $-66(%rip)
+
+LBB8_60:
+	LONG $0x08fb8348               // cmpq         $8, %rbx
+	LONG $0x007b8c0f; WORD $0x0000 // jl           LBB8_64, $123(%rip)
+	WORD $0xb60f; BYTE $0x0f       // movzbl       (%rdi), %ecx
+	LONG $0x0157b60f               // movzbl       $1(%rdi), %edx
+	LONG $0x14b60f42; BYTE $0x0a   // movzbl       (%rdx,%r9), %edx
+	WORD $0xd200                   // addb         %dl, %dl
+	LONG $0x09140a42               // orb          (%rcx,%r9), %dl
+	LONG $0x024fb60f               // movzbl       $2(%rdi), %ecx
+	LONG $0x0cb60f42; BYTE $0x09   // movzbl       (%rcx,%r9), %ecx
+	WORD $0xe1c0; BYTE $0x02       // shlb         $2, %cl
+	WORD $0xd108                   // orb          %dl, %cl
+	LONG $0x0357b60f               // movzbl       $3(%rdi), %edx
+	LONG $0x14b60f42; BYTE $0x0a   // movzbl       (%rdx,%r9), %edx
+	WORD $0xe2c0; BYTE $0x03       // shlb         $3, %dl
+	WORD $0xca08                   // orb          %cl, %dl
+	WORD $0x8b48; BYTE $0x0f       // movq         (%rdi), %rcx
+	WORD $0x8948; BYTE $0x0e       // movq         %rcx, (%rsi)
+	LONG $0x0117850f; WORD $0x0000 // jne          LBB8_75, $279(%rip)
+	LONG $0x044fb60f               // movzbl       $4(%rdi), %ecx
+	LONG $0x0557b60f               // movzbl       $5(%rdi), %edx
+	LONG $0x14b60f42; BYTE $0x0a   // movzbl       (%rdx,%r9), %edx
+	WORD $0xd200                   // addb         %dl, %dl
+	LONG $0x09140a42               // orb          (%rcx,%r9), %dl
+	LONG $0x064fb60f               // movzbl       $6(%rdi), %ecx
+	LONG $0x0cb60f42; BYTE $0x09   // movzbl       (%rcx,%r9), %ecx
+	WORD $0xe1c0; BYTE $0x02       // shlb         $2, %cl
+	WORD $0xd108                   // orb          %dl, %cl
+	LONG $0x0757b60f               // movzbl       $7(%rdi), %edx
+	LONG $0x14b60f42; BYTE $0x0a   // movzbl       (%rdx,%r9), %edx
+	WORD $0xe2c0; BYTE $0x03       // shlb         $3, %dl
+	WORD $0xca08                   // orb          %cl, %dl
+	LONG $0x00ed850f; WORD $0x0000 // jne          LBB8_76, $237(%rip)
+	LONG $0x08c68348               // addq         $8, %rsi
+	LONG $0x08c78348               // addq         $8, %rdi
+	LONG $0xf8c38348               // addq         $-8, %rbx
+
+LBB8_64:
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x00448c0f; WORD $0x0000 // jl           LBB8_67, $68(%rip)
+	WORD $0xb60f; BYTE $0x0f       // movzbl       (%rdi), %ecx
+	LONG $0x0157b60f               // movzbl       $1(%rdi), %edx
+	LONG $0x14b60f42; BYTE $0x0a   // movzbl       (%rdx,%r9), %edx
+	WORD $0xd200                   // addb         %dl, %dl
+	LONG $0x09140a42               // orb          (%rcx,%r9), %dl
+	LONG $0x024fb60f               // movzbl       $2(%rdi), %ecx
+	LONG $0x0cb60f42; BYTE $0x09   // movzbl       (%rcx,%r9), %ecx
+	WORD $0xe1c0; BYTE $0x02       // shlb         $2, %cl
+	WORD $0xd108                   // orb          %dl, %cl
+	LONG $0x0357b60f               // movzbl       $3(%rdi), %edx
+	LONG $0x14b60f42; BYTE $0x0a   // movzbl       (%rdx,%r9), %edx
+	WORD $0xe2c0; BYTE $0x03       // shlb         $3, %dl
+	WORD $0xca08                   // orb          %cl, %dl
+	WORD $0x0f8b                   // movl         (%rdi), %ecx
+	WORD $0x0e89                   // movl         %ecx, (%rsi)
+	LONG $0x0094850f; WORD $0x0000 // jne          LBB8_75, $148(%rip)
+	LONG $0x04c68348               // addq         $4, %rsi
+	LONG $0x04c78348               // addq         $4, %rdi
+	LONG $0xfcc38348               // addq         $-4, %rbx
+
+LBB8_67:
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x00aa8e0f; WORD $0x0000 // jle          LBB8_77, $170(%rip)
+	WORD $0x9090                   // .p2align 4, 0x90
+
+LBB8_68:
+	WORD $0xb60f; BYTE $0x0f       // movzbl       (%rdi), %ecx
+	LONG $0x093c8042; BYTE $0x00   // cmpb         $0, (%rcx,%r9)
+	LONG $0x002e850f; WORD $0x0000 // jne          LBB8_72, $46(%rip)
+	WORD $0xff48; BYTE $0xc7       // incq         %rdi
+	WORD $0x0e88                   // movb         %cl, (%rsi)
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	LONG $0xff4b8d48               // leaq         $-1(%rbx), %rcx
+	LONG $0x01fb8348               // cmpq         $1, %rbx
+	WORD $0x8948; BYTE $0xcb       // movq         %rcx, %rbx
+	LONG $0xffd98f0f; WORD $0xffff // jg           LBB8_68, $-39(%rip)
+	LONG $0x00007ce9; BYTE $0x00   // jmp          LBB8_77, $124(%rip)
+
+LBB8_70:
+	LONG $0xc9bc0f66         // bsfw         %cx, %cx
+	WORD $0xb70f; BYTE $0xc9 // movzwl       %cx, %ecx
+
+LBB8_71:
+	WORD $0x0148; BYTE $0xcf // addq         %rcx, %rdi
+	WORD $0x2948; BYTE $0xcb // subq         %rcx, %rbx
+	WORD $0x0148; BYTE $0xce // addq         %rcx, %rsi
+
+LBB8_72:
+	WORD $0xb60f; BYTE $0x0f // movzbl       (%rdi), %ecx
+	BYTE $0x90               // .p2align 4, 0x90
+
+LBB8_73:
+	WORD $0x8948; BYTE $0xf2       // movq         %rsi, %rdx
+	WORD $0xb60f; BYTE $0xc9       // movzbl       %cl, %ecx
+	LONG $0x04e1c148               // shlq         $4, %rcx
+	LONG $0x0c346349               // movslq       (%r12,%rcx), %rsi
+	LONG $0x0c4c8b49; BYTE $0x08   // movq         $8(%r12,%rcx), %rcx
+	WORD $0x8948; BYTE $0x0a       // movq         %rcx, (%rdx)
+	WORD $0x0148; BYTE $0xd6       // addq         %rdx, %rsi
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0x00458c0f; WORD $0x0000 // jl           LBB8_77, $69(%rip)
+	WORD $0xff48; BYTE $0xcb       // decq         %rbx
+	LONG $0x014fb60f               // movzbl       $1(%rdi), %ecx
+	WORD $0xff48; BYTE $0xc7       // incq         %rdi
+	LONG $0x093c8042; BYTE $0x00   // cmpb         $0, (%rcx,%r9)
+	LONG $0xffc8850f; WORD $0xffff // jne          LBB8_73, $-56(%rip)
+	LONG $0xfffe58e9; BYTE $0xff   // jmp          LBB8_57, $-424(%rip)
+
+LBB8_75:
+	WORD $0xb60f; BYTE $0xca     // movzbl       %dl, %ecx
+	WORD $0xbc0f; BYTE $0xc9     // bsfl         %ecx, %ecx
+	LONG $0xffffabe9; BYTE $0xff // jmp          LBB8_71, $-85(%rip)
+
+LBB8_76:
+	WORD $0xb60f; BYTE $0xca     // movzbl       %dl, %ecx
+	WORD $0xbc0f; BYTE $0xc9     // bsfl         %ecx, %ecx
+	LONG $0x04518d48             // leaq         $4(%rcx), %rdx
+	WORD $0x0148; BYTE $0xcf     // addq         %rcx, %rdi
+	LONG $0x04c78348             // addq         $4, %rdi
+	WORD $0x2948; BYTE $0xd3     // subq         %rdx, %rbx
+	WORD $0x0148; BYTE $0xce     // addq         %rcx, %rsi
+	LONG $0x04c68348             // addq         $4, %rsi
+	LONG $0xffff94e9; BYTE $0xff // jmp          LBB8_72, $-108(%rip)
+
+LBB8_77:
+	WORD $0x294c; BYTE $0xfe     // subq         %r15, %rsi
+	WORD $0x8949; BYTE $0x33     // movq         %rsi, (%r11)
+	LONG $0x000017e9; BYTE $0x00 // jmp          LBB8_81, $23(%rip)
+
+LBB8_80:
+	LONG $0xd0752b4c         // subq         $-48(%rbp), %r14
+	LONG $0xc8458b48         // movq         $-56(%rbp), %rax
+	WORD $0x894c; BYTE $0x30 // movq         %r14, (%rax)
+	WORD $0x294c; BYTE $0xcf // subq         %r9, %rdi
+	WORD $0xf749; BYTE $0xd5 // notq         %r13
+	WORD $0x0149; BYTE $0xfd // addq         %rdi, %r13
+	WORD $0x894c; BYTE $0xe8 // movq         %r13, %rax
+
+LBB8_81:
+	LONG $0x20c48348 // addq         $32, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5d41     // popq         %r13
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB8_82:
+	LONG $0xd04d8b48             // movq         $-48(%rbp), %rcx
+	WORD $0x014c; BYTE $0xe9     // addq         %r13, %rcx
+	WORD $0xf748; BYTE $0xd1     // notq         %rcx
+	WORD $0x014c; BYTE $0xf1     // addq         %r14, %rcx
+	LONG $0xc8458b48             // movq         $-56(%rbp), %rax
+	WORD $0x8948; BYTE $0x08     // movq         %rcx, (%rax)
+	WORD $0x294c; BYTE $0xcf     // subq         %r9, %rdi
+	WORD $0x014c; BYTE $0xef     // addq         %r13, %rdi
+	WORD $0x8948; BYTE $0xf8     // movq         %rdi, %rax
+	LONG $0xffffcfe9; BYTE $0xff // jmp          LBB8_81, $-49(%rip)
+	LONG $0x00000000; BYTE $0x00 // .p2align 4, 0x00
+
+LCPI9_0:
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+
+LCPI9_1:
+	BYTE $0xf0 // .byte 240
+	BYTE $0x80 // .byte 128
+	BYTE $0x80 // .byte 128
+	BYTE $0x80 // .byte 128
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+
+	// .p2align 4, 0x90
+_unquote:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x48ec8348                           // subq         $72, %rsp
+	WORD $0x8548; BYTE $0xf6                   // testq        %rsi, %rsi
+	LONG $0x0683840f; WORD $0x0000             // je           LBB9_1, $1667(%rip)
+	LONG $0xd04d8948                           // movq         %rcx, $-48(%rbp)
+	WORD $0x8945; BYTE $0xc2                   // movl         %r8d, %r10d
+	LONG $0x01e28341                           // andl         $1, %r10d
+	LONG $0xd4258d4c; WORD $0x00e5; BYTE $0x00 // leaq         $58836(%rip), %r12  /* __UnquoteTab(%rip) */
+	QUAD $0xffffffbc0d6ff9c5                   // vmovdqa      $-68(%rip), %xmm1  /* LCPI9_1(%rip) */
+	QUAD $0xffffffa4156ff9c5                   // vmovdqa      $-92(%rip), %xmm2  /* LCPI9_0(%rip) */
+	WORD $0x8949; BYTE $0xff                   // movq         %rdi, %r15
+	WORD $0x8949; BYTE $0xf5                   // movq         %rsi, %r13
+	WORD $0x8949; BYTE $0xd6                   // movq         %rdx, %r14
+	LONG $0xb845894c                           // movq         %r8, $-72(%rbp)
+
+LBB9_4:
+	LONG $0x5c3f8041               // cmpb         $92, (%r15)
+	LONG $0x000d850f; WORD $0x0000 // jne          LBB9_6, $13(%rip)
+	WORD $0x3145; BYTE $0xdb       // xorl         %r11d, %r11d
+	LONG $0x0000c5e9; BYTE $0x00   // jmp          LBB9_18, $197(%rip)
+	LONG $0x90909090; BYTE $0x90   // .p2align 4, 0x90
+
+LBB9_6:
+	WORD $0x894d; BYTE $0xe9       // movq         %r13, %r9
+	WORD $0x894c; BYTE $0xf1       // movq         %r14, %rcx
+	WORD $0x894d; BYTE $0xfb       // movq         %r15, %r11
+	LONG $0x10fd8349               // cmpq         $16, %r13
+	LONG $0x00458c0f; WORD $0x0000 // jl           LBB9_12, $69(%rip)
+	WORD $0xc931                   // xorl         %ecx, %ecx
+	WORD $0x894c; BYTE $0xe8       // movq         %r13, %rax
+	QUAD $0x9090909090909090       // .p2align 4, 0x90
+
+LBB9_8:
+	LONG $0x6f7ac1c4; WORD $0x0f04 // vmovdqu      (%r15,%rcx), %xmm0
+	LONG $0x7f7ac1c4; WORD $0x0e04 // vmovdqu      %xmm0, (%r14,%rcx)
+	LONG $0xc274f9c5               // vpcmpeqb     %xmm2, %xmm0, %xmm0
+	LONG $0xd8d7f9c5               // vpmovmskb    %xmm0, %ebx
+	WORD $0xdb85                   // testl        %ebx, %ebx
+	LONG $0x006b850f; WORD $0x0000 // jne          LBB9_9, $107(%rip)
+	LONG $0xf0488d4c               // leaq         $-16(%rax), %r9
+	LONG $0x10c18348               // addq         $16, %rcx
+	LONG $0x1ff88348               // cmpq         $31, %rax
+	WORD $0x894c; BYTE $0xc8       // movq         %r9, %rax
+	LONG $0xffcf870f; WORD $0xffff // ja           LBB9_8, $-49(%rip)
+	LONG $0x0f1c8d4d               // leaq         (%r15,%rcx), %r11
+	WORD $0x014c; BYTE $0xf1       // addq         %r14, %rcx
+
+LBB9_12:
+	WORD $0x854d; BYTE $0xc9                               // testq        %r9, %r9
+	LONG $0x05e2840f; WORD $0x0000                         // je           LBB9_2, $1506(%rip)
+	WORD $0xc031                                           // xorl         %eax, %eax
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB9_14:
+	LONG $0x1cb60f41; BYTE $0x03   // movzbl       (%r11,%rax), %ebx
+	WORD $0xfb80; BYTE $0x5c       // cmpb         $92, %bl
+	LONG $0x0014840f; WORD $0x0000 // je           LBB9_16, $20(%rip)
+	WORD $0x1c88; BYTE $0x01       // movb         %bl, (%rcx,%rax)
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3949; BYTE $0xc1       // cmpq         %rax, %r9
+	LONG $0xffe3850f; WORD $0xffff // jne          LBB9_14, $-29(%rip)
+	LONG $0x0005b1e9; BYTE $0x00   // jmp          LBB9_2, $1457(%rip)
+
+LBB9_16:
+	WORD $0x294d; BYTE $0xfb       // subq         %r15, %r11
+	WORD $0x0149; BYTE $0xc3       // addq         %rax, %r11
+	LONG $0xfffb8349               // cmpq         $-1, %r11
+	LONG $0x001e850f; WORD $0x0000 // jne          LBB9_18, $30(%rip)
+	LONG $0x00059ce9; BYTE $0x00   // jmp          LBB9_2, $1436(%rip)
+
+LBB9_9:
+	LONG $0xc3bc0f66               // bsfw         %bx, %ax
+	LONG $0xd8b70f44               // movzwl       %ax, %r11d
+	WORD $0x0149; BYTE $0xcb       // addq         %rcx, %r11
+	LONG $0xfffb8349               // cmpq         $-1, %r11
+	LONG $0x0587840f; WORD $0x0000 // je           LBB9_2, $1415(%rip)
+	LONG $0x90909090               // .p2align 4, 0x90
+
+LBB9_18:
+	LONG $0x024b8d49               // leaq         $2(%r11), %rcx
+	WORD $0x2949; BYTE $0xcd       // subq         %rcx, %r13
+	LONG $0x0642880f; WORD $0x0000 // js           LBB9_19, $1602(%rip)
+	WORD $0x014d; BYTE $0xdf       // addq         %r11, %r15
+	LONG $0x02c78349               // addq         $2, %r15
+	WORD $0x854d; BYTE $0xd2       // testq        %r10, %r10
+	LONG $0x028d850f; WORD $0x0000 // jne          LBB9_21, $653(%rip)
+
+LBB9_32:
+	WORD $0x014d; BYTE $0xde                                             // addq         %r11, %r14
+	LONG $0x47b60f41; BYTE $0xff                                         // movzbl       $-1(%r15), %eax
+	LONG $0x04b60f42; BYTE $0x20                                         // movzbl       (%rax,%r12), %eax
+	LONG $0x0000ff3d; BYTE $0x00                                         // cmpl         $255, %eax
+	LONG $0x002b840f; WORD $0x0000                                       // je           LBB9_38, $43(%rip)
+	WORD $0xc085                                                         // testl        %eax, %eax
+	LONG $0x062d840f; WORD $0x0000                                       // je           LBB9_34, $1581(%rip)
+	WORD $0x8841; BYTE $0x06                                             // movb         %al, (%r14)
+	WORD $0xff49; BYTE $0xc6                                             // incq         %r14
+	WORD $0x854d; BYTE $0xed                                             // testq        %r13, %r13
+	LONG $0xfedd850f; WORD $0xffff                                       // jne          LBB9_4, $-291(%rip)
+	LONG $0x000611e9; BYTE $0x00                                         // jmp          LBB9_37, $1553(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB9_38:
+	LONG $0x03fd8349                           // cmpq         $3, %r13
+	LONG $0x05e5860f; WORD $0x0000             // jbe          LBB9_19, $1509(%rip)
+	WORD $0x8b41; BYTE $0x1f                   // movl         (%r15), %ebx
+	WORD $0xd989                               // movl         %ebx, %ecx
+	WORD $0xd1f7                               // notl         %ecx
+	LONG $0xcfd0838d; WORD $0xcfcf             // leal         $-808464432(%rbx), %eax
+	LONG $0x8080e181; WORD $0x8080             // andl         $-2139062144, %ecx
+	WORD $0xc185                               // testl        %eax, %ecx
+	LONG $0x0516850f; WORD $0x0000             // jne          LBB9_43, $1302(%rip)
+	LONG $0x1919838d; WORD $0x1919             // leal         $421075225(%rbx), %eax
+	WORD $0xd809                               // orl          %ebx, %eax
+	LONG $0x808080a9; BYTE $0x80               // testl        $-2139062144, %eax
+	LONG $0x0503850f; WORD $0x0000             // jne          LBB9_43, $1283(%rip)
+	WORD $0xd889                               // movl         %ebx, %eax
+	LONG $0x7f7f7f25; BYTE $0x7f               // andl         $2139062143, %eax
+	LONG $0xc0c0bb41; WORD $0xc0c0             // movl         $-1061109568, %r11d
+	WORD $0x2941; BYTE $0xc3                   // subl         %eax, %r11d
+	LONG $0x46888d44; WORD $0x4646; BYTE $0x46 // leal         $1179010630(%rax), %r9d
+	WORD $0x2141; BYTE $0xcb                   // andl         %ecx, %r11d
+	WORD $0x8545; BYTE $0xcb                   // testl        %r9d, %r11d
+	LONG $0x04e0850f; WORD $0x0000             // jne          LBB9_43, $1248(%rip)
+	LONG $0xe0e0b941; WORD $0xe0e0             // movl         $-522133280, %r9d
+	WORD $0x2941; BYTE $0xc1                   // subl         %eax, %r9d
+	LONG $0x39393905; BYTE $0x39               // addl         $960051513, %eax
+	WORD $0x2144; BYTE $0xc9                   // andl         %r9d, %ecx
+	WORD $0xc185                               // testl        %eax, %ecx
+	LONG $0x04c7850f; WORD $0x0000             // jne          LBB9_43, $1223(%rip)
+	WORD $0xcb0f                               // bswapl       %ebx
+	WORD $0xd989                               // movl         %ebx, %ecx
+	WORD $0xd1f7                               // notl         %ecx
+	WORD $0xe9c1; BYTE $0x04                   // shrl         $4, %ecx
+	LONG $0x0101e181; WORD $0x0101             // andl         $16843009, %ecx
+	WORD $0x0c8d; BYTE $0xc9                   // leal         (%rcx,%rcx,8), %ecx
+	LONG $0x0f0fe381; WORD $0x0f0f             // andl         $252645135, %ebx
+	WORD $0xcb01                               // addl         %ecx, %ebx
+	WORD $0xd989                               // movl         %ebx, %ecx
+	WORD $0xe9c1; BYTE $0x04                   // shrl         $4, %ecx
+	WORD $0xd909                               // orl          %ebx, %ecx
+	WORD $0xb60f; BYTE $0xd9                   // movzbl       %cl, %ebx
+	WORD $0xe9c1; BYTE $0x08                   // shrl         $8, %ecx
+	LONG $0xff00e181; WORD $0x0000             // andl         $65280, %ecx
+	WORD $0xcb09                               // orl          %ecx, %ebx
+	LONG $0x044f8d4d                           // leaq         $4(%r15), %r9
+	LONG $0xfc4d8d49                           // leaq         $-4(%r13), %rcx
+	LONG $0x0080fb81; WORD $0x0000             // cmpl         $128, %ebx
+	LONG $0x01e3820f; WORD $0x0000             // jb           LBB9_54, $483(%rip)
+	LONG $0x02c0f641                           // testb        $2, %r8b
+	LONG $0x01ea840f; WORD $0x0000             // je           LBB9_65, $490(%rip)
+	WORD $0x894d; BYTE $0xcf                   // movq         %r9, %r15
+	WORD $0x8941; BYTE $0xdc                   // movl         %ebx, %r12d
+	WORD $0x8949; BYTE $0xcd                   // movq         %rcx, %r13
+
+LBB9_59:
+	LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl         $2047, %r12d
+	LONG $0x02e3860f; WORD $0x0000             // jbe          LBB9_67, $739(%rip)
+	QUAD $0xffff200024848d41                   // leal         $-57344(%r12), %eax
+	LONG $0xfff7ff3d; BYTE $0xff               // cmpl         $-2049, %eax
+	LONG $0x01f6860f; WORD $0x0000             // jbe          LBB9_70, $502(%rip)
+	WORD $0x854d; BYTE $0xd2                   // testq        %r10, %r10
+	LONG $0xc07d8948                           // movq         %rdi, $-64(%rbp)
+	LONG $0xb0758948                           // movq         %rsi, $-80(%rbp)
+	LONG $0x00d2850f; WORD $0x0000             // jne          LBB9_62, $210(%rip)
+	LONG $0xa855894c                           // movq         %r10, $-88(%rbp)
+	LONG $0xa0558948                           // movq         %rdx, $-96(%rbp)
+	LONG $0x06fd8349                           // cmpq         $6, %r13
+	LONG $0x00eb8c0f; WORD $0x0000             // jl           LBB9_94, $235(%rip)
+
+LBB9_91:
+	LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl         $56319, %r12d
+	LONG $0x00de870f; WORD $0x0000             // ja           LBB9_94, $222(%rip)
+	LONG $0x5c3f8041                           // cmpb         $92, (%r15)
+	LONG $0x00d4850f; WORD $0x0000             // jne          LBB9_94, $212(%rip)
+	LONG $0x017f8041; BYTE $0x75               // cmpb         $117, $1(%r15)
+	LONG $0x00c9850f; WORD $0x0000             // jne          LBB9_94, $201(%rip)
+	LONG $0x025f8b41                           // movl         $2(%r15), %ebx
+	WORD $0xdf89                               // movl         %ebx, %edi
+	LONG $0x000636e8; BYTE $0x00               // callq        _unhex16_is, $1590(%rip)
+	WORD $0xc084                               // testb        %al, %al
+	LONG $0x052a840f; WORD $0x0000             // je           LBB9_100, $1322(%rip)
+	WORD $0xcb0f                               // bswapl       %ebx
+	WORD $0xd889                               // movl         %ebx, %eax
+	WORD $0xd0f7                               // notl         %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	LONG $0x01010125; BYTE $0x01               // andl         $16843009, %eax
+	WORD $0x048d; BYTE $0xc0                   // leal         (%rax,%rax,8), %eax
+	LONG $0x0f0fe381; WORD $0x0f0f             // andl         $252645135, %ebx
+	WORD $0xc301                               // addl         %eax, %ebx
+	WORD $0xd889                               // movl         %ebx, %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	WORD $0xd809                               // orl          %ebx, %eax
+	WORD $0xb60f; BYTE $0xc8                   // movzbl       %al, %ecx
+	WORD $0xe8c1; BYTE $0x08                   // shrl         $8, %eax
+	LONG $0x00ff0025; BYTE $0x00               // andl         $65280, %eax
+	WORD $0x1c8d; BYTE $0x08                   // leal         (%rax,%rcx), %ebx
+	LONG $0x06c78349                           // addq         $6, %r15
+	LONG $0xfac58349                           // addq         $-6, %r13
+	WORD $0xc801                               // addl         %ecx, %eax
+	LONG $0xff200005; BYTE $0xff               // addl         $-57344, %eax
+	LONG $0xfffbff3d; BYTE $0xff               // cmpl         $-1025, %eax
+	LONG $0xc07d8b48                           // movq         $-64(%rbp), %rdi
+	LONG $0xa0558b48                           // movq         $-96(%rbp), %rdx
+	LONG $0xb0758b48                           // movq         $-80(%rbp), %rsi
+	QUAD $0xfffffcd80d6ff9c5                   // vmovdqa      $-808(%rip), %xmm1  /* LCPI9_1(%rip) */
+	QUAD $0xfffffcc0156ff9c5                   // vmovdqa      $-832(%rip), %xmm2  /* LCPI9_0(%rip) */
+	LONG $0x017c870f; WORD $0x0000             // ja           LBB9_110, $380(%rip)
+	LONG $0x06c74166; WORD $0xbfef             // movw         $-16401, (%r14)
+	LONG $0x0246c641; BYTE $0xbd               // movb         $-67, $2(%r14)
+	LONG $0x03c68349                           // addq         $3, %r14
+	WORD $0x8941; BYTE $0xdc                   // movl         %ebx, %r12d
+	LONG $0x0080fb81; WORD $0x0000             // cmpl         $128, %ebx
+	LONG $0xa8558b4c                           // movq         $-88(%rbp), %r10
+	LONG $0xff02830f; WORD $0xffff             // jae          LBB9_59, $-254(%rip)
+	LONG $0x0000d3e9; BYTE $0x00               // jmp          LBB9_55, $211(%rip)
+
+LBB9_62:
+	WORD $0x854d; BYTE $0xed       // testq        %r13, %r13
+	LONG $0x04718e0f; WORD $0x0000 // jle          LBB9_63, $1137(%rip)
+	LONG $0x5c3f8041               // cmpb         $92, (%r15)
+	LONG $0x02bf850f; WORD $0x0000 // jne          LBB9_96, $703(%rip)
+	WORD $0xff49; BYTE $0xcd       // decq         %r13
+	WORD $0xff49; BYTE $0xc7       // incq         %r15
+	LONG $0xa855894c               // movq         %r10, $-88(%rbp)
+	LONG $0xa0558948               // movq         %rdx, $-96(%rbp)
+	LONG $0x06fd8349               // cmpq         $6, %r13
+	LONG $0xff158d0f; WORD $0xffff // jge          LBB9_91, $-235(%rip)
+
+LBB9_94:
+	LONG $0x02b845f6                           // testb        $2, $-72(%rbp)
+	LONG $0x02f9840f; WORD $0x0000             // je           LBB9_77, $761(%rip)
+	LONG $0x06c74166; WORD $0xbfef             // movw         $-16401, (%r14)
+	LONG $0x0246c641; BYTE $0xbd               // movb         $-67, $2(%r14)
+	LONG $0x03c68349                           // addq         $3, %r14
+	LONG $0xc07d8b48                           // movq         $-64(%rbp), %rdi
+	LONG $0xa0558b48                           // movq         $-96(%rbp), %rdx
+	LONG $0xa8558b4c                           // movq         $-88(%rbp), %r10
+	LONG $0xb0758b48                           // movq         $-80(%rbp), %rsi
+	LONG $0xb8458b4c                           // movq         $-72(%rbp), %r8
+	LONG $0x54258d4c; WORD $0x00e2; BYTE $0x00 // leaq         $57940(%rip), %r12  /* __UnquoteTab(%rip) */
+	QUAD $0xfffffc3c0d6ff9c5                   // vmovdqa      $-964(%rip), %xmm1  /* LCPI9_1(%rip) */
+	QUAD $0xfffffc24156ff9c5                   // vmovdqa      $-988(%rip), %xmm2  /* LCPI9_0(%rip) */
+	WORD $0x854d; BYTE $0xed                   // testq        %r13, %r13
+	LONG $0xfc84850f; WORD $0xffff             // jne          LBB9_4, $-892(%rip)
+	LONG $0x0003b8e9; BYTE $0x00               // jmp          LBB9_37, $952(%rip)
+
+LBB9_21:
+	WORD $0x8545; BYTE $0xed       // testl        %r13d, %r13d
+	LONG $0x039c840f; WORD $0x0000 // je           LBB9_19, $924(%rip)
+	LONG $0xff7f8041; BYTE $0x5c   // cmpb         $92, $-1(%r15)
+	LONG $0x03c5850f; WORD $0x0000 // jne          LBB9_23, $965(%rip)
+	LONG $0x5c3f8041               // cmpb         $92, (%r15)
+	LONG $0x0027850f; WORD $0x0000 // jne          LBB9_31, $39(%rip)
+	LONG $0x01fd8341               // cmpl         $1, %r13d
+	LONG $0x037d8e0f; WORD $0x0000 // jle          LBB9_19, $893(%rip)
+	LONG $0x4fb60f41; BYTE $0x01   // movzbl       $1(%r15), %ecx
+	WORD $0xf983; BYTE $0x22       // cmpl         $34, %ecx
+	LONG $0x0009840f; WORD $0x0000 // je           LBB9_30, $9(%rip)
+	WORD $0xf983; BYTE $0x5c       // cmpl         $92, %ecx
+	LONG $0x03b3850f; WORD $0x0000 // jne          LBB9_29, $947(%rip)
+
+LBB9_30:
+	WORD $0xff49; BYTE $0xc7 // incq         %r15
+	WORD $0xff49; BYTE $0xcd // decq         %r13
+
+LBB9_31:
+	WORD $0xff49; BYTE $0xc7     // incq         %r15
+	WORD $0xff49; BYTE $0xcd     // decq         %r13
+	LONG $0xfffd23e9; BYTE $0xff // jmp          LBB9_32, $-733(%rip)
+
+LBB9_54:
+	WORD $0x8949; BYTE $0xcd // movq         %rcx, %r13
+	WORD $0x894d; BYTE $0xcf // movq         %r9, %r15
+
+LBB9_55:
+	WORD $0x8841; BYTE $0x1e     // movb         %bl, (%r14)
+	WORD $0xff49; BYTE $0xc6     // incq         %r14
+	LONG $0x00005ee9; BYTE $0x00 // jmp          LBB9_56, $94(%rip)
+
+LBB9_65:
+	LONG $0x0800fb81; WORD $0x0000                                       // cmpl         $2048, %ebx
+	LONG $0x00fa820f; WORD $0x0000                                       // jb           LBB9_66, $250(%rip)
+	LONG $0x2000838d; WORD $0xffff                                       // leal         $-57344(%rbx), %eax
+	LONG $0xfff8003d; BYTE $0xff                                         // cmpl         $-2048, %eax
+	LONG $0x0112830f; WORD $0x0000                                       // jae          LBB9_71, $274(%rip)
+	WORD $0x8949; BYTE $0xcd                                             // movq         %rcx, %r13
+	WORD $0x8941; BYTE $0xdc                                             // movl         %ebx, %r12d
+	WORD $0x894d; BYTE $0xcf                                             // movq         %r9, %r15
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB9_70:
+	WORD $0x8944; BYTE $0xe0 // movl         %r12d, %eax
+	WORD $0xe8c1; BYTE $0x0c // shrl         $12, %eax
+	WORD $0xe00c             // orb          $-32, %al
+	WORD $0x8841; BYTE $0x06 // movb         %al, (%r14)
+	WORD $0x8944; BYTE $0xe0 // movl         %r12d, %eax
+	WORD $0xe8c1; BYTE $0x06 // shrl         $6, %eax
+	WORD $0x3f24             // andb         $63, %al
+	WORD $0x800c             // orb          $-128, %al
+	LONG $0x01468841         // movb         %al, $1(%r14)
+	LONG $0x3fe48041         // andb         $63, %r12b
+	LONG $0x80cc8041         // orb          $-128, %r12b
+	LONG $0x02668845         // movb         %r12b, $2(%r14)
+	LONG $0x03c68349         // addq         $3, %r14
+
+LBB9_56:
+	LONG $0xb8458b4c                           // movq         $-72(%rbp), %r8
+	LONG $0x6c258d4c; WORD $0x00e1; BYTE $0x00 // leaq         $57708(%rip), %r12  /* __UnquoteTab(%rip) */
+	WORD $0x854d; BYTE $0xed                   // testq        %r13, %r13
+	LONG $0xfbac850f; WORD $0xffff             // jne          LBB9_4, $-1108(%rip)
+	LONG $0x0002e0e9; BYTE $0x00               // jmp          LBB9_37, $736(%rip)
+
+LBB9_110:
+	WORD $0xd889 // movl         %ebx, %eax
+
+LBB9_85:
+	LONG $0x0ae4c141                           // shll         $10, %r12d
+	WORD $0xc189                               // movl         %eax, %ecx
+	WORD $0x0144; BYTE $0xe1                   // addl         %r12d, %ecx
+	WORD $0x0144; BYTE $0xe0                   // addl         %r12d, %eax
+	LONG $0xa0240005; BYTE $0xfc               // addl         $-56613888, %eax
+	WORD $0xc289                               // movl         %eax, %edx
+	WORD $0xeac1; BYTE $0x12                   // shrl         $18, %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xeec1; BYTE $0x0c                   // shrl         $12, %esi
+	LONG $0x3fe68040                           // andb         $63, %sil
+	WORD $0xe8c1; BYTE $0x06                   // shrl         $6, %eax
+	LONG $0xc26ef9c5                           // vmovd        %edx, %xmm0
+	LONG $0xd6b60f40                           // movzbl       %sil, %edx
+	LONG $0x2079e3c4; WORD $0x01c2             // vpinsrb      $1, %edx, %xmm0, %xmm0
+	WORD $0x3f24                               // andb         $63, %al
+	WORD $0xb60f; BYTE $0xc0                   // movzbl       %al, %eax
+	LONG $0x2079e3c4; WORD $0x02c0             // vpinsrb      $2, %eax, %xmm0, %xmm0
+	WORD $0xe180; BYTE $0x3f                   // andb         $63, %cl
+	WORD $0xb60f; BYTE $0xc1                   // movzbl       %cl, %eax
+	LONG $0x2079e3c4; WORD $0x03c0             // vpinsrb      $3, %eax, %xmm0, %xmm0
+	QUAD $0xfffffafd0d6ff9c5                   // vmovdqa      $-1283(%rip), %xmm1  /* LCPI9_1(%rip) */
+	LONG $0xc1ebf9c5                           // vpor         %xmm1, %xmm0, %xmm0
+	LONG $0x7e79c1c4; BYTE $0x06               // vmovd        %xmm0, (%r14)
+	LONG $0x04c68349                           // addq         $4, %r14
+	LONG $0xc07d8b48                           // movq         $-64(%rbp), %rdi
+	LONG $0xa0558b48                           // movq         $-96(%rbp), %rdx
+	LONG $0xa8558b4c                           // movq         $-88(%rbp), %r10
+	LONG $0xb0758b48                           // movq         $-80(%rbp), %rsi
+	LONG $0xb8458b4c                           // movq         $-72(%rbp), %r8
+	LONG $0xe5258d4c; WORD $0x00e0; BYTE $0x00 // leaq         $57573(%rip), %r12  /* __UnquoteTab(%rip) */
+	QUAD $0xfffffabd156ff9c5                   // vmovdqa      $-1347(%rip), %xmm2  /* LCPI9_0(%rip) */
+	WORD $0x854d; BYTE $0xed                   // testq        %r13, %r13
+	LONG $0xfb1d850f; WORD $0xffff             // jne          LBB9_4, $-1251(%rip)
+	LONG $0x000251e9; BYTE $0x00               // jmp          LBB9_37, $593(%rip)
+
+LBB9_66:
+	WORD $0x8949; BYTE $0xcd // movq         %rcx, %r13
+	WORD $0x8941; BYTE $0xdc // movl         %ebx, %r12d
+	WORD $0x894d; BYTE $0xcf // movq         %r9, %r15
+
+LBB9_67:
+	WORD $0x8944; BYTE $0xe0     // movl         %r12d, %eax
+	WORD $0xe8c1; BYTE $0x06     // shrl         $6, %eax
+	WORD $0xc00c                 // orb          $-64, %al
+	WORD $0x8841; BYTE $0x06     // movb         %al, (%r14)
+	LONG $0x3fe48041             // andb         $63, %r12b
+	LONG $0x80cc8041             // orb          $-128, %r12b
+	LONG $0x01668845             // movb         %r12b, $1(%r14)
+	LONG $0x02c68349             // addq         $2, %r14
+	LONG $0xffff2fe9; BYTE $0xff // jmp          LBB9_56, $-209(%rip)
+
+LBB9_71:
+	WORD $0x8949; BYTE $0xdc       // movq         %rbx, %r12
+	LONG $0x984d8948               // movq         %rcx, $-104(%rbp)
+	LONG $0xc84d894c               // movq         %r9, $-56(%rbp)
+	LONG $0xb0758948               // movq         %rsi, $-80(%rbp)
+	LONG $0xa0558948               // movq         %rdx, $-96(%rbp)
+	LONG $0xc07d8948               // movq         %rdi, $-64(%rbp)
+	LONG $0xa855894c               // movq         %r10, $-88(%rbp)
+	WORD $0x854d; BYTE $0xd2       // testq        %r10, %r10
+	LONG $0x00c7850f; WORD $0x0000 // jne          LBB9_72, $199(%rip)
+	LONG $0x987d8348; BYTE $0x06   // cmpq         $6, $-104(%rbp)
+	LONG $0x00ee820f; WORD $0x0000 // jb           LBB9_76, $238(%rip)
+
+LBB9_78:
+	LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl         $56319, %r12d
+	LONG $0x00e1870f; WORD $0x0000             // ja           LBB9_76, $225(%rip)
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	WORD $0x3880; BYTE $0x5c                   // cmpb         $92, (%rax)
+	LONG $0x00d4850f; WORD $0x0000             // jne          LBB9_76, $212(%rip)
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	LONG $0x75017880                           // cmpb         $117, $1(%rax)
+	LONG $0x00c6850f; WORD $0x0000             // jne          LBB9_76, $198(%rip)
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	WORD $0x588b; BYTE $0x02                   // movl         $2(%rax), %ebx
+	WORD $0xdf89                               // movl         %ebx, %edi
+	LONG $0x000331e8; BYTE $0x00               // callq        _unhex16_is, $817(%rip)
+	WORD $0xc084                               // testb        %al, %al
+	LONG $0x0221840f; WORD $0x0000             // je           LBB9_82, $545(%rip)
+	WORD $0xcb0f                               // bswapl       %ebx
+	WORD $0xd889                               // movl         %ebx, %eax
+	WORD $0xd0f7                               // notl         %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	LONG $0x01010125; BYTE $0x01               // andl         $16843009, %eax
+	WORD $0x048d; BYTE $0xc0                   // leal         (%rax,%rax,8), %eax
+	LONG $0x0f0fe381; WORD $0x0f0f             // andl         $252645135, %ebx
+	WORD $0xc301                               // addl         %eax, %ebx
+	WORD $0xd889                               // movl         %ebx, %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	WORD $0xd809                               // orl          %ebx, %eax
+	WORD $0xb60f; BYTE $0xc8                   // movzbl       %al, %ecx
+	WORD $0xe8c1; BYTE $0x08                   // shrl         $8, %eax
+	LONG $0x00ff0025; BYTE $0x00               // andl         $65280, %eax
+	LONG $0xc8458348; BYTE $0x06               // addq         $6, $-56(%rbp)
+	WORD $0x148d; BYTE $0x08                   // leal         (%rax,%rcx), %edx
+	LONG $0x2000c281; WORD $0xffff             // addl         $-57344, %edx
+	LONG $0xfc00fa81; WORD $0xffff             // cmpl         $-1024, %edx
+	LONG $0x02ae820f; WORD $0x0000             // jb           LBB9_98, $686(%rip)
+	WORD $0xc809                               // orl          %ecx, %eax
+	LONG $0x986d8b4c                           // movq         $-104(%rbp), %r13
+	LONG $0xfac58349                           // addq         $-6, %r13
+	LONG $0xc87d8b4c                           // movq         $-56(%rbp), %r15
+	LONG $0xfffe85e9; BYTE $0xff               // jmp          LBB9_85, $-379(%rip)
+
+LBB9_96:
+	LONG $0x02b845f6               // testb        $2, $-72(%rbp)
+	LONG $0x028d840f; WORD $0x0000 // je           LBB9_97, $653(%rip)
+	LONG $0x06c74166; WORD $0xbfef // movw         $-16401, (%r14)
+	LONG $0x0246c641; BYTE $0xbd   // movb         $-67, $2(%r14)
+	LONG $0x03c68349               // addq         $3, %r14
+	LONG $0xc07d8b48               // movq         $-64(%rbp), %rdi
+	LONG $0xb0758b48               // movq         $-80(%rbp), %rsi
+	LONG $0xfffe44e9; BYTE $0xff   // jmp          LBB9_56, $-444(%rip)
+
+LBB9_72:
+	LONG $0x05fd8349               // cmpq         $5, %r13
+	LONG $0x028a820f; WORD $0x0000 // jb           LBB9_87, $650(%rip)
+	LONG $0xc8458b48               // movq         $-56(%rbp), %rax
+	WORD $0x3880; BYTE $0x5c       // cmpb         $92, (%rax)
+	LONG $0x025e850f; WORD $0x0000 // jne          LBB9_98, $606(%rip)
+	LONG $0xfbc58349               // addq         $-5, %r13
+	LONG $0x05c78349               // addq         $5, %r15
+	LONG $0x986d894c               // movq         %r13, $-104(%rbp)
+	LONG $0xc87d894c               // movq         %r15, $-56(%rbp)
+	LONG $0x987d8348; BYTE $0x06   // cmpq         $6, $-104(%rbp)
+	LONG $0xff12830f; WORD $0xffff // jae          LBB9_78, $-238(%rip)
+
+LBB9_76:
+	LONG $0xc87d8b4c // movq         $-56(%rbp), %r15
+
+LBB9_77:
+	LONG $0xa8458b48                           // movq         $-88(%rbp), %rax
+	LONG $0xc0450348                           // addq         $-64(%rbp), %rax
+	WORD $0x2949; BYTE $0xc7                   // subq         %rax, %r15
+	LONG $0xfcc78349                           // addq         $-4, %r15
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	WORD $0x894c; BYTE $0x38                   // movq         %r15, (%rax)
+	LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq         $-4, %r14
+	LONG $0x00000ce9; BYTE $0x00               // jmp          LBB9_52, $12(%rip)
+
+LBB9_1:
+	WORD $0x3145; BYTE $0xed // xorl         %r13d, %r13d
+	WORD $0x8949; BYTE $0xd6 // movq         %rdx, %r14
+
+LBB9_2:
+	WORD $0x014d; BYTE $0xee // addq         %r13, %r14
+	WORD $0x2949; BYTE $0xd6 // subq         %rdx, %r14
+
+LBB9_52:
+	WORD $0x894c; BYTE $0xf0 // movq         %r14, %rax
+	LONG $0x48c48348         // addq         $72, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB9_43:
+	WORD $0x894c; BYTE $0xf8                   // movq         %r15, %rax
+	WORD $0x2948; BYTE $0xf8                   // subq         %rdi, %rax
+	LONG $0xd0758b48                           // movq         $-48(%rbp), %rsi
+	WORD $0x8948; BYTE $0x06                   // movq         %rax, (%rsi)
+	LONG $0x0fb60f41                           // movzbl       (%r15), %ecx
+	WORD $0x518d; BYTE $0xc6                   // leal         $-58(%rcx), %edx
+	LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r14
+	WORD $0xfa80; BYTE $0xf5                   // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000             // ja           LBB9_45, $15(%rip)
+	WORD $0xe180; BYTE $0xdf                   // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9                   // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa                   // cmpb         $-6, %cl
+	LONG $0xffbb820f; WORD $0xffff             // jb           LBB9_52, $-69(%rip)
+
+LBB9_45:
+	LONG $0x01488d48               // leaq         $1(%rax), %rcx
+	WORD $0x8948; BYTE $0x0e       // movq         %rcx, (%rsi)
+	LONG $0x4fb60f41; BYTE $0x01   // movzbl       $1(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_47, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xff94820f; WORD $0xffff // jb           LBB9_52, $-108(%rip)
+
+LBB9_47:
+	LONG $0x02488d48               // leaq         $2(%rax), %rcx
+	WORD $0x8948; BYTE $0x0e       // movq         %rcx, (%rsi)
+	LONG $0x4fb60f41; BYTE $0x02   // movzbl       $2(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_49, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xff6d820f; WORD $0xffff // jb           LBB9_52, $-147(%rip)
+
+LBB9_49:
+	LONG $0x03488d48               // leaq         $3(%rax), %rcx
+	WORD $0x8948; BYTE $0x0e       // movq         %rcx, (%rsi)
+	LONG $0x4fb60f41; BYTE $0x03   // movzbl       $3(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_51, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xff46820f; WORD $0xffff // jb           LBB9_52, $-186(%rip)
+
+LBB9_51:
+	LONG $0x04c08348             // addq         $4, %rax
+	WORD $0x8948; BYTE $0x06     // movq         %rax, (%rsi)
+	LONG $0xffff3ae9; BYTE $0xff // jmp          LBB9_52, $-198(%rip)
+
+LBB9_19:
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	WORD $0x8948; BYTE $0x30                   // movq         %rsi, (%rax)
+	LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r14
+	LONG $0xffff27e9; BYTE $0xff               // jmp          LBB9_52, $-217(%rip)
+
+LBB9_37:
+	WORD $0x3145; BYTE $0xed     // xorl         %r13d, %r13d
+	LONG $0xffff19e9; BYTE $0xff // jmp          LBB9_2, $-231(%rip)
+
+LBB9_34:
+	WORD $0xf748; BYTE $0xd7                   // notq         %rdi
+	WORD $0x0149; BYTE $0xff                   // addq         %rdi, %r15
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	WORD $0x894c; BYTE $0x38                   // movq         %r15, (%rax)
+	LONG $0xfdc6c749; WORD $0xffff; BYTE $0xff // movq         $-3, %r14
+	LONG $0xffff06e9; BYTE $0xff               // jmp          LBB9_52, $-250(%rip)
+
+LBB9_23:
+	WORD $0xf748; BYTE $0xd7 // notq         %rdi
+	WORD $0x0149; BYTE $0xff // addq         %rdi, %r15
+
+LBB9_24:
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	WORD $0x894c; BYTE $0x38                   // movq         %r15, (%rax)
+	LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r14
+	LONG $0xfffeede9; BYTE $0xff               // jmp          LBB9_52, $-275(%rip)
+
+LBB9_29:
+	WORD $0x2949; BYTE $0xff     // subq         %rdi, %r15
+	WORD $0xff49; BYTE $0xc7     // incq         %r15
+	LONG $0xffffe2e9; BYTE $0xff // jmp          LBB9_24, $-30(%rip)
+
+LBB9_63:
+	LONG $0x02b845f6               // testb        $2, $-72(%rbp)
+	LONG $0x0108840f; WORD $0x0000 // je           LBB9_87, $264(%rip)
+	LONG $0x06c74166; WORD $0xbfef // movw         $-16401, (%r14)
+	LONG $0x0246c641; BYTE $0xbd   // movb         $-67, $2(%r14)
+	LONG $0x03c68349               // addq         $3, %r14
+	WORD $0x3145; BYTE $0xed       // xorl         %r13d, %r13d
+	LONG $0xfffebbe9; BYTE $0xff   // jmp          LBB9_2, $-325(%rip)
+
+LBB9_82:
+	LONG $0xc87d8b4c // movq         $-56(%rbp), %r15
+
+LBB9_100:
+	WORD $0x894c; BYTE $0xf8                   // movq         %r15, %rax
+	LONG $0xc0452b48                           // subq         $-64(%rbp), %rax
+	LONG $0x02c08348                           // addq         $2, %rax
+	LONG $0xd04d8b48                           // movq         $-48(%rbp), %rcx
+	WORD $0x8948; BYTE $0x01                   // movq         %rax, (%rcx)
+	LONG $0x4fb60f41; BYTE $0x02               // movzbl       $2(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6                   // leal         $-58(%rcx), %edx
+	LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r14
+	WORD $0xfa80; BYTE $0xf5                   // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000             // ja           LBB9_102, $15(%rip)
+	WORD $0xe180; BYTE $0xdf                   // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9                   // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa                   // cmpb         $-6, %cl
+	LONG $0xfe84820f; WORD $0xffff             // jb           LBB9_52, $-380(%rip)
+
+LBB9_102:
+	LONG $0x01488d48               // leaq         $1(%rax), %rcx
+	LONG $0xd0558b48               // movq         $-48(%rbp), %rdx
+	WORD $0x8948; BYTE $0x0a       // movq         %rcx, (%rdx)
+	LONG $0x4fb60f41; BYTE $0x03   // movzbl       $3(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_104, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xfe59820f; WORD $0xffff // jb           LBB9_52, $-423(%rip)
+
+LBB9_104:
+	LONG $0x02488d48               // leaq         $2(%rax), %rcx
+	LONG $0xd0558b48               // movq         $-48(%rbp), %rdx
+	WORD $0x8948; BYTE $0x0a       // movq         %rcx, (%rdx)
+	LONG $0x4fb60f41; BYTE $0x04   // movzbl       $4(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_106, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xfe2e820f; WORD $0xffff // jb           LBB9_52, $-466(%rip)
+
+LBB9_106:
+	LONG $0x03488d48               // leaq         $3(%rax), %rcx
+	LONG $0xd0558b48               // movq         $-48(%rbp), %rdx
+	WORD $0x8948; BYTE $0x0a       // movq         %rcx, (%rdx)
+	LONG $0x4fb60f41; BYTE $0x05   // movzbl       $5(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_108, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xfe03820f; WORD $0xffff // jb           LBB9_52, $-509(%rip)
+
+LBB9_108:
+	LONG $0x04c08348             // addq         $4, %rax
+	LONG $0xd04d8b48             // movq         $-48(%rbp), %rcx
+	WORD $0x8948; BYTE $0x01     // movq         %rax, (%rcx)
+	LONG $0xfffdf3e9; BYTE $0xff // jmp          LBB9_52, $-525(%rip)
+
+LBB9_97:
+	LONG $0xc87d894c // movq         %r15, $-56(%rbp)
+
+LBB9_98:
+	LONG $0xc8658b4c                           // movq         $-56(%rbp), %r12
+	LONG $0xc0652b4c                           // subq         $-64(%rbp), %r12
+	LONG $0xfcc48349                           // addq         $-4, %r12
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	WORD $0x894c; BYTE $0x20                   // movq         %r12, (%rax)
+	LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq         $-4, %r14
+	LONG $0xfffdd0e9; BYTE $0xff               // jmp          LBB9_52, $-560(%rip)
+
+LBB9_87:
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	LONG $0xb04d8b48                           // movq         $-80(%rbp), %rcx
+	WORD $0x8948; BYTE $0x08                   // movq         %rcx, (%rax)
+	LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r14
+	LONG $0xfffdb9e9; BYTE $0xff               // jmp          LBB9_52, $-583(%rip)
+
+	// .p2align 4, 0x90
+_unhex16_is:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0xf889                   // movl         %edi, %eax
+	WORD $0xd0f7                   // notl         %eax
+	LONG $0xcfd08f8d; WORD $0xcfcf // leal         $-808464432(%rdi), %ecx
+	LONG $0x80808025; BYTE $0x80   // andl         $-2139062144, %eax
+	WORD $0xc885                   // testl        %ecx, %eax
+	LONG $0x0007840f; WORD $0x0000 // je           LBB10_2, $7(%rip)
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xb60f; BYTE $0xc0       // movzbl       %al, %eax
+	BYTE $0x5d                     // popq         %rbp
+	BYTE $0xc3                     // retq
+
+LBB10_2:
+	LONG $0x19198f8d; WORD $0x1919 // leal         $421075225(%rdi), %ecx
+	WORD $0xf909                   // orl          %edi, %ecx
+	LONG $0x8080c1f7; WORD $0x8080 // testl        $-2139062144, %ecx
+	LONG $0x0007840f; WORD $0x0000 // je           LBB10_4, $7(%rip)
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xb60f; BYTE $0xc0       // movzbl       %al, %eax
+	BYTE $0x5d                     // popq         %rbp
+	BYTE $0xc3                     // retq
+
+LBB10_4:
+	LONG $0x7f7fe781; WORD $0x7f7f // andl         $2139062143, %edi
+	LONG $0xc0c0c0b9; BYTE $0xc0   // movl         $-1061109568, %ecx
+	WORD $0xf929                   // subl         %edi, %ecx
+	LONG $0x4646978d; WORD $0x4646 // leal         $1179010630(%rdi), %edx
+	WORD $0xc121                   // andl         %eax, %ecx
+	WORD $0xd185                   // testl        %edx, %ecx
+	LONG $0x0007840f; WORD $0x0000 // je           LBB10_6, $7(%rip)
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xb60f; BYTE $0xc0       // movzbl       %al, %eax
+	BYTE $0x5d                     // popq         %rbp
+	BYTE $0xc3                     // retq
+
+LBB10_6:
+	LONG $0xe0e0e0b9; BYTE $0xe0   // movl         $-522133280, %ecx
+	WORD $0xf929                   // subl         %edi, %ecx
+	LONG $0x3939c781; WORD $0x3939 // addl         $960051513, %edi
+	WORD $0xc821                   // andl         %ecx, %eax
+	WORD $0xf885                   // testl        %edi, %eax
+	WORD $0x940f; BYTE $0xc0       // sete         %al
+	WORD $0xb60f; BYTE $0xc0       // movzbl       %al, %eax
+	BYTE $0x5d                     // popq         %rbp
+	BYTE $0xc3                     // retq
+	LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00
+
+LCPI11_0:
+	QUAD $0x2626262626262626; QUAD $0x2626262626262626 // .space 16, '&&&&&&&&&&&&&&&&'
+
+LCPI11_1:
+	QUAD $0xe2e2e2e2e2e2e2e2; QUAD $0xe2e2e2e2e2e2e2e2 // .space 16, '\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2'
+
+LCPI11_2:
+	QUAD $0xfdfdfdfdfdfdfdfd; QUAD $0xfdfdfdfdfdfdfdfd // .space 16, '\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd'
+
+LCPI11_3:
+	QUAD $0x3c3c3c3c3c3c3c3c; QUAD $0x3c3c3c3c3c3c3c3c // .space 16, '<<<<<<<<<<<<<<<<'
+
+	// .p2align 4, 0x90
+_html_escape:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x10ec8348                           // subq         $16, %rsp
+	LONG $0xc84d8948                           // movq         %rcx, $-56(%rbp)
+	WORD $0x8949; BYTE $0xd6                   // movq         %rdx, %r14
+	LONG $0xd0558948                           // movq         %rdx, $-48(%rbp)
+	WORD $0x8948; BYTE $0xf8                   // movq         %rdi, %rax
+	WORD $0x8548; BYTE $0xf6                   // testq        %rsi, %rsi
+	LONG $0x04a18e0f; WORD $0x0000             // jle          LBB11_70, $1185(%rip)
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	WORD $0x8b4c; BYTE $0x08                   // movq         (%rax), %r9
+	QUAD $0xffffff89056ff9c5                   // vmovdqa      $-119(%rip), %xmm0  /* LCPI11_0(%rip) */
+	QUAD $0xffffff910d6ff9c5                   // vmovdqa      $-111(%rip), %xmm1  /* LCPI11_1(%rip) */
+	QUAD $0xffffff99156ff9c5                   // vmovdqa      $-103(%rip), %xmm2  /* LCPI11_2(%rip) */
+	QUAD $0xffffffa11d6ff9c5                   // vmovdqa      $-95(%rip), %xmm3  /* LCPI11_3(%rip) */
+	LONG $0xfa1d8d4c; WORD $0x00dc; BYTE $0x00 // leaq         $56570(%rip), %r11  /* __HtmlQuoteTab(%rip) */
+	WORD $0x8949; BYTE $0xfc                   // movq         %rdi, %r12
+	LONG $0xd0758b4c                           // movq         $-48(%rbp), %r14
+	WORD $0x9090; BYTE $0x90                   // .p2align 4, 0x90
+
+LBB11_2:
+	WORD $0x854d; BYTE $0xc9                   // testq        %r9, %r9
+	LONG $0x047e8e0f; WORD $0x0000             // jle          LBB11_3, $1150(%rip)
+	LONG $0x10fe8348                           // cmpq         $16, %rsi
+	WORD $0x930f; BYTE $0xc0                   // setae        %al
+	WORD $0x894d; BYTE $0xcd                   // movq         %r9, %r13
+	WORD $0x894d; BYTE $0xf0                   // movq         %r14, %r8
+	WORD $0x8948; BYTE $0xf3                   // movq         %rsi, %rbx
+	WORD $0x894d; BYTE $0xe7                   // movq         %r12, %r15
+	LONG $0x10f98349                           // cmpq         $16, %r9
+	LONG $0x007a820f; WORD $0x0000             // jb           LBB11_12, $122(%rip)
+	LONG $0x10fe8348                           // cmpq         $16, %rsi
+	LONG $0x0070820f; WORD $0x0000             // jb           LBB11_12, $112(%rip)
+	WORD $0x3145; BYTE $0xc0                   // xorl         %r8d, %r8d
+	WORD $0x8948; BYTE $0xf2                   // movq         %rsi, %rdx
+	WORD $0x894c; BYTE $0xc9                   // movq         %r9, %rcx
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB11_7:
+	LONG $0x6f7a81c4; WORD $0x0424 // vmovdqu      (%r12,%r8), %xmm4
+	LONG $0xe874d9c5               // vpcmpeqb     %xmm0, %xmm4, %xmm5
+	LONG $0xf174d9c5               // vpcmpeqb     %xmm1, %xmm4, %xmm6
+	LONG $0xedebc9c5               // vpor         %xmm5, %xmm6, %xmm5
+	LONG $0xf2dbd9c5               // vpand        %xmm2, %xmm4, %xmm6
+	LONG $0xf374c9c5               // vpcmpeqb     %xmm3, %xmm6, %xmm6
+	LONG $0xeeebd1c5               // vpor         %xmm6, %xmm5, %xmm5
+	LONG $0x7f7a81c4; WORD $0x0624 // vmovdqu      %xmm4, (%r14,%r8)
+	LONG $0xc5d7f9c5               // vpmovmskb    %xmm5, %eax
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x0150850f; WORD $0x0000 // jne          LBB11_8, $336(%rip)
+	LONG $0xf05a8d48               // leaq         $-16(%rdx), %rbx
+	LONG $0xf0698d4c               // leaq         $-16(%rcx), %r13
+	LONG $0x10c08349               // addq         $16, %r8
+	LONG $0x20fa8348               // cmpq         $32, %rdx
+	WORD $0x9d0f; BYTE $0xc0       // setge        %al
+	LONG $0x00108c0f; WORD $0x0000 // jl           LBB11_11, $16(%rip)
+	WORD $0x8948; BYTE $0xda       // movq         %rbx, %rdx
+	LONG $0x1ff98348               // cmpq         $31, %rcx
+	WORD $0x894c; BYTE $0xe9       // movq         %r13, %rcx
+	LONG $0xffa78f0f; WORD $0xffff // jg           LBB11_7, $-89(%rip)
+
+LBB11_11:
+	LONG $0x043c8d4f         // leaq         (%r12,%r8), %r15
+	WORD $0x014d; BYTE $0xf0 // addq         %r14, %r8
+
+LBB11_12:
+	WORD $0xc084                   // testb        %al, %al
+	LONG $0x0068840f; WORD $0x0000 // je           LBB11_13, $104(%rip)
+	LONG $0x6f7ac1c4; BYTE $0x27   // vmovdqu      (%r15), %xmm4
+	LONG $0xe874d9c5               // vpcmpeqb     %xmm0, %xmm4, %xmm5
+	LONG $0xf174d9c5               // vpcmpeqb     %xmm1, %xmm4, %xmm6
+	LONG $0xedebc9c5               // vpor         %xmm5, %xmm6, %xmm5
+	LONG $0xf2dbd9c5               // vpand        %xmm2, %xmm4, %xmm6
+	LONG $0xf374c9c5               // vpcmpeqb     %xmm3, %xmm6, %xmm6
+	LONG $0xeeebd1c5               // vpor         %xmm6, %xmm5, %xmm5
+	LONG $0xc5d7f9c5               // vpmovmskb    %xmm5, %eax
+	LONG $0x0100000d; BYTE $0x00   // orl          $65536, %eax
+	LONG $0xd0bc0f44               // bsfl         %eax, %r10d
+	LONG $0x7ef9e1c4; BYTE $0xe0   // vmovq        %xmm4, %rax
+	WORD $0x394d; BYTE $0xd5       // cmpq         %r10, %r13
+	LONG $0x00f98d0f; WORD $0x0000 // jge          LBB11_24, $249(%rip)
+	LONG $0x08fd8349               // cmpq         $8, %r13
+	LONG $0x0132820f; WORD $0x0000 // jb           LBB11_35, $306(%rip)
+	WORD $0x8949; BYTE $0x00       // movq         %rax, (%r8)
+	LONG $0x08578d4d               // leaq         $8(%r15), %r10
+	LONG $0x08c08349               // addq         $8, %r8
+	LONG $0xf85d8d49               // leaq         $-8(%r13), %rbx
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x01298d0f; WORD $0x0000 // jge          LBB11_38, $297(%rip)
+	LONG $0x000136e9; BYTE $0x00   // jmp          LBB11_39, $310(%rip)
+	QUAD $0x9090909090909090       // .p2align 4, 0x90
+
+LBB11_13:
+	WORD $0x8548; BYTE $0xdb               // testq        %rbx, %rbx
+	LONG $0x00878e0f; WORD $0x0000         // jle          LBB11_21, $135(%rip)
+	WORD $0x854d; BYTE $0xed               // testq        %r13, %r13
+	LONG $0x007e8e0f; WORD $0x0000         // jle          LBB11_21, $126(%rip)
+	WORD $0xd231                           // xorl         %edx, %edx
+	WORD $0xc031                           // xorl         %eax, %eax
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB11_16:
+	LONG $0x1cb60f45; BYTE $0x17           // movzbl       (%r15,%rdx), %r11d
+	LONG $0x3efb8349                       // cmpq         $62, %r11
+	LONG $0x0014870f; WORD $0x0000         // ja           LBB11_17, $20(%rip)
+	QUAD $0x004000000000b948; WORD $0x5000 // movabsq      $5764607797912141824, %rcx
+	LONG $0xd9a30f4c                       // btq          %r11, %rcx
+	LONG $0x00ae820f; WORD $0x0000         // jb           LBB11_45, $174(%rip)
+
+LBB11_17:
+	LONG $0xe2fb8141; WORD $0x0000; BYTE $0x00 // cmpl         $226, %r11d
+	LONG $0x00a1840f; WORD $0x0000             // je           LBB11_45, $161(%rip)
+	LONG $0x03148d4c                           // leaq         (%rbx,%rax), %r10
+	LONG $0x101c8845                           // movb         %r11b, (%r8,%rdx)
+	LONG $0xff488d48                           // leaq         $-1(%rax), %rcx
+	LONG $0x02fa8349                           // cmpq         $2, %r10
+	LONG $0x00138c0f; WORD $0x0000             // jl           LBB11_20, $19(%rip)
+	WORD $0x014c; BYTE $0xe8                   // addq         %r13, %rax
+	WORD $0xff48; BYTE $0xc2                   // incq         %rdx
+	LONG $0x01f88348                           // cmpq         $1, %rax
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	LONG $0xffa78f0f; WORD $0xffff             // jg           LBB11_16, $-89(%rip)
+
+LBB11_20:
+	WORD $0x2949; BYTE $0xcf                   // subq         %rcx, %r15
+	WORD $0x0148; BYTE $0xcb                   // addq         %rcx, %rbx
+	LONG $0x5a1d8d4c; WORD $0x00db; BYTE $0x00 // leaq         $56154(%rip), %r11  /* __HtmlQuoteTab(%rip) */
+	QUAD $0x9090909090909090; WORD $0x9090     // .p2align 4, 0x90
+
+LBB11_21:
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0160840f; WORD $0x0000 // je           LBB11_22, $352(%rip)
+	WORD $0xf749; BYTE $0xd7       // notq         %r15
+	WORD $0x014d; BYTE $0xe7       // addq         %r12, %r15
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x0168890f; WORD $0x0000 // jns          LBB11_49, $360(%rip)
+	LONG $0x000287e9; BYTE $0x00   // jmp          LBB11_48, $647(%rip)
+	WORD $0x9090; BYTE $0x90       // .p2align 4, 0x90
+
+LBB11_8:
+	LONG $0xc0bc0f66               // bsfw         %ax, %ax
+	LONG $0xf8b70f44               // movzwl       %ax, %r15d
+	WORD $0x014d; BYTE $0xc7       // addq         %r8, %r15
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x014c890f; WORD $0x0000 // jns          LBB11_49, $332(%rip)
+	LONG $0x00026be9; BYTE $0x00   // jmp          LBB11_48, $619(%rip)
+
+LBB11_24:
+	LONG $0x08fa8341               // cmpl         $8, %r10d
+	LONG $0x008f820f; WORD $0x0000 // jb           LBB11_25, $143(%rip)
+	WORD $0x8949; BYTE $0x00       // movq         %rax, (%r8)
+	LONG $0x086f8d4d               // leaq         $8(%r15), %r13
+	LONG $0x08c08349               // addq         $8, %r8
+	LONG $0xf85a8d49               // leaq         $-8(%r10), %rbx
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x0086830f; WORD $0x0000 // jae          LBB11_28, $134(%rip)
+	LONG $0x000094e9; BYTE $0x00   // jmp          LBB11_29, $148(%rip)
+
+LBB11_45:
+	WORD $0x294d; BYTE $0xe7                   // subq         %r12, %r15
+	WORD $0x2949; BYTE $0xc7                   // subq         %rax, %r15
+	LONG $0xe21d8d4c; WORD $0x00da; BYTE $0x00 // leaq         $56034(%rip), %r11  /* __HtmlQuoteTab(%rip) */
+	WORD $0x854d; BYTE $0xff                   // testq        %r15, %r15
+	LONG $0x0109890f; WORD $0x0000             // jns          LBB11_49, $265(%rip)
+	LONG $0x000228e9; BYTE $0x00               // jmp          LBB11_48, $552(%rip)
+
+LBB11_35:
+	WORD $0x894d; BYTE $0xfa       // movq         %r15, %r10
+	WORD $0x894c; BYTE $0xeb       // movq         %r13, %rbx
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x00128c0f; WORD $0x0000 // jl           LBB11_39, $18(%rip)
+
+LBB11_38:
+	WORD $0x8b41; BYTE $0x02 // movl         (%r10), %eax
+	WORD $0x8941; BYTE $0x00 // movl         %eax, (%r8)
+	LONG $0x04c28349         // addq         $4, %r10
+	LONG $0x04c08349         // addq         $4, %r8
+	LONG $0xfcc38348         // addq         $-4, %rbx
+
+LBB11_39:
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0x007c830f; WORD $0x0000 // jae          LBB11_40, $124(%rip)
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0007840f; WORD $0x0000 // je           LBB11_43, $7(%rip)
+
+LBB11_42:
+	LONG $0x02b60f41         // movzbl       (%r10), %eax
+	WORD $0x8841; BYTE $0x00 // movb         %al, (%r8)
+
+LBB11_43:
+	WORD $0x014d; BYTE $0xfd       // addq         %r15, %r13
+	WORD $0xf749; BYTE $0xd5       // notq         %r13
+	WORD $0x014d; BYTE $0xe5       // addq         %r12, %r13
+	WORD $0x894d; BYTE $0xef       // movq         %r13, %r15
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x00b3890f; WORD $0x0000 // jns          LBB11_49, $179(%rip)
+	LONG $0x0001d2e9; BYTE $0x00   // jmp          LBB11_48, $466(%rip)
+
+LBB11_25:
+	WORD $0x894d; BYTE $0xfd       // movq         %r15, %r13
+	WORD $0x894c; BYTE $0xd3       // movq         %r10, %rbx
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x0013820f; WORD $0x0000 // jb           LBB11_29, $19(%rip)
+
+LBB11_28:
+	LONG $0x00458b41         // movl         (%r13), %eax
+	WORD $0x8941; BYTE $0x00 // movl         %eax, (%r8)
+	LONG $0x04c58349         // addq         $4, %r13
+	LONG $0x04c08349         // addq         $4, %r8
+	LONG $0xfcc38348         // addq         $-4, %rbx
+
+LBB11_29:
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0x0047830f; WORD $0x0000 // jae          LBB11_30, $71(%rip)
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0008840f; WORD $0x0000 // je           LBB11_33, $8(%rip)
+
+LBB11_32:
+	LONG $0x45b60f41; BYTE $0x00 // movzbl       (%r13), %eax
+	WORD $0x8841; BYTE $0x00     // movb         %al, (%r8)
+
+LBB11_33:
+	WORD $0x294d; BYTE $0xe7       // subq         %r12, %r15
+	WORD $0x014d; BYTE $0xd7       // addq         %r10, %r15
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x0061890f; WORD $0x0000 // jns          LBB11_49, $97(%rip)
+	LONG $0x000180e9; BYTE $0x00   // jmp          LBB11_48, $384(%rip)
+
+LBB11_40:
+	LONG $0x02b70f41               // movzwl       (%r10), %eax
+	LONG $0x00894166               // movw         %ax, (%r8)
+	LONG $0x02c28349               // addq         $2, %r10
+	LONG $0x02c08349               // addq         $2, %r8
+	LONG $0xfec38348               // addq         $-2, %rbx
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0xff70850f; WORD $0xffff // jne          LBB11_42, $-144(%rip)
+	LONG $0xffff72e9; BYTE $0xff   // jmp          LBB11_43, $-142(%rip)
+
+LBB11_30:
+	LONG $0x45b70f41; BYTE $0x00   // movzwl       (%r13), %eax
+	LONG $0x00894166               // movw         %ax, (%r8)
+	LONG $0x02c58349               // addq         $2, %r13
+	LONG $0x02c08349               // addq         $2, %r8
+	LONG $0xfec38348               // addq         $-2, %rbx
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0xffa4850f; WORD $0xffff // jne          LBB11_32, $-92(%rip)
+	LONG $0xffffa7e9; BYTE $0xff   // jmp          LBB11_33, $-89(%rip)
+
+LBB11_22:
+	WORD $0x294d; BYTE $0xe7                           // subq         %r12, %r15
+	WORD $0x854d; BYTE $0xff                           // testq        %r15, %r15
+	LONG $0x012f880f; WORD $0x0000                     // js           LBB11_48, $303(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB11_49:
+	WORD $0x014d; BYTE $0xfc       // addq         %r15, %r12
+	WORD $0x014d; BYTE $0xfe       // addq         %r15, %r14
+	WORD $0x294c; BYTE $0xfe       // subq         %r15, %rsi
+	LONG $0x01378e0f; WORD $0x0000 // jle          LBB11_50, $311(%rip)
+	WORD $0x294d; BYTE $0xf9       // subq         %r15, %r9
+	LONG $0x0cb60f41; BYTE $0x24   // movzbl       (%r12), %ecx
+	WORD $0xf980; BYTE $0xe2       // cmpb         $-30, %cl
+	LONG $0x00b3840f; WORD $0x0000 // je           LBB11_53, $179(%rip)
+	WORD $0x894c; BYTE $0xe0       // movq         %r12, %rax
+
+LBB11_57:
+	WORD $0xb60f; BYTE $0xc9               // movzbl       %cl, %ecx
+	LONG $0x04e1c148                       // shlq         $4, %rcx
+	LONG $0x19148b4a                       // movq         (%rcx,%r11), %rdx
+	WORD $0x6348; BYTE $0xda               // movslq       %edx, %rbx
+	WORD $0x2949; BYTE $0xd9               // subq         %rbx, %r9
+	LONG $0x01228c0f; WORD $0x0000         // jl           LBB11_58, $290(%rip)
+	LONG $0x20e2c148                       // shlq         $32, %rdx
+	LONG $0x19148d4e                       // leaq         (%rcx,%r11), %r10
+	LONG $0x08c28349                       // addq         $8, %r10
+	QUAD $0x000300000001b948; WORD $0x0000 // movabsq      $12884901889, %rcx
+	WORD $0x3948; BYTE $0xca               // cmpq         %rcx, %rdx
+	LONG $0x00278c0f; WORD $0x0000         // jl           LBB11_62, $39(%rip)
+	WORD $0x8b41; BYTE $0x0a               // movl         (%r10), %ecx
+	WORD $0x8941; BYTE $0x0e               // movl         %ecx, (%r14)
+	LONG $0x04c28349                       // addq         $4, %r10
+	LONG $0x04468d4d                       // leaq         $4(%r14), %r8
+	LONG $0xfc4b8d48                       // leaq         $-4(%rbx), %rcx
+	LONG $0x02f98348                       // cmpq         $2, %rcx
+	LONG $0x001b830f; WORD $0x0000         // jae          LBB11_65, $27(%rip)
+	LONG $0x00002ae9; BYTE $0x00           // jmp          LBB11_66, $42(%rip)
+	LONG $0x90909090; WORD $0x9090         // .p2align 4, 0x90
+
+LBB11_62:
+	WORD $0x894d; BYTE $0xf0       // movq         %r14, %r8
+	WORD $0x8948; BYTE $0xd9       // movq         %rbx, %rcx
+	LONG $0x02f98348               // cmpq         $2, %rcx
+	LONG $0x0014820f; WORD $0x0000 // jb           LBB11_66, $20(%rip)
+
+LBB11_65:
+	LONG $0x12b70f41 // movzwl       (%r10), %edx
+	LONG $0x10894166 // movw         %dx, (%r8)
+	LONG $0x02c28349 // addq         $2, %r10
+	LONG $0x02c08349 // addq         $2, %r8
+	LONG $0xfec18348 // addq         $-2, %rcx
+
+LBB11_66:
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x0007840f; WORD $0x0000 // je           LBB11_68, $7(%rip)
+	LONG $0x0ab60f41               // movzbl       (%r10), %ecx
+	WORD $0x8841; BYTE $0x08       // movb         %cl, (%r8)
+
+LBB11_68:
+	WORD $0x0149; BYTE $0xde // addq         %rbx, %r14
+
+LBB11_69:
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	LONG $0xff4e8d48               // leaq         $-1(%rsi), %rcx
+	WORD $0x8949; BYTE $0xc4       // movq         %rax, %r12
+	LONG $0x01fe8348               // cmpq         $1, %rsi
+	WORD $0x8948; BYTE $0xce       // movq         %rcx, %rsi
+	LONG $0xfc12870f; WORD $0xffff // ja           LBB11_2, $-1006(%rip)
+	LONG $0x000076e9; BYTE $0x00   // jmp          LBB11_70, $118(%rip)
+
+LBB11_53:
+	LONG $0x03fe8348               // cmpq         $3, %rsi
+	LONG $0x002c820f; WORD $0x0000 // jb           LBB11_59, $44(%rip)
+	LONG $0x247c8041; WORD $0x8001 // cmpb         $-128, $1(%r12)
+	LONG $0x0020850f; WORD $0x0000 // jne          LBB11_59, $32(%rip)
+	LONG $0x4cb60f41; WORD $0x0224 // movzbl       $2(%r12), %ecx
+	WORD $0xc889                   // movl         %ecx, %eax
+	WORD $0xfe24                   // andb         $-2, %al
+	WORD $0xa83c                   // cmpb         $-88, %al
+	LONG $0x000e850f; WORD $0x0000 // jne          LBB11_59, $14(%rip)
+	LONG $0x24448d49; BYTE $0x02   // leaq         $2(%r12), %rax
+	LONG $0xfec68348               // addq         $-2, %rsi
+	LONG $0xffff1ae9; BYTE $0xff   // jmp          LBB11_57, $-230(%rip)
+
+LBB11_59:
+	WORD $0x854d; BYTE $0xc9       // testq        %r9, %r9
+	LONG $0x00558e0f; WORD $0x0000 // jle          LBB11_3, $85(%rip)
+	LONG $0xe206c641               // movb         $-30, (%r14)
+	WORD $0xff49; BYTE $0xc6       // incq         %r14
+	WORD $0xff49; BYTE $0xc9       // decq         %r9
+	WORD $0x894c; BYTE $0xe0       // movq         %r12, %rax
+	LONG $0xffff93e9; BYTE $0xff   // jmp          LBB11_69, $-109(%rip)
+
+LBB11_48:
+	LONG $0xd04d8b48             // movq         $-48(%rbp), %rcx
+	WORD $0x014c; BYTE $0xf9     // addq         %r15, %rcx
+	WORD $0xf748; BYTE $0xd1     // notq         %rcx
+	WORD $0x014c; BYTE $0xf1     // addq         %r14, %rcx
+	LONG $0xc8458b48             // movq         $-56(%rbp), %rax
+	WORD $0x8948; BYTE $0x08     // movq         %rcx, (%rax)
+	WORD $0x294c; BYTE $0xe7     // subq         %r12, %rdi
+	WORD $0x014c; BYTE $0xff     // addq         %r15, %rdi
+	WORD $0x8948; BYTE $0xf8     // movq         %rdi, %rax
+	LONG $0x00002ae9; BYTE $0x00 // jmp          LBB11_71, $42(%rip)
+
+LBB11_50:
+	WORD $0x894c; BYTE $0xe0 // movq         %r12, %rax
+
+LBB11_70:
+	LONG $0xd0752b4c             // subq         $-48(%rbp), %r14
+	LONG $0xc84d8b48             // movq         $-56(%rbp), %rcx
+	WORD $0x894c; BYTE $0x31     // movq         %r14, (%rcx)
+	WORD $0x2948; BYTE $0xf8     // subq         %rdi, %rax
+	LONG $0x000014e9; BYTE $0x00 // jmp          LBB11_71, $20(%rip)
+
+LBB11_58:
+	LONG $0xd0752b4c         // subq         $-48(%rbp), %r14
+	LONG $0xc8458b48         // movq         $-56(%rbp), %rax
+	WORD $0x894c; BYTE $0x30 // movq         %r14, (%rax)
+
+LBB11_3:
+	WORD $0xf749; BYTE $0xd4 // notq         %r12
+	WORD $0x0149; BYTE $0xfc // addq         %rdi, %r12
+	WORD $0x894c; BYTE $0xe0 // movq         %r12, %rax
+
+LBB11_71:
+	LONG $0x10c48348 // addq         $16, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5d41     // popq         %r13
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+	BYTE $0x90       // .p2align 4, 0x90
+
+_atof_eisel_lemire64:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5741                   // pushq        %r15
+	WORD $0x5641                   // pushq        %r14
+	WORD $0x5441                   // pushq        %r12
+	BYTE $0x53                     // pushq        %rbx
+	LONG $0xfea4868d; WORD $0xffff // leal         $-348(%rsi), %eax
+	LONG $0xfffd483d; BYTE $0xff   // cmpl         $-696, %eax
+	LONG $0x0122820f; WORD $0x0000 // jb           LBB12_1, $290(%rip)
+	WORD $0x8949; BYTE $0xc8       // movq         %rcx, %r8
+	WORD $0x8941; BYTE $0xd1       // movl         %edx, %r9d
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0x000d840f; WORD $0x0000 // je           LBB12_4, $13(%rip)
+	LONG $0xd7bd0f4c               // bsrq         %rdi, %r10
+	LONG $0x3ff28349               // xorq         $63, %r10
+	LONG $0x000006e9; BYTE $0x00   // jmp          LBB12_5, $6(%rip)
+
+LBB12_4:
+	LONG $0x0040ba41; WORD $0x0000 // movl         $64, %r10d
+
+LBB12_5:
+	WORD $0x8944; BYTE $0xd1                   // movl         %r10d, %ecx
+	WORD $0xd348; BYTE $0xe7                   // shlq         %cl, %rdi
+	LONG $0x015c8e8d; WORD $0x0000             // leal         $348(%rsi), %ecx
+	LONG $0x04e1c148                           // shlq         $4, %rcx
+	LONG $0x4b258d4c; WORD $0x0062; BYTE $0x00 // leaq         $25163(%rip), %r12  /* _POW10_M128_TAB(%rip) */
+	WORD $0x8948; BYTE $0xf8                   // movq         %rdi, %rax
+	LONG $0x2164f74a; BYTE $0x08               // mulq         $8(%rcx,%r12)
+	WORD $0x8949; BYTE $0xc7                   // movq         %rax, %r15
+	WORD $0x8949; BYTE $0xd3                   // movq         %rdx, %r11
+	WORD $0x8944; BYTE $0xdb                   // movl         %r11d, %ebx
+	LONG $0x01ffe381; WORD $0x0000             // andl         $511, %ebx
+	LONG $0xfffb8148; WORD $0x0001; BYTE $0x00 // cmpq         $511, %rbx
+	LONG $0x0050850f; WORD $0x0000             // jne          LBB12_11, $80(%rip)
+	WORD $0x8949; BYTE $0xfe                   // movq         %rdi, %r14
+	WORD $0xf749; BYTE $0xd6                   // notq         %r14
+	WORD $0x894c; BYTE $0xfa                   // movq         %r15, %rdx
+	WORD $0x394d; BYTE $0xf7                   // cmpq         %r14, %r15
+	LONG $0x0041860f; WORD $0x0000             // jbe          LBB12_13, $65(%rip)
+	WORD $0x8948; BYTE $0xf8                   // movq         %rdi, %rax
+	LONG $0x2124f74a                           // mulq         (%rcx,%r12)
+	WORD $0x014c; BYTE $0xfa                   // addq         %r15, %rdx
+	LONG $0x00d38349                           // adcq         $0, %r11
+	WORD $0x8944; BYTE $0xd9                   // movl         %r11d, %ecx
+	WORD $0xd1f7                               // notl         %ecx
+	LONG $0x37e1c148                           // shlq         $55, %rcx
+	LONG $0x0013850f; WORD $0x0000             // jne          LBB12_12, $19(%rip)
+	LONG $0xfffa8348                           // cmpq         $-1, %rdx
+	LONG $0x0009850f; WORD $0x0000             // jne          LBB12_12, $9(%rip)
+	WORD $0x394c; BYTE $0xf0                   // cmpq         %r14, %rax
+	LONG $0x0083870f; WORD $0x0000             // ja           LBB12_1, $131(%rip)
+
+LBB12_12:
+	WORD $0x8944; BYTE $0xdb       // movl         %r11d, %ebx
+	LONG $0x01ffe381; WORD $0x0000 // andl         $511, %ebx
+	LONG $0x000003e9; BYTE $0x00   // jmp          LBB12_13, $3(%rip)
+
+LBB12_11:
+	WORD $0x894c; BYTE $0xfa // movq         %r15, %rdx
+
+LBB12_13:
+	WORD $0x894c; BYTE $0xd8       // movq         %r11, %rax
+	LONG $0x3fe8c148               // shrq         $63, %rax
+	WORD $0x488d; BYTE $0x09       // leal         $9(%rax), %ecx
+	WORD $0xd349; BYTE $0xeb       // shrq         %cl, %r11
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0x0018850f; WORD $0x0000 // jne          LBB12_17, $24(%rip)
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x000f850f; WORD $0x0000 // jne          LBB12_17, $15(%rip)
+	WORD $0x8944; BYTE $0xd9       // movl         %r11d, %ecx
+	WORD $0xe183; BYTE $0x03       // andl         $3, %ecx
+	WORD $0xf983; BYTE $0x01       // cmpl         $1, %ecx
+	LONG $0x0044840f; WORD $0x0000 // je           LBB12_1, $68(%rip)
+
+LBB12_17:
+	LONG $0x526ace69; WORD $0x0003             // imull        $217706, %esi, %ecx
+	WORD $0xf9c1; BYTE $0x10                   // sarl         $16, %ecx
+	LONG $0x043fc181; WORD $0x0000             // addl         $1087, %ecx
+	WORD $0x6348; BYTE $0xf1                   // movslq       %ecx, %rsi
+	WORD $0x294c; BYTE $0xd6                   // subq         %r10, %rsi
+	WORD $0x8944; BYTE $0xda                   // movl         %r11d, %edx
+	WORD $0xe283; BYTE $0x01                   // andl         $1, %edx
+	WORD $0x014c; BYTE $0xda                   // addq         %r11, %rdx
+	WORD $0x8948; BYTE $0xd1                   // movq         %rdx, %rcx
+	LONG $0x36e9c148                           // shrq         $54, %rcx
+	WORD $0x0148; BYTE $0xf0                   // addq         %rsi, %rax
+	LONG $0x01f98348                           // cmpq         $1, %rcx
+	LONG $0x00d88348                           // sbbq         $0, %rax
+	LONG $0x01b08d48; WORD $0xfff8; BYTE $0xff // leaq         $-2047(%rax), %rsi
+	LONG $0x02fe8148; WORD $0xfff8; BYTE $0xff // cmpq         $-2046, %rsi
+	LONG $0x000b830f; WORD $0x0000             // jae          LBB12_19, $11(%rip)
+
+LBB12_1:
+	WORD $0xc031 // xorl         %eax, %eax
+
+LBB12_20:
+	BYTE $0x5b   // popq         %rbx
+	WORD $0x5c41 // popq         %r12
+	WORD $0x5e41 // popq         %r14
+	WORD $0x5f41 // popq         %r15
+	BYTE $0x5d   // popq         %rbp
+	BYTE $0xc3   // retq
+
+LBB12_19:
+	LONG $0x01f98348                       // cmpq         $1, %rcx
+	WORD $0x02b1                           // movb         $2, %cl
+	WORD $0xd980; BYTE $0x00               // sbbb         $0, %cl
+	WORD $0xd348; BYTE $0xea               // shrq         %cl, %rdx
+	LONG $0x34e0c148                       // shlq         $52, %rax
+	QUAD $0xffffffffffffb948; WORD $0x000f // movabsq      $4503599627370495, %rcx
+	WORD $0x2148; BYTE $0xd1               // andq         %rdx, %rcx
+	WORD $0x0948; BYTE $0xc1               // orq          %rax, %rcx
+	QUAD $0x000000000000b848; WORD $0x8000 // movabsq      $-9223372036854775808, %rax
+	WORD $0x0948; BYTE $0xc8               // orq          %rcx, %rax
+	LONG $0xfff98341                       // cmpl         $-1, %r9d
+	LONG $0xc1450f48                       // cmovneq      %rcx, %rax
+	WORD $0x8949; BYTE $0x00               // movq         %rax, (%r8)
+	WORD $0x01b0                           // movb         $1, %al
+	LONG $0xffffb8e9; BYTE $0xff           // jmp          LBB12_20, $-72(%rip)
+	QUAD $0x0000000000000000               // .p2align 5, 0x00
+
+LCPI13_0:
+	QUAD $0x0000000000000000 // .space 8, '\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000001 // .quad 1
+	QUAD $0x0000000000000001 // .quad 1
+	QUAD $0x0000000000000001 // .quad 1
+
+LCPI13_1:
+	QUAD $0x0000000000000001 // .quad 1
+	QUAD $0x0000000000000001 // .quad 1
+	QUAD $0x0000000000000001 // .quad 1
+	QUAD $0x0000000000000001 // .quad 1
+
+	// .p2align 4, 0x00
+LCPI13_2:
+	QUAD $0x0000000000002710 // .quad 10000
+	QUAD $0x0000000000002710 // .quad 10000
+
+LCPI13_3:
+	QUAD $0x000000000000000a // .quad 10
+	QUAD $0x000000000000000a // .quad 10
+
+	// .p2align 4, 0x90
+_decimal_to_f64:
+	BYTE $0x55                             // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5               // movq         %rsp, %rbp
+	WORD $0x5741                           // pushq        %r15
+	WORD $0x5641                           // pushq        %r14
+	WORD $0x5541                           // pushq        %r13
+	WORD $0x5441                           // pushq        %r12
+	BYTE $0x53                             // pushq        %rbx
+	BYTE $0x50                             // pushq        %rax
+	WORD $0x8948; BYTE $0xf3               // movq         %rsi, %rbx
+	WORD $0x8949; BYTE $0xff               // movq         %rdi, %r15
+	QUAD $0x000000000000bd49; WORD $0x0010 // movabsq      $4503599627370496, %r13
+	LONG $0x00107f83                       // cmpl         $0, $16(%rdi)
+	LONG $0x0021840f; WORD $0x0000         // je           LBB13_3, $33(%rip)
+	LONG $0x14478b41                       // movl         $20(%r15), %eax
+	LONG $0x0001363d; BYTE $0x00           // cmpl         $310, %eax
+	LONG $0x001d8e0f; WORD $0x0000         // jle          LBB13_4, $29(%rip)
+
+LBB13_2:
+	WORD $0x3145; BYTE $0xe4               // xorl         %r12d, %r12d
+	QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq      $9218868437227405312, %r14
+	LONG $0x000706e9; BYTE $0x00           // jmp          LBB13_74, $1798(%rip)
+
+LBB13_3:
+	WORD $0x3145; BYTE $0xf6     // xorl         %r14d, %r14d
+	WORD $0x3145; BYTE $0xe4     // xorl         %r12d, %r12d
+	LONG $0x0006fbe9; BYTE $0x00 // jmp          LBB13_74, $1787(%rip)
+
+LBB13_4:
+	WORD $0x3145; BYTE $0xe4       // xorl         %r12d, %r12d
+	LONG $0xfffeb63d; BYTE $0xff   // cmpl         $-330, %eax
+	LONG $0x00088d0f; WORD $0x0000 // jge          LBB13_6, $8(%rip)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	LONG $0x0006e5e9; BYTE $0x00   // jmp          LBB13_74, $1765(%rip)
+
+LBB13_6:
+	WORD $0xc085                                       // testl        %eax, %eax
+	LONG $0xd05d8948                                   // movq         %rbx, $-48(%rbp)
+	LONG $0x00aa8e0f; WORD $0x0000                     // jle          LBB13_17, $170(%rip)
+	WORD $0x3145; BYTE $0xe4                           // xorl         %r12d, %r12d
+	LONG $0xc0358d4c; WORD $0x008b; BYTE $0x00         // leaq         $35776(%rip), %r14  /* _POW_TAB(%rip) */
+	LONG $0x000039e9; BYTE $0x00                       // jmp          LBB13_11, $57(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB13_8:
+	LONG $0xffffe5be; BYTE $0xff   // movl         $-27, %esi
+	LONG $0x00001bbb; BYTE $0x00   // movl         $27, %ebx
+	LONG $0x107f8341; BYTE $0x00   // cmpl         $0, $16(%r15)
+	LONG $0x000a840f; WORD $0x0000 // je           LBB13_10, $10(%rip)
+
+LBB13_9:
+	WORD $0xdef7                 // negl         %esi
+	WORD $0x894c; BYTE $0xff     // movq         %r15, %rdi
+	LONG $0x0057a1e8; BYTE $0x00 // callq        _right_shift, $22433(%rip)
+
+LBB13_10:
+	WORD $0x0141; BYTE $0xdc       // addl         %ebx, %r12d
+	LONG $0x14478b41               // movl         $20(%r15), %eax
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x00628e0f; WORD $0x0000 // jle          LBB13_17, $98(%rip)
+
+LBB13_11:
+	WORD $0xf883; BYTE $0x08       // cmpl         $8, %eax
+	LONG $0xffc9870f; WORD $0xffff // ja           LBB13_8, $-55(%rip)
+	WORD $0xc089                   // movl         %eax, %eax
+	LONG $0x861c8b41               // movl         (%r14,%rax,4), %ebx
+	LONG $0x107f8341; BYTE $0x00   // cmpl         $0, $16(%r15)
+	LONG $0xffd7840f; WORD $0xffff // je           LBB13_10, $-41(%rip)
+	WORD $0xde89                   // movl         %ebx, %esi
+	WORD $0xdef7                   // negl         %esi
+	WORD $0xfe83; BYTE $0xc3       // cmpl         $-61, %esi
+	LONG $0xffc0870f; WORD $0xffff // ja           LBB13_9, $-64(%rip)
+	WORD $0x894d; BYTE $0xf5       // movq         %r14, %r13
+	QUAD $0x9090909090909090       // .p2align 4, 0x90
+
+LBB13_15:
+	WORD $0x8941; BYTE $0xf6               // movl         %esi, %r14d
+	WORD $0x894c; BYTE $0xff               // movq         %r15, %rdi
+	LONG $0x00003cbe; BYTE $0x00           // movl         $60, %esi
+	LONG $0x005750e8; BYTE $0x00           // callq        _right_shift, $22352(%rip)
+	LONG $0x3c768d41                       // leal         $60(%r14), %esi
+	LONG $0x88fe8341                       // cmpl         $-120, %r14d
+	LONG $0xffe2820f; WORD $0xffff         // jb           LBB13_15, $-30(%rip)
+	WORD $0x894d; BYTE $0xee               // movq         %r13, %r14
+	QUAD $0x000000000000bd49; WORD $0x0010 // movabsq      $4503599627370496, %r13
+	LONG $0xffff85e9; BYTE $0xff           // jmp          LBB13_9, $-123(%rip)
+
+LBB13_17:
+	LONG $0x19358d4c; WORD $0x008b; BYTE $0x00 // leaq         $35609(%rip), %r14  /* _POW_TAB(%rip) */
+	LONG $0x000025e9; BYTE $0x00               // jmp          LBB13_19, $37(%rip)
+
+LBB13_23:
+	LONG $0x00001bbb; BYTE $0x00   // movl         $27, %ebx
+	LONG $0x107f8341; BYTE $0x00   // cmpl         $0, $16(%r15)
+	LONG $0x0012840f; WORD $0x0000 // je           LBB13_18, $18(%rip)
+	LONG $0x90909090               // .p2align 4, 0x90
+
+LBB13_25:
+	WORD $0x894c; BYTE $0xff     // movq         %r15, %rdi
+	WORD $0xde89                 // movl         %ebx, %esi
+	LONG $0x005516e8; BYTE $0x00 // callq        _left_shift, $21782(%rip)
+	LONG $0x14478b41             // movl         $20(%r15), %eax
+
+LBB13_18:
+	WORD $0x2941; BYTE $0xdc // subl         %ebx, %r12d
+
+LBB13_19:
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x0017880f; WORD $0x0000 // js           LBB13_22, $23(%rip)
+	LONG $0x0032850f; WORD $0x0000 // jne          LBB13_26, $50(%rip)
+	WORD $0x8b49; BYTE $0x0f       // movq         (%r15), %rcx
+	WORD $0x3980; BYTE $0x35       // cmpb         $53, (%rcx)
+	LONG $0x000e8c0f; WORD $0x0000 // jl           LBB13_24, $14(%rip)
+	LONG $0x000021e9; BYTE $0x00   // jmp          LBB13_26, $33(%rip)
+
+	// .p2align 4, 0x90
+LBB13_22:
+	WORD $0xf883; BYTE $0xf8       // cmpl         $-8, %eax
+	LONG $0xffb3820f; WORD $0xffff // jb           LBB13_23, $-77(%rip)
+
+LBB13_24:
+	WORD $0xc189                   // movl         %eax, %ecx
+	WORD $0xd9f7                   // negl         %ecx
+	LONG $0x8e1c8b41               // movl         (%r14,%rcx,4), %ebx
+	LONG $0x107f8341; BYTE $0x00   // cmpl         $0, $16(%r15)
+	LONG $0xffb4850f; WORD $0xffff // jne          LBB13_25, $-76(%rip)
+	LONG $0xffffbde9; BYTE $0xff   // jmp          LBB13_18, $-67(%rip)
+
+LBB13_26:
+	LONG $0x02fc8141; WORD $0xfffc; BYTE $0xff                           // cmpl         $-1022, %r12d
+	LONG $0x00568f0f; WORD $0x0000                                       // jg           LBB13_32, $86(%rip)
+	LONG $0x107f8341; BYTE $0x00                                         // cmpl         $0, $16(%r15)
+	LONG $0xd05d8b48                                                     // movq         $-48(%rbp), %rbx
+	LONG $0x0075840f; WORD $0x0000                                       // je           LBB13_35, $117(%rip)
+	LONG $0xc6fc8141; WORD $0xfffb; BYTE $0xff                           // cmpl         $-1082, %r12d
+	LONG $0x0073870f; WORD $0x0000                                       // ja           LBB13_36, $115(%rip)
+	LONG $0xc1c48141; WORD $0x0003; BYTE $0x00                           // addl         $961, %r12d
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB13_30:
+	WORD $0x894c; BYTE $0xff       // movq         %r15, %rdi
+	LONG $0x00003cbe; BYTE $0x00   // movl         $60, %esi
+	LONG $0x005673e8; BYTE $0x00   // callq        _right_shift, $22131(%rip)
+	LONG $0x3cc48341               // addl         $60, %r12d
+	LONG $0x88fc8341               // cmpl         $-120, %r12d
+	LONG $0xffe5820f; WORD $0xffff // jb           LBB13_30, $-27(%rip)
+	LONG $0x3cc48341               // addl         $60, %r12d
+	LONG $0x000040e9; BYTE $0x00   // jmp          LBB13_37, $64(%rip)
+
+LBB13_32:
+	LONG $0x00fc8141; WORD $0x0004; BYTE $0x00 // cmpl         $1024, %r12d
+	LONG $0xd05d8b48                           // movq         $-48(%rbp), %rbx
+	QUAD $0x000000000000be49; WORD $0x7ff0     // movabsq      $9218868437227405312, %r14
+	LONG $0x00088e0f; WORD $0x0000             // jle          LBB13_34, $8(%rip)
+	WORD $0x3145; BYTE $0xe4                   // xorl         %r12d, %r12d
+	LONG $0x000538e9; BYTE $0x00               // jmp          LBB13_74, $1336(%rip)
+
+LBB13_34:
+	WORD $0xff41; BYTE $0xcc     // decl         %r12d
+	WORD $0x8945; BYTE $0xe6     // movl         %r12d, %r14d
+	LONG $0x000026e9; BYTE $0x00 // jmp          LBB13_38, $38(%rip)
+
+LBB13_35:
+	LONG $0xfc02be41; WORD $0xffff // movl         $-1022, %r14d
+	LONG $0x000033e9; BYTE $0x00   // jmp          LBB13_40, $51(%rip)
+
+LBB13_36:
+	LONG $0xfdc48141; WORD $0x0003; BYTE $0x00 // addl         $1021, %r12d
+
+LBB13_37:
+	WORD $0xf741; BYTE $0xdc       // negl         %r12d
+	WORD $0x894c; BYTE $0xff       // movq         %r15, %rdi
+	WORD $0x8944; BYTE $0xe6       // movl         %r12d, %esi
+	LONG $0x00560ee8; BYTE $0x00   // callq        _right_shift, $22030(%rip)
+	LONG $0xfc02be41; WORD $0xffff // movl         $-1022, %r14d
+
+LBB13_38:
+	LONG $0x107f8341; BYTE $0x00   // cmpl         $0, $16(%r15)
+	LONG $0x000d840f; WORD $0x0000 // je           LBB13_40, $13(%rip)
+	WORD $0x894c; BYTE $0xff       // movq         %r15, %rdi
+	LONG $0x000035be; BYTE $0x00   // movl         $53, %esi
+	LONG $0x005400e8; BYTE $0x00   // callq        _left_shift, $21504(%rip)
+
+LBB13_40:
+	LONG $0x14478b41                           // movl         $20(%r15), %eax
+	LONG $0xffc4c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r12
+	WORD $0xf883; BYTE $0x14                   // cmpl         $20, %eax
+	LONG $0x04bc8f0f; WORD $0x0000             // jg           LBB13_73, $1212(%rip)
+	WORD $0xc085                               // testl        %eax, %eax
+	LONG $0x00558e0f; WORD $0x0000             // jle          LBB13_46, $85(%rip)
+	LONG $0x10578b41                           // movl         $16(%r15), %edx
+	WORD $0xf631                               // xorl         %esi, %esi
+	WORD $0xd285                               // testl        %edx, %edx
+	WORD $0x4e0f; BYTE $0xd6                   // cmovlel      %esi, %edx
+	LONG $0xff488d4c                           // leaq         $-1(%rax), %r9
+	WORD $0x3949; BYTE $0xd1                   // cmpq         %rdx, %r9
+	LONG $0xca430f4c                           // cmovaeq      %rdx, %r9
+	LONG $0x01418d4d                           // leaq         $1(%r9), %r8
+	WORD $0x3145; BYTE $0xe4                   // xorl         %r12d, %r12d
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB13_43:
+	WORD $0x3948; BYTE $0xf2       // cmpq         %rsi, %rdx
+	LONG $0x002e840f; WORD $0x0000 // je           LBB13_47, $46(%rip)
+	LONG $0xa40c8d4b               // leaq         (%r12,%r12,4), %rcx
+	WORD $0x8b49; BYTE $0x3f       // movq         (%r15), %rdi
+	LONG $0x3cbe0f48; BYTE $0x37   // movsbq       (%rdi,%rsi), %rdi
+	LONG $0x4f248d4c               // leaq         (%rdi,%rcx,2), %r12
+	LONG $0xd0c48349               // addq         $-48, %r12
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0xffd7850f; WORD $0xffff // jne          LBB13_43, $-41(%rip)
+	WORD $0x894d; BYTE $0xc1       // movq         %r8, %r9
+	LONG $0x000006e9; BYTE $0x00   // jmp          LBB13_47, $6(%rip)
+
+LBB13_46:
+	WORD $0x3145; BYTE $0xc9 // xorl         %r9d, %r9d
+	WORD $0x3145; BYTE $0xe4 // xorl         %r12d, %r12d
+
+LBB13_47:
+	WORD $0x3944; BYTE $0xc8               // cmpl         %r9d, %eax
+	LONG $0x03cf8e0f; WORD $0x0000         // jle          LBB13_60, $975(%rip)
+	WORD $0xc289                           // movl         %eax, %edx
+	WORD $0x2944; BYTE $0xca               // subl         %r9d, %edx
+	WORD $0xfa83; BYTE $0x10               // cmpl         $16, %edx
+	LONG $0x03a0820f; WORD $0x0000         // jb           LBB13_58, $928(%rip)
+	WORD $0x8941; BYTE $0xd0               // movl         %edx, %r8d
+	QUAD $0xfffffca7056ff9c5               // vmovdqa      $-857(%rip), %xmm0  /* LCPI13_0(%rip) */
+	LONG $0x22f9c3c4; WORD $0x00c4         // vpinsrq      $0, %r12, %xmm0, %xmm0
+	QUAD $0xfffc970d0c7de3c4; WORD $0xf0ff // vblendps     $240, $-873(%rip), %ymm0, %ymm1  /* LCPI13_0(%rip) */
+	LONG $0xf0e08341                       // andl         $-16, %r8d
+	LONG $0xf0488d41                       // leal         $-16(%r8), %ecx
+	WORD $0xcf89                           // movl         %ecx, %edi
+	WORD $0xefc1; BYTE $0x04               // shrl         $4, %edi
+	WORD $0xc7ff                           // incl         %edi
+	WORD $0xfe89                           // movl         %edi, %esi
+	WORD $0xe683; BYTE $0x03               // andl         $3, %esi
+	WORD $0xf983; BYTE $0x30               // cmpl         $48, %ecx
+	LONG $0x0015830f; WORD $0x0000         // jae          LBB13_51, $21(%rip)
+	QUAD $0xfffffc92156ffdc5               // vmovdqa      $-878(%rip), %ymm2  /* LCPI13_1(%rip) */
+	LONG $0xda6ffdc5                       // vmovdqa      %ymm2, %ymm3
+	LONG $0xc26ffdc5                       // vmovdqa      %ymm2, %ymm0
+	LONG $0x00010ee9; BYTE $0x00           // jmp          LBB13_53, $270(%rip)
+
+LBB13_51:
+	WORD $0xe783; BYTE $0xfc               // andl         $-4, %edi
+	QUAD $0xfffffc7a156ffdc5               // vmovdqa      $-902(%rip), %ymm2  /* LCPI13_1(%rip) */
+	QUAD $0xfffffc92256ff9c5               // vmovdqa      $-878(%rip), %xmm4  /* LCPI13_2(%rip) */
+	LONG $0xda6ffdc5                       // vmovdqa      %ymm2, %ymm3
+	LONG $0xc26ffdc5                       // vmovdqa      %ymm2, %ymm0
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB13_52:
+	LONG $0x197de3c4; WORD $0x01cd // vextractf128 $1, %ymm1, %xmm5
+	LONG $0xf4f4d1c5               // vpmuludq     %xmm4, %xmm5, %xmm6
+	LONG $0xd573d1c5; BYTE $0x20   // vpsrlq       $32, %xmm5, %xmm5
+	LONG $0xecf4d1c5               // vpmuludq     %xmm4, %xmm5, %xmm5
+	LONG $0xf573d1c5; BYTE $0x20   // vpsllq       $32, %xmm5, %xmm5
+	LONG $0xedd4c9c5               // vpaddq       %xmm5, %xmm6, %xmm5
+	LONG $0xf4f4f1c5               // vpmuludq     %xmm4, %xmm1, %xmm6
+	LONG $0xd173f1c5; BYTE $0x20   // vpsrlq       $32, %xmm1, %xmm1
+	LONG $0xccf4f1c5               // vpmuludq     %xmm4, %xmm1, %xmm1
+	LONG $0xf173f1c5; BYTE $0x20   // vpsllq       $32, %xmm1, %xmm1
+	LONG $0xc9d4c9c5               // vpaddq       %xmm1, %xmm6, %xmm1
+	LONG $0x1875e3c4; WORD $0x01cd // vinsertf128  $1, %xmm5, %ymm1, %ymm1
+	LONG $0x197de3c4; WORD $0x01d5 // vextractf128 $1, %ymm2, %xmm5
+	LONG $0xf4f4d1c5               // vpmuludq     %xmm4, %xmm5, %xmm6
+	LONG $0xd573d1c5; BYTE $0x20   // vpsrlq       $32, %xmm5, %xmm5
+	LONG $0xecf4d1c5               // vpmuludq     %xmm4, %xmm5, %xmm5
+	LONG $0xf573d1c5; BYTE $0x20   // vpsllq       $32, %xmm5, %xmm5
+	LONG $0xedd4c9c5               // vpaddq       %xmm5, %xmm6, %xmm5
+	LONG $0xf4f4e9c5               // vpmuludq     %xmm4, %xmm2, %xmm6
+	LONG $0xd273e9c5; BYTE $0x20   // vpsrlq       $32, %xmm2, %xmm2
+	LONG $0xd4f4e9c5               // vpmuludq     %xmm4, %xmm2, %xmm2
+	LONG $0xf273e9c5; BYTE $0x20   // vpsllq       $32, %xmm2, %xmm2
+	LONG $0xd2d4c9c5               // vpaddq       %xmm2, %xmm6, %xmm2
+	LONG $0x186de3c4; WORD $0x01d5 // vinsertf128  $1, %xmm5, %ymm2, %ymm2
+	LONG $0x197de3c4; WORD $0x01dd // vextractf128 $1, %ymm3, %xmm5
+	LONG $0xf4f4d1c5               // vpmuludq     %xmm4, %xmm5, %xmm6
+	LONG $0xd573d1c5; BYTE $0x20   // vpsrlq       $32, %xmm5, %xmm5
+	LONG $0xecf4d1c5               // vpmuludq     %xmm4, %xmm5, %xmm5
+	LONG $0xf573d1c5; BYTE $0x20   // vpsllq       $32, %xmm5, %xmm5
+	LONG $0xedd4c9c5               // vpaddq       %xmm5, %xmm6, %xmm5
+	LONG $0xf4f4e1c5               // vpmuludq     %xmm4, %xmm3, %xmm6
+	LONG $0xd373e1c5; BYTE $0x20   // vpsrlq       $32, %xmm3, %xmm3
+	LONG $0xdcf4e1c5               // vpmuludq     %xmm4, %xmm3, %xmm3
+	LONG $0xf373e1c5; BYTE $0x20   // vpsllq       $32, %xmm3, %xmm3
+	LONG $0xdbd4c9c5               // vpaddq       %xmm3, %xmm6, %xmm3
+	LONG $0x1865e3c4; WORD $0x01dd // vinsertf128  $1, %xmm5, %ymm3, %ymm3
+	LONG $0x197de3c4; WORD $0x01c5 // vextractf128 $1, %ymm0, %xmm5
+	LONG $0xf4f4d1c5               // vpmuludq     %xmm4, %xmm5, %xmm6
+	LONG $0xd573d1c5; BYTE $0x20   // vpsrlq       $32, %xmm5, %xmm5
+	LONG $0xecf4d1c5               // vpmuludq     %xmm4, %xmm5, %xmm5
+	LONG $0xf573d1c5; BYTE $0x20   // vpsllq       $32, %xmm5, %xmm5
+	LONG $0xedd4c9c5               // vpaddq       %xmm5, %xmm6, %xmm5
+	LONG $0xf4f4f9c5               // vpmuludq     %xmm4, %xmm0, %xmm6
+	LONG $0xd073f9c5; BYTE $0x20   // vpsrlq       $32, %xmm0, %xmm0
+	LONG $0xc4f4f9c5               // vpmuludq     %xmm4, %xmm0, %xmm0
+	LONG $0xf073f9c5; BYTE $0x20   // vpsllq       $32, %xmm0, %xmm0
+	LONG $0xc0d4c9c5               // vpaddq       %xmm0, %xmm6, %xmm0
+	LONG $0x187de3c4; WORD $0x01c5 // vinsertf128  $1, %xmm5, %ymm0, %ymm0
+	WORD $0xc783; BYTE $0xfc       // addl         $-4, %edi
+	LONG $0xff17850f; WORD $0xffff // jne          LBB13_52, $-233(%rip)
+
+LBB13_53:
+	WORD $0xf685                               // testl        %esi, %esi
+	LONG $0x00f7840f; WORD $0x0000             // je           LBB13_56, $247(%rip)
+	QUAD $0xfffffb97256ff9c5                   // vmovdqa      $-1129(%rip), %xmm4  /* LCPI13_3(%rip) */
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB13_55:
+	LONG $0x197de3c4; WORD $0x01cd // vextractf128 $1, %ymm1, %xmm5
+	LONG $0xf4f4d1c5               // vpmuludq     %xmm4, %xmm5, %xmm6
+	LONG $0xd573d1c5; BYTE $0x20   // vpsrlq       $32, %xmm5, %xmm5
+	LONG $0xecf4d1c5               // vpmuludq     %xmm4, %xmm5, %xmm5
+	LONG $0xf573d1c5; BYTE $0x20   // vpsllq       $32, %xmm5, %xmm5
+	LONG $0xedd4c9c5               // vpaddq       %xmm5, %xmm6, %xmm5
+	LONG $0xf4f4f1c5               // vpmuludq     %xmm4, %xmm1, %xmm6
+	LONG $0xd173f1c5; BYTE $0x20   // vpsrlq       $32, %xmm1, %xmm1
+	LONG $0xccf4f1c5               // vpmuludq     %xmm4, %xmm1, %xmm1
+	LONG $0xf173f1c5; BYTE $0x20   // vpsllq       $32, %xmm1, %xmm1
+	LONG $0xc9d4c9c5               // vpaddq       %xmm1, %xmm6, %xmm1
+	LONG $0x1875e3c4; WORD $0x01cd // vinsertf128  $1, %xmm5, %ymm1, %ymm1
+	LONG $0x197de3c4; WORD $0x01d5 // vextractf128 $1, %ymm2, %xmm5
+	LONG $0xf4f4d1c5               // vpmuludq     %xmm4, %xmm5, %xmm6
+	LONG $0xd573d1c5; BYTE $0x20   // vpsrlq       $32, %xmm5, %xmm5
+	LONG $0xecf4d1c5               // vpmuludq     %xmm4, %xmm5, %xmm5
+	LONG $0xf573d1c5; BYTE $0x20   // vpsllq       $32, %xmm5, %xmm5
+	LONG $0xedd4c9c5               // vpaddq       %xmm5, %xmm6, %xmm5
+	LONG $0xf4f4e9c5               // vpmuludq     %xmm4, %xmm2, %xmm6
+	LONG $0xd273e9c5; BYTE $0x20   // vpsrlq       $32, %xmm2, %xmm2
+	LONG $0xd4f4e9c5               // vpmuludq     %xmm4, %xmm2, %xmm2
+	LONG $0xf273e9c5; BYTE $0x20   // vpsllq       $32, %xmm2, %xmm2
+	LONG $0xd2d4c9c5               // vpaddq       %xmm2, %xmm6, %xmm2
+	LONG $0x186de3c4; WORD $0x01d5 // vinsertf128  $1, %xmm5, %ymm2, %ymm2
+	LONG $0x197de3c4; WORD $0x01dd // vextractf128 $1, %ymm3, %xmm5
+	LONG $0xf4f4d1c5               // vpmuludq     %xmm4, %xmm5, %xmm6
+	LONG $0xd573d1c5; BYTE $0x20   // vpsrlq       $32, %xmm5, %xmm5
+	LONG $0xecf4d1c5               // vpmuludq     %xmm4, %xmm5, %xmm5
+	LONG $0xf573d1c5; BYTE $0x20   // vpsllq       $32, %xmm5, %xmm5
+	LONG $0xedd4c9c5               // vpaddq       %xmm5, %xmm6, %xmm5
+	LONG $0xf4f4e1c5               // vpmuludq     %xmm4, %xmm3, %xmm6
+	LONG $0xd373e1c5; BYTE $0x20   // vpsrlq       $32, %xmm3, %xmm3
+	LONG $0xdcf4e1c5               // vpmuludq     %xmm4, %xmm3, %xmm3
+	LONG $0xf373e1c5; BYTE $0x20   // vpsllq       $32, %xmm3, %xmm3
+	LONG $0xdbd4c9c5               // vpaddq       %xmm3, %xmm6, %xmm3
+	LONG $0x1865e3c4; WORD $0x01dd // vinsertf128  $1, %xmm5, %ymm3, %ymm3
+	LONG $0x197de3c4; WORD $0x01c5 // vextractf128 $1, %ymm0, %xmm5
+	LONG $0xf4f4d1c5               // vpmuludq     %xmm4, %xmm5, %xmm6
+	LONG $0xd573d1c5; BYTE $0x20   // vpsrlq       $32, %xmm5, %xmm5
+	LONG $0xecf4d1c5               // vpmuludq     %xmm4, %xmm5, %xmm5
+	LONG $0xf573d1c5; BYTE $0x20   // vpsllq       $32, %xmm5, %xmm5
+	LONG $0xedd4c9c5               // vpaddq       %xmm5, %xmm6, %xmm5
+	LONG $0xf4f4f9c5               // vpmuludq     %xmm4, %xmm0, %xmm6
+	LONG $0xd073f9c5; BYTE $0x20   // vpsrlq       $32, %xmm0, %xmm0
+	LONG $0xc4f4f9c5               // vpmuludq     %xmm4, %xmm0, %xmm0
+	LONG $0xf073f9c5; BYTE $0x20   // vpsllq       $32, %xmm0, %xmm0
+	LONG $0xc0d4c9c5               // vpaddq       %xmm0, %xmm6, %xmm0
+	LONG $0x187de3c4; WORD $0x01c5 // vinsertf128  $1, %xmm5, %ymm0, %ymm0
+	WORD $0xceff                   // decl         %esi
+	LONG $0xff18850f; WORD $0xffff // jne          LBB13_55, $-232(%rip)
+
+LBB13_56:
+	LONG $0x197de3c4; WORD $0x01cc // vextractf128 $1, %ymm1, %xmm4
+	LONG $0x197de3c4; WORD $0x01d5 // vextractf128 $1, %ymm2, %xmm5
+	LONG $0xd573c9c5; BYTE $0x20   // vpsrlq       $32, %xmm5, %xmm6
+	LONG $0xf4f4c9c5               // vpmuludq     %xmm4, %xmm6, %xmm6
+	LONG $0xd473c1c5; BYTE $0x20   // vpsrlq       $32, %xmm4, %xmm7
+	LONG $0xfff4d1c5               // vpmuludq     %xmm7, %xmm5, %xmm7
+	LONG $0xf6d4c1c5               // vpaddq       %xmm6, %xmm7, %xmm6
+	LONG $0xf673c9c5; BYTE $0x20   // vpsllq       $32, %xmm6, %xmm6
+	LONG $0xe4f4d1c5               // vpmuludq     %xmm4, %xmm5, %xmm4
+	LONG $0xe6d4d9c5               // vpaddq       %xmm6, %xmm4, %xmm4
+	LONG $0xd273d1c5; BYTE $0x20   // vpsrlq       $32, %xmm2, %xmm5
+	LONG $0xe9f4d1c5               // vpmuludq     %xmm1, %xmm5, %xmm5
+	LONG $0xd173c9c5; BYTE $0x20   // vpsrlq       $32, %xmm1, %xmm6
+	LONG $0xf6f4e9c5               // vpmuludq     %xmm6, %xmm2, %xmm6
+	LONG $0xedd4c9c5               // vpaddq       %xmm5, %xmm6, %xmm5
+	LONG $0xf573d1c5; BYTE $0x20   // vpsllq       $32, %xmm5, %xmm5
+	LONG $0xc9f4e9c5               // vpmuludq     %xmm1, %xmm2, %xmm1
+	LONG $0xcdd4f1c5               // vpaddq       %xmm5, %xmm1, %xmm1
+	LONG $0xd373e9c5; BYTE $0x20   // vpsrlq       $32, %xmm3, %xmm2
+	LONG $0xd1f4e9c5               // vpmuludq     %xmm1, %xmm2, %xmm2
+	LONG $0xd173d1c5; BYTE $0x20   // vpsrlq       $32, %xmm1, %xmm5
+	LONG $0xedf4e1c5               // vpmuludq     %xmm5, %xmm3, %xmm5
+	LONG $0xd2d4d1c5               // vpaddq       %xmm2, %xmm5, %xmm2
+	LONG $0xf273e9c5; BYTE $0x20   // vpsllq       $32, %xmm2, %xmm2
+	LONG $0xc9f4e1c5               // vpmuludq     %xmm1, %xmm3, %xmm1
+	LONG $0xcad4f1c5               // vpaddq       %xmm2, %xmm1, %xmm1
+	LONG $0x197de3c4; WORD $0x01da // vextractf128 $1, %ymm3, %xmm2
+	LONG $0xd273e1c5; BYTE $0x20   // vpsrlq       $32, %xmm2, %xmm3
+	LONG $0xdcf4e1c5               // vpmuludq     %xmm4, %xmm3, %xmm3
+	LONG $0xd473d1c5; BYTE $0x20   // vpsrlq       $32, %xmm4, %xmm5
+	LONG $0xedf4e9c5               // vpmuludq     %xmm5, %xmm2, %xmm5
+	LONG $0xdbd4d1c5               // vpaddq       %xmm3, %xmm5, %xmm3
+	LONG $0xf373e1c5; BYTE $0x20   // vpsllq       $32, %xmm3, %xmm3
+	LONG $0xd4f4e9c5               // vpmuludq     %xmm4, %xmm2, %xmm2
+	LONG $0xd3d4e9c5               // vpaddq       %xmm3, %xmm2, %xmm2
+	LONG $0x197de3c4; WORD $0x01c3 // vextractf128 $1, %ymm0, %xmm3
+	LONG $0xd373d9c5; BYTE $0x20   // vpsrlq       $32, %xmm3, %xmm4
+	LONG $0xe2f4d9c5               // vpmuludq     %xmm2, %xmm4, %xmm4
+	LONG $0xd273d1c5; BYTE $0x20   // vpsrlq       $32, %xmm2, %xmm5
+	LONG $0xedf4e1c5               // vpmuludq     %xmm5, %xmm3, %xmm5
+	LONG $0xe4d4d1c5               // vpaddq       %xmm4, %xmm5, %xmm4
+	LONG $0xf473d9c5; BYTE $0x20   // vpsllq       $32, %xmm4, %xmm4
+	LONG $0xd2f4e1c5               // vpmuludq     %xmm2, %xmm3, %xmm2
+	LONG $0xd4d4e9c5               // vpaddq       %xmm4, %xmm2, %xmm2
+	LONG $0xd073e1c5; BYTE $0x20   // vpsrlq       $32, %xmm0, %xmm3
+	LONG $0xd9f4e1c5               // vpmuludq     %xmm1, %xmm3, %xmm3
+	LONG $0xd173d9c5; BYTE $0x20   // vpsrlq       $32, %xmm1, %xmm4
+	LONG $0xe4f4f9c5               // vpmuludq     %xmm4, %xmm0, %xmm4
+	LONG $0xdbd4d9c5               // vpaddq       %xmm3, %xmm4, %xmm3
+	LONG $0xf373e1c5; BYTE $0x20   // vpsllq       $32, %xmm3, %xmm3
+	LONG $0xc1f4f9c5               // vpmuludq     %xmm1, %xmm0, %xmm0
+	LONG $0xc3d4f9c5               // vpaddq       %xmm3, %xmm0, %xmm0
+	LONG $0xd073f1c5; BYTE $0x20   // vpsrlq       $32, %xmm0, %xmm1
+	LONG $0xcaf4f1c5               // vpmuludq     %xmm2, %xmm1, %xmm1
+	LONG $0xd273e1c5; BYTE $0x20   // vpsrlq       $32, %xmm2, %xmm3
+	LONG $0xdbf4f9c5               // vpmuludq     %xmm3, %xmm0, %xmm3
+	LONG $0xc9d4e1c5               // vpaddq       %xmm1, %xmm3, %xmm1
+	LONG $0xf173f1c5; BYTE $0x20   // vpsllq       $32, %xmm1, %xmm1
+	LONG $0xc2f4f9c5               // vpmuludq     %xmm2, %xmm0, %xmm0
+	LONG $0xc1d4f9c5               // vpaddq       %xmm1, %xmm0, %xmm0
+	LONG $0xc870f9c5; BYTE $0xee   // vpshufd      $238, %xmm0, %xmm1
+	LONG $0xd073e9c5; BYTE $0x20   // vpsrlq       $32, %xmm0, %xmm2
+	LONG $0xd1f4e9c5               // vpmuludq     %xmm1, %xmm2, %xmm2
+	LONG $0xd870f9c5; BYTE $0xff   // vpshufd      $255, %xmm0, %xmm3
+	LONG $0xdbf4f9c5               // vpmuludq     %xmm3, %xmm0, %xmm3
+	LONG $0xd2d4e1c5               // vpaddq       %xmm2, %xmm3, %xmm2
+	LONG $0xf273e9c5; BYTE $0x20   // vpsllq       $32, %xmm2, %xmm2
+	LONG $0xc1f4f9c5               // vpmuludq     %xmm1, %xmm0, %xmm0
+	LONG $0xc2d4f9c5               // vpaddq       %xmm2, %xmm0, %xmm0
+	LONG $0x7ef9c1c4; BYTE $0xc4   // vmovq        %xmm0, %r12
+	WORD $0x3944; BYTE $0xc2       // cmpl         %r8d, %edx
+	LONG $0x0024840f; WORD $0x0000 // je           LBB13_60, $36(%rip)
+	WORD $0x0145; BYTE $0xc1       // addl         %r8d, %r9d
+
+LBB13_58:
+	WORD $0xc289                                           // movl         %eax, %edx
+	WORD $0x2944; BYTE $0xca                               // subl         %r9d, %edx
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB13_59:
+	WORD $0x014d; BYTE $0xe4       // addq         %r12, %r12
+	LONG $0xa4248d4f               // leaq         (%r12,%r12,4), %r12
+	WORD $0xcaff                   // decl         %edx
+	LONG $0xfff1850f; WORD $0xffff // jne          LBB13_59, $-15(%rip)
+
+LBB13_60:
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x004b880f; WORD $0x0000 // js           LBB13_67, $75(%rip)
+	LONG $0x10578b41               // movl         $16(%r15), %edx
+	WORD $0xc239                   // cmpl         %eax, %edx
+	LONG $0x003f8e0f; WORD $0x0000 // jle          LBB13_67, $63(%rip)
+	WORD $0x8b49; BYTE $0x37       // movq         (%r15), %rsi
+	LONG $0x060cb60f               // movzbl       (%rsi,%rax), %ecx
+	WORD $0xf980; BYTE $0x35       // cmpb         $53, %cl
+	LONG $0x00b2850f; WORD $0x0000 // jne          LBB13_69, $178(%rip)
+	WORD $0x788d; BYTE $0x01       // leal         $1(%rax), %edi
+	WORD $0xd739                   // cmpl         %edx, %edi
+	LONG $0x00a7850f; WORD $0x0000 // jne          LBB13_69, $167(%rip)
+	WORD $0x01b2                   // movb         $1, %dl
+	LONG $0x1c7f8341; BYTE $0x00   // cmpl         $0, $28(%r15)
+	LONG $0x0019850f; WORD $0x0000 // jne          LBB13_70, $25(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x000e840f; WORD $0x0000 // je           LBB13_67, $14(%rip)
+	WORD $0xc8ff                   // decl         %eax
+	LONG $0x0614b60f               // movzbl       (%rsi,%rax), %edx
+	WORD $0xe280; BYTE $0x01       // andb         $1, %dl
+	LONG $0x000002e9; BYTE $0x00   // jmp          LBB13_70, $2(%rip)
+
+LBB13_67:
+	WORD $0xd231 // xorl         %edx, %edx
+
+LBB13_70:
+	WORD $0xb60f; BYTE $0xc2                   // movzbl       %dl, %eax
+	WORD $0x0149; BYTE $0xc4                   // addq         %rax, %r12
+	QUAD $0x000000000000b848; WORD $0x0020     // movabsq      $9007199254740992, %rax
+	WORD $0x3949; BYTE $0xc4                   // cmpq         %rax, %r12
+	LONG $0x0013850f; WORD $0x0000             // jne          LBB13_73, $19(%rip)
+	LONG $0xfefe8141; WORD $0x0003; BYTE $0x00 // cmpl         $1022, %r14d
+	LONG $0xf90d8f0f; WORD $0xffff             // jg           LBB13_2, $-1779(%rip)
+	WORD $0xff41; BYTE $0xc6                   // incl         %r14d
+	WORD $0x894d; BYTE $0xec                   // movq         %r13, %r12
+
+LBB13_73:
+	WORD $0x894c; BYTE $0xe0                   // movq         %r12, %rax
+	WORD $0x214c; BYTE $0xe8                   // andq         %r13, %rax
+	LONG $0xffc68141; WORD $0x0003; BYTE $0x00 // addl         $1023, %r14d
+	LONG $0xffe68141; WORD $0x0007; BYTE $0x00 // andl         $2047, %r14d
+	LONG $0x34e6c149                           // shlq         $52, %r14
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0xf0440f4c                           // cmoveq       %rax, %r14
+
+LBB13_74:
+	WORD $0xff49; BYTE $0xcd               // decq         %r13
+	WORD $0x214d; BYTE $0xe5               // andq         %r12, %r13
+	WORD $0x094d; BYTE $0xf5               // orq          %r14, %r13
+	QUAD $0x000000000000b848; WORD $0x8000 // movabsq      $-9223372036854775808, %rax
+	WORD $0x094c; BYTE $0xe8               // orq          %r13, %rax
+	LONG $0x187f8341; BYTE $0x00           // cmpl         $0, $24(%r15)
+	LONG $0xc5440f49                       // cmoveq       %r13, %rax
+	WORD $0x8948; BYTE $0x03               // movq         %rax, (%rbx)
+	WORD $0xc031                           // xorl         %eax, %eax
+	LONG $0x08c48348                       // addq         $8, %rsp
+	BYTE $0x5b                             // popq         %rbx
+	WORD $0x5c41                           // popq         %r12
+	WORD $0x5d41                           // popq         %r13
+	WORD $0x5e41                           // popq         %r14
+	WORD $0x5f41                           // popq         %r15
+	BYTE $0x5d                             // popq         %rbp
+	WORD $0xf8c5; BYTE $0x77               // vzeroupper
+	BYTE $0xc3                             // retq
+
+LBB13_69:
+	WORD $0xf980; BYTE $0x35     // cmpb         $53, %cl
+	WORD $0x9d0f; BYTE $0xc2     // setge        %dl
+	LONG $0xffff74e9; BYTE $0xff // jmp          LBB13_70, $-140(%rip)
+
+	// .p2align 4, 0x90
+_atof_native:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5741                   // pushq        %r15
+	WORD $0x5641                   // pushq        %r14
+	WORD $0x5541                   // pushq        %r13
+	WORD $0x5441                   // pushq        %r12
+	BYTE $0x53                     // pushq        %rbx
+	LONG $0x28ec8348               // subq         $40, %rsp
+	QUAD $0x00000000d045c748       // movq         $0, $-48(%rbp)
+	LONG $0xb0558948               // movq         %rdx, $-80(%rbp)
+	LONG $0xb84d8948               // movq         %rcx, $-72(%rbp)
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x0197840f; WORD $0x0000 // je           LBB14_18, $407(%rip)
+	LONG $0x10f98348               // cmpq         $16, %rcx
+	LONG $0x0008830f; WORD $0x0000 // jae          LBB14_3, $8(%rip)
+	WORD $0x3145; BYTE $0xd2       // xorl         %r10d, %r10d
+	LONG $0x000174e9; BYTE $0x00   // jmp          LBB14_17, $372(%rip)
+
+LBB14_3:
+	LONG $0x80f98148; WORD $0x0000; BYTE $0x00 // cmpq         $128, %rcx
+	LONG $0x0008830f; WORD $0x0000             // jae          LBB14_5, $8(%rip)
+	WORD $0x3145; BYTE $0xd2                   // xorl         %r10d, %r10d
+	LONG $0x000129e9; BYTE $0x00               // jmp          LBB14_14, $297(%rip)
+
+LBB14_5:
+	WORD $0x8949; BYTE $0xca       // movq         %rcx, %r10
+	LONG $0x80e28349               // andq         $-128, %r10
+	LONG $0x80428d49               // leaq         $-128(%r10), %rax
+	WORD $0x8949; BYTE $0xc1       // movq         %rax, %r9
+	LONG $0x07e9c149               // shrq         $7, %r9
+	WORD $0xff49; BYTE $0xc1       // incq         %r9
+	WORD $0x8945; BYTE $0xc8       // movl         %r9d, %r8d
+	LONG $0x03e08341               // andl         $3, %r8d
+	LONG $0x01803d48; WORD $0x0000 // cmpq         $384, %rax
+	LONG $0x0007830f; WORD $0x0000 // jae          LBB14_7, $7(%rip)
+	WORD $0xdb31                   // xorl         %ebx, %ebx
+	LONG $0x0000a4e9; BYTE $0x00   // jmp          LBB14_9, $164(%rip)
+
+LBB14_7:
+	LONG $0xfce18349               // andq         $-4, %r9
+	WORD $0xdb31                   // xorl         %ebx, %ebx
+	LONG $0xc057f8c5               // vxorps       %xmm0, %xmm0, %xmm0
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB14_8:
+	LONG $0x0411fcc5; BYTE $0x1a               // vmovups      %ymm0, (%rdx,%rbx)
+	LONG $0x4411fcc5; WORD $0x201a             // vmovups      %ymm0, $32(%rdx,%rbx)
+	LONG $0x4411fcc5; WORD $0x401a             // vmovups      %ymm0, $64(%rdx,%rbx)
+	LONG $0x4411fcc5; WORD $0x601a             // vmovups      %ymm0, $96(%rdx,%rbx)
+	QUAD $0x0000801a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $128(%rdx,%rbx)
+	QUAD $0x0000a01a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $160(%rdx,%rbx)
+	QUAD $0x0000c01a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $192(%rdx,%rbx)
+	QUAD $0x0000e01a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $224(%rdx,%rbx)
+	QUAD $0x0001001a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $256(%rdx,%rbx)
+	QUAD $0x0001201a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $288(%rdx,%rbx)
+	QUAD $0x0001401a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $320(%rdx,%rbx)
+	QUAD $0x0001601a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $352(%rdx,%rbx)
+	QUAD $0x0001801a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $384(%rdx,%rbx)
+	QUAD $0x0001a01a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $416(%rdx,%rbx)
+	QUAD $0x0001c01a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $448(%rdx,%rbx)
+	QUAD $0x0001e01a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $480(%rdx,%rbx)
+	LONG $0x00c38148; WORD $0x0002; BYTE $0x00 // addq         $512, %rbx
+	LONG $0xfcc18349                           // addq         $-4, %r9
+	LONG $0xff6c850f; WORD $0xffff             // jne          LBB14_8, $-148(%rip)
+
+LBB14_9:
+	WORD $0x854d; BYTE $0xc0       // testq        %r8, %r8
+	LONG $0x003b840f; WORD $0x0000 // je           LBB14_12, $59(%rip)
+	LONG $0x130c8d4c               // leaq         (%rbx,%rdx), %r9
+	LONG $0x60c18349               // addq         $96, %r9
+	LONG $0x07e0c149               // shlq         $7, %r8
+	WORD $0xdb31                   // xorl         %ebx, %ebx
+	LONG $0xc057f8c5               // vxorps       %xmm0, %xmm0, %xmm0
+	BYTE $0x90                     // .p2align 4, 0x90
+
+LBB14_11:
+	LONG $0x117cc1c4; WORD $0x1944; BYTE $0xa0 // vmovups      %ymm0, $-96(%r9,%rbx)
+	LONG $0x117cc1c4; WORD $0x1944; BYTE $0xc0 // vmovups      %ymm0, $-64(%r9,%rbx)
+	LONG $0x117cc1c4; WORD $0x1944; BYTE $0xe0 // vmovups      %ymm0, $-32(%r9,%rbx)
+	LONG $0x117cc1c4; WORD $0x1904             // vmovups      %ymm0, (%r9,%rbx)
+	LONG $0x80eb8348                           // subq         $-128, %rbx
+	WORD $0x3949; BYTE $0xd8                   // cmpq         %rbx, %r8
+	LONG $0xffd8850f; WORD $0xffff             // jne          LBB14_11, $-40(%rip)
+
+LBB14_12:
+	WORD $0x3949; BYTE $0xca       // cmpq         %rcx, %r10
+	LONG $0x0050840f; WORD $0x0000 // je           LBB14_18, $80(%rip)
+	WORD $0xc1f6; BYTE $0x70       // testb        $112, %cl
+	LONG $0x0036840f; WORD $0x0000 // je           LBB14_17, $54(%rip)
+
+LBB14_14:
+	WORD $0x894c; BYTE $0xd0 // movq         %r10, %rax
+	WORD $0x8949; BYTE $0xca // movq         %rcx, %r10
+	LONG $0xf0e28349         // andq         $-16, %r10
+	LONG $0xc057f8c5         // vxorps       %xmm0, %xmm0, %xmm0
+	QUAD $0x9090909090909090 // .p2align 4, 0x90
+
+LBB14_15:
+	LONG $0x0411f8c5; BYTE $0x02   // vmovups      %xmm0, (%rdx,%rax)
+	LONG $0x10c08348               // addq         $16, %rax
+	WORD $0x3949; BYTE $0xc2       // cmpq         %rax, %r10
+	LONG $0xffee850f; WORD $0xffff // jne          LBB14_15, $-18(%rip)
+	WORD $0x3949; BYTE $0xca       // cmpq         %rcx, %r10
+	LONG $0x0016840f; WORD $0x0000 // je           LBB14_18, $22(%rip)
+	LONG $0x90909090; BYTE $0x90   // .p2align 4, 0x90
+
+LBB14_17:
+	LONG $0x1204c642; BYTE $0x00   // movb         $0, (%rdx,%r10)
+	WORD $0xff49; BYTE $0xc2       // incq         %r10
+	WORD $0x394c; BYTE $0xd1       // cmpq         %r10, %rcx
+	LONG $0xffef850f; WORD $0xffff // jne          LBB14_17, $-17(%rip)
+
+LBB14_18:
+	LONG $0x00c045c7; WORD $0x0000; BYTE $0x00 // movl         $0, $-64(%rbp)
+	QUAD $0x00000000c845c748                   // movq         $0, $-56(%rbp)
+	WORD $0x3145; BYTE $0xc0                   // xorl         %r8d, %r8d
+	WORD $0x3f80; BYTE $0x2d                   // cmpb         $45, (%rdi)
+	LONG $0x001b850f; WORD $0x0000             // jne          LBB14_19, $27(%rip)
+	LONG $0x01c845c7; WORD $0x0000; BYTE $0x00 // movl         $1, $-56(%rbp)
+	LONG $0x0001bd41; WORD $0x0000             // movl         $1, %r13d
+	WORD $0x3949; BYTE $0xf5                   // cmpq         %rsi, %r13
+	LONG $0x00118c0f; WORD $0x0000             // jl           LBB14_22, $17(%rip)
+	LONG $0x0001b5e9; BYTE $0x00               // jmp          LBB14_54, $437(%rip)
+
+LBB14_19:
+	WORD $0x3145; BYTE $0xed       // xorl         %r13d, %r13d
+	WORD $0x3949; BYTE $0xf5       // cmpq         %rsi, %r13
+	LONG $0x01a98d0f; WORD $0x0000 // jge          LBB14_54, $425(%rip)
+
+LBB14_22:
+	WORD $0xb741; BYTE $0x01                   // movb         $1, %r15b
+	WORD $0x3145; BYTE $0xc0                   // xorl         %r8d, %r8d
+	WORD $0x3145; BYTE $0xc9                   // xorl         %r9d, %r9d
+	WORD $0x3145; BYTE $0xe4                   // xorl         %r12d, %r12d
+	WORD $0x3145; BYTE $0xdb                   // xorl         %r11d, %r11d
+	WORD $0xdb31                               // xorl         %ebx, %ebx
+	LONG $0x000027e9; BYTE $0x00               // jmp          LBB14_23, $39(%rip)
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB14_33:
+	LONG $0x000001bb; BYTE $0x00   // movl         $1, %ebx
+	WORD $0x8945; BYTE $0xdc       // movl         %r11d, %r12d
+	WORD $0x2e3c                   // cmpb         $46, %al
+	LONG $0x0095850f; WORD $0x0000 // jne          LBB14_36, $149(%rip)
+
+LBB14_34:
+	WORD $0xff49; BYTE $0xc5       // incq         %r13
+	WORD $0x3949; BYTE $0xf5       // cmpq         %rsi, %r13
+	LONG $0xc79c0f41               // setl         %r15b
+	LONG $0x007c840f; WORD $0x0000 // je           LBB14_35, $124(%rip)
+
+LBB14_23:
+	WORD $0x8941; BYTE $0xda                   // movl         %ebx, %r10d
+	WORD $0x8945; BYTE $0xe6                   // movl         %r12d, %r14d
+	LONG $0x04b60f42; BYTE $0x2f               // movzbl       (%rdi,%r13), %eax
+	WORD $0x588d; BYTE $0xd0                   // leal         $-48(%rax), %ebx
+	WORD $0xfb80; BYTE $0x09                   // cmpb         $9, %bl
+	LONG $0xffc9870f; WORD $0xffff             // ja           LBB14_33, $-55(%rip)
+	WORD $0x303c                               // cmpb         $48, %al
+	LONG $0x0021850f; WORD $0x0000             // jne          LBB14_29, $33(%rip)
+	WORD $0x8545; BYTE $0xdb                   // testl        %r11d, %r11d
+	LONG $0x0043840f; WORD $0x0000             // je           LBB14_26, $67(%rip)
+	WORD $0x6349; BYTE $0xd8                   // movslq       %r8d, %rbx
+	WORD $0x3948; BYTE $0xcb                   // cmpq         %rcx, %rbx
+	LONG $0x0018820f; WORD $0x0000             // jb           LBB14_32, $24(%rip)
+	LONG $0x000019e9; BYTE $0x00               // jmp          LBB14_28, $25(%rip)
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB14_29:
+	WORD $0x6349; BYTE $0xdb       // movslq       %r11d, %rbx
+	WORD $0x3948; BYTE $0xcb       // cmpq         %rcx, %rbx
+	LONG $0x0014830f; WORD $0x0000 // jae          LBB14_30, $20(%rip)
+
+LBB14_32:
+	WORD $0x0488; BYTE $0x1a // movb         %al, (%rdx,%rbx)
+	WORD $0xff41; BYTE $0xc0 // incl         %r8d
+
+LBB14_28:
+	WORD $0x8945; BYTE $0xf4     // movl         %r14d, %r12d
+	WORD $0x8945; BYTE $0xc3     // movl         %r8d, %r11d
+	WORD $0x8944; BYTE $0xd3     // movl         %r10d, %ebx
+	LONG $0xffff90e9; BYTE $0xff // jmp          LBB14_34, $-112(%rip)
+
+LBB14_30:
+	LONG $0x0001b941; WORD $0x0000 // movl         $1, %r9d
+	LONG $0x000006e9; BYTE $0x00   // jmp          LBB14_31, $6(%rip)
+
+LBB14_26:
+	WORD $0xff41; BYTE $0xce // decl         %r14d
+	WORD $0x3145; BYTE $0xdb // xorl         %r11d, %r11d
+
+LBB14_31:
+	WORD $0x8945; BYTE $0xf4     // movl         %r14d, %r12d
+	WORD $0x8944; BYTE $0xd3     // movl         %r10d, %ebx
+	LONG $0xffff74e9; BYTE $0xff // jmp          LBB14_34, $-140(%rip)
+
+LBB14_35:
+	WORD $0x8945; BYTE $0xe6 // movl         %r12d, %r14d
+	WORD $0x8949; BYTE $0xf5 // movq         %rsi, %r13
+	WORD $0x8941; BYTE $0xda // movl         %ebx, %r10d
+
+LBB14_36:
+	LONG $0xc4758944               // movl         %r14d, $-60(%rbp)
+	LONG $0xcc4d8944               // movl         %r9d, $-52(%rbp)
+	LONG $0xc0458944               // movl         %r8d, $-64(%rbp)
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0x0012840f; WORD $0x0000 // je           LBB14_37, $18(%rip)
+	WORD $0x8945; BYTE $0xf0       // movl         %r14d, %r8d
+	LONG $0x01c7f641               // testb        $1, %r15b
+	LONG $0x0013850f; WORD $0x0000 // jne          LBB14_40, $19(%rip)
+	LONG $0x0000c4e9; BYTE $0x00   // jmp          LBB14_55, $196(%rip)
+
+LBB14_37:
+	LONG $0xc4458944               // movl         %r8d, $-60(%rbp)
+	LONG $0x01c7f641               // testb        $1, %r15b
+	LONG $0x00b6840f; WORD $0x0000 // je           LBB14_55, $182(%rip)
+
+LBB14_40:
+	WORD $0x8944; BYTE $0xe8       // movl         %r13d, %eax
+	LONG $0x070cb60f               // movzbl       (%rdi,%rax), %ecx
+	WORD $0xc983; BYTE $0x20       // orl          $32, %ecx
+	WORD $0xf983; BYTE $0x65       // cmpl         $101, %ecx
+	LONG $0x00a3850f; WORD $0x0000 // jne          LBB14_55, $163(%rip)
+	LONG $0x0754b60f; BYTE $0x01   // movzbl       $1(%rdi,%rax), %edx
+	WORD $0xfa83; BYTE $0x2d       // cmpl         $45, %edx
+	LONG $0x0017840f; WORD $0x0000 // je           LBB14_45, $23(%rip)
+	LONG $0x000001b9; BYTE $0x00   // movl         $1, %ecx
+	WORD $0xfa83; BYTE $0x2b       // cmpl         $43, %edx
+	LONG $0x0028850f; WORD $0x0000 // jne          LBB14_43, $40(%rip)
+	LONG $0x02c58341               // addl         $2, %r13d
+	LONG $0x000009e9; BYTE $0x00   // jmp          LBB14_46, $9(%rip)
+
+LBB14_45:
+	LONG $0x02c58341             // addl         $2, %r13d
+	LONG $0xffffffb9; BYTE $0xff // movl         $-1, %ecx
+
+LBB14_46:
+	WORD $0x8944; BYTE $0xe8       // movl         %r13d, %eax
+	WORD $0x6348; BYTE $0xd0       // movslq       %eax, %rdx
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0x3948; BYTE $0xf2       // cmpq         %rsi, %rdx
+	LONG $0x00168c0f; WORD $0x0000 // jl           LBB14_48, $22(%rip)
+	LONG $0x000055e9; BYTE $0x00   // jmp          LBB14_53, $85(%rip)
+
+LBB14_43:
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x6348; BYTE $0xd0       // movslq       %eax, %rdx
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0x3948; BYTE $0xf2       // cmpq         %rsi, %rdx
+	LONG $0x00448d0f; WORD $0x0000 // jge          LBB14_53, $68(%rip)
+
+LBB14_48:
+	WORD $0xc031                               // xorl         %eax, %eax
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+LBB14_49:
+	LONG $0x171cbe0f               // movsbl       (%rdi,%rdx), %ebx
+	WORD $0xfb83; BYTE $0x30       // cmpl         $48, %ebx
+	LONG $0x00298c0f; WORD $0x0000 // jl           LBB14_53, $41(%rip)
+	WORD $0xfb80; BYTE $0x39       // cmpb         $57, %bl
+	LONG $0x0020870f; WORD $0x0000 // ja           LBB14_53, $32(%rip)
+	LONG $0x00270f3d; BYTE $0x00   // cmpl         $9999, %eax
+	LONG $0x00158f0f; WORD $0x0000 // jg           LBB14_53, $21(%rip)
+	WORD $0x048d; BYTE $0x80       // leal         (%rax,%rax,4), %eax
+	WORD $0x048d; BYTE $0x43       // leal         (%rbx,%rax,2), %eax
+	WORD $0xc083; BYTE $0xd0       // addl         $-48, %eax
+	WORD $0xff48; BYTE $0xc2       // incq         %rdx
+	WORD $0x3948; BYTE $0xd6       // cmpq         %rdx, %rsi
+	LONG $0xffca850f; WORD $0xffff // jne          LBB14_49, $-54(%rip)
+
+LBB14_53:
+	WORD $0xaf0f; BYTE $0xc1 // imull        %ecx, %eax
+	WORD $0x0141; BYTE $0xc0 // addl         %eax, %r8d
+
+LBB14_54:
+	LONG $0xc4458944 // movl         %r8d, $-60(%rbp)
+
+LBB14_55:
+	LONG $0xb07d8d48                           // leaq         $-80(%rbp), %rdi
+	LONG $0xd0758d48                           // leaq         $-48(%rbp), %rsi
+	WORD $0xf8c5; BYTE $0x77                   // vzeroupper
+	LONG $0xfff4b0e8; BYTE $0xff               // callq        _decimal_to_f64, $-2896(%rip)
+	LONG $0x4510fbc5; BYTE $0xd0               // vmovsd       $-48(%rbp), %xmm0
+	LONG $0x28c48348                           // addq         $40, %rsp
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5c41                               // popq         %r12
+	WORD $0x5d41                               // popq         %r13
+	WORD $0x5e41                               // popq         %r14
+	WORD $0x5f41                               // popq         %r15
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+_value:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x28ec8348                           // subq         $40, %rsp
+	WORD $0x894d; BYTE $0xc7                   // movq         %r8, %r15
+	WORD $0x8949; BYTE $0xce                   // movq         %rcx, %r14
+	WORD $0x8948; BYTE $0xf3                   // movq         %rsi, %rbx
+	WORD $0x8949; BYTE $0xfc                   // movq         %rdi, %r12
+	LONG $0xd0558948                           // movq         %rdx, $-48(%rbp)
+	LONG $0xb07d8948                           // movq         %rdi, $-80(%rbp)
+	LONG $0xb8758948                           // movq         %rsi, $-72(%rbp)
+	LONG $0xd0558d48                           // leaq         $-48(%rbp), %rdx
+	LONG $0x0005eee8; BYTE $0x00               // callq        _advance_ns, $1518(%rip)
+	WORD $0xbe0f; BYTE $0xc0                   // movsbl       %al, %eax
+	WORD $0xf883; BYTE $0x7d                   // cmpl         $125, %eax
+	LONG $0x00bc870f; WORD $0x0000             // ja           LBB15_11, $188(%rip)
+	LONG $0x9f0d8d48; WORD $0x0003; BYTE $0x00 // leaq         $927(%rip), %rcx  /* LJTI15_0(%rip) */
+	LONG $0x81046348                           // movslq       (%rcx,%rax,4), %rax
+	WORD $0x0148; BYTE $0xc8                   // addq         %rcx, %rax
+	JMP  AX
+
+LBB15_2:
+	LONG $0xc875894c               // movq         %r14, $-56(%rbp)
+	LONG $0xd0758b4c               // movq         $-48(%rbp), %r14
+	LONG $0xff6e8d4d               // leaq         $-1(%r14), %r13
+	LONG $0xd06d894c               // movq         %r13, $-48(%rbp)
+	LONG $0x02c7f641               // testb        $2, %r15b
+	LONG $0x001a850f; WORD $0x0000 // jne          LBB15_4, $26(%rip)
+	LONG $0xb07d8d48               // leaq         $-80(%rbp), %rdi
+	LONG $0xd0758d48               // leaq         $-48(%rbp), %rsi
+	LONG $0xc8558b48               // movq         $-56(%rbp), %rdx
+	LONG $0x000dc7e8; BYTE $0x00   // callq        _vnumber, $3527(%rip)
+	LONG $0xd07d8b4c               // movq         $-48(%rbp), %r15
+	LONG $0x00034de9; BYTE $0x00   // jmp          LBB15_58, $845(%rip)
+
+LBB15_4:
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x2c3c8043; BYTE $0x2d   // cmpb         $45, (%r12,%r13)
+	LONG $0x2c3c8d4f               // leaq         (%r12,%r13), %r15
+	WORD $0x940f; BYTE $0xc0       // sete         %al
+	WORD $0x0149; BYTE $0xc7       // addq         %rax, %r15
+	WORD $0x2948; BYTE $0xc3       // subq         %rax, %rbx
+	LONG $0x030c840f; WORD $0x0000 // je           LBB15_53, $780(%rip)
+	WORD $0x3949; BYTE $0xdd       // cmpq         %rbx, %r13
+	LONG $0x000e830f; WORD $0x0000 // jae          LBB15_7, $14(%rip)
+	LONG $0x07b60f41               // movzbl       (%r15), %eax
+	WORD $0xc604                   // addb         $-58, %al
+	WORD $0xf63c                   // cmpb         $-10, %al
+	LONG $0x0307820f; WORD $0x0000 // jb           LBB15_55, $775(%rip)
+
+LBB15_7:
+	WORD $0x894c; BYTE $0xff                   // movq         %r15, %rdi
+	WORD $0x8948; BYTE $0xde                   // movq         %rbx, %rsi
+	LONG $0x001f22e8; BYTE $0x00               // callq        _do_skip_number, $7970(%rip)
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0x02ed880f; WORD $0x0000             // js           LBB15_54, $749(%rip)
+	WORD $0x0149; BYTE $0xc7                   // addq         %rax, %r15
+	WORD $0x294d; BYTE $0xe7                   // subq         %r12, %r15
+	WORD $0x854d; BYTE $0xf6                   // testq        %r14, %r14
+	LONG $0x02f28e0f; WORD $0x0000             // jle          LBB15_57, $754(%rip)
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	LONG $0x0800c748; WORD $0x0000; BYTE $0x00 // movq         $8, (%rax)
+	LONG $0x1868894c                           // movq         %r13, $24(%rax)
+	LONG $0x0002e5e9; BYTE $0x00               // jmp          LBB15_58, $741(%rip)
+
+LBB15_10:
+	LONG $0x0106c749; WORD $0x0000; BYTE $0x00 // movq         $1, (%r14)
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0x0002d5e9; BYTE $0x00               // jmp          LBB15_58, $725(%rip)
+
+LBB15_11:
+	LONG $0xfe06c749; WORD $0xffff; BYTE $0xff // movq         $-2, (%r14)
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	WORD $0xff49; BYTE $0xcf                   // decq         %r15
+	LONG $0x0002c2e9; BYTE $0x00               // jmp          LBB15_58, $706(%rip)
+
+LBB15_12:
+	QUAD $0xffffffffc045c748                   // movq         $-1, $-64(%rbp)
+	LONG $0xd0658b4c                           // movq         $-48(%rbp), %r12
+	LONG $0xb07d8d48                           // leaq         $-80(%rbp), %rdi
+	LONG $0xc0558d48                           // leaq         $-64(%rbp), %rdx
+	WORD $0x894c; BYTE $0xe6                   // movq         %r12, %rsi
+	WORD $0x894c; BYTE $0xf9                   // movq         %r15, %rcx
+	LONG $0x000814e8; BYTE $0x00               // callq        _advance_string, $2068(%rip)
+	WORD $0x8949; BYTE $0xc7                   // movq         %rax, %r15
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0x0174880f; WORD $0x0000             // js           LBB15_32, $372(%rip)
+	LONG $0xd07d894c                           // movq         %r15, $-48(%rbp)
+	LONG $0x1066894d                           // movq         %r12, $16(%r14)
+	LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq         $7, (%r14)
+	LONG $0xc0458b48                           // movq         $-64(%rbp), %rax
+	WORD $0x394c; BYTE $0xf8                   // cmpq         %r15, %rax
+	LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rcx
+	LONG $0xc84c0f48                           // cmovlq       %rax, %rcx
+	LONG $0x184e8949                           // movq         %rcx, $24(%r14)
+	LONG $0x00026de9; BYTE $0x00               // jmp          LBB15_58, $621(%rip)
+
+LBB15_14:
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl        $-2147483648, %r15d
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0x00000bba; BYTE $0x00               // movl         $11, %edx
+	LONG $0x00011ae9; BYTE $0x00               // jmp          LBB15_31, $282(%rip)
+
+LBB15_15:
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl        $-2147483648, %r15d
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0x00000aba; BYTE $0x00               // movl         $10, %edx
+	LONG $0x000100e9; BYTE $0x00               // jmp          LBB15_31, $256(%rip)
+
+LBB15_16:
+	LONG $0x0506c749; WORD $0x0000; BYTE $0x00 // movq         $5, (%r14)
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0x000229e9; BYTE $0x00               // jmp          LBB15_58, $553(%rip)
+
+LBB15_17:
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl        $-2147483648, %r15d
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0x00000cba; BYTE $0x00               // movl         $12, %edx
+	LONG $0x0000d6e9; BYTE $0x00               // jmp          LBB15_31, $214(%rip)
+
+LBB15_18:
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0xfc4b8d48                           // leaq         $-4(%rbx), %rcx
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x3949; BYTE $0xcf                   // cmpq         %rcx, %r15
+	LONG $0x008a870f; WORD $0x0000             // ja           LBB15_25, $138(%rip)
+	LONG $0x3c0c8b43                           // movl         (%r12,%r15), %ecx
+	LONG $0x6c61f981; WORD $0x6573             // cmpl         $1702063201, %ecx
+	LONG $0x00d3850f; WORD $0x0000             // jne          LBB15_33, $211(%rip)
+	LONG $0x04c78349                           // addq         $4, %r15
+	LONG $0x000004b8; BYTE $0x00               // movl         $4, %eax
+	LONG $0x000069e9; BYTE $0x00               // jmp          LBB15_24, $105(%rip)
+
+LBB15_21:
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0xfd4b8d48                           // leaq         $-3(%rbx), %rcx
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x3949; BYTE $0xcf                   // cmpq         %rcx, %r15
+	LONG $0x0054870f; WORD $0x0000             // ja           LBB15_25, $84(%rip)
+	LONG $0x3c4c8b43; BYTE $0xff               // movl         $-1(%r12,%r15), %ecx
+	LONG $0x756ef981; WORD $0x6c6c             // cmpl         $1819047278, %ecx
+	LONG $0x00db850f; WORD $0x0000             // jne          LBB15_37, $219(%rip)
+	LONG $0x03c78349                           // addq         $3, %r15
+	LONG $0x000002b8; BYTE $0x00               // movl         $2, %eax
+	LONG $0x000032e9; BYTE $0x00               // jmp          LBB15_24, $50(%rip)
+
+LBB15_26:
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0xfd4b8d48                           // leaq         $-3(%rbx), %rcx
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x3949; BYTE $0xcf                   // cmpq         %rcx, %r15
+	LONG $0x001d870f; WORD $0x0000             // ja           LBB15_25, $29(%rip)
+	LONG $0x3c4c8b43; BYTE $0xff               // movl         $-1(%r12,%r15), %ecx
+	LONG $0x7274f981; WORD $0x6575             // cmpl         $1702195828, %ecx
+	LONG $0x00e2850f; WORD $0x0000             // jne          LBB15_41, $226(%rip)
+	LONG $0x03c78349                           // addq         $3, %r15
+	LONG $0x000003b8; BYTE $0x00               // movl         $3, %eax
+
+LBB15_24:
+	WORD $0x894c; BYTE $0xfb // movq         %r15, %rbx
+
+LBB15_25:
+	LONG $0xd05d8948             // movq         %rbx, $-48(%rbp)
+	WORD $0x8949; BYTE $0xdf     // movq         %rbx, %r15
+	WORD $0x8949; BYTE $0x06     // movq         %rax, (%r14)
+	LONG $0x00015ee9; BYTE $0x00 // jmp          LBB15_58, $350(%rip)
+
+LBB15_29:
+	LONG $0x0606c749; WORD $0x0000; BYTE $0x00 // movq         $6, (%r14)
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0x00014ee9; BYTE $0x00               // jmp          LBB15_58, $334(%rip)
+
+LBB15_30:
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl        $-2147483648, %r15d
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0x00000dba; BYTE $0x00               // movl         $13, %edx
+
+LBB15_31:
+	LONG $0xd1440f48             // cmoveq       %rcx, %rdx
+	WORD $0x940f; BYTE $0xc0     // sete         %al
+	WORD $0x8949; BYTE $0x16     // movq         %rdx, (%r14)
+	LONG $0xd07d8b4c             // movq         $-48(%rbp), %r15
+	WORD $0x2949; BYTE $0xc7     // subq         %rax, %r15
+	LONG $0x000123e9; BYTE $0x00 // jmp          LBB15_58, $291(%rip)
+
+LBB15_32:
+	LONG $0xd05d8948             // movq         %rbx, $-48(%rbp)
+	WORD $0x894d; BYTE $0x3e     // movq         %r15, (%r14)
+	WORD $0x8949; BYTE $0xdf     // movq         %rbx, %r15
+	LONG $0x000114e9; BYTE $0x00 // jmp          LBB15_58, $276(%rip)
+
+LBB15_33:
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	WORD $0xf980; BYTE $0x61                   // cmpb         $97, %cl
+	LONG $0x00d5850f; WORD $0x0000             // jne          LBB15_49, $213(%rip)
+	LONG $0x3c7c8043; WORD $0x6c01             // cmpb         $108, $1(%r12,%r15)
+	LONG $0x00aa850f; WORD $0x0000             // jne          LBB15_46, $170(%rip)
+	LONG $0x3c7c8043; WORD $0x7302             // cmpb         $115, $2(%r12,%r15)
+	LONG $0x00b5850f; WORD $0x0000             // jne          LBB15_47, $181(%rip)
+	LONG $0x044f8d49                           // leaq         $4(%r15), %rcx
+	LONG $0x3c7c8043; WORD $0x6503             // cmpb         $101, $3(%r12,%r15)
+	LONG $0x037f8d4d                           // leaq         $3(%r15), %r15
+	LONG $0xf9440f4c                           // cmoveq       %rcx, %r15
+	LONG $0x0000a2e9; BYTE $0x00               // jmp          LBB15_48, $162(%rip)
+
+LBB15_37:
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	WORD $0xf980; BYTE $0x6e                   // cmpb         $110, %cl
+	LONG $0x006c850f; WORD $0x0000             // jne          LBB15_45, $108(%rip)
+	LONG $0x3c3c8043; BYTE $0x75               // cmpb         $117, (%r12,%r15)
+	LONG $0x0077850f; WORD $0x0000             // jne          LBB15_51, $119(%rip)
+	LONG $0x3c7c8043; WORD $0x6c01             // cmpb         $108, $1(%r12,%r15)
+	LONG $0x0068850f; WORD $0x0000             // jne          LBB15_50, $104(%rip)
+	LONG $0x034f8d49                           // leaq         $3(%r15), %rcx
+	LONG $0x3c7c8043; WORD $0x6c02             // cmpb         $108, $2(%r12,%r15)
+	LONG $0x027f8d4d                           // leaq         $2(%r15), %r15
+	LONG $0xf9440f4c                           // cmoveq       %rcx, %r15
+	LONG $0x000054e9; BYTE $0x00               // jmp          LBB15_51, $84(%rip)
+
+LBB15_41:
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	WORD $0xf980; BYTE $0x74                   // cmpb         $116, %cl
+	LONG $0x002e850f; WORD $0x0000             // jne          LBB15_45, $46(%rip)
+	LONG $0x3c3c8043; BYTE $0x72               // cmpb         $114, (%r12,%r15)
+	LONG $0x0039850f; WORD $0x0000             // jne          LBB15_51, $57(%rip)
+	LONG $0x3c7c8043; WORD $0x7501             // cmpb         $117, $1(%r12,%r15)
+	LONG $0x002a850f; WORD $0x0000             // jne          LBB15_50, $42(%rip)
+	LONG $0x034f8d49                           // leaq         $3(%r15), %rcx
+	LONG $0x3c7c8043; WORD $0x6502             // cmpb         $101, $2(%r12,%r15)
+	LONG $0x027f8d4d                           // leaq         $2(%r15), %r15
+	LONG $0xf9440f4c                           // cmoveq       %rcx, %r15
+	LONG $0x000016e9; BYTE $0x00               // jmp          LBB15_51, $22(%rip)
+
+LBB15_45:
+	WORD $0xff49; BYTE $0xcf     // decq         %r15
+	WORD $0x8949; BYTE $0x06     // movq         %rax, (%r14)
+	LONG $0x00004ee9; BYTE $0x00 // jmp          LBB15_58, $78(%rip)
+
+LBB15_46:
+	WORD $0xff49; BYTE $0xc7     // incq         %r15
+	LONG $0x000013e9; BYTE $0x00 // jmp          LBB15_48, $19(%rip)
+
+LBB15_50:
+	WORD $0xff49; BYTE $0xc7 // incq         %r15
+
+LBB15_51:
+	LONG $0xd07d894c             // movq         %r15, $-48(%rbp)
+	WORD $0x8949; BYTE $0x06     // movq         %rax, (%r14)
+	LONG $0x000037e9; BYTE $0x00 // jmp          LBB15_58, $55(%rip)
+
+LBB15_47:
+	LONG $0x02c78349 // addq         $2, %r15
+
+LBB15_48:
+	LONG $0xd07d894c // movq         %r15, $-48(%rbp)
+
+LBB15_49:
+	WORD $0x8949; BYTE $0x06     // movq         %rax, (%r14)
+	LONG $0x000027e9; BYTE $0x00 // jmp          LBB15_58, $39(%rip)
+
+LBB15_53:
+	LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r13
+	LONG $0x00000de9; BYTE $0x00               // jmp          LBB15_56, $13(%rip)
+
+LBB15_54:
+	WORD $0xf748; BYTE $0xd0 // notq         %rax
+	WORD $0x0149; BYTE $0xc7 // addq         %rax, %r15
+
+LBB15_55:
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+
+LBB15_56:
+	WORD $0x294d; BYTE $0xe7 // subq         %r12, %r15
+	LONG $0xd07d894c         // movq         %r15, $-48(%rbp)
+
+LBB15_57:
+	LONG $0xc8458b48         // movq         $-56(%rbp), %rax
+	WORD $0x894c; BYTE $0x28 // movq         %r13, (%rax)
+
+LBB15_58:
+	WORD $0x894c; BYTE $0xf8 // movq         %r15, %rax
+	LONG $0x28c48348         // addq         $40, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+	WORD $0x9090; BYTE $0x90 // .p2align 2, 0x90
+
+	// .set L15_0_set_10, LBB15_10-LJTI15_0
+	// .set L15_0_set_11, LBB15_11-LJTI15_0
+	// .set L15_0_set_12, LBB15_12-LJTI15_0
+	// .set L15_0_set_14, LBB15_14-LJTI15_0
+	// .set L15_0_set_2, LBB15_2-LJTI15_0
+	// .set L15_0_set_15, LBB15_15-LJTI15_0
+	// .set L15_0_set_16, LBB15_16-LJTI15_0
+	// .set L15_0_set_17, LBB15_17-LJTI15_0
+	// .set L15_0_set_18, LBB15_18-LJTI15_0
+	// .set L15_0_set_21, LBB15_21-LJTI15_0
+	// .set L15_0_set_26, LBB15_26-LJTI15_0
+	// .set L15_0_set_29, LBB15_29-LJTI15_0
+	// .set L15_0_set_30, LBB15_30-LJTI15_0
+LJTI15_0:
+	LONG $0xfffffd06 // .long L15_0_set_10
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd29 // .long L15_0_set_12
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd7e // .long L15_0_set_14
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffd98 // .long L15_0_set_15
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffdb2 // .long L15_0_set_16
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffdc2 // .long L15_0_set_17
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffddc // .long L15_0_set_18
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffe12 // .long L15_0_set_21
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffe49 // .long L15_0_set_26
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffe8d // .long L15_0_set_29
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffe9d // .long L15_0_set_30
+	LONG $0x00000000 // .p2align 4, 0x00
+
+LCPI16_0:
+	QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, '                '
+
+LCPI16_1:
+	QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'
+
+LCPI16_2:
+	QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n'
+
+LCPI16_3:
+	QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r'
+
+	// .p2align 4, 0x90
+_advance_ns:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x8b4c; BYTE $0x02       // movq         (%rdx), %r8
+	WORD $0x3949; BYTE $0xf0       // cmpq         %rsi, %r8
+	LONG $0x0029830f; WORD $0x0000 // jae          LBB16_6, $41(%rip)
+	LONG $0x04b60f42; BYTE $0x07   // movzbl       (%rdi,%r8), %eax
+	WORD $0xf883; BYTE $0x0d       // cmpl         $13, %eax
+	LONG $0x001b840f; WORD $0x0000 // je           LBB16_6, $27(%rip)
+	WORD $0xf883; BYTE $0x20       // cmpl         $32, %eax
+	LONG $0x0012840f; WORD $0x0000 // je           LBB16_6, $18(%rip)
+	WORD $0xf504                   // addb         $-11, %al
+	WORD $0xfe3c                   // cmpb         $-2, %al
+	LONG $0x0008830f; WORD $0x0000 // jae          LBB16_6, $8(%rip)
+	WORD $0x894c; BYTE $0xc0       // movq         %r8, %rax
+	LONG $0x000207e9; BYTE $0x00   // jmp          LBB16_5, $519(%rip)
+
+LBB16_6:
+	LONG $0x01408d49               // leaq         $1(%r8), %rax
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0x0022830f; WORD $0x0000 // jae          LBB16_10, $34(%rip)
+	LONG $0x070cb60f               // movzbl       (%rdi,%rax), %ecx
+	WORD $0xf983; BYTE $0x0d       // cmpl         $13, %ecx
+	LONG $0x0015840f; WORD $0x0000 // je           LBB16_10, $21(%rip)
+	WORD $0xf983; BYTE $0x20       // cmpl         $32, %ecx
+	LONG $0x000c840f; WORD $0x0000 // je           LBB16_10, $12(%rip)
+	WORD $0xc180; BYTE $0xf5       // addb         $-11, %cl
+	WORD $0xf980; BYTE $0xfe       // cmpb         $-2, %cl
+	LONG $0x01d8820f; WORD $0x0000 // jb           LBB16_5, $472(%rip)
+
+LBB16_10:
+	LONG $0x02408d49               // leaq         $2(%r8), %rax
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0x0022830f; WORD $0x0000 // jae          LBB16_14, $34(%rip)
+	LONG $0x070cb60f               // movzbl       (%rdi,%rax), %ecx
+	WORD $0xf983; BYTE $0x0d       // cmpl         $13, %ecx
+	LONG $0x0015840f; WORD $0x0000 // je           LBB16_14, $21(%rip)
+	WORD $0xf983; BYTE $0x20       // cmpl         $32, %ecx
+	LONG $0x000c840f; WORD $0x0000 // je           LBB16_14, $12(%rip)
+	WORD $0xc180; BYTE $0xf5       // addb         $-11, %cl
+	WORD $0xf980; BYTE $0xfe       // cmpb         $-2, %cl
+	LONG $0x01a9820f; WORD $0x0000 // jb           LBB16_5, $425(%rip)
+
+LBB16_14:
+	LONG $0x03408d49               // leaq         $3(%r8), %rax
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0x0022830f; WORD $0x0000 // jae          LBB16_18, $34(%rip)
+	LONG $0x070cb60f               // movzbl       (%rdi,%rax), %ecx
+	WORD $0xf983; BYTE $0x0d       // cmpl         $13, %ecx
+	LONG $0x0015840f; WORD $0x0000 // je           LBB16_18, $21(%rip)
+	WORD $0xf983; BYTE $0x20       // cmpl         $32, %ecx
+	LONG $0x000c840f; WORD $0x0000 // je           LBB16_18, $12(%rip)
+	WORD $0xc180; BYTE $0xf5       // addb         $-11, %cl
+	WORD $0xf980; BYTE $0xfe       // cmpb         $-2, %cl
+	LONG $0x017a820f; WORD $0x0000 // jb           LBB16_5, $378(%rip)
+
+LBB16_18:
+	LONG $0x04c08349                                         // addq         $4, %r8
+	WORD $0x3949; BYTE $0xf0                                 // cmpq         %rsi, %r8
+	LONG $0x014d830f; WORD $0x0000                           // jae          LBB16_19, $333(%rip)
+	LONG $0x070c8d4e                                         // leaq         (%rdi,%r8), %r9
+	WORD $0x8949; BYTE $0xf3                                 // movq         %rsi, %r11
+	WORD $0x294d; BYTE $0xc3                                 // subq         %r8, %r11
+	LONG $0x0073840f; WORD $0x0000                           // je           LBB16_27, $115(%rip)
+	WORD $0x8944; BYTE $0xc8                                 // movl         %r9d, %eax
+	WORD $0xe083; BYTE $0x0f                                 // andl         $15, %eax
+	LONG $0x0067840f; WORD $0x0000                           // je           LBB16_27, $103(%rip)
+	LONG $0x0005ba41; WORD $0x0000                           // movl         $5, %r10d
+	WORD $0x2949; BYTE $0xf2                                 // subq         %rsi, %r10
+	QUAD $0x000100002600b949; WORD $0x0000                   // movabsq      $4294977024, %r9
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB16_23:
+	LONG $0x0cbe0f42; BYTE $0x07   // movsbl       (%rdi,%r8), %ecx
+	WORD $0xf983; BYTE $0x20       // cmpl         $32, %ecx
+	LONG $0x0116870f; WORD $0x0000 // ja           LBB16_42, $278(%rip)
+	LONG $0xc9a30f49               // btq          %rcx, %r9
+	LONG $0x010c830f; WORD $0x0000 // jae          LBB16_42, $268(%rip)
+	LONG $0x02048d4b               // leaq         (%r10,%r8), %rax
+	LONG $0x01488d49               // leaq         $1(%r8), %rcx
+	LONG $0x04f88348               // cmpq         $4, %rax
+	LONG $0x0012840f; WORD $0x0000 // je           LBB16_26, $18(%rip)
+	LONG $0x07048d42               // leal         (%rdi,%r8), %eax
+	WORD $0xc0ff                   // incl         %eax
+	WORD $0x8949; BYTE $0xc8       // movq         %rcx, %r8
+	WORD $0xe083; BYTE $0x0f       // andl         $15, %eax
+	LONG $0xffc4850f; WORD $0xffff // jne          LBB16_23, $-60(%rip)
+
+LBB16_26:
+	LONG $0x0f0c8d4c         // leaq         (%rdi,%rcx), %r9
+	WORD $0x8949; BYTE $0xf3 // movq         %rsi, %r11
+	WORD $0x2949; BYTE $0xcb // subq         %rcx, %r11
+
+LBB16_27:
+	LONG $0x10fb8349                       // cmpq         $16, %r11
+	LONG $0x0075820f; WORD $0x0000         // jb           LBB16_33, $117(%rip)
+	WORD $0x8948; BYTE $0xf9               // movq         %rdi, %rcx
+	WORD $0x294c; BYTE $0xc9               // subq         %r9, %rcx
+	QUAD $0xfffffe52056ff9c5               // vmovdqa      $-430(%rip), %xmm0  /* LCPI16_0(%rip) */
+	QUAD $0xfffffe5a0d6ff9c5               // vmovdqa      $-422(%rip), %xmm1  /* LCPI16_1(%rip) */
+	QUAD $0xfffffe62156ff9c5               // vmovdqa      $-414(%rip), %xmm2  /* LCPI16_2(%rip) */
+	QUAD $0xfffffe6a1d6ff9c5               // vmovdqa      $-406(%rip), %xmm3  /* LCPI16_3(%rip) */
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB16_29:
+	LONG $0x6f79c1c4; BYTE $0x21   // vmovdqa      (%r9), %xmm4
+	LONG $0xe874d9c5               // vpcmpeqb     %xmm0, %xmm4, %xmm5
+	LONG $0xf174d9c5               // vpcmpeqb     %xmm1, %xmm4, %xmm6
+	LONG $0xeeebd1c5               // vpor         %xmm6, %xmm5, %xmm5
+	LONG $0xf274d9c5               // vpcmpeqb     %xmm2, %xmm4, %xmm6
+	LONG $0xe374d9c5               // vpcmpeqb     %xmm3, %xmm4, %xmm4
+	LONG $0xe6ebd9c5               // vpor         %xmm6, %xmm4, %xmm4
+	LONG $0xe5ebd9c5               // vpor         %xmm5, %xmm4, %xmm4
+	LONG $0xc4d7f9c5               // vpmovmskb    %xmm4, %eax
+	LONG $0xfff88366               // cmpw         $-1, %ax
+	LONG $0x0069850f; WORD $0x0000 // jne          LBB16_30, $105(%rip)
+	LONG $0x10c18349               // addq         $16, %r9
+	LONG $0xf0c38349               // addq         $-16, %r11
+	LONG $0xf0c18348               // addq         $-16, %rcx
+	LONG $0x0ffb8349               // cmpq         $15, %r11
+	LONG $0xffbb870f; WORD $0xffff // ja           LBB16_29, $-69(%rip)
+
+LBB16_33:
+	WORD $0x854d; BYTE $0xdb               // testq        %r11, %r11
+	LONG $0x0037840f; WORD $0x0000         // je           LBB16_40, $55(%rip)
+	LONG $0x19048d4f                       // leaq         (%r9,%r11), %r8
+	WORD $0xc931                           // xorl         %ecx, %ecx
+	QUAD $0x000100002600ba49; WORD $0x0000 // movabsq      $4294977024, %r10
+
+LBB16_35:
+	LONG $0x04be0f41; BYTE $0x09   // movsbl       (%r9,%rcx), %eax
+	WORD $0xf883; BYTE $0x20       // cmpl         $32, %eax
+	LONG $0x005b870f; WORD $0x0000 // ja           LBB16_37, $91(%rip)
+	LONG $0xc2a30f49               // btq          %rax, %r10
+	LONG $0x0051830f; WORD $0x0000 // jae          LBB16_37, $81(%rip)
+	WORD $0xff48; BYTE $0xc1       // incq         %rcx
+	WORD $0x3949; BYTE $0xcb       // cmpq         %rcx, %r11
+	LONG $0xffdc850f; WORD $0xffff // jne          LBB16_35, $-36(%rip)
+	WORD $0x894d; BYTE $0xc1       // movq         %r8, %r9
+
+LBB16_40:
+	WORD $0x2949; BYTE $0xf9 // subq         %rdi, %r9
+
+LBB16_41:
+	WORD $0x894d; BYTE $0xc8     // movq         %r9, %r8
+	LONG $0x000014e9; BYTE $0x00 // jmp          LBB16_42, $20(%rip)
+
+LBB16_19:
+	WORD $0x894c; BYTE $0x02     // movq         %r8, (%rdx)
+	LONG $0x000028e9; BYTE $0x00 // jmp          LBB16_43, $40(%rip)
+
+LBB16_30:
+	WORD $0xb70f; BYTE $0xc0 // movzwl       %ax, %eax
+	WORD $0xd0f7             // notl         %eax
+	LONG $0xc0bc0f44         // bsfl         %eax, %r8d
+	WORD $0x2949; BYTE $0xc8 // subq         %rcx, %r8
+
+LBB16_42:
+	WORD $0x894c; BYTE $0xc0       // movq         %r8, %rax
+	WORD $0x3949; BYTE $0xf0       // cmpq         %rsi, %r8
+	LONG $0x0010830f; WORD $0x0000 // jae          LBB16_43, $16(%rip)
+
+LBB16_5:
+	LONG $0x01488d48         // leaq         $1(%rax), %rcx
+	WORD $0x8948; BYTE $0x0a // movq         %rcx, (%rdx)
+	LONG $0x0704b60f         // movzbl       (%rdi,%rax), %eax
+	WORD $0xbe0f; BYTE $0xc0 // movsbl       %al, %eax
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB16_43:
+	WORD $0xc031             // xorl         %eax, %eax
+	WORD $0xbe0f; BYTE $0xc0 // movsbl       %al, %eax
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB16_37:
+	WORD $0x2949; BYTE $0xf9                                 // subq         %rdi, %r9
+	WORD $0x0149; BYTE $0xc9                                 // addq         %rcx, %r9
+	LONG $0xffffb6e9; BYTE $0xff                             // jmp          LBB16_41, $-74(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+_vstring:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x10ec8348                           // subq         $16, %rsp
+	WORD $0x8949; BYTE $0xd6                   // movq         %rdx, %r14
+	WORD $0x8948; BYTE $0xf3                   // movq         %rsi, %rbx
+	WORD $0x8949; BYTE $0xff                   // movq         %rdi, %r15
+	QUAD $0xffffffffd845c748                   // movq         $-1, $-40(%rbp)
+	WORD $0x8b4c; BYTE $0x26                   // movq         (%rsi), %r12
+	LONG $0xd8558d48                           // leaq         $-40(%rbp), %rdx
+	WORD $0x894c; BYTE $0xe6                   // movq         %r12, %rsi
+	LONG $0x000081e8; BYTE $0x00               // callq        _advance_string, $129(%rip)
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0x0029880f; WORD $0x0000             // js           LBB17_1, $41(%rip)
+	WORD $0x8948; BYTE $0x03                   // movq         %rax, (%rbx)
+	LONG $0x1066894d                           // movq         %r12, $16(%r14)
+	LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq         $7, (%r14)
+	LONG $0xd84d8b48                           // movq         $-40(%rbp), %rcx
+	WORD $0x3948; BYTE $0xc1                   // cmpq         %rax, %rcx
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xc14c0f48                           // cmovlq       %rcx, %rax
+	LONG $0x18468949                           // movq         %rax, $24(%r14)
+	LONG $0x00000ae9; BYTE $0x00               // jmp          LBB17_3, $10(%rip)
+
+LBB17_1:
+	LONG $0x084f8b49         // movq         $8(%r15), %rcx
+	WORD $0x8948; BYTE $0x0b // movq         %rcx, (%rbx)
+	WORD $0x8949; BYTE $0x06 // movq         %rax, (%r14)
+
+LBB17_3:
+	LONG $0x10c48348         // addq         $16, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+	QUAD $0x0000000000000000 // .p2align 4, 0x00
+
+LCPI18_0:
+	QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
+
+LCPI18_1:
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+
+LCPI18_2:
+	QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f'
+
+	// .p2align 4, 0x90
+_advance_string:
+	WORD $0xc1f6; BYTE $0x20       // testb        $32, %cl
+	LONG $0x0005850f; WORD $0x0000 // jne          LBB18_2, $5(%rip)
+	LONG $0x004572e9; BYTE $0x00   // jmp          _advance_string_default, $17778(%rip)
+
+LBB18_2:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x18ec8348                           // subq         $24, %rsp
+	LONG $0x087f8b4c                           // movq         $8(%rdi), %r15
+	WORD $0x2949; BYTE $0xf7                   // subq         %rsi, %r15
+	LONG $0x0483840f; WORD $0x0000             // je           LBB18_47, $1155(%rip)
+	WORD $0x8b48; BYTE $0x07                   // movq         (%rdi), %rax
+	LONG $0xd0458948                           // movq         %rax, $-48(%rbp)
+	LONG $0xc0558948                           // movq         %rdx, $-64(%rbp)
+	LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq         $-1, (%rdx)
+	LONG $0x40ff8349                           // cmpq         $64, %r15
+	LONG $0x0390820f; WORD $0x0000             // jb           LBB18_48, $912(%rip)
+	QUAD $0xffffffffc845c748                   // movq         $-1, $-56(%rbp)
+	WORD $0x3145; BYTE $0xf6                   // xorl         %r14d, %r14d
+	QUAD $0xffffff75056ff9c5                   // vmovdqa      $-139(%rip), %xmm0  /* LCPI18_0(%rip) */
+	QUAD $0xffffff7d0d6ff9c5                   // vmovdqa      $-131(%rip), %xmm1  /* LCPI18_1(%rip) */
+	QUAD $0xffffff85156ff9c5                   // vmovdqa      $-123(%rip), %xmm2  /* LCPI18_2(%rip) */
+	LONG $0x90909090; BYTE $0x90               // .p2align 4, 0x90
+
+LBB18_5:
+	LONG $0xd0458b48               // movq         $-48(%rbp), %rax
+	LONG $0x1c6ffac5; BYTE $0x30   // vmovdqu      (%rax,%rsi), %xmm3
+	LONG $0x646ffac5; WORD $0x1030 // vmovdqu      $16(%rax,%rsi), %xmm4
+	LONG $0x6c6ffac5; WORD $0x2030 // vmovdqu      $32(%rax,%rsi), %xmm5
+	LONG $0x746ffac5; WORD $0x3030 // vmovdqu      $48(%rax,%rsi), %xmm6
+	LONG $0xf874e1c5               // vpcmpeqb     %xmm0, %xmm3, %xmm7
+	LONG $0xe7d779c5               // vpmovmskb    %xmm7, %r12d
+	LONG $0xf874d9c5               // vpcmpeqb     %xmm0, %xmm4, %xmm7
+	LONG $0xcfd779c5               // vpmovmskb    %xmm7, %r9d
+	LONG $0xf874d1c5               // vpcmpeqb     %xmm0, %xmm5, %xmm7
+	LONG $0xdfd779c5               // vpmovmskb    %xmm7, %r11d
+	LONG $0xf874c9c5               // vpcmpeqb     %xmm0, %xmm6, %xmm7
+	LONG $0xd7d7f9c5               // vpmovmskb    %xmm7, %edx
+	LONG $0xf974e1c5               // vpcmpeqb     %xmm1, %xmm3, %xmm7
+	LONG $0xefd779c5               // vpmovmskb    %xmm7, %r13d
+	LONG $0xf974d9c5               // vpcmpeqb     %xmm1, %xmm4, %xmm7
+	LONG $0xcfd7f9c5               // vpmovmskb    %xmm7, %ecx
+	LONG $0xf974d1c5               // vpcmpeqb     %xmm1, %xmm5, %xmm7
+	LONG $0xffd7f9c5               // vpmovmskb    %xmm7, %edi
+	LONG $0xf974c9c5               // vpcmpeqb     %xmm1, %xmm6, %xmm7
+	LONG $0xd7d779c5               // vpmovmskb    %xmm7, %r10d
+	LONG $0xfadad9c5               // vpminub      %xmm2, %xmm4, %xmm7
+	LONG $0xe774d9c5               // vpcmpeqb     %xmm7, %xmm4, %xmm4
+	LONG $0xdcd7f9c5               // vpmovmskb    %xmm4, %ebx
+	LONG $0xe2dad1c5               // vpminub      %xmm2, %xmm5, %xmm4
+	LONG $0xe474d1c5               // vpcmpeqb     %xmm4, %xmm5, %xmm4
+	LONG $0xc4d7f9c5               // vpmovmskb    %xmm4, %eax
+	LONG $0xe2dac9c5               // vpminub      %xmm2, %xmm6, %xmm4
+	LONG $0xe474c9c5               // vpcmpeqb     %xmm4, %xmm6, %xmm4
+	LONG $0xc4d779c5               // vpmovmskb    %xmm4, %r8d
+	LONG $0x30e2c148               // shlq         $48, %rdx
+	LONG $0x20e3c149               // shlq         $32, %r11
+	WORD $0x0949; BYTE $0xd3       // orq          %rdx, %r11
+	LONG $0x10e1c149               // shlq         $16, %r9
+	WORD $0x094d; BYTE $0xd9       // orq          %r11, %r9
+	WORD $0x094d; BYTE $0xcc       // orq          %r9, %r12
+	LONG $0x30e2c149               // shlq         $48, %r10
+	LONG $0x20e7c148               // shlq         $32, %rdi
+	WORD $0x094c; BYTE $0xd7       // orq          %r10, %rdi
+	LONG $0x10e1c148               // shlq         $16, %rcx
+	WORD $0x0948; BYTE $0xf9       // orq          %rdi, %rcx
+	LONG $0x30e0c149               // shlq         $48, %r8
+	LONG $0x20e0c148               // shlq         $32, %rax
+	WORD $0x094c; BYTE $0xc0       // orq          %r8, %rax
+	LONG $0x10e3c148               // shlq         $16, %rbx
+	WORD $0x0948; BYTE $0xc3       // orq          %rax, %rbx
+	WORD $0x0949; BYTE $0xcd       // orq          %rcx, %r13
+	LONG $0x0044850f; WORD $0x0000 // jne          LBB18_11, $68(%rip)
+	WORD $0x854d; BYTE $0xf6       // testq        %r14, %r14
+	LONG $0x0058850f; WORD $0x0000 // jne          LBB18_13, $88(%rip)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+
+LBB18_8:
+	LONG $0xe2dae1c5               // vpminub      %xmm2, %xmm3, %xmm4
+	LONG $0xdc74e1c5               // vpcmpeqb     %xmm4, %xmm3, %xmm3
+	LONG $0xc3d7f9c5               // vpmovmskb    %xmm3, %eax
+	WORD $0x0948; BYTE $0xc3       // orq          %rax, %rbx
+	WORD $0x854d; BYTE $0xe4       // testq        %r12, %r12
+	LONG $0x008b850f; WORD $0x0000 // jne          LBB18_14, $139(%rip)
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x00d5850f; WORD $0x0000 // jne          LBB18_20, $213(%rip)
+	LONG $0xc0c78349               // addq         $-64, %r15
+	LONG $0x40c68348               // addq         $64, %rsi
+	LONG $0x3fff8349               // cmpq         $63, %r15
+	LONG $0xff00870f; WORD $0xffff // ja           LBB18_5, $-256(%rip)
+	LONG $0x0000e3e9; BYTE $0x00   // jmp          LBB18_22, $227(%rip)
+
+LBB18_11:
+	LONG $0xc87d8348; BYTE $0xff   // cmpq         $-1, $-56(%rbp)
+	LONG $0x0012850f; WORD $0x0000 // jne          LBB18_13, $18(%rip)
+	LONG $0xcdbc0f49               // bsfq         %r13, %rcx
+	WORD $0x0148; BYTE $0xf1       // addq         %rsi, %rcx
+	LONG $0xc0458b48               // movq         $-64(%rbp), %rax
+	LONG $0xc84d8948               // movq         %rcx, $-56(%rbp)
+	WORD $0x8948; BYTE $0x08       // movq         %rcx, (%rax)
+
+LBB18_13:
+	WORD $0x894c; BYTE $0xf0               // movq         %r14, %rax
+	WORD $0xf748; BYTE $0xd0               // notq         %rax
+	WORD $0x214c; BYTE $0xe8               // andq         %r13, %rax
+	LONG $0x000c8d48                       // leaq         (%rax,%rax), %rcx
+	WORD $0x094c; BYTE $0xf1               // orq          %r14, %rcx
+	WORD $0x8948; BYTE $0xca               // movq         %rcx, %rdx
+	WORD $0xf748; BYTE $0xd2               // notq         %rdx
+	WORD $0x214c; BYTE $0xea               // andq         %r13, %rdx
+	QUAD $0xaaaaaaaaaaaabf48; WORD $0xaaaa // movabsq      $-6148914691236517206, %rdi
+	WORD $0x2148; BYTE $0xfa               // andq         %rdi, %rdx
+	WORD $0x3145; BYTE $0xf6               // xorl         %r14d, %r14d
+	WORD $0x0148; BYTE $0xc2               // addq         %rax, %rdx
+	LONG $0xc6920f41                       // setb         %r14b
+	WORD $0x0148; BYTE $0xd2               // addq         %rdx, %rdx
+	QUAD $0x555555555555b848; WORD $0x5555 // movabsq      $6148914691236517205, %rax
+	WORD $0x3148; BYTE $0xc2               // xorq         %rax, %rdx
+	WORD $0x2148; BYTE $0xca               // andq         %rcx, %rdx
+	WORD $0xf748; BYTE $0xd2               // notq         %rdx
+	WORD $0x2149; BYTE $0xd4               // andq         %rdx, %r12
+	LONG $0xffff5de9; BYTE $0xff           // jmp          LBB18_8, $-163(%rip)
+
+LBB18_14:
+	LONG $0xc4bc0f49               // bsfq         %r12, %rax
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0022840f; WORD $0x0000 // je           LBB18_18, $34(%rip)
+	LONG $0xcbbc0f48               // bsfq         %rbx, %rcx
+	WORD $0x3948; BYTE $0xc1       // cmpq         %rax, %rcx
+	LONG $0x0023820f; WORD $0x0000 // jb           LBB18_19, $35(%rip)
+
+LBB18_16:
+	WORD $0x0148; BYTE $0xf0 // addq         %rsi, %rax
+	WORD $0xff48; BYTE $0xc0 // incq         %rax
+
+LBB18_17:
+	LONG $0x18c48348 // addq         $24, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5d41     // popq         %r13
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB18_18:
+	LONG $0x000040b9; BYTE $0x00   // movl         $64, %ecx
+	WORD $0x3948; BYTE $0xc1       // cmpq         %rax, %rcx
+	LONG $0xffdd830f; WORD $0xffff // jae          LBB18_16, $-35(%rip)
+
+LBB18_19:
+	WORD $0x0148; BYTE $0xf1                   // addq         %rsi, %rcx
+	LONG $0xc0458b48                           // movq         $-64(%rbp), %rax
+	WORD $0x8948; BYTE $0x08                   // movq         %rcx, (%rax)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	LONG $0xffffcde9; BYTE $0xff               // jmp          LBB18_17, $-51(%rip)
+
+LBB18_20:
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	LONG $0xc87d8348; BYTE $0xff               // cmpq         $-1, $-56(%rbp)
+	LONG $0xffbb850f; WORD $0xffff             // jne          LBB18_17, $-69(%rip)
+	LONG $0xcbbc0f48                           // bsfq         %rbx, %rcx
+	WORD $0x0148; BYTE $0xf1                   // addq         %rsi, %rcx
+	LONG $0xc0558b48                           // movq         $-64(%rbp), %rdx
+	WORD $0x8948; BYTE $0x0a                   // movq         %rcx, (%rdx)
+	LONG $0xffffa8e9; BYTE $0xff               // jmp          LBB18_17, $-88(%rip)
+
+LBB18_22:
+	LONG $0xd0750348               // addq         $-48(%rbp), %rsi
+	LONG $0x20ff8349               // cmpq         $32, %r15
+	LONG $0x00d7820f; WORD $0x0000 // jb           LBB18_35, $215(%rip)
+
+LBB18_23:
+	LONG $0x066ffac5               // vmovdqu      (%rsi), %xmm0
+	LONG $0x4e6ffac5; BYTE $0x10   // vmovdqu      $16(%rsi), %xmm1
+	QUAD $0xfffffd59156ff9c5       // vmovdqa      $-679(%rip), %xmm2  /* LCPI18_0(%rip) */
+	LONG $0xda74f9c5               // vpcmpeqb     %xmm2, %xmm0, %xmm3
+	LONG $0xc3d7f9c5               // vpmovmskb    %xmm3, %eax
+	LONG $0xd274f1c5               // vpcmpeqb     %xmm2, %xmm1, %xmm2
+	LONG $0xcad7f9c5               // vpmovmskb    %xmm2, %ecx
+	QUAD $0xfffffd51156ff9c5       // vmovdqa      $-687(%rip), %xmm2  /* LCPI18_1(%rip) */
+	LONG $0xda74f9c5               // vpcmpeqb     %xmm2, %xmm0, %xmm3
+	LONG $0xd3d779c5               // vpmovmskb    %xmm3, %r10d
+	LONG $0xd274f1c5               // vpcmpeqb     %xmm2, %xmm1, %xmm2
+	LONG $0xd2d7f9c5               // vpmovmskb    %xmm2, %edx
+	QUAD $0xfffffd49156ff9c5       // vmovdqa      $-695(%rip), %xmm2  /* LCPI18_2(%rip) */
+	LONG $0xdadaf9c5               // vpminub      %xmm2, %xmm0, %xmm3
+	LONG $0xc374f9c5               // vpcmpeqb     %xmm3, %xmm0, %xmm0
+	LONG $0xc8d779c5               // vpmovmskb    %xmm0, %r9d
+	LONG $0xc2daf1c5               // vpminub      %xmm2, %xmm1, %xmm0
+	LONG $0xc074f1c5               // vpcmpeqb     %xmm0, %xmm1, %xmm0
+	LONG $0xd8d7f9c5               // vpmovmskb    %xmm0, %ebx
+	LONG $0x10e1c148               // shlq         $16, %rcx
+	WORD $0x0948; BYTE $0xc8       // orq          %rcx, %rax
+	LONG $0x10e2c148               // shlq         $16, %rdx
+	LONG $0x10e3c148               // shlq         $16, %rbx
+	WORD $0x0949; BYTE $0xd2       // orq          %rdx, %r10
+	LONG $0x011f850f; WORD $0x0000 // jne          LBB18_49, $287(%rip)
+	WORD $0x854d; BYTE $0xf6       // testq        %r14, %r14
+	LONG $0x013a850f; WORD $0x0000 // jne          LBB18_51, $314(%rip)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+
+LBB18_26:
+	WORD $0x094c; BYTE $0xcb       // orq          %r9, %rbx
+	LONG $0x000040b9; BYTE $0x00   // movl         $64, %ecx
+	LONG $0x000040ba; BYTE $0x00   // movl         $64, %edx
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0004840f; WORD $0x0000 // je           LBB18_28, $4(%rip)
+	LONG $0xd0bc0f48               // bsfq         %rax, %rdx
+
+LBB18_28:
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0004840f; WORD $0x0000 // je           LBB18_30, $4(%rip)
+	LONG $0xcbbc0f48               // bsfq         %rbx, %rcx
+
+LBB18_30:
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0019840f; WORD $0x0000 // je           LBB18_33, $25(%rip)
+	WORD $0x3948; BYTE $0xd1       // cmpq         %rdx, %rcx
+	LONG $0x0135820f; WORD $0x0000 // jb           LBB18_52, $309(%rip)
+	LONG $0xd0752b48               // subq         $-48(%rbp), %rsi
+	LONG $0x16048d48               // leaq         (%rsi,%rdx), %rax
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	LONG $0xfffed4e9; BYTE $0xff   // jmp          LBB18_17, $-300(%rip)
+
+LBB18_33:
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x011c850f; WORD $0x0000 // jne          LBB18_52, $284(%rip)
+	LONG $0x20c68348               // addq         $32, %rsi
+	LONG $0xe0c78349               // addq         $-32, %r15
+
+LBB18_35:
+	WORD $0x854d; BYTE $0xf6                   // testq        %r14, %r14
+	LONG $0x0125850f; WORD $0x0000             // jne          LBB18_54, $293(%rip)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x854d; BYTE $0xff                   // testq        %r15, %r15
+	LONG $0xfeaa840f; WORD $0xffff             // je           LBB18_17, $-342(%rip)
+
+LBB18_37:
+	LONG $0xc07d8b48 // movq         $-64(%rbp), %rdi
+
+LBB18_38:
+	WORD $0xb60f; BYTE $0x0e                   // movzbl       (%rsi), %ecx
+	WORD $0xf983; BYTE $0x22                   // cmpl         $34, %ecx
+	LONG $0x0063840f; WORD $0x0000             // je           LBB18_46, $99(%rip)
+	WORD $0xf983; BYTE $0x5c                   // cmpl         $92, %ecx
+	LONG $0x0026840f; WORD $0x0000             // je           LBB18_43, $38(%rip)
+	WORD $0xf980; BYTE $0x1f                   // cmpb         $31, %cl
+	LONG $0x0143860f; WORD $0x0000             // jbe          LBB18_58, $323(%rip)
+	LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rcx
+	LONG $0x000001ba; BYTE $0x00               // movl         $1, %edx
+
+LBB18_42:
+	WORD $0x0148; BYTE $0xd6       // addq         %rdx, %rsi
+	WORD $0x0149; BYTE $0xcf       // addq         %rcx, %r15
+	LONG $0xffca850f; WORD $0xffff // jne          LBB18_38, $-54(%rip)
+	LONG $0xfffe6be9; BYTE $0xff   // jmp          LBB18_17, $-405(%rip)
+
+LBB18_43:
+	LONG $0x01ff8349                           // cmpq         $1, %r15
+	LONG $0xfe61840f; WORD $0xffff             // je           LBB18_17, $-415(%rip)
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0x000002ba; BYTE $0x00               // movl         $2, %edx
+	LONG $0xc87d8348; BYTE $0xff               // cmpq         $-1, $-56(%rbp)
+	LONG $0xffce850f; WORD $0xffff             // jne          LBB18_42, $-50(%rip)
+	WORD $0x8948; BYTE $0xf3                   // movq         %rsi, %rbx
+	LONG $0xd05d2b48                           // subq         $-48(%rbp), %rbx
+	LONG $0xc85d8948                           // movq         %rbx, $-56(%rbp)
+	WORD $0x8948; BYTE $0x1f                   // movq         %rbx, (%rdi)
+	LONG $0xffffbbe9; BYTE $0xff               // jmp          LBB18_42, $-69(%rip)
+
+LBB18_46:
+	LONG $0xd0752b48             // subq         $-48(%rbp), %rsi
+	WORD $0xff48; BYTE $0xc6     // incq         %rsi
+	WORD $0x8948; BYTE $0xf0     // movq         %rsi, %rax
+	LONG $0xfffe28e9; BYTE $0xff // jmp          LBB18_17, $-472(%rip)
+
+LBB18_48:
+	LONG $0xd0750348               // addq         $-48(%rbp), %rsi
+	QUAD $0xffffffffc845c748       // movq         $-1, $-56(%rbp)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	LONG $0x20ff8349               // cmpq         $32, %r15
+	LONG $0xfe75830f; WORD $0xffff // jae          LBB18_23, $-395(%rip)
+	LONG $0xffff47e9; BYTE $0xff   // jmp          LBB18_35, $-185(%rip)
+
+LBB18_49:
+	LONG $0xc87d8348; BYTE $0xff   // cmpq         $-1, $-56(%rbp)
+	LONG $0x0019850f; WORD $0x0000 // jne          LBB18_51, $25(%rip)
+	WORD $0x8948; BYTE $0xf1       // movq         %rsi, %rcx
+	LONG $0xd04d2b48               // subq         $-48(%rbp), %rcx
+	LONG $0xd2bc0f49               // bsfq         %r10, %rdx
+	WORD $0x0148; BYTE $0xca       // addq         %rcx, %rdx
+	LONG $0xc04d8b48               // movq         $-64(%rbp), %rcx
+	LONG $0xc8558948               // movq         %rdx, $-56(%rbp)
+	WORD $0x8948; BYTE $0x11       // movq         %rdx, (%rcx)
+
+LBB18_51:
+	WORD $0x8944; BYTE $0xf1       // movl         %r14d, %ecx
+	WORD $0xd1f7                   // notl         %ecx
+	WORD $0x2144; BYTE $0xd1       // andl         %r10d, %ecx
+	WORD $0x148d; BYTE $0x09       // leal         (%rcx,%rcx), %edx
+	LONG $0x4e048d45               // leal         (%r14,%rcx,2), %r8d
+	WORD $0xd2f7                   // notl         %edx
+	WORD $0x2144; BYTE $0xd2       // andl         %r10d, %edx
+	LONG $0xaaaae281; WORD $0xaaaa // andl         $-1431655766, %edx
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	WORD $0xca01                   // addl         %ecx, %edx
+	LONG $0xc6920f41               // setb         %r14b
+	WORD $0xd201                   // addl         %edx, %edx
+	LONG $0x5555f281; WORD $0x5555 // xorl         $1431655765, %edx
+	WORD $0x2144; BYTE $0xc2       // andl         %r8d, %edx
+	WORD $0xd2f7                   // notl         %edx
+	WORD $0xd021                   // andl         %edx, %eax
+	LONG $0xfffe92e9; BYTE $0xff   // jmp          LBB18_26, $-366(%rip)
+
+LBB18_52:
+	LONG $0xd0752b48         // subq         $-48(%rbp), %rsi
+	WORD $0x0148; BYTE $0xce // addq         %rcx, %rsi
+
+LBB18_53:
+	LONG $0xc0458b48                           // movq         $-64(%rbp), %rax
+	WORD $0x8948; BYTE $0x30                   // movq         %rsi, (%rax)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	LONG $0xfffd95e9; BYTE $0xff               // jmp          LBB18_17, $-619(%rip)
+
+LBB18_54:
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x003b840f; WORD $0x0000 // je           LBB18_47, $59(%rip)
+	LONG $0xc87d8348; BYTE $0xff   // cmpq         $-1, $-56(%rbp)
+	LONG $0x0015850f; WORD $0x0000 // jne          LBB18_57, $21(%rip)
+	LONG $0xd04d8b48               // movq         $-48(%rbp), %rcx
+	WORD $0xf748; BYTE $0xd1       // notq         %rcx
+	WORD $0x0148; BYTE $0xf1       // addq         %rsi, %rcx
+	LONG $0xc0458b48               // movq         $-64(%rbp), %rax
+	LONG $0xc84d8948               // movq         %rcx, $-56(%rbp)
+	WORD $0x8948; BYTE $0x08       // movq         %rcx, (%rax)
+
+LBB18_57:
+	WORD $0xff48; BYTE $0xc6                   // incq         %rsi
+	WORD $0xff49; BYTE $0xcf                   // decq         %r15
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x854d; BYTE $0xff                   // testq        %r15, %r15
+	LONG $0xfeac850f; WORD $0xffff             // jne          LBB18_37, $-340(%rip)
+	LONG $0xfffd51e9; BYTE $0xff               // jmp          LBB18_17, $-687(%rip)
+
+LBB18_47:
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xfffd45e9; BYTE $0xff               // jmp          LBB18_17, $-699(%rip)
+
+LBB18_58:
+	LONG $0xd0752b48                           // subq         $-48(%rbp), %rsi
+	LONG $0xffff94e9; BYTE $0xff               // jmp          LBB18_53, $-108(%rip)
+	QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00
+
+LCPI19_0:
+	LONG $0x43300000 // .long 1127219200
+	LONG $0x45300000 // .long 1160773632
+	LONG $0x00000000 // .long 0
+	LONG $0x00000000 // .long 0
+
+LCPI19_1:
+	QUAD $0x4330000000000000 // .quad 0x4330000000000000
+	QUAD $0x4530000000000000 // .quad 0x4530000000000000
+
+	// .p2align 3, 0x00
+LCPI19_2:
+	QUAD $0x430c6bf526340000 // .quad 0x430c6bf526340000
+
+LCPI19_3:
+	QUAD $0xc30c6bf526340000 // .quad 0xc30c6bf526340000
+
+	// .p2align 4, 0x90
+_vnumber:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x38ec8348                           // subq         $56, %rsp
+	WORD $0x8948; BYTE $0xd3                   // movq         %rdx, %rbx
+	WORD $0x8949; BYTE $0xf6                   // movq         %rsi, %r14
+	WORD $0x8b48; BYTE $0x06                   // movq         (%rsi), %rax
+	WORD $0x8b4c; BYTE $0x3f                   // movq         (%rdi), %r15
+	LONG $0x086f8b4c                           // movq         $8(%rdi), %r13
+	LONG $0x20528b4c                           // movq         $32(%rdx), %r10
+	LONG $0x285a8b4c                           // movq         $40(%rdx), %r11
+	LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq         $9, (%rdx)
+	LONG $0xc057f9c5                           // vxorpd       %xmm0, %xmm0, %xmm0
+	LONG $0x4211f9c5; BYTE $0x08               // vmovupd      %xmm0, $8(%rdx)
+	WORD $0x8b48; BYTE $0x0e                   // movq         (%rsi), %rcx
+	LONG $0x184a8948                           // movq         %rcx, $24(%rdx)
+	WORD $0x394c; BYTE $0xe8                   // cmpq         %r13, %rax
+	LONG $0x02c9830f; WORD $0x0000             // jae          LBB19_51, $713(%rip)
+	LONG $0x0cb60f41; BYTE $0x07               // movzbl       (%r15,%rax), %ecx
+	LONG $0x000001bf; BYTE $0x00               // movl         $1, %edi
+	WORD $0xf980; BYTE $0x2d                   // cmpb         $45, %cl
+	LONG $0x0016850f; WORD $0x0000             // jne          LBB19_4, $22(%rip)
+	WORD $0xff48; BYTE $0xc0                   // incq         %rax
+	WORD $0x394c; BYTE $0xe8                   // cmpq         %r13, %rax
+	LONG $0x02aa830f; WORD $0x0000             // jae          LBB19_51, $682(%rip)
+	LONG $0x0cb60f41; BYTE $0x07               // movzbl       (%r15,%rax), %ecx
+	LONG $0xffffffbf; BYTE $0xff               // movl         $-1, %edi
+
+LBB19_4:
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB19_6, $15(%rip)
+
+LBB19_5:
+	WORD $0x8949; BYTE $0x06                   // movq         %rax, (%r14)
+	LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq         $-2, (%rbx)
+	LONG $0x00028fe9; BYTE $0x00               // jmp          LBB19_52, $655(%rip)
+
+LBB19_6:
+	WORD $0xf980; BYTE $0x30               // cmpb         $48, %cl
+	LONG $0x0032850f; WORD $0x0000         // jne          LBB19_10, $50(%rip)
+	LONG $0x01488d48                       // leaq         $1(%rax), %rcx
+	WORD $0x394c; BYTE $0xe8               // cmpq         %r13, %rax
+	LONG $0x00a6830f; WORD $0x0000         // jae          LBB19_18, $166(%rip)
+	LONG $0x14b60f41; BYTE $0x0f           // movzbl       (%r15,%rcx), %edx
+	WORD $0xc283; BYTE $0xd2               // addl         $-46, %edx
+	WORD $0xfa83; BYTE $0x37               // cmpl         $55, %edx
+	LONG $0x0095870f; WORD $0x0000         // ja           LBB19_18, $149(%rip)
+	QUAD $0x000000800001be48; WORD $0x0080 // movabsq      $36028797027352577, %rsi
+	LONG $0xd6a30f48                       // btq          %rdx, %rsi
+	LONG $0x0081830f; WORD $0x0000         // jae          LBB19_18, $129(%rip)
+
+LBB19_10:
+	WORD $0x7d89; BYTE $0xd4       // movl         %edi, $-44(%rbp)
+	WORD $0x01b1                   // movb         $1, %cl
+	WORD $0x4d89; BYTE $0xc8       // movl         %ecx, $-56(%rbp)
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	LONG $0x0063830f; WORD $0x0000 // jae          LBB19_17, $99(%rip)
+	WORD $0x3145; BYTE $0xe4       // xorl         %r12d, %r12d
+	LONG $0xffd0b941; WORD $0xffff // movl         $4294967248, %r9d
+	WORD $0x3145; BYTE $0xc0       // xorl         %r8d, %r8d
+	WORD $0xc931                   // xorl         %ecx, %ecx
+	LONG $0x000012e9; BYTE $0x00   // jmp          LBB19_13, $18(%rip)
+	LONG $0x90909090               // .p2align 4, 0x90
+
+LBB19_12:
+	WORD $0xc1ff                   // incl         %ecx
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3949; BYTE $0xc5       // cmpq         %rax, %r13
+	LONG $0x0036840f; WORD $0x0000 // je           LBB19_16, $54(%rip)
+
+LBB19_13:
+	LONG $0x14be0f49; BYTE $0x07   // movsbq       (%r15,%rax), %rdx
+	WORD $0x7a8d; BYTE $0xd0       // leal         $-48(%rdx), %edi
+	LONG $0x09ff8040               // cmpb         $9, %dil
+	LONG $0x0041870f; WORD $0x0000 // ja           LBB19_19, $65(%rip)
+	LONG $0x12f88341               // cmpl         $18, %r8d
+	LONG $0xffd68f0f; WORD $0xffff // jg           LBB19_12, $-42(%rip)
+	LONG $0xa43c8d4b               // leaq         (%r12,%r12,4), %rdi
+	WORD $0x0144; BYTE $0xca       // addl         %r9d, %edx
+	LONG $0x7a248d4c               // leaq         (%rdx,%rdi,2), %r12
+	WORD $0xff41; BYTE $0xc0       // incl         %r8d
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3949; BYTE $0xc5       // cmpq         %rax, %r13
+	LONG $0xffca850f; WORD $0xffff // jne          LBB19_13, $-54(%rip)
+
+LBB19_16:
+	WORD $0x894c; BYTE $0xe8     // movq         %r13, %rax
+	LONG $0x00005be9; BYTE $0x00 // jmp          LBB19_24, $91(%rip)
+
+LBB19_17:
+	WORD $0xc931                 // xorl         %ecx, %ecx
+	WORD $0x3145; BYTE $0xc0     // xorl         %r8d, %r8d
+	WORD $0x3145; BYTE $0xe4     // xorl         %r12d, %r12d
+	LONG $0x00004ee9; BYTE $0x00 // jmp          LBB19_24, $78(%rip)
+
+LBB19_18:
+	WORD $0x8949; BYTE $0x0e     // movq         %rcx, (%r14)
+	LONG $0x0001cbe9; BYTE $0x00 // jmp          LBB19_52, $459(%rip)
+
+LBB19_19:
+	WORD $0xfa80; BYTE $0x2e                   // cmpb         $46, %dl
+	LONG $0x003d850f; WORD $0x0000             // jne          LBB19_24, $61(%rip)
+	LONG $0x01508d48                           // leaq         $1(%rax), %rdx
+	LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq         $8, (%rbx)
+	WORD $0x394c; BYTE $0xea                   // cmpq         %r13, %rdx
+	LONG $0x01a4830f; WORD $0x0000             // jae          LBB19_51, $420(%rip)
+	LONG $0x44b60f41; WORD $0x0107             // movzbl       $1(%r15,%rax), %eax
+	WORD $0xc604                               // addb         $-58, %al
+	WORD $0xf53c                               // cmpb         $-11, %al
+	LONG $0x000f870f; WORD $0x0000             // ja           LBB19_23, $15(%rip)
+	WORD $0x8949; BYTE $0x16                   // movq         %rdx, (%r14)
+	LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq         $-2, (%rbx)
+	LONG $0x00018fe9; BYTE $0x00               // jmp          LBB19_52, $399(%rip)
+
+LBB19_23:
+	LONG $0x00c845c7; WORD $0x0000; BYTE $0x00 // movl         $0, $-56(%rbp)
+	WORD $0x8948; BYTE $0xd0                   // movq         %rdx, %rax
+
+LBB19_24:
+	WORD $0xd231                                       // xorl         %edx, %edx
+	WORD $0xc985                                       // testl        %ecx, %ecx
+	WORD $0x9f0f; BYTE $0xc2                           // setg         %dl
+	WORD $0x5589; BYTE $0xbc                           // movl         %edx, $-68(%rbp)
+	WORD $0x854d; BYTE $0xe4                           // testq        %r12, %r12
+	LONG $0x005d850f; WORD $0x0000                     // jne          LBB19_33, $93(%rip)
+	WORD $0xc985                                       // testl        %ecx, %ecx
+	LONG $0x0055850f; WORD $0x0000                     // jne          LBB19_33, $85(%rip)
+	WORD $0x394c; BYTE $0xe8                           // cmpq         %r13, %rax
+	LONG $0x0044830f; WORD $0x0000                     // jae          LBB19_31, $68(%rip)
+	WORD $0xc689                                       // movl         %eax, %esi
+	WORD $0x2944; BYTE $0xee                           // subl         %r13d, %esi
+	WORD $0x3145; BYTE $0xc0                           // xorl         %r8d, %r8d
+	WORD $0xc931                                       // xorl         %ecx, %ecx
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB19_28:
+	LONG $0x073c8041; BYTE $0x30   // cmpb         $48, (%r15,%rax)
+	LONG $0x0029850f; WORD $0x0000 // jne          LBB19_32, $41(%rip)
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0xc9ff                   // decl         %ecx
+	WORD $0x3949; BYTE $0xc5       // cmpq         %rax, %r13
+	LONG $0xffe7850f; WORD $0xffff // jne          LBB19_28, $-25(%rip)
+	WORD $0x3145; BYTE $0xe4       // xorl         %r12d, %r12d
+	WORD $0x458b; BYTE $0xc8       // movl         $-56(%rbp), %eax
+	WORD $0xc084                   // testb        %al, %al
+	LONG $0x0144850f; WORD $0x0000 // jne          LBB19_54, $324(%rip)
+
+LBB19_59:
+	WORD $0x558b; BYTE $0xd4     // movl         $-44(%rbp), %edx
+	LONG $0x000173e9; BYTE $0x00 // jmp          LBB19_60, $371(%rip)
+
+LBB19_31:
+	WORD $0xc931             // xorl         %ecx, %ecx
+	WORD $0x3145; BYTE $0xc0 // xorl         %r8d, %r8d
+
+LBB19_32:
+	WORD $0x3145; BYTE $0xe4 // xorl         %r12d, %r12d
+
+LBB19_33:
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	LONG $0x004c830f; WORD $0x0000 // jae          LBB19_39, $76(%rip)
+	LONG $0x12f88341               // cmpl         $18, %r8d
+	LONG $0x00428f0f; WORD $0x0000 // jg           LBB19_39, $66(%rip)
+	LONG $0xffd0b941; WORD $0xffff // movl         $4294967248, %r9d
+
+	// .p2align 4, 0x90
+LBB19_36:
+	LONG $0x14b60f41; BYTE $0x07   // movzbl       (%r15,%rax), %edx
+	WORD $0x7a8d; BYTE $0xd0       // leal         $-48(%rdx), %edi
+	LONG $0x09ff8040               // cmpb         $9, %dil
+	LONG $0x002a870f; WORD $0x0000 // ja           LBB19_39, $42(%rip)
+	LONG $0xa43c8d4b               // leaq         (%r12,%r12,4), %rdi
+	WORD $0x0144; BYTE $0xca       // addl         %r9d, %edx
+	LONG $0x7a248d4c               // leaq         (%rdx,%rdi,2), %r12
+	WORD $0xc9ff                   // decl         %ecx
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	LONG $0x0011830f; WORD $0x0000 // jae          LBB19_39, $17(%rip)
+	LONG $0x01508d41               // leal         $1(%r8), %edx
+	LONG $0x12f88341               // cmpl         $18, %r8d
+	WORD $0x8941; BYTE $0xd0       // movl         %edx, %r8d
+	LONG $0xffc48c0f; WORD $0xffff // jl           LBB19_36, $-60(%rip)
+
+LBB19_39:
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	LONG $0x00c6830f; WORD $0x0000 // jae          LBB19_53, $198(%rip)
+	LONG $0x34b60f41; BYTE $0x07   // movzbl       (%r15,%rax), %esi
+	WORD $0x568d; BYTE $0xd0       // leal         $-48(%rsi), %edx
+	WORD $0xfa80; BYTE $0x09       // cmpb         $9, %dl
+	LONG $0x0030870f; WORD $0x0000 // ja           LBB19_45, $48(%rip)
+	LONG $0xff558d49               // leaq         $-1(%r13), %rdx
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB19_42:
+	WORD $0x3948; BYTE $0xc2                   // cmpq         %rax, %rdx
+	LONG $0x0180840f; WORD $0x0000             // je           LBB19_58, $384(%rip)
+	LONG $0x74b60f41; WORD $0x0107             // movzbl       $1(%r15,%rax), %esi
+	WORD $0x7e8d; BYTE $0xd0                   // leal         $-48(%rsi), %edi
+	WORD $0xff48; BYTE $0xc0                   // incq         %rax
+	LONG $0x09ff8040                           // cmpb         $9, %dil
+	LONG $0xffe1860f; WORD $0xffff             // jbe          LBB19_42, $-31(%rip)
+	LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl         $1, $-68(%rbp)
+
+LBB19_45:
+	LONG $0xd6b60f40                           // movzbl       %sil, %edx
+	WORD $0xca83; BYTE $0x20                   // orl          $32, %edx
+	WORD $0xfa83; BYTE $0x65                   // cmpl         $101, %edx
+	LONG $0x0075850f; WORD $0x0000             // jne          LBB19_53, $117(%rip)
+	LONG $0x01788d48                           // leaq         $1(%rax), %rdi
+	LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq         $8, (%rbx)
+	WORD $0x394c; BYTE $0xef                   // cmpq         %r13, %rdi
+	LONG $0x0048830f; WORD $0x0000             // jae          LBB19_51, $72(%rip)
+	LONG $0x34b60f41; BYTE $0x3f               // movzbl       (%r15,%rdi), %esi
+	WORD $0xfe83; BYTE $0x2d                   // cmpl         $45, %esi
+	LONG $0x000f840f; WORD $0x0000             // je           LBB19_49, $15(%rip)
+	LONG $0x0001b841; WORD $0x0000             // movl         $1, %r8d
+	WORD $0xfe83; BYTE $0x2b                   // cmpl         $43, %esi
+	LONG $0x02a8850f; WORD $0x0000             // jne          LBB19_86, $680(%rip)
+
+LBB19_49:
+	LONG $0x02c08348               // addq         $2, %rax
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	WORD $0x558b; BYTE $0xd4       // movl         $-44(%rbp), %edx
+	LONG $0x001b830f; WORD $0x0000 // jae          LBB19_51, $27(%rip)
+	WORD $0xff31                   // xorl         %edi, %edi
+	LONG $0x2bfe8040               // cmpb         $43, %sil
+	LONG $0xc7940f40               // sete         %dil
+	LONG $0x3f048d44               // leal         (%rdi,%rdi), %r8d
+	WORD $0xff41; BYTE $0xc8       // decl         %r8d
+	LONG $0x34b60f41; BYTE $0x07   // movzbl       (%r15,%rax), %esi
+	LONG $0x000283e9; BYTE $0x00   // jmp          LBB19_87, $643(%rip)
+
+LBB19_51:
+	WORD $0x894d; BYTE $0x2e                   // movq         %r13, (%r14)
+	LONG $0xff03c748; WORD $0xffff; BYTE $0xff // movq         $-1, (%rbx)
+
+LBB19_52:
+	LONG $0x38c48348 // addq         $56, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5d41     // popq         %r13
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB19_53:
+	WORD $0xce89                   // movl         %ecx, %esi
+	WORD $0x8949; BYTE $0xc5       // movq         %rax, %r13
+	WORD $0x458b; BYTE $0xc8       // movl         $-56(%rbp), %eax
+	WORD $0xc084                   // testb        %al, %al
+	LONG $0xfebc840f; WORD $0xffff // je           LBB19_59, $-324(%rip)
+
+LBB19_54:
+	WORD $0xf685                           // testl        %esi, %esi
+	WORD $0x558b; BYTE $0xd4               // movl         $-44(%rbp), %edx
+	LONG $0x0025850f; WORD $0x0000         // jne          LBB19_57, $37(%rip)
+	QUAD $0x000000000000b848; WORD $0x8000 // movabsq      $-9223372036854775808, %rax
+	WORD $0x6348; BYTE $0xca               // movslq       %edx, %rcx
+	WORD $0x854d; BYTE $0xe4               // testq        %r12, %r12
+	LONG $0x00e7890f; WORD $0x0000         // jns          LBB19_68, $231(%rip)
+	WORD $0x894c; BYTE $0xe7               // movq         %r12, %rdi
+	WORD $0x2148; BYTE $0xcf               // andq         %rcx, %rdi
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x00d8840f; WORD $0x0000         // je           LBB19_68, $216(%rip)
+
+LBB19_57:
+	LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq         $8, (%rbx)
+
+LBB19_60:
+	LONG $0x6ef9c1c4; BYTE $0xc4               // vmovq        %r12, %xmm0
+	QUAD $0xfffffc510562f9c5                   // vpunpckldq   $-943(%rip), %xmm0, %xmm0  /* LCPI19_0(%rip) */
+	QUAD $0x00000000b045c748                   // movq         $0, $-80(%rbp)
+	QUAD $0xfffffc51055cf9c5                   // vsubpd       $-943(%rip), %xmm0, %xmm0  /* LCPI19_1(%rip) */
+	LONG $0x0579e3c4; WORD $0x01c8             // vpermilpd    $1, %xmm0, %xmm1
+	LONG $0xc058f3c5                           // vaddsd       %xmm0, %xmm1, %xmm0
+	LONG $0x4511fbc5; BYTE $0xc0               // vmovsd       %xmm0, $-64(%rbp)
+	WORD $0x894c; BYTE $0xe0                   // movq         %r12, %rax
+	LONG $0x34e8c148                           // shrq         $52, %rax
+	LONG $0x010d850f; WORD $0x0000             // jne          LBB19_73, $269(%rip)
+	LONG $0x7ef9e1c4; BYTE $0xc1               // vmovq        %xmm0, %rcx
+	WORD $0xd089                               // movl         %edx, %eax
+	WORD $0xe8c1; BYTE $0x1f                   // shrl         $31, %eax
+	LONG $0x3fe0c148                           // shlq         $63, %rax
+	WORD $0x0948; BYTE $0xc8                   // orq          %rcx, %rax
+	LONG $0xc0458948                           // movq         %rax, $-64(%rbp)
+	WORD $0x854d; BYTE $0xe4                   // testq        %r12, %r12
+	LONG $0x018a840f; WORD $0x0000             // je           LBB19_81, $394(%rip)
+	WORD $0xf685                               // testl        %esi, %esi
+	LONG $0x0182840f; WORD $0x0000             // je           LBB19_81, $386(%rip)
+	LONG $0x6ef9e1c4; BYTE $0xc0               // vmovq        %rax, %xmm0
+	WORD $0x468d; BYTE $0xff                   // leal         $-1(%rsi), %eax
+	WORD $0xf883; BYTE $0x24                   // cmpl         $36, %eax
+	LONG $0x0040870f; WORD $0x0000             // ja           LBB19_66, $64(%rip)
+	WORD $0xfe83; BYTE $0x17                   // cmpl         $23, %esi
+	LONG $0x0093820f; WORD $0x0000             // jb           LBB19_69, $147(%rip)
+	WORD $0x468d; BYTE $0xea                   // leal         $-22(%rsi), %eax
+	LONG $0x8b0d8d48; WORD $0x00e1; BYTE $0x00 // leaq         $57739(%rip), %rcx  /* _P10_TAB(%rip) */
+	LONG $0x0459fbc5; BYTE $0xc1               // vmulsd       (%rcx,%rax,8), %xmm0, %xmm0
+	LONG $0x4511fbc5; BYTE $0xc0               // vmovsd       %xmm0, $-64(%rbp)
+	LONG $0x000016b8; BYTE $0x00               // movl         $22, %eax
+	LONG $0x000077e9; BYTE $0x00               // jmp          LBB19_70, $119(%rip)
+
+LBB19_58:
+	LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl         $1, $-68(%rbp)
+	WORD $0xce89                               // movl         %ecx, %esi
+	WORD $0x458b; BYTE $0xc8                   // movl         $-56(%rbp), %eax
+	WORD $0xc084                               // testb        %al, %al
+	LONG $0xff1e850f; WORD $0xffff             // jne          LBB19_54, $-226(%rip)
+	LONG $0xfffdd5e9; BYTE $0xff               // jmp          LBB19_59, $-555(%rip)
+
+LBB19_66:
+	WORD $0xfe83; BYTE $0xea                   // cmpl         $-22, %esi
+	LONG $0x008d820f; WORD $0x0000             // jb           LBB19_73, $141(%rip)
+	WORD $0xdef7                               // negl         %esi
+	LONG $0x4c058d48; WORD $0x00e1; BYTE $0x00 // leaq         $57676(%rip), %rax  /* _P10_TAB(%rip) */
+	LONG $0x045efbc5; BYTE $0xf0               // vdivsd       (%rax,%rsi,8), %xmm0, %xmm0
+	LONG $0x4511fbc5; BYTE $0xc0               // vmovsd       %xmm0, $-64(%rbp)
+	LONG $0x0000d7e9; BYTE $0x00               // jmp          LBB19_77, $215(%rip)
+
+LBB19_68:
+	LONG $0x6ef9c1c4; BYTE $0xc4   // vmovq        %r12, %xmm0
+	LONG $0xe1af0f4c               // imulq        %rcx, %r12
+	QUAD $0xfffffb7c0562f9c5       // vpunpckldq   $-1156(%rip), %xmm0, %xmm0  /* LCPI19_0(%rip) */
+	QUAD $0xfffffb84055cf9c5       // vsubpd       $-1148(%rip), %xmm0, %xmm0  /* LCPI19_1(%rip) */
+	LONG $0x1063894c               // movq         %r12, $16(%rbx)
+	LONG $0x0579e3c4; WORD $0x01c8 // vpermilpd    $1, %xmm0, %xmm1
+	LONG $0xc058f3c5               // vaddsd       %xmm0, %xmm1, %xmm0
+	WORD $0x2148; BYTE $0xc8       // andq         %rcx, %rax
+	LONG $0x7ef9e1c4; BYTE $0xc1   // vmovq        %xmm0, %rcx
+	WORD $0x0948; BYTE $0xc1       // orq          %rax, %rcx
+	LONG $0x084b8948               // movq         %rcx, $8(%rbx)
+	LONG $0x000109e9; BYTE $0x00   // jmp          LBB19_85, $265(%rip)
+
+LBB19_69:
+	WORD $0xf089 // movl         %esi, %eax
+
+LBB19_70:
+	QUAD $0xfffffb68052ef9c5                   // vucomisd     $-1176(%rip), %xmm0  /* LCPI19_2(%rip) */
+	LONG $0x002a870f; WORD $0x0000             // ja           LBB19_73, $42(%rip)
+	QUAD $0xfffffb620d10fbc5                   // vmovsd       $-1182(%rip), %xmm1  /* LCPI19_3(%rip) */
+	LONG $0xc82ef9c5                           // vucomisd     %xmm0, %xmm1
+	LONG $0x0018870f; WORD $0x0000             // ja           LBB19_73, $24(%rip)
+	WORD $0xc089                               // movl         %eax, %eax
+	LONG $0xd70d8d48; WORD $0x00e0; BYTE $0x00 // leaq         $57559(%rip), %rcx  /* _P10_TAB(%rip) */
+	LONG $0x0459fbc5; BYTE $0xc1               // vmulsd       (%rcx,%rax,8), %xmm0, %xmm0
+	LONG $0x4511fbc5; BYTE $0xc0               // vmovsd       %xmm0, $-64(%rbp)
+	LONG $0x000062e9; BYTE $0x00               // jmp          LBB19_77, $98(%rip)
+
+LBB19_73:
+	LONG $0xa05d894c               // movq         %r11, $-96(%rbp)
+	LONG $0xc855894c               // movq         %r10, $-56(%rbp)
+	LONG $0xc04d8d48               // leaq         $-64(%rbp), %rcx
+	WORD $0x894c; BYTE $0xe7       // movq         %r12, %rdi
+	LONG $0xa8758948               // movq         %rsi, $-88(%rbp)
+	LONG $0xffdf90e8; BYTE $0xff   // callq        _atof_eisel_lemire64, $-8304(%rip)
+	WORD $0xc084                   // testb        %al, %al
+	LONG $0x004c840f; WORD $0x0000 // je           LBB19_79, $76(%rip)
+	LONG $0x00bc7d83               // cmpl         $0, $-68(%rbp)
+	LONG $0x006d840f; WORD $0x0000 // je           LBB19_80, $109(%rip)
+	WORD $0xff49; BYTE $0xc4       // incq         %r12
+	LONG $0xb04d8d48               // leaq         $-80(%rbp), %rcx
+	WORD $0x894c; BYTE $0xe7       // movq         %r12, %rdi
+	LONG $0xa8758b48               // movq         $-88(%rbp), %rsi
+	WORD $0x558b; BYTE $0xd4       // movl         $-44(%rbp), %edx
+	LONG $0xffdf68e8; BYTE $0xff   // callq        _atof_eisel_lemire64, $-8344(%rip)
+	WORD $0xc084                   // testb        %al, %al
+	LONG $0x0024840f; WORD $0x0000 // je           LBB19_79, $36(%rip)
+	LONG $0x4d10fbc5; BYTE $0xb0   // vmovsd       $-80(%rbp), %xmm1
+	LONG $0x4510fbc5; BYTE $0xc0   // vmovsd       $-64(%rbp), %xmm0
+	LONG $0xc82ef9c5               // vucomisd     %xmm0, %xmm1
+	LONG $0x0010850f; WORD $0x0000 // jne          LBB19_79, $16(%rip)
+	LONG $0x000a8a0f; WORD $0x0000 // jp           LBB19_79, $10(%rip)
+
+LBB19_77:
+	LONG $0x7ef9e1c4; BYTE $0xc0 // vmovq        %xmm0, %rax
+	LONG $0x00002fe9; BYTE $0x00 // jmp          LBB19_81, $47(%rip)
+
+LBB19_79:
+	WORD $0x8b49; BYTE $0x06     // movq         (%r14), %rax
+	WORD $0x0149; BYTE $0xc7     // addq         %rax, %r15
+	WORD $0x894c; BYTE $0xee     // movq         %r13, %rsi
+	WORD $0x2948; BYTE $0xc6     // subq         %rax, %rsi
+	WORD $0x894c; BYTE $0xff     // movq         %r15, %rdi
+	LONG $0xc8558b48             // movq         $-56(%rbp), %rdx
+	LONG $0xa04d8b48             // movq         $-96(%rbp), %rcx
+	LONG $0xffe8a0e8; BYTE $0xff // callq        _atof_native, $-5984(%rip)
+	LONG $0x4511fbc5; BYTE $0xc0 // vmovsd       %xmm0, $-64(%rbp)
+	LONG $0x7ef9e1c4; BYTE $0xc0 // vmovq        %xmm0, %rax
+	LONG $0x000009e9; BYTE $0x00 // jmp          LBB19_82, $9(%rip)
+
+LBB19_80:
+	LONG $0xc0458b48 // movq         $-64(%rbp), %rax
+
+LBB19_81:
+	LONG $0x6ef9e1c4; BYTE $0xc0 // vmovq        %rax, %xmm0
+
+LBB19_82:
+	QUAD $0x000000000000b948; WORD $0x8000     // movabsq      $-9223372036854775808, %rcx
+	WORD $0xff48; BYTE $0xc9                   // decq         %rcx
+	WORD $0x2148; BYTE $0xc1                   // andq         %rax, %rcx
+	QUAD $0x000000000000b848; WORD $0x7ff0     // movabsq      $9218868437227405312, %rax
+	WORD $0x3948; BYTE $0xc1                   // cmpq         %rax, %rcx
+	LONG $0x0007850f; WORD $0x0000             // jne          LBB19_84, $7(%rip)
+	LONG $0xf803c748; WORD $0xffff; BYTE $0xff // movq         $-8, (%rbx)
+
+LBB19_84:
+	LONG $0x4311fbc5; BYTE $0x08 // vmovsd       %xmm0, $8(%rbx)
+
+LBB19_85:
+	WORD $0x894d; BYTE $0x2e     // movq         %r13, (%r14)
+	LONG $0xfffd8de9; BYTE $0xff // jmp          LBB19_52, $-627(%rip)
+
+LBB19_86:
+	WORD $0x8948; BYTE $0xf8 // movq         %rdi, %rax
+	WORD $0x558b; BYTE $0xd4 // movl         $-44(%rbp), %edx
+
+LBB19_87:
+	LONG $0xc6c68040               // addb         $-58, %sil
+	LONG $0xf6fe8040               // cmpb         $-10, %sil
+	LONG $0xfadb820f; WORD $0xffff // jb           LBB19_5, $-1317(%rip)
+	WORD $0xf631                   // xorl         %esi, %esi
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	LONG $0x0035830f; WORD $0x0000 // jae          LBB19_93, $53(%rip)
+	WORD $0xf631                   // xorl         %esi, %esi
+
+LBB19_90:
+	LONG $0x0cb60f45; BYTE $0x07   // movzbl       (%r15,%rax), %r9d
+	LONG $0xd0798d41               // leal         $-48(%r9), %edi
+	LONG $0x09ff8040               // cmpb         $9, %dil
+	LONG $0x0020870f; WORD $0x0000 // ja           LBB19_93, $32(%rip)
+	LONG $0x2710fe81; WORD $0x0000 // cmpl         $10000, %esi
+	WORD $0x3c8d; BYTE $0xb6       // leal         (%rsi,%rsi,4), %edi
+	LONG $0x797c8d41; BYTE $0xd0   // leal         $-48(%r9,%rdi,2), %edi
+	WORD $0x4c0f; BYTE $0xf7       // cmovll       %edi, %esi
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3949; BYTE $0xc5       // cmpq         %rax, %r13
+	LONG $0xffd0850f; WORD $0xffff // jne          LBB19_90, $-48(%rip)
+	WORD $0x894c; BYTE $0xe8       // movq         %r13, %rax
+
+LBB19_93:
+	LONG $0xf0af0f41                                                     // imull        %r8d, %esi
+	WORD $0xce01                                                         // addl         %ecx, %esi
+	WORD $0x8949; BYTE $0xc5                                             // movq         %rax, %r13
+	LONG $0xfffd81e9; BYTE $0xff                                         // jmp          LBB19_60, $-639(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+_vsigned:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	BYTE $0x53                                 // pushq        %rbx
+	WORD $0x8b48; BYTE $0x06                   // movq         (%rsi), %rax
+	WORD $0x8b4c; BYTE $0x0f                   // movq         (%rdi), %r9
+	LONG $0x085f8b4c                           // movq         $8(%rdi), %r11
+	LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq         $9, (%rdx)
+	LONG $0xc057f8c5                           // vxorps       %xmm0, %xmm0, %xmm0
+	LONG $0x4211f8c5; BYTE $0x08               // vmovups      %xmm0, $8(%rdx)
+	WORD $0x8b48; BYTE $0x0e                   // movq         (%rsi), %rcx
+	LONG $0x184a8948                           // movq         %rcx, $24(%rdx)
+	WORD $0x394c; BYTE $0xd8                   // cmpq         %r11, %rax
+	LONG $0x0046830f; WORD $0x0000             // jae          LBB20_1, $70(%rip)
+	LONG $0x0cb60f41; BYTE $0x01               // movzbl       (%r9,%rax), %ecx
+	LONG $0x0001b841; WORD $0x0000             // movl         $1, %r8d
+	WORD $0xf980; BYTE $0x2d                   // cmpb         $45, %cl
+	LONG $0x0018850f; WORD $0x0000             // jne          LBB20_5, $24(%rip)
+	WORD $0xff48; BYTE $0xc0                   // incq         %rax
+	WORD $0x394c; BYTE $0xd8                   // cmpq         %r11, %rax
+	LONG $0x0026830f; WORD $0x0000             // jae          LBB20_1, $38(%rip)
+	LONG $0x0cb60f41; BYTE $0x01               // movzbl       (%r9,%rax), %ecx
+	LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r8
+
+LBB20_5:
+	WORD $0x798d; BYTE $0xc6                   // leal         $-58(%rcx), %edi
+	LONG $0xf5ff8040                           // cmpb         $-11, %dil
+	LONG $0x001a870f; WORD $0x0000             // ja           LBB20_7, $26(%rip)
+	WORD $0x8948; BYTE $0x06                   // movq         %rax, (%rsi)
+	LONG $0xfe02c748; WORD $0xffff; BYTE $0xff // movq         $-2, (%rdx)
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB20_1:
+	WORD $0x894c; BYTE $0x1e                   // movq         %r11, (%rsi)
+	LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq         $-1, (%rdx)
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB20_7:
+	WORD $0xf980; BYTE $0x30               // cmpb         $48, %cl
+	LONG $0x0032850f; WORD $0x0000         // jne          LBB20_12, $50(%rip)
+	LONG $0x01508d4c                       // leaq         $1(%rax), %r10
+	WORD $0x394c; BYTE $0xd8               // cmpq         %r11, %rax
+	LONG $0x007f830f; WORD $0x0000         // jae          LBB20_11, $127(%rip)
+	LONG $0x3cb60f43; BYTE $0x11           // movzbl       (%r9,%r10), %edi
+	WORD $0xc783; BYTE $0xd2               // addl         $-46, %edi
+	WORD $0xff83; BYTE $0x37               // cmpl         $55, %edi
+	LONG $0x006e870f; WORD $0x0000         // ja           LBB20_11, $110(%rip)
+	QUAD $0x000000800001b948; WORD $0x0080 // movabsq      $36028797027352577, %rcx
+	LONG $0xf9a30f48                       // btq          %rdi, %rcx
+	LONG $0x005a830f; WORD $0x0000         // jae          LBB20_11, $90(%rip)
+
+LBB20_12:
+	WORD $0x394c; BYTE $0xd8                   // cmpq         %r11, %rax
+	WORD $0x894d; BYTE $0xda                   // movq         %r11, %r10
+	LONG $0xd0470f4c                           // cmovaq       %rax, %r10
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB20_13:
+	WORD $0x394c; BYTE $0xd8       // cmpq         %r11, %rax
+	LONG $0x007d830f; WORD $0x0000 // jae          LBB20_23, $125(%rip)
+	LONG $0x3cbe0f49; BYTE $0x01   // movsbq       (%r9,%rax), %rdi
+	WORD $0x5f8d; BYTE $0xd0       // leal         $-48(%rdi), %ebx
+	WORD $0xfb80; BYTE $0x09       // cmpb         $9, %bl
+	LONG $0x0033870f; WORD $0x0000 // ja           LBB20_18, $51(%rip)
+	LONG $0x0ac96b48               // imulq        $10, %rcx, %rcx
+	LONG $0x0013800f; WORD $0x0000 // jo           LBB20_17, $19(%rip)
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0xc783; BYTE $0xd0       // addl         $-48, %edi
+	LONG $0xf8af0f49               // imulq        %r8, %rdi
+	WORD $0x0148; BYTE $0xf9       // addq         %rdi, %rcx
+	LONG $0xffc9810f; WORD $0xffff // jno          LBB20_13, $-55(%rip)
+
+LBB20_17:
+	WORD $0xff48; BYTE $0xc8                   // decq         %rax
+	WORD $0x8948; BYTE $0x06                   // movq         %rax, (%rsi)
+	LONG $0xfb02c748; WORD $0xffff; BYTE $0xff // movq         $-5, (%rdx)
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB20_11:
+	WORD $0x894c; BYTE $0x16 // movq         %r10, (%rsi)
+	BYTE $0x5b               // popq         %rbx
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB20_18:
+	WORD $0x394c; BYTE $0xd8       // cmpq         %r11, %rax
+	LONG $0x002d830f; WORD $0x0000 // jae          LBB20_22, $45(%rip)
+	LONG $0x3cb60f41; BYTE $0x01   // movzbl       (%r9,%rax), %edi
+	WORD $0xff83; BYTE $0x2e       // cmpl         $46, %edi
+	LONG $0x0012840f; WORD $0x0000 // je           LBB20_25, $18(%rip)
+	WORD $0xff83; BYTE $0x45       // cmpl         $69, %edi
+	LONG $0x0009840f; WORD $0x0000 // je           LBB20_25, $9(%rip)
+	WORD $0xff83; BYTE $0x65       // cmpl         $101, %edi
+	LONG $0x000d850f; WORD $0x0000 // jne          LBB20_22, $13(%rip)
+
+LBB20_25:
+	WORD $0x8948; BYTE $0x06                   // movq         %rax, (%rsi)
+	LONG $0xfa02c748; WORD $0xffff; BYTE $0xff // movq         $-6, (%rdx)
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB20_22:
+	WORD $0x8949; BYTE $0xc2 // movq         %rax, %r10
+
+LBB20_23:
+	WORD $0x894c; BYTE $0x16 // movq         %r10, (%rsi)
+	LONG $0x104a8948         // movq         %rcx, $16(%rdx)
+	BYTE $0x5b               // popq         %rbx
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+	// .p2align 4, 0x90
+_vunsigned:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5641                               // pushq        %r14
+	BYTE $0x53                                 // pushq        %rbx
+	WORD $0x8949; BYTE $0xd0                   // movq         %rdx, %r8
+	WORD $0x8b48; BYTE $0x0e                   // movq         (%rsi), %rcx
+	WORD $0x8b4c; BYTE $0x0f                   // movq         (%rdi), %r9
+	LONG $0x08778b4c                           // movq         $8(%rdi), %r14
+	LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq         $9, (%rdx)
+	LONG $0xc057f8c5                           // vxorps       %xmm0, %xmm0, %xmm0
+	LONG $0x4211f8c5; BYTE $0x08               // vmovups      %xmm0, $8(%rdx)
+	WORD $0x8b48; BYTE $0x06                   // movq         (%rsi), %rax
+	LONG $0x18428948                           // movq         %rax, $24(%rdx)
+	WORD $0x394c; BYTE $0xf1                   // cmpq         %r14, %rcx
+	LONG $0x001c830f; WORD $0x0000             // jae          LBB21_1, $28(%rip)
+	LONG $0x04b60f41; BYTE $0x09               // movzbl       (%r9,%rcx), %eax
+	WORD $0x2d3c                               // cmpb         $45, %al
+	LONG $0x001e850f; WORD $0x0000             // jne          LBB21_4, $30(%rip)
+
+LBB21_3:
+	WORD $0x8948; BYTE $0x0e                   // movq         %rcx, (%rsi)
+	LONG $0xfa00c749; WORD $0xffff; BYTE $0xff // movq         $-6, (%r8)
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5e41                               // popq         %r14
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB21_1:
+	WORD $0x894c; BYTE $0x36                   // movq         %r14, (%rsi)
+	LONG $0xff00c749; WORD $0xffff; BYTE $0xff // movq         $-1, (%r8)
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5e41                               // popq         %r14
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB21_4:
+	WORD $0x508d; BYTE $0xc6                   // leal         $-58(%rax), %edx
+	WORD $0xfa80; BYTE $0xf5                   // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000             // ja           LBB21_6, $15(%rip)
+	WORD $0x8948; BYTE $0x0e                   // movq         %rcx, (%rsi)
+	LONG $0xfe00c749; WORD $0xffff; BYTE $0xff // movq         $-2, (%r8)
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5e41                               // popq         %r14
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB21_6:
+	WORD $0x303c                           // cmpb         $48, %al
+	LONG $0x0026850f; WORD $0x0000         // jne          LBB21_10, $38(%rip)
+	LONG $0x44b60f41; WORD $0x0109         // movzbl       $1(%r9,%rcx), %eax
+	WORD $0xc083; BYTE $0xd2               // addl         $-46, %eax
+	WORD $0xf883; BYTE $0x37               // cmpl         $55, %eax
+	LONG $0x00c0870f; WORD $0x0000         // ja           LBB21_9, $192(%rip)
+	QUAD $0x000000800001ba48; WORD $0x0080 // movabsq      $36028797027352577, %rdx
+	LONG $0xc2a30f48                       // btq          %rax, %rdx
+	LONG $0x00ac830f; WORD $0x0000         // jae          LBB21_9, $172(%rip)
+
+LBB21_10:
+	WORD $0x3949; BYTE $0xce       // cmpq         %rcx, %r14
+	WORD $0x8949; BYTE $0xca       // movq         %rcx, %r10
+	LONG $0xd6470f4d               // cmovaq       %r14, %r10
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x000abb41; WORD $0x0000 // movl         $10, %r11d
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB21_11:
+	WORD $0x394c; BYTE $0xf1       // cmpq         %r14, %rcx
+	LONG $0x007f830f; WORD $0x0000 // jae          LBB21_22, $127(%rip)
+	LONG $0x1cbe0f41; BYTE $0x09   // movsbl       (%r9,%rcx), %ebx
+	WORD $0x538d; BYTE $0xd0       // leal         $-48(%rbx), %edx
+	WORD $0xfa80; BYTE $0x09       // cmpb         $9, %dl
+	LONG $0x0042870f; WORD $0x0000 // ja           LBB21_17, $66(%rip)
+	WORD $0xf749; BYTE $0xe3       // mulq         %r11
+	LONG $0x0027800f; WORD $0x0000 // jo           LBB21_16, $39(%rip)
+	WORD $0xff48; BYTE $0xc1       // incq         %rcx
+	WORD $0xc383; BYTE $0xd0       // addl         $-48, %ebx
+	WORD $0xff31                   // xorl         %edi, %edi
+	WORD $0x0148; BYTE $0xd8       // addq         %rbx, %rax
+	LONG $0xc7920f40               // setb         %dil
+	WORD $0x8948; BYTE $0xfa       // movq         %rdi, %rdx
+	WORD $0xf748; BYTE $0xda       // negq         %rdx
+	WORD $0x3148; BYTE $0xd7       // xorq         %rdx, %rdi
+	LONG $0x0009850f; WORD $0x0000 // jne          LBB21_16, $9(%rip)
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0xffb6890f; WORD $0xffff // jns          LBB21_11, $-74(%rip)
+
+LBB21_16:
+	WORD $0xff48; BYTE $0xc9                   // decq         %rcx
+	WORD $0x8948; BYTE $0x0e                   // movq         %rcx, (%rsi)
+	LONG $0xfb00c749; WORD $0xffff; BYTE $0xff // movq         $-5, (%r8)
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5e41                               // popq         %r14
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB21_17:
+	WORD $0x394c; BYTE $0xf1       // cmpq         %r14, %rcx
+	LONG $0x0020830f; WORD $0x0000 // jae          LBB21_21, $32(%rip)
+	LONG $0x14b60f41; BYTE $0x09   // movzbl       (%r9,%rcx), %edx
+	WORD $0xfa83; BYTE $0x2e       // cmpl         $46, %edx
+	LONG $0xff0e840f; WORD $0xffff // je           LBB21_3, $-242(%rip)
+	WORD $0xfa83; BYTE $0x45       // cmpl         $69, %edx
+	LONG $0xff05840f; WORD $0xffff // je           LBB21_3, $-251(%rip)
+	WORD $0xfa83; BYTE $0x65       // cmpl         $101, %edx
+	LONG $0xfefc840f; WORD $0xffff // je           LBB21_3, $-260(%rip)
+
+LBB21_21:
+	WORD $0x8949; BYTE $0xca // movq         %rcx, %r10
+
+LBB21_22:
+	WORD $0x894c; BYTE $0x16 // movq         %r10, (%rsi)
+	LONG $0x10408949         // movq         %rax, $16(%r8)
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5e41             // popq         %r14
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB21_9:
+	WORD $0xff48; BYTE $0xc1 // incq         %rcx
+	WORD $0x8948; BYTE $0x0e // movq         %rcx, (%rsi)
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5e41             // popq         %r14
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+	BYTE $0x00               // .p2align 4, 0x00
+
+LCPI22_0:
+	QUAD $0x0000000000000001 // .quad 1
+	QUAD $0x0000000000000005 // .quad 5
+
+	// .p2align 4, 0x90
+_skip_array:
+	BYTE $0x55                                               // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                                 // movq         %rsp, %rbp
+	WORD $0x8948; BYTE $0xd0                                 // movq         %rdx, %rax
+	WORD $0x8948; BYTE $0xf2                                 // movq         %rsi, %rdx
+	WORD $0x8948; BYTE $0xfe                                 // movq         %rdi, %rsi
+	QUAD $0xffffffdb0528f8c5                                 // vmovaps      $-37(%rip), %xmm0  /* LCPI22_0(%rip) */
+	LONG $0x0011f8c5                                         // vmovups      %xmm0, (%rax)
+	WORD $0x8948; BYTE $0xc7                                 // movq         %rax, %rdi
+	BYTE $0x5d                                               // popq         %rbp
+	LONG $0x00000ee9; BYTE $0x00                             // jmp          _fsm_exec, $14(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+_fsm_exec:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x28ec8348                           // subq         $40, %rsp
+	LONG $0xb84d8948                           // movq         %rcx, $-72(%rbp)
+	LONG $0x003f8348                           // cmpq         $0, (%rdi)
+	LONG $0x03b1840f; WORD $0x0000             // je           LBB23_2, $945(%rip)
+	WORD $0x8949; BYTE $0xd4                   // movq         %rdx, %r12
+	WORD $0x8949; BYTE $0xff                   // movq         %rdi, %r15
+	LONG $0xd0758948                           // movq         %rsi, $-48(%rbp)
+	LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r14
+	LONG $0xc8558948                           // movq         %rdx, $-56(%rbp)
+	LONG $0x000033e9; BYTE $0x00               // jmp          LBB23_7, $51(%rip)
+
+LBB23_3:
+	WORD $0x8b49; BYTE $0x0f                   // movq         (%r15), %rcx
+	LONG $0x000006b8; BYTE $0x00               // movl         $6, %eax
+	LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq         $4095, %rcx
+	LONG $0x03a78f0f; WORD $0x0000             // jg           LBB23_62, $935(%rip)
+	WORD $0x9090                               // .p2align 4, 0x90
+
+LBB23_4:
+	LONG $0x01518d48         // leaq         $1(%rcx), %rdx
+	WORD $0x8949; BYTE $0x17 // movq         %rdx, (%r15)
+	WORD $0x8948; BYTE $0xca // movq         %rcx, %rdx
+
+LBB23_5:
+	LONG $0xd7448949; BYTE $0x08 // movq         %rax, $8(%r15,%rdx,8)
+
+LBB23_6:
+	LONG $0x003f8349               // cmpq         $0, (%r15)
+	WORD $0x894c; BYTE $0xf0       // movq         %r14, %rax
+	LONG $0x035c840f; WORD $0x0000 // je           LBB23_54, $860(%rip)
+
+LBB23_7:
+	LONG $0xd06d8b4c               // movq         $-48(%rbp), %r13
+	LONG $0x007d8b49               // movq         (%r13), %rdi
+	LONG $0x08758b49               // movq         $8(%r13), %rsi
+	WORD $0x894c; BYTE $0xe2       // movq         %r12, %rdx
+	LONG $0xffee60e8; BYTE $0xff   // callq        _advance_ns, $-4512(%rip)
+	WORD $0xc084                   // testb        %al, %al
+	LONG $0x0348840f; WORD $0x0000 // je           LBB23_2, $840(%rip)
+	LONG $0xfffe8349               // cmpq         $-1, %r14
+	LONG $0x0007850f; WORD $0x0000 // jne          LBB23_10, $7(%rip)
+	LONG $0x24348b4d               // movq         (%r12), %r14
+	WORD $0xff49; BYTE $0xce       // decq         %r14
+
+LBB23_10:
+	WORD $0xbe0f; BYTE $0xf0                   // movsbl       %al, %esi
+	WORD $0x8b49; BYTE $0x0f                   // movq         (%r15), %rcx
+	LONG $0xff518d48                           // leaq         $-1(%rcx), %rdx
+	LONG $0xcf3c8b41                           // movl         (%r15,%rcx,8), %edi
+	WORD $0xcfff                               // decl         %edi
+	WORD $0xff83; BYTE $0x05                   // cmpl         $5, %edi
+	LONG $0x0027870f; WORD $0x0000             // ja           LBB23_14, $39(%rip)
+	LONG $0x7b1d8d48; WORD $0x0004; BYTE $0x00 // leaq         $1147(%rip), %rbx  /* LJTI23_0(%rip) */
+	LONG $0xbb3c6348                           // movslq       (%rbx,%rdi,4), %rdi
+	WORD $0x0148; BYTE $0xdf                   // addq         %rbx, %rdi
+	JMP  DI
+
+LBB23_12:
+	WORD $0xfe83; BYTE $0x2c       // cmpl         $44, %esi
+	LONG $0x01a8840f; WORD $0x0000 // je           LBB23_35, $424(%rip)
+	WORD $0xfe83; BYTE $0x5d       // cmpl         $93, %esi
+	LONG $0x016c840f; WORD $0x0000 // je           LBB23_32, $364(%rip)
+	LONG $0x000310e9; BYTE $0x00   // jmp          LBB23_58, $784(%rip)
+
+LBB23_14:
+	WORD $0x8949; BYTE $0x17                   // movq         %rdx, (%r15)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	WORD $0xfe83; BYTE $0x7b                   // cmpl         $123, %esi
+	LONG $0x0099860f; WORD $0x0000             // jbe          LBB23_26, $153(%rip)
+	LONG $0x0002d7e9; BYTE $0x00               // jmp          LBB23_54, $727(%rip)
+
+LBB23_15:
+	WORD $0xfe83; BYTE $0x7d                   // cmpl         $125, %esi
+	LONG $0x0146840f; WORD $0x0000             // je           LBB23_32, $326(%rip)
+	WORD $0xfe83; BYTE $0x2c                   // cmpl         $44, %esi
+	LONG $0x02e6850f; WORD $0x0000             // jne          LBB23_58, $742(%rip)
+	LONG $0x000003b8; BYTE $0x00               // movl         $3, %eax
+	LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq         $4095, %rcx
+	LONG $0xff3b8e0f; WORD $0xffff             // jle          LBB23_4, $-197(%rip)
+	LONG $0x0002dbe9; BYTE $0x00               // jmp          LBB23_62, $731(%rip)
+
+LBB23_18:
+	WORD $0x223c                   // cmpb         $34, %al
+	LONG $0x02c7850f; WORD $0x0000 // jne          LBB23_58, $711(%rip)
+	QUAD $0x00000004cf04c749       // movq         $4, (%r15,%rcx,8)
+	LONG $0x241c8b49               // movq         (%r12), %rbx
+	WORD $0x894c; BYTE $0xef       // movq         %r13, %rdi
+
+LBB23_20:
+	WORD $0x8948; BYTE $0xde       // movq         %rbx, %rsi
+	LONG $0xc0558d48               // leaq         $-64(%rbp), %rdx
+	LONG $0xb84d8b48               // movq         $-72(%rbp), %rcx
+	LONG $0xfff0bfe8; BYTE $0xff   // callq        _advance_string, $-3905(%rip)
+	WORD $0x8949; BYTE $0xc5       // movq         %rax, %r13
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0107890f; WORD $0x0000 // jns          LBB23_33, $263(%rip)
+	LONG $0xc0458b48               // movq         $-64(%rbp), %rax
+	LONG $0x000107e9; BYTE $0x00   // jmp          LBB23_34, $263(%rip)
+
+LBB23_22:
+	WORD $0x3a3c                   // cmpb         $58, %al
+	LONG $0x028b850f; WORD $0x0000 // jne          LBB23_58, $651(%rip)
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0xfffef5e9; BYTE $0xff   // jmp          LBB23_5, $-267(%rip)
+
+LBB23_24:
+	WORD $0x5d3c                               // cmpb         $93, %al
+	LONG $0x00d3840f; WORD $0x0000             // je           LBB23_32, $211(%rip)
+	QUAD $0x00000001cf04c749                   // movq         $1, (%r15,%rcx,8)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	WORD $0xfe83; BYTE $0x7b                   // cmpl         $123, %esi
+	LONG $0x0243870f; WORD $0x0000             // ja           LBB23_54, $579(%rip)
+
+LBB23_26:
+	WORD $0xf189                               // movl         %esi, %ecx
+	LONG $0xbe158d48; WORD $0x0003; BYTE $0x00 // leaq         $958(%rip), %rdx  /* LJTI23_1(%rip) */
+	LONG $0x8a0c6348                           // movslq       (%rdx,%rcx,4), %rcx
+	WORD $0x0148; BYTE $0xd1                   // addq         %rdx, %rcx
+	LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r13
+	JMP  CX
+
+LBB23_27:
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	WORD $0x8b48; BYTE $0x18                   // movq         (%rax), %rbx
+	LONG $0xff6b8d4c                           // leaq         $-1(%rbx), %r13
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	WORD $0x8b48; BYTE $0x38                   // movq         (%rax), %rdi
+	WORD $0x014c; BYTE $0xef                   // addq         %r13, %rdi
+	LONG $0x08708b48                           // movq         $8(%rax), %rsi
+	WORD $0x294c; BYTE $0xee                   // subq         %r13, %rsi
+	LONG $0x0006e1e8; BYTE $0x00               // callq        _do_skip_number, $1761(%rip)
+	LONG $0xff488d48                           // leaq         $-1(%rax), %rcx
+	LONG $0xfec2c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rdx
+	WORD $0x2948; BYTE $0xc2                   // subq         %rax, %rdx
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0xd1490f48                           // cmovnsq      %rcx, %rdx
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	LONG $0xe8480f4c                           // cmovsq       %rax, %r13
+	WORD $0x0148; BYTE $0xda                   // addq         %rbx, %rdx
+	LONG $0xc8658b4c                           // movq         $-56(%rbp), %r12
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	WORD $0x854d; BYTE $0xed                   // testq        %r13, %r13
+	LONG $0xfe6c890f; WORD $0xffff             // jns          LBB23_6, $-404(%rip)
+	LONG $0x0001dfe9; BYTE $0x00               // jmp          LBB23_55, $479(%rip)
+
+LBB23_28:
+	WORD $0xfe83; BYTE $0x7d       // cmpl         $125, %esi
+	LONG $0x003f840f; WORD $0x0000 // je           LBB23_32, $63(%rip)
+	WORD $0xfe83; BYTE $0x22       // cmpl         $34, %esi
+	LONG $0x01df850f; WORD $0x0000 // jne          LBB23_58, $479(%rip)
+	QUAD $0x00000002cf04c749       // movq         $2, (%r15,%rcx,8)
+	LONG $0x241c8b49               // movq         (%r12), %rbx
+	WORD $0x894c; BYTE $0xef       // movq         %r13, %rdi
+	WORD $0x8948; BYTE $0xde       // movq         %rbx, %rsi
+	LONG $0xc0558d48               // leaq         $-64(%rbp), %rdx
+	LONG $0xb84d8b48               // movq         $-72(%rbp), %rcx
+	LONG $0xffefd7e8; BYTE $0xff   // callq        _advance_string, $-4137(%rip)
+	WORD $0x8949; BYTE $0xc5       // movq         %rax, %r13
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0052890f; WORD $0x0000 // jns          LBB23_37, $82(%rip)
+	LONG $0xc0458b48               // movq         $-64(%rbp), %rax
+	LONG $0x000052e9; BYTE $0x00   // jmp          LBB23_38, $82(%rip)
+	WORD $0x9090                   // .p2align 4, 0x90
+
+LBB23_32:
+	WORD $0x8949; BYTE $0x17       // movq         %rdx, (%r15)
+	WORD $0x894d; BYTE $0xf5       // movq         %r14, %r13
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0xfe1d850f; WORD $0xffff // jne          LBB23_7, $-483(%rip)
+	LONG $0x000183e9; BYTE $0x00   // jmp          LBB23_55, $387(%rip)
+
+LBB23_33:
+	WORD $0xff48; BYTE $0xcb // decq         %rbx
+	WORD $0x894c; BYTE $0xe8 // movq         %r13, %rax
+	WORD $0x8949; BYTE $0xdd // movq         %rbx, %r13
+
+LBB23_34:
+	LONG $0xc8658b4c               // movq         $-56(%rbp), %r12
+	LONG $0x24048949               // movq         %rax, (%r12)
+	WORD $0x854d; BYTE $0xed       // testq        %r13, %r13
+	LONG $0xfdf1890f; WORD $0xffff // jns          LBB23_6, $-527(%rip)
+	LONG $0x000164e9; BYTE $0x00   // jmp          LBB23_55, $356(%rip)
+
+LBB23_35:
+	LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq         $4095, %rcx
+	LONG $0x01758f0f; WORD $0x0000             // jg           LBB23_62, $373(%rip)
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0xfffdc9e9; BYTE $0xff               // jmp          LBB23_4, $-567(%rip)
+
+LBB23_37:
+	WORD $0xff48; BYTE $0xcb // decq         %rbx
+	WORD $0x894c; BYTE $0xe8 // movq         %r13, %rax
+	WORD $0x8949; BYTE $0xdd // movq         %rbx, %r13
+
+LBB23_38:
+	LONG $0xc8658b4c                           // movq         $-56(%rbp), %r12
+	LONG $0x24048949                           // movq         %rax, (%r12)
+	WORD $0x854d; BYTE $0xed                   // testq        %r13, %r13
+	LONG $0x0136880f; WORD $0x0000             // js           LBB23_55, $310(%rip)
+	WORD $0x8b49; BYTE $0x0f                   // movq         (%r15), %rcx
+	LONG $0x000004b8; BYTE $0x00               // movl         $4, %eax
+	LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq         $4095, %rcx
+	LONG $0xfd9a8e0f; WORD $0xffff             // jle          LBB23_4, $-614(%rip)
+	LONG $0x00013ae9; BYTE $0x00               // jmp          LBB23_62, $314(%rip)
+
+LBB23_40:
+	LONG $0x241c8b49             // movq         (%r12), %rbx
+	LONG $0xd07d8b48             // movq         $-48(%rbp), %rdi
+	LONG $0xfffe69e9; BYTE $0xff // jmp          LBB23_20, $-407(%rip)
+
+LBB23_41:
+	LONG $0x242c8b4d               // movq         (%r12), %r13
+	LONG $0xd0458b48               // movq         $-48(%rbp), %rax
+	WORD $0x8b48; BYTE $0x38       // movq         (%rax), %rdi
+	WORD $0x014c; BYTE $0xef       // addq         %r13, %rdi
+	LONG $0x08708b48               // movq         $8(%rax), %rsi
+	WORD $0x294c; BYTE $0xee       // subq         %r13, %rsi
+	LONG $0x0005bee8; BYTE $0x00   // callq        _do_skip_number, $1470(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0126880f; WORD $0x0000 // js           LBB23_66, $294(%rip)
+	WORD $0x014c; BYTE $0xe8       // addq         %r13, %rax
+	LONG $0x24048949               // movq         %rax, (%r12)
+	WORD $0x854d; BYTE $0xed       // testq        %r13, %r13
+	LONG $0xfd648f0f; WORD $0xffff // jg           LBB23_6, $-668(%rip)
+	LONG $0x000127e9; BYTE $0x00   // jmp          LBB23_68, $295(%rip)
+
+LBB23_43:
+	WORD $0x8b49; BYTE $0x0f                   // movq         (%r15), %rcx
+	LONG $0x000005b8; BYTE $0x00               // movl         $5, %eax
+	LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq         $4095, %rcx
+	LONG $0xfd3b8e0f; WORD $0xffff             // jle          LBB23_4, $-709(%rip)
+	LONG $0x0000dbe9; BYTE $0x00               // jmp          LBB23_62, $219(%rip)
+
+LBB23_44:
+	LONG $0x24048b49               // movq         (%r12), %rax
+	LONG $0xd0758b48               // movq         $-48(%rbp), %rsi
+	LONG $0x084e8b48               // movq         $8(%rsi), %rcx
+	LONG $0xfc518d48               // leaq         $-4(%rcx), %rdx
+	WORD $0x3948; BYTE $0xd0       // cmpq         %rdx, %rax
+	LONG $0x00ce870f; WORD $0x0000 // ja           LBB23_64, $206(%rip)
+	WORD $0x8b48; BYTE $0x0e       // movq         (%rsi), %rcx
+	WORD $0x148b; BYTE $0x01       // movl         (%rcx,%rax), %edx
+	LONG $0x6c61fa81; WORD $0x6573 // cmpl         $1702063201, %edx
+	LONG $0x0198850f; WORD $0x0000 // jne          LBB23_78, $408(%rip)
+	LONG $0x04488d48               // leaq         $4(%rax), %rcx
+	LONG $0x240c8949               // movq         %rcx, (%r12)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0xfd098f0f; WORD $0xffff // jg           LBB23_6, $-759(%rip)
+	LONG $0x00006ae9; BYTE $0x00   // jmp          LBB23_52, $106(%rip)
+
+LBB23_47:
+	LONG $0x24048b49               // movq         (%r12), %rax
+	LONG $0xd0758b48               // movq         $-48(%rbp), %rsi
+	LONG $0x084e8b48               // movq         $8(%rsi), %rcx
+	LONG $0xfd518d48               // leaq         $-3(%rcx), %rdx
+	WORD $0x3948; BYTE $0xd0       // cmpq         %rdx, %rax
+	LONG $0x008d870f; WORD $0x0000 // ja           LBB23_64, $141(%rip)
+	WORD $0x8b48; BYTE $0x0e       // movq         (%rsi), %rcx
+	QUAD $0x6c6c756eff017c81       // cmpl         $1819047278, $-1(%rcx,%rax)
+	LONG $0x002f840f; WORD $0x0000 // je           LBB23_51, $47(%rip)
+	LONG $0x0000a5e9; BYTE $0x00   // jmp          LBB23_69, $165(%rip)
+
+LBB23_49:
+	LONG $0x24048b49               // movq         (%r12), %rax
+	LONG $0xd0758b48               // movq         $-48(%rbp), %rsi
+	LONG $0x084e8b48               // movq         $8(%rsi), %rcx
+	LONG $0xfd518d48               // leaq         $-3(%rcx), %rdx
+	WORD $0x3948; BYTE $0xd0       // cmpq         %rdx, %rax
+	LONG $0x005e870f; WORD $0x0000 // ja           LBB23_64, $94(%rip)
+	WORD $0x8b48; BYTE $0x0e       // movq         (%rsi), %rcx
+	QUAD $0x65757274ff017c81       // cmpl         $1702195828, $-1(%rcx,%rax)
+	LONG $0x00ce850f; WORD $0x0000 // jne          LBB23_73, $206(%rip)
+
+LBB23_51:
+	LONG $0x03488d48               // leaq         $3(%rax), %rcx
+	LONG $0x240c8949               // movq         %rcx, (%r12)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0xfc9a8f0f; WORD $0xffff // jg           LBB23_6, $-870(%rip)
+
+LBB23_52:
+	WORD $0xff48; BYTE $0xc8 // decq         %rax
+
+LBB23_54:
+	WORD $0x8949; BYTE $0xc5     // movq         %rax, %r13
+	LONG $0x000007e9; BYTE $0x00 // jmp          LBB23_55, $7(%rip)
+
+LBB23_2:
+	LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r13
+
+LBB23_55:
+	WORD $0x894c; BYTE $0xe8 // movq         %r13, %rax
+	LONG $0x28c48348         // addq         $40, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB23_58:
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+	LONG $0xffffe2e9; BYTE $0xff               // jmp          LBB23_55, $-30(%rip)
+
+LBB23_62:
+	LONG $0xf9c5c749; WORD $0xffff; BYTE $0xff // movq         $-7, %r13
+	LONG $0xffffd6e9; BYTE $0xff               // jmp          LBB23_55, $-42(%rip)
+
+LBB23_64:
+	LONG $0x240c8949                           // movq         %rcx, (%r12)
+	LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r13
+	LONG $0xffffc6e9; BYTE $0xff               // jmp          LBB23_55, $-58(%rip)
+
+LBB23_66:
+	WORD $0xf748; BYTE $0xd0                   // notq         %rax
+	WORD $0x0149; BYTE $0xc5                   // addq         %rax, %r13
+	LONG $0x242c894d                           // movq         %r13, (%r12)
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+	LONG $0xffffb0e9; BYTE $0xff               // jmp          LBB23_55, $-80(%rip)
+
+LBB23_68:
+	WORD $0xff49; BYTE $0xcd     // decq         %r13
+	LONG $0xffffa8e9; BYTE $0xff // jmp          LBB23_55, $-88(%rip)
+
+LBB23_69:
+	LONG $0xff508d48                           // leaq         $-1(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+	LONG $0xff017c80; BYTE $0x6e               // cmpb         $110, $-1(%rcx,%rax)
+	LONG $0xff8e850f; WORD $0xffff             // jne          LBB23_55, $-114(%rip)
+	LONG $0x24048949                           // movq         %rax, (%r12)
+	LONG $0x75013c80                           // cmpb         $117, (%rcx,%rax)
+	LONG $0xff80850f; WORD $0xffff             // jne          LBB23_55, $-128(%rip)
+	LONG $0x01508d48                           // leaq         $1(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0x01017c80; BYTE $0x6c               // cmpb         $108, $1(%rcx,%rax)
+	LONG $0xff6d850f; WORD $0xffff             // jne          LBB23_55, $-147(%rip)
+	LONG $0x02508d48                           // leaq         $2(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0x02017c80; BYTE $0x6c               // cmpb         $108, $2(%rcx,%rax)
+	LONG $0xff5a850f; WORD $0xffff             // jne          LBB23_55, $-166(%rip)
+	LONG $0x00004ee9; BYTE $0x00               // jmp          LBB23_77, $78(%rip)
+
+LBB23_73:
+	LONG $0xff508d48                           // leaq         $-1(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+	LONG $0xff017c80; BYTE $0x74               // cmpb         $116, $-1(%rcx,%rax)
+	LONG $0xff3b850f; WORD $0xffff             // jne          LBB23_55, $-197(%rip)
+	LONG $0x24048949                           // movq         %rax, (%r12)
+	LONG $0x72013c80                           // cmpb         $114, (%rcx,%rax)
+	LONG $0xff2d850f; WORD $0xffff             // jne          LBB23_55, $-211(%rip)
+	LONG $0x01508d48                           // leaq         $1(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0x01017c80; BYTE $0x75               // cmpb         $117, $1(%rcx,%rax)
+	LONG $0xff1a850f; WORD $0xffff             // jne          LBB23_55, $-230(%rip)
+	LONG $0x02508d48                           // leaq         $2(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0x02017c80; BYTE $0x65               // cmpb         $101, $2(%rcx,%rax)
+	LONG $0xff07850f; WORD $0xffff             // jne          LBB23_55, $-249(%rip)
+
+LBB23_77:
+	LONG $0x03c08348             // addq         $3, %rax
+	LONG $0x24048949             // movq         %rax, (%r12)
+	LONG $0xfffefae9; BYTE $0xff // jmp          LBB23_55, $-262(%rip)
+
+LBB23_78:
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+	WORD $0xfa80; BYTE $0x61                   // cmpb         $97, %dl
+	LONG $0xfeea850f; WORD $0xffff             // jne          LBB23_55, $-278(%rip)
+	LONG $0x01508d48                           // leaq         $1(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0x01017c80; BYTE $0x6c               // cmpb         $108, $1(%rcx,%rax)
+	LONG $0xfed7850f; WORD $0xffff             // jne          LBB23_55, $-297(%rip)
+	LONG $0x02508d48                           // leaq         $2(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0x02017c80; BYTE $0x73               // cmpb         $115, $2(%rcx,%rax)
+	LONG $0xfec4850f; WORD $0xffff             // jne          LBB23_55, $-316(%rip)
+	LONG $0x03508d48                           // leaq         $3(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0x03017c80; BYTE $0x65               // cmpb         $101, $3(%rcx,%rax)
+	LONG $0xfeb1850f; WORD $0xffff             // jne          LBB23_55, $-335(%rip)
+	LONG $0x04c08348                           // addq         $4, %rax
+	LONG $0x24048949                           // movq         %rax, (%r12)
+	LONG $0xfffea4e9; BYTE $0xff               // jmp          LBB23_55, $-348(%rip)
+	BYTE $0x90                                 // .p2align 2, 0x90
+
+	// .set L23_0_set_12, LBB23_12-LJTI23_0
+	// .set L23_0_set_15, LBB23_15-LJTI23_0
+	// .set L23_0_set_18, LBB23_18-LJTI23_0
+	// .set L23_0_set_22, LBB23_22-LJTI23_0
+	// .set L23_0_set_24, LBB23_24-LJTI23_0
+	// .set L23_0_set_28, LBB23_28-LJTI23_0
+LJTI23_0:
+	LONG $0xfffffb8e // .long L23_0_set_12
+	LONG $0xfffffbbd // .long L23_0_set_15
+	LONG $0xfffffbe6 // .long L23_0_set_18
+	LONG $0xfffffc22 // .long L23_0_set_22
+	LONG $0xfffffc31 // .long L23_0_set_24
+	LONG $0xfffffcc4 // .long L23_0_set_28
+
+	// .set L23_1_set_55, LBB23_55-LJTI23_1
+	// .set L23_1_set_54, LBB23_54-LJTI23_1
+	// .set L23_1_set_40, LBB23_40-LJTI23_1
+	// .set L23_1_set_41, LBB23_41-LJTI23_1
+	// .set L23_1_set_27, LBB23_27-LJTI23_1
+	// .set L23_1_set_43, LBB23_43-LJTI23_1
+	// .set L23_1_set_44, LBB23_44-LJTI23_1
+	// .set L23_1_set_47, LBB23_47-LJTI23_1
+	// .set L23_1_set_49, LBB23_49-LJTI23_1
+	// .set L23_1_set_3, LBB23_3-LJTI23_1
+LJTI23_1:
+	LONG $0xfffffe8b // .long L23_1_set_55
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffd6f // .long L23_1_set_40
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffd7c // .long L23_1_set_41
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffdb4 // .long L23_1_set_43
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffdce // .long L23_1_set_44
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe0f // .long L23_1_set_47
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe3e // .long L23_1_set_49
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffaed // .long L23_1_set_3
+	LONG $0x00000000 // .p2align 4, 0x00
+
+LCPI24_0:
+	QUAD $0x0000000000000001 // .quad 1
+	QUAD $0x0000000000000006 // .quad 6
+
+	// .p2align 4, 0x90
+_skip_object:
+	BYTE $0x55                                               // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                                 // movq         %rsp, %rbp
+	WORD $0x8948; BYTE $0xd0                                 // movq         %rdx, %rax
+	WORD $0x8948; BYTE $0xf2                                 // movq         %rsi, %rdx
+	WORD $0x8948; BYTE $0xfe                                 // movq         %rdi, %rsi
+	QUAD $0xffffffdb0528f8c5                                 // vmovaps      $-37(%rip), %xmm0  /* LCPI24_0(%rip) */
+	LONG $0x0011f8c5                                         // vmovups      %xmm0, (%rax)
+	WORD $0x8948; BYTE $0xc7                                 // movq         %rax, %rdi
+	BYTE $0x5d                                               // popq         %rbp
+	LONG $0xfff88ee9; BYTE $0xff                             // jmp          _fsm_exec, $-1906(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+_skip_string:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5641                   // pushq        %r14
+	BYTE $0x53                     // pushq        %rbx
+	LONG $0x10ec8348               // subq         $16, %rsp
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	WORD $0x8949; BYTE $0xf6       // movq         %rsi, %r14
+	WORD $0x8b48; BYTE $0x1e       // movq         (%rsi), %rbx
+	LONG $0xe8558d48               // leaq         $-24(%rbp), %rdx
+	WORD $0x8948; BYTE $0xde       // movq         %rbx, %rsi
+	LONG $0xffea60e8; BYTE $0xff   // callq        _advance_string, $-5536(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0009890f; WORD $0x0000 // jns          LBB25_1, $9(%rip)
+	LONG $0xe84d8b48               // movq         $-24(%rbp), %rcx
+	LONG $0x000009e9; BYTE $0x00   // jmp          LBB25_3, $9(%rip)
+
+LBB25_1:
+	WORD $0xff48; BYTE $0xcb // decq         %rbx
+	WORD $0x8948; BYTE $0xc1 // movq         %rax, %rcx
+	WORD $0x8948; BYTE $0xd8 // movq         %rbx, %rax
+
+LBB25_3:
+	WORD $0x8949; BYTE $0x0e             // movq         %rcx, (%r14)
+	LONG $0x10c48348                     // addq         $16, %rsp
+	BYTE $0x5b                           // popq         %rbx
+	WORD $0x5e41                         // popq         %r14
+	BYTE $0x5d                           // popq         %rbp
+	BYTE $0xc3                           // retq
+	QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90
+
+_skip_negative:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5641                   // pushq        %r14
+	BYTE $0x53                     // pushq        %rbx
+	WORD $0x8949; BYTE $0xf6       // movq         %rsi, %r14
+	WORD $0x8b48; BYTE $0x1e       // movq         (%rsi), %rbx
+	WORD $0x8b48; BYTE $0x07       // movq         (%rdi), %rax
+	WORD $0x0148; BYTE $0xd8       // addq         %rbx, %rax
+	LONG $0x08778b48               // movq         $8(%rdi), %rsi
+	WORD $0x2948; BYTE $0xde       // subq         %rbx, %rsi
+	WORD $0x8948; BYTE $0xc7       // movq         %rax, %rdi
+	LONG $0x0000aee8; BYTE $0x00   // callq        _do_skip_number, $174(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x000e880f; WORD $0x0000 // js           LBB26_1, $14(%rip)
+	WORD $0x0148; BYTE $0xd8       // addq         %rbx, %rax
+	WORD $0x8949; BYTE $0x06       // movq         %rax, (%r14)
+	WORD $0xff48; BYTE $0xcb       // decq         %rbx
+	LONG $0x000010e9; BYTE $0x00   // jmp          LBB26_3, $16(%rip)
+
+LBB26_1:
+	WORD $0xf748; BYTE $0xd0                   // notq         %rax
+	WORD $0x0148; BYTE $0xc3                   // addq         %rax, %rbx
+	WORD $0x8949; BYTE $0x1e                   // movq         %rbx, (%r14)
+	LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rbx
+
+LBB26_3:
+	WORD $0x8948; BYTE $0xd8                                             // movq         %rbx, %rax
+	BYTE $0x5b                                                           // popq         %rbx
+	WORD $0x5e41                                                         // popq         %r14
+	BYTE $0x5d                                                           // popq         %rbp
+	BYTE $0xc3                                                           // retq
+	QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00
+
+LCPI27_0:
+	QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++'
+
+LCPI27_1:
+	QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------'
+
+LCPI27_2:
+	QUAD $0xd0d0d0d0d0d0d0d0; QUAD $0xd0d0d0d0d0d0d0d0 // .space 16, '\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0'
+
+LCPI27_3:
+	QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'
+
+LCPI27_4:
+	QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
+
+LCPI27_5:
+	QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................'
+
+LCPI27_6:
+	QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE'
+
+	// .p2align 4, 0x90
+_do_skip_number:
+	BYTE $0x55                             // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5               // movq         %rsp, %rbp
+	WORD $0x5741                           // pushq        %r15
+	WORD $0x5641                           // pushq        %r14
+	BYTE $0x53                             // pushq        %rbx
+	WORD $0x8548; BYTE $0xf6               // testq        %rsi, %rsi
+	LONG $0x0235840f; WORD $0x0000         // je           LBB27_1, $565(%rip)
+	WORD $0x3f80; BYTE $0x30               // cmpb         $48, (%rdi)
+	LONG $0x0033850f; WORD $0x0000         // jne          LBB27_6, $51(%rip)
+	LONG $0x000001b8; BYTE $0x00           // movl         $1, %eax
+	LONG $0x01fe8348                       // cmpq         $1, %rsi
+	LONG $0x02b8840f; WORD $0x0000         // je           LBB27_55, $696(%rip)
+	LONG $0x014fb60f                       // movzbl       $1(%rdi), %ecx
+	WORD $0xc183; BYTE $0xd2               // addl         $-46, %ecx
+	WORD $0xf983; BYTE $0x37               // cmpl         $55, %ecx
+	LONG $0x02a8870f; WORD $0x0000         // ja           LBB27_55, $680(%rip)
+	QUAD $0x000000800001ba48; WORD $0x0080 // movabsq      $36028797027352577, %rdx
+	LONG $0xcaa30f48                       // btq          %rcx, %rdx
+	LONG $0x0294830f; WORD $0x0000         // jae          LBB27_55, $660(%rip)
+
+LBB27_6:
+	LONG $0x10fe8348                           // cmpq         $16, %rsi
+	LONG $0x02f3820f; WORD $0x0000             // jb           LBB27_7, $755(%rip)
+	LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r10
+	WORD $0xc031                               // xorl         %eax, %eax
+	QUAD $0xffffff27056f79c5                   // vmovdqa      $-217(%rip), %xmm8  /* LCPI27_0(%rip) */
+	QUAD $0xffffff2f0d6f79c5                   // vmovdqa      $-209(%rip), %xmm9  /* LCPI27_1(%rip) */
+	QUAD $0xffffff37156f79c5                   // vmovdqa      $-201(%rip), %xmm10  /* LCPI27_2(%rip) */
+	QUAD $0xffffff3f1d6ff9c5                   // vmovdqa      $-193(%rip), %xmm3  /* LCPI27_3(%rip) */
+	QUAD $0xffffff47256ff9c5                   // vmovdqa      $-185(%rip), %xmm4  /* LCPI27_4(%rip) */
+	QUAD $0xffffff4f2d6ff9c5                   // vmovdqa      $-177(%rip), %xmm5  /* LCPI27_5(%rip) */
+	QUAD $0xffffff57356ff9c5                   // vmovdqa      $-169(%rip), %xmm6  /* LCPI27_6(%rip) */
+	LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r9
+	LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r8
+	WORD $0x8949; BYTE $0xf7                   // movq         %rsi, %r15
+	LONG $0x90909090; WORD $0x9090             // .p2align 4, 0x90
+
+LBB27_9:
+	LONG $0x3c6ffac5; BYTE $0x07   // vmovdqu      (%rdi,%rax), %xmm7
+	LONG $0xc774b9c5               // vpcmpeqb     %xmm7, %xmm8, %xmm0
+	LONG $0xcf74b1c5               // vpcmpeqb     %xmm7, %xmm9, %xmm1
+	LONG $0xc0ebf1c5               // vpor         %xmm0, %xmm1, %xmm0
+	LONG $0xcffca9c5               // vpaddb       %xmm7, %xmm10, %xmm1
+	LONG $0xd3daf1c5               // vpminub      %xmm3, %xmm1, %xmm2
+	LONG $0xca74f1c5               // vpcmpeqb     %xmm2, %xmm1, %xmm1
+	LONG $0xd4dbc1c5               // vpand        %xmm4, %xmm7, %xmm2
+	LONG $0xd674e9c5               // vpcmpeqb     %xmm6, %xmm2, %xmm2
+	LONG $0xfd74c1c5               // vpcmpeqb     %xmm5, %xmm7, %xmm7
+	LONG $0xdfd7f9c5               // vpmovmskb    %xmm7, %ebx
+	LONG $0xf2d779c5               // vpmovmskb    %xmm2, %r14d
+	LONG $0xd8d779c5               // vpmovmskb    %xmm0, %r11d
+	LONG $0xd7ebe9c5               // vpor         %xmm7, %xmm2, %xmm2
+	LONG $0xc0ebe9c5               // vpor         %xmm0, %xmm2, %xmm0
+	LONG $0xc1ebf9c5               // vpor         %xmm1, %xmm0, %xmm0
+	LONG $0xc8d7f9c5               // vpmovmskb    %xmm0, %ecx
+	WORD $0xd1f7                   // notl         %ecx
+	WORD $0xbc0f; BYTE $0xc9       // bsfl         %ecx, %ecx
+	WORD $0xf983; BYTE $0x10       // cmpl         $16, %ecx
+	LONG $0x0014840f; WORD $0x0000 // je           LBB27_11, $20(%rip)
+	LONG $0xffffffba; BYTE $0xff   // movl         $-1, %edx
+	WORD $0xe2d3                   // shll         %cl, %edx
+	WORD $0xd2f7                   // notl         %edx
+	WORD $0xd321                   // andl         %edx, %ebx
+	WORD $0x2141; BYTE $0xd6       // andl         %edx, %r14d
+	WORD $0x2144; BYTE $0xda       // andl         %r11d, %edx
+	WORD $0x8941; BYTE $0xd3       // movl         %edx, %r11d
+
+LBB27_11:
+	WORD $0x538d; BYTE $0xff       // leal         $-1(%rbx), %edx
+	WORD $0xda21                   // andl         %ebx, %edx
+	LONG $0x0206850f; WORD $0x0000 // jne          LBB27_12, $518(%rip)
+	LONG $0xff568d41               // leal         $-1(%r14), %edx
+	WORD $0x2144; BYTE $0xf2       // andl         %r14d, %edx
+	LONG $0x01f9850f; WORD $0x0000 // jne          LBB27_12, $505(%rip)
+	LONG $0xff538d41               // leal         $-1(%r11), %edx
+	WORD $0x2144; BYTE $0xda       // andl         %r11d, %edx
+	LONG $0x01ec850f; WORD $0x0000 // jne          LBB27_12, $492(%rip)
+	WORD $0xdb85                   // testl        %ebx, %ebx
+	LONG $0x0013840f; WORD $0x0000 // je           LBB27_19, $19(%rip)
+	WORD $0xbc0f; BYTE $0xdb       // bsfl         %ebx, %ebx
+	LONG $0xfff88349               // cmpq         $-1, %r8
+	LONG $0x01ed850f; WORD $0x0000 // jne          LBB27_56, $493(%rip)
+	WORD $0x0148; BYTE $0xc3       // addq         %rax, %rbx
+	WORD $0x8949; BYTE $0xd8       // movq         %rbx, %r8
+
+LBB27_19:
+	WORD $0x8545; BYTE $0xf6       // testl        %r14d, %r14d
+	LONG $0x0014840f; WORD $0x0000 // je           LBB27_22, $20(%rip)
+	LONG $0xdebc0f41               // bsfl         %r14d, %ebx
+	LONG $0xfff98349               // cmpq         $-1, %r9
+	LONG $0x01d0850f; WORD $0x0000 // jne          LBB27_56, $464(%rip)
+	WORD $0x0148; BYTE $0xc3       // addq         %rax, %rbx
+	WORD $0x8949; BYTE $0xd9       // movq         %rbx, %r9
+
+LBB27_22:
+	WORD $0x8545; BYTE $0xdb       // testl        %r11d, %r11d
+	LONG $0x0014840f; WORD $0x0000 // je           LBB27_25, $20(%rip)
+	LONG $0xdbbc0f41               // bsfl         %r11d, %ebx
+	LONG $0xfffa8349               // cmpq         $-1, %r10
+	LONG $0x01b3850f; WORD $0x0000 // jne          LBB27_56, $435(%rip)
+	WORD $0x0148; BYTE $0xc3       // addq         %rax, %rbx
+	WORD $0x8949; BYTE $0xda       // movq         %rbx, %r10
+
+LBB27_25:
+	WORD $0xf983; BYTE $0x10       // cmpl         $16, %ecx
+	LONG $0x00b9850f; WORD $0x0000 // jne          LBB27_57, $185(%rip)
+	LONG $0xf0c78349               // addq         $-16, %r15
+	LONG $0x10c08348               // addq         $16, %rax
+	LONG $0x0fff8349               // cmpq         $15, %r15
+	LONG $0xff04870f; WORD $0xffff // ja           LBB27_9, $-252(%rip)
+	LONG $0x070c8d48               // leaq         (%rdi,%rax), %rcx
+	WORD $0x8949; BYTE $0xcb       // movq         %rcx, %r11
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0x00a0840f; WORD $0x0000 // je           LBB27_41, $160(%rip)
+
+LBB27_28:
+	LONG $0x391c8d4e                           // leaq         (%rcx,%r15), %r11
+	WORD $0x8948; BYTE $0xce                   // movq         %rcx, %rsi
+	WORD $0x2948; BYTE $0xfe                   // subq         %rdi, %rsi
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0x9d358d4c; WORD $0x0001; BYTE $0x00 // leaq         $413(%rip), %r14  /* LJTI27_0(%rip) */
+	LONG $0x000028e9; BYTE $0x00               // jmp          LBB27_29, $40(%rip)
+
+LBB27_31:
+	WORD $0xfb83; BYTE $0x65       // cmpl         $101, %ebx
+	LONG $0x0094850f; WORD $0x0000 // jne          LBB27_40, $148(%rip)
+
+LBB27_32:
+	LONG $0xfff98349               // cmpq         $-1, %r9
+	LONG $0x0149850f; WORD $0x0000 // jne          LBB27_58, $329(%rip)
+	LONG $0x060c8d4c               // leaq         (%rsi,%rax), %r9
+	LONG $0x90909090; BYTE $0x90   // .p2align 4, 0x90
+
+LBB27_39:
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3949; BYTE $0xc7       // cmpq         %rax, %r15
+	LONG $0x0060840f; WORD $0x0000 // je           LBB27_41, $96(%rip)
+
+LBB27_29:
+	LONG $0x011cbe0f               // movsbl       (%rcx,%rax), %ebx
+	WORD $0x538d; BYTE $0xd0       // leal         $-48(%rbx), %edx
+	WORD $0xfa83; BYTE $0x0a       // cmpl         $10, %edx
+	LONG $0xffe4820f; WORD $0xffff // jb           LBB27_39, $-28(%rip)
+	WORD $0x538d; BYTE $0xd5       // leal         $-43(%rbx), %edx
+	WORD $0xfa83; BYTE $0x1a       // cmpl         $26, %edx
+	LONG $0xffbc870f; WORD $0xffff // ja           LBB27_31, $-68(%rip)
+	LONG $0x96146349               // movslq       (%r14,%rdx,4), %rdx
+	WORD $0x014c; BYTE $0xf2       // addq         %r14, %rdx
+	JMP  DX
+
+LBB27_37:
+	LONG $0xfffa8349               // cmpq         $-1, %r10
+	LONG $0x0105850f; WORD $0x0000 // jne          LBB27_58, $261(%rip)
+	LONG $0x06148d4c               // leaq         (%rsi,%rax), %r10
+	LONG $0xffffbce9; BYTE $0xff   // jmp          LBB27_39, $-68(%rip)
+
+LBB27_35:
+	LONG $0xfff88349               // cmpq         $-1, %r8
+	LONG $0x00f2850f; WORD $0x0000 // jne          LBB27_58, $242(%rip)
+	LONG $0x06048d4c               // leaq         (%rsi,%rax), %r8
+	LONG $0xffffa9e9; BYTE $0xff   // jmp          LBB27_39, $-87(%rip)
+
+LBB27_1:
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0x00008fe9; BYTE $0x00               // jmp          LBB27_55, $143(%rip)
+
+LBB27_57:
+	WORD $0x8941; BYTE $0xcb // movl         %ecx, %r11d
+	WORD $0x0149; BYTE $0xfb // addq         %rdi, %r11
+	WORD $0x0149; BYTE $0xc3 // addq         %rax, %r11
+
+LBB27_41:
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x854d; BYTE $0xc0                   // testq        %r8, %r8
+	LONG $0x001b850f; WORD $0x0000             // jne          LBB27_42, $27(%rip)
+	LONG $0x000071e9; BYTE $0x00               // jmp          LBB27_55, $113(%rip)
+
+LBB27_40:
+	WORD $0x0148; BYTE $0xc1                   // addq         %rax, %rcx
+	WORD $0x8949; BYTE $0xcb                   // movq         %rcx, %r11
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x854d; BYTE $0xc0                   // testq        %r8, %r8
+	LONG $0x005b840f; WORD $0x0000             // je           LBB27_55, $91(%rip)
+
+LBB27_42:
+	WORD $0x854d; BYTE $0xd2       // testq        %r10, %r10
+	LONG $0x0052840f; WORD $0x0000 // je           LBB27_55, $82(%rip)
+	WORD $0x854d; BYTE $0xc9       // testq        %r9, %r9
+	LONG $0x0049840f; WORD $0x0000 // je           LBB27_55, $73(%rip)
+	WORD $0x2949; BYTE $0xfb       // subq         %rdi, %r11
+	LONG $0xff438d49               // leaq         $-1(%r11), %rax
+	WORD $0x3949; BYTE $0xc0       // cmpq         %rax, %r8
+	LONG $0x0033840f; WORD $0x0000 // je           LBB27_47, $51(%rip)
+	WORD $0x3949; BYTE $0xc2       // cmpq         %rax, %r10
+	LONG $0x002a840f; WORD $0x0000 // je           LBB27_47, $42(%rip)
+	WORD $0x3949; BYTE $0xc1       // cmpq         %rax, %r9
+	LONG $0x0021840f; WORD $0x0000 // je           LBB27_47, $33(%rip)
+	WORD $0x854d; BYTE $0xd2       // testq        %r10, %r10
+	LONG $0x00258e0f; WORD $0x0000 // jle          LBB27_51, $37(%rip)
+	LONG $0xff428d49               // leaq         $-1(%r10), %rax
+	WORD $0x3949; BYTE $0xc1       // cmpq         %rax, %r9
+	LONG $0x0018840f; WORD $0x0000 // je           LBB27_51, $24(%rip)
+	WORD $0xf749; BYTE $0xd2       // notq         %r10
+	WORD $0x894c; BYTE $0xd0       // movq         %r10, %rax
+	LONG $0x000006e9; BYTE $0x00   // jmp          LBB27_55, $6(%rip)
+
+LBB27_47:
+	WORD $0xf749; BYTE $0xdb // negq         %r11
+	WORD $0x894c; BYTE $0xd8 // movq         %r11, %rax
+
+LBB27_55:
+	BYTE $0x5b   // popq         %rbx
+	WORD $0x5e41 // popq         %r14
+	WORD $0x5f41 // popq         %r15
+	BYTE $0x5d   // popq         %rbp
+	BYTE $0xc3   // retq
+
+LBB27_51:
+	WORD $0x894c; BYTE $0xc0       // movq         %r8, %rax
+	WORD $0x094c; BYTE $0xc8       // orq          %r9, %rax
+	WORD $0x990f; BYTE $0xc0       // setns        %al
+	LONG $0x0014880f; WORD $0x0000 // js           LBB27_54, $20(%rip)
+	WORD $0x394d; BYTE $0xc8       // cmpq         %r9, %r8
+	LONG $0x000b8c0f; WORD $0x0000 // jl           LBB27_54, $11(%rip)
+	WORD $0xf749; BYTE $0xd0       // notq         %r8
+	WORD $0x894c; BYTE $0xc0       // movq         %r8, %rax
+	LONG $0xffffd6e9; BYTE $0xff   // jmp          LBB27_55, $-42(%rip)
+
+LBB27_54:
+	LONG $0xff498d49             // leaq         $-1(%r9), %rcx
+	WORD $0x3949; BYTE $0xc8     // cmpq         %rcx, %r8
+	WORD $0xf749; BYTE $0xd1     // notq         %r9
+	LONG $0xcb450f4d             // cmovneq      %r11, %r9
+	WORD $0xc084                 // testb        %al, %al
+	LONG $0xcb440f4d             // cmoveq       %r11, %r9
+	WORD $0x894c; BYTE $0xc8     // movq         %r9, %rax
+	LONG $0xffffbae9; BYTE $0xff // jmp          LBB27_55, $-70(%rip)
+
+LBB27_12:
+	WORD $0xbc0f; BYTE $0xca     // bsfl         %edx, %ecx
+	LONG $0x000010e9; BYTE $0x00 // jmp          LBB27_13, $16(%rip)
+
+LBB27_58:
+	WORD $0x2948; BYTE $0xcf     // subq         %rcx, %rdi
+	WORD $0xf748; BYTE $0xd0     // notq         %rax
+	WORD $0x0148; BYTE $0xf8     // addq         %rdi, %rax
+	LONG $0xffffa4e9; BYTE $0xff // jmp          LBB27_55, $-92(%rip)
+
+LBB27_56:
+	WORD $0xd989 // movl         %ebx, %ecx
+
+LBB27_13:
+	WORD $0xf748; BYTE $0xd0     // notq         %rax
+	WORD $0x2948; BYTE $0xc8     // subq         %rcx, %rax
+	LONG $0xffff97e9; BYTE $0xff // jmp          LBB27_55, $-105(%rip)
+
+LBB27_7:
+	LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r8
+	WORD $0x8948; BYTE $0xf9                   // movq         %rdi, %rcx
+	WORD $0x8949; BYTE $0xf7                   // movq         %rsi, %r15
+	LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r9
+	LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r10
+	LONG $0xfffe51e9; BYTE $0xff               // jmp          LBB27_28, $-431(%rip)
+	BYTE $0x90                                 // .p2align 2, 0x90
+
+	// .set L27_0_set_37, LBB27_37-LJTI27_0
+	// .set L27_0_set_40, LBB27_40-LJTI27_0
+	// .set L27_0_set_35, LBB27_35-LJTI27_0
+	// .set L27_0_set_32, LBB27_32-LJTI27_0
+LJTI27_0:
+	LONG $0xfffffeb5         // .long L27_0_set_37
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xfffffeb5         // .long L27_0_set_37
+	LONG $0xfffffec8         // .long L27_0_set_35
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xfffffe71         // .long L27_0_set_32
+	QUAD $0x9090909090909090 // .p2align 4, 0x90
+
+_skip_positive:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	BYTE $0x53                                 // pushq        %rbx
+	BYTE $0x50                                 // pushq        %rax
+	WORD $0x8949; BYTE $0xf6                   // movq         %rsi, %r14
+	WORD $0x8b4c; BYTE $0x3e                   // movq         (%rsi), %r15
+	LONG $0xff5f8d49                           // leaq         $-1(%r15), %rbx
+	WORD $0x8b48; BYTE $0x07                   // movq         (%rdi), %rax
+	WORD $0x0148; BYTE $0xd8                   // addq         %rbx, %rax
+	LONG $0x08778b48                           // movq         $8(%rdi), %rsi
+	WORD $0x2948; BYTE $0xde                   // subq         %rbx, %rsi
+	WORD $0x8948; BYTE $0xc7                   // movq         %rax, %rdi
+	LONG $0xfffbf7e8; BYTE $0xff               // callq        _do_skip_number, $-1033(%rip)
+	LONG $0xff508d48                           // leaq         $-1(%rax), %rdx
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0xfec6c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rsi
+	WORD $0x2948; BYTE $0xc6                   // subq         %rax, %rsi
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0xf2490f48                           // cmovnsq      %rdx, %rsi
+	LONG $0xcb490f48                           // cmovnsq      %rbx, %rcx
+	WORD $0x014c; BYTE $0xfe                   // addq         %r15, %rsi
+	WORD $0x8949; BYTE $0x36                   // movq         %rsi, (%r14)
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	LONG $0x08c48348                           // addq         $8, %rsp
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5e41                               // popq         %r14
+	WORD $0x5f41                               // popq         %r15
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+	WORD $0x9090; BYTE $0x90                   // .p2align 4, 0x90
+
+_skip_number:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5741                   // pushq        %r15
+	WORD $0x5641                   // pushq        %r14
+	WORD $0x5441                   // pushq        %r12
+	BYTE $0x53                     // pushq        %rbx
+	WORD $0x8949; BYTE $0xf6       // movq         %rsi, %r14
+	WORD $0x8b4c; BYTE $0x27       // movq         (%rdi), %r12
+	LONG $0x08778b48               // movq         $8(%rdi), %rsi
+	WORD $0x8b4d; BYTE $0x3e       // movq         (%r14), %r15
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x3c3c8043; BYTE $0x2d   // cmpb         $45, (%r12,%r15)
+	LONG $0x3c1c8d4b               // leaq         (%r12,%r15), %rbx
+	WORD $0x940f; BYTE $0xc0       // sete         %al
+	WORD $0x0148; BYTE $0xc3       // addq         %rax, %rbx
+	WORD $0x2948; BYTE $0xc6       // subq         %rax, %rsi
+	LONG $0x003c840f; WORD $0x0000 // je           LBB29_6, $60(%rip)
+	WORD $0x3949; BYTE $0xf7       // cmpq         %rsi, %r15
+	LONG $0x000d830f; WORD $0x0000 // jae          LBB29_3, $13(%rip)
+	WORD $0xb60f; BYTE $0x03       // movzbl       (%rbx), %eax
+	WORD $0xc604                   // addb         $-58, %al
+	WORD $0xf63c                   // cmpb         $-10, %al
+	LONG $0x0038820f; WORD $0x0000 // jb           LBB29_8, $56(%rip)
+
+LBB29_3:
+	WORD $0x8948; BYTE $0xdf       // movq         %rbx, %rdi
+	LONG $0xfffb70e8; BYTE $0xff   // callq        _do_skip_number, $-1168(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0021880f; WORD $0x0000 // js           LBB29_7, $33(%rip)
+	WORD $0x0148; BYTE $0xc3       // addq         %rax, %rbx
+
+LBB29_5:
+	WORD $0x294c; BYTE $0xe3 // subq         %r12, %rbx
+	WORD $0x8949; BYTE $0x1e // movq         %rbx, (%r14)
+	WORD $0x894c; BYTE $0xf8 // movq         %r15, %rax
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB29_6:
+	LONG $0xffc7c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r15
+	LONG $0xffffe2e9; BYTE $0xff               // jmp          LBB29_5, $-30(%rip)
+
+LBB29_7:
+	WORD $0xf748; BYTE $0xd0 // notq         %rax
+	WORD $0x0148; BYTE $0xc3 // addq         %rax, %rbx
+
+LBB29_8:
+	LONG $0xfec7c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r15
+	LONG $0xffffd0e9; BYTE $0xff               // jmp          LBB29_5, $-48(%rip)
+	LONG $0x00000000                           // .p2align 4, 0x00
+
+LCPI30_0:
+	LONG $0x00000001 // .long 1
+	LONG $0x00000000 // .long 0
+	LONG $0x00000000 // .long 0
+	LONG $0x00000000 // .long 0
+
+	// .p2align 4, 0x90
+_skip_one:
+	BYTE $0x55                                               // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                                 // movq         %rsp, %rbp
+	WORD $0x8948; BYTE $0xd0                                 // movq         %rdx, %rax
+	WORD $0x8948; BYTE $0xf2                                 // movq         %rsi, %rdx
+	WORD $0x8948; BYTE $0xfe                                 // movq         %rdi, %rsi
+	QUAD $0xffffffdb0528f8c5                                 // vmovaps      $-37(%rip), %xmm0  /* LCPI30_0(%rip) */
+	LONG $0x0011f8c5                                         // vmovups      %xmm0, (%rax)
+	WORD $0x8948; BYTE $0xc7                                 // movq         %rax, %rdi
+	BYTE $0x5d                                               // popq         %rbp
+	LONG $0xfff25ee9; BYTE $0xff                             // jmp          _fsm_exec, $-3490(%rip)
+	QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00
+
+LCPI31_0:
+	LONG $0x00000001 // .long 1
+	LONG $0x00000000 // .long 0
+	LONG $0x00000000 // .long 0
+	LONG $0x00000000 // .long 0
+
+	// .p2align 4, 0x90
+_validate_one:
+	BYTE $0x55                           // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5             // movq         %rsp, %rbp
+	WORD $0x8948; BYTE $0xd0             // movq         %rdx, %rax
+	WORD $0x8948; BYTE $0xf2             // movq         %rsi, %rdx
+	WORD $0x8948; BYTE $0xfe             // movq         %rdi, %rsi
+	QUAD $0xffffffdb0528f8c5             // vmovaps      $-37(%rip), %xmm0  /* LCPI31_0(%rip) */
+	LONG $0x0011f8c5                     // vmovups      %xmm0, (%rax)
+	LONG $0x000020b9; BYTE $0x00         // movl         $32, %ecx
+	WORD $0x8948; BYTE $0xc7             // movq         %rax, %rdi
+	BYTE $0x5d                           // popq         %rbp
+	LONG $0xfff219e9; BYTE $0xff         // jmp          _fsm_exec, $-3559(%rip)
+	QUAD $0x0000000000000000; BYTE $0x00 // .p2align 4, 0x00
+
+LCPI32_0:
+	QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,'
+
+LCPI32_1:
+	QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
+
+LCPI32_2:
+	QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]'
+
+LCPI32_3:
+	QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
+
+LCPI32_4:
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+
+LCPI32_5:
+	QUAD $0x7b7b7b7b7b7b7b7b; QUAD $0x7b7b7b7b7b7b7b7b // .space 16, '{{{{{{{{{{{{{{{{'
+
+LCPI32_6:
+	QUAD $0x7d7d7d7d7d7d7d7d; QUAD $0x7d7d7d7d7d7d7d7d // .space 16, '}}}}}}}}}}}}}}}}'
+
+LCPI32_7:
+	QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b // .space 16, '[[[[[[[[[[[[[[[['
+
+	// .p2align 4, 0x90
+_skip_one_fast:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0xe0e48348                           // andq         $-32, %rsp
+	LONG $0x80ec8148; WORD $0x0000; BYTE $0x00 // subq         $128, %rsp
+	WORD $0x8949; BYTE $0xf6                   // movq         %rsi, %r14
+	WORD $0x8949; BYTE $0xff                   // movq         %rdi, %r15
+	WORD $0x8b48; BYTE $0x3f                   // movq         (%rdi), %rdi
+	LONG $0x08778b49                           // movq         $8(%r15), %rsi
+	WORD $0x894c; BYTE $0xf2                   // movq         %r14, %rdx
+	LONG $0xffe043e8; BYTE $0xff               // callq        _advance_ns, $-8125(%rip)
+	WORD $0x8b49; BYTE $0x16                   // movq         (%r14), %rdx
+	LONG $0xff528d4c                           // leaq         $-1(%rdx), %r10
+	WORD $0xbe0f; BYTE $0xc8                   // movsbl       %al, %ecx
+	WORD $0xf983; BYTE $0x7b                   // cmpl         $123, %ecx
+	LONG $0x0111870f; WORD $0x0000             // ja           LBB32_18, $273(%rip)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xd6358d48; WORD $0x0009; BYTE $0x00 // leaq         $2518(%rip), %rsi  /* LJTI32_0(%rip) */
+	LONG $0x8e0c6348                           // movslq       (%rsi,%rcx,4), %rcx
+	WORD $0x0148; BYTE $0xf1                   // addq         %rsi, %rcx
+	JMP  CX
+
+LBB32_2:
+	WORD $0x8b49; BYTE $0x07       // movq         (%r15), %rax
+	LONG $0x08778b49               // movq         $8(%r15), %rsi
+	WORD $0x8948; BYTE $0xf1       // movq         %rsi, %rcx
+	WORD $0x2948; BYTE $0xd1       // subq         %rdx, %rcx
+	LONG $0x10f98348               // cmpq         $16, %rcx
+	LONG $0x0909820f; WORD $0x0000 // jb           LBB32_82, $2313(%rip)
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	WORD $0xf748; BYTE $0xd9       // negq         %rcx
+	QUAD $0xffffff04056ff9c5       // vmovdqa      $-252(%rip), %xmm0  /* LCPI32_0(%rip) */
+	QUAD $0xffffff0c0d6ff9c5       // vmovdqa      $-244(%rip), %xmm1  /* LCPI32_1(%rip) */
+	QUAD $0xffffff14156ff9c5       // vmovdqa      $-236(%rip), %xmm2  /* LCPI32_2(%rip) */
+	LONG $0x90909090               // .p2align 4, 0x90
+
+LBB32_4:
+	LONG $0x1c6ffac5; BYTE $0x10   // vmovdqu      (%rax,%rdx), %xmm3
+	LONG $0xe074e1c5               // vpcmpeqb     %xmm0, %xmm3, %xmm4
+	LONG $0xd9dbe1c5               // vpand        %xmm1, %xmm3, %xmm3
+	LONG $0xda74e1c5               // vpcmpeqb     %xmm2, %xmm3, %xmm3
+	LONG $0xdcebe1c5               // vpor         %xmm4, %xmm3, %xmm3
+	LONG $0xfbd7f9c5               // vpmovmskb    %xmm3, %edi
+	WORD $0xff85                   // testl        %edi, %edi
+	LONG $0x006b850f; WORD $0x0000 // jne          LBB32_14, $107(%rip)
+	LONG $0x10c28348               // addq         $16, %rdx
+	LONG $0x0e3c8d48               // leaq         (%rsi,%rcx), %rdi
+	LONG $0xf0c78348               // addq         $-16, %rdi
+	LONG $0xf0c18348               // addq         $-16, %rcx
+	LONG $0x0fff8348               // cmpq         $15, %rdi
+	LONG $0xffc5870f; WORD $0xffff // ja           LBB32_4, $-59(%rip)
+	WORD $0x8948; BYTE $0xc2       // movq         %rax, %rdx
+	WORD $0x2948; BYTE $0xca       // subq         %rcx, %rdx
+	WORD $0x0148; BYTE $0xce       // addq         %rcx, %rsi
+	WORD $0x8948; BYTE $0xf1       // movq         %rsi, %rcx
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x0034840f; WORD $0x0000 // je           LBB32_13, $52(%rip)
+
+LBB32_7:
+	LONG $0x0a3c8d48 // leaq         (%rdx,%rcx), %rdi
+	WORD $0xf631     // xorl         %esi, %esi
+
+LBB32_8:
+	LONG $0x321cb60f               // movzbl       (%rdx,%rsi), %ebx
+	WORD $0xfb83; BYTE $0x2c       // cmpl         $44, %ebx
+	LONG $0x0859840f; WORD $0x0000 // je           LBB32_80, $2137(%rip)
+	WORD $0xfb83; BYTE $0x7d       // cmpl         $125, %ebx
+	LONG $0x0850840f; WORD $0x0000 // je           LBB32_80, $2128(%rip)
+	WORD $0xfb83; BYTE $0x5d       // cmpl         $93, %ebx
+	LONG $0x0847840f; WORD $0x0000 // je           LBB32_80, $2119(%rip)
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0x3948; BYTE $0xf1       // cmpq         %rsi, %rcx
+	LONG $0xffd5850f; WORD $0xffff // jne          LBB32_8, $-43(%rip)
+	WORD $0x8948; BYTE $0xfa       // movq         %rdi, %rdx
+
+LBB32_13:
+	WORD $0x2948; BYTE $0xc2     // subq         %rax, %rdx
+	LONG $0x000836e9; BYTE $0x00 // jmp          LBB32_81, $2102(%rip)
+
+LBB32_14:
+	LONG $0xc7bc0f66         // bsfw         %di, %ax
+	WORD $0xb70f; BYTE $0xc0 // movzwl       %ax, %eax
+	WORD $0x2948; BYTE $0xc8 // subq         %rcx, %rax
+	WORD $0x8949; BYTE $0x06 // movq         %rax, (%r14)
+
+LBB32_15:
+	WORD $0x894c; BYTE $0xd0 // movq         %r10, %rax
+
+LBB32_16:
+	LONG $0xd8658d48         // leaq         $-40(%rbp), %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	BYTE $0xc3               // retq
+
+LBB32_17:
+	LONG $0x03c28348               // addq         $3, %rdx
+	LONG $0x08573b49               // cmpq         $8(%r15), %rdx
+	LONG $0xffe0830f; WORD $0xffff // jae          LBB32_16, $-32(%rip)
+	LONG $0x000801e9; BYTE $0x00   // jmp          LBB32_81, $2049(%rip)
+
+LBB32_18:
+	WORD $0x894d; BYTE $0x16                   // movq         %r10, (%r14)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	LONG $0xffffcce9; BYTE $0xff               // jmp          LBB32_16, $-52(%rip)
+
+LBB32_19:
+	WORD $0x894d; BYTE $0xd0       // movq         %r10, %r8
+	WORD $0x8b49; BYTE $0x0f       // movq         (%r15), %rcx
+	LONG $0x084f8b4d               // movq         $8(%r15), %r9
+	LONG $0x244c8948; BYTE $0x08   // movq         %rcx, $8(%rsp)
+	LONG $0x11148d4c               // leaq         (%rcx,%rdx), %r10
+	WORD $0x2949; BYTE $0xd1       // subq         %rdx, %r9
+	LONG $0x20f98349               // cmpq         $32, %r9
+	LONG $0x07e9820f; WORD $0x0000 // jb           LBB32_27, $2025(%rip)
+	WORD $0x3145; BYTE $0xff       // xorl         %r15d, %r15d
+	QUAD $0xfffffe25056ff9c5       // vmovdqa      $-475(%rip), %xmm0  /* LCPI32_3(%rip) */
+	QUAD $0xfffffe2d0d6ff9c5       // vmovdqa      $-467(%rip), %xmm1  /* LCPI32_4(%rip) */
+	WORD $0x3145; BYTE $0xed       // xorl         %r13d, %r13d
+	WORD $0x3145; BYTE $0xdb       // xorl         %r11d, %r11d
+	LONG $0x000028e9; BYTE $0x00   // jmp          LBB32_21, $40(%rip)
+	WORD $0x9090                   // .p2align 4, 0x90
+
+LBB32_23:
+	WORD $0x3145; BYTE $0xdb       // xorl         %r11d, %r11d
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x009d850f; WORD $0x0000 // jne          LBB32_79, $157(%rip)
+
+LBB32_24:
+	LONG $0x20c58349               // addq         $32, %r13
+	LONG $0x390c8d4b               // leaq         (%r9,%r15), %rcx
+	LONG $0xe0c18348               // addq         $-32, %rcx
+	LONG $0xe0c78349               // addq         $-32, %r15
+	LONG $0x1ff98348               // cmpq         $31, %rcx
+	LONG $0x0794860f; WORD $0x0000 // jbe          LBB32_25, $1940(%rip)
+
+LBB32_21:
+	LONG $0x6f7a81c4; WORD $0x2a14             // vmovdqu      (%r10,%r13), %xmm2
+	LONG $0x6f7a81c4; WORD $0x2a5c; BYTE $0x10 // vmovdqu      $16(%r10,%r13), %xmm3
+	LONG $0xe074e9c5                           // vpcmpeqb     %xmm0, %xmm2, %xmm4
+	LONG $0xfcd7f9c5                           // vpmovmskb    %xmm4, %edi
+	LONG $0xe074e1c5                           // vpcmpeqb     %xmm0, %xmm3, %xmm4
+	LONG $0xccd7f9c5                           // vpmovmskb    %xmm4, %ecx
+	LONG $0x10e1c148                           // shlq         $16, %rcx
+	WORD $0x0948; BYTE $0xf9                   // orq          %rdi, %rcx
+	LONG $0xd174e9c5                           // vpcmpeqb     %xmm1, %xmm2, %xmm2
+	LONG $0xf2d7f9c5                           // vpmovmskb    %xmm2, %esi
+	LONG $0xd174e1c5                           // vpcmpeqb     %xmm1, %xmm3, %xmm2
+	LONG $0xfad7f9c5                           // vpmovmskb    %xmm2, %edi
+	LONG $0x10e7c148                           // shlq         $16, %rdi
+	WORD $0x0948; BYTE $0xf7                   // orq          %rsi, %rdi
+	WORD $0x8948; BYTE $0xfe                   // movq         %rdi, %rsi
+	WORD $0x094c; BYTE $0xde                   // orq          %r11, %rsi
+	LONG $0xff93840f; WORD $0xffff             // je           LBB32_23, $-109(%rip)
+	WORD $0x8944; BYTE $0xde                   // movl         %r11d, %esi
+	WORD $0xd6f7                               // notl         %esi
+	WORD $0xfe21                               // andl         %edi, %esi
+	LONG $0x36248d44                           // leal         (%rsi,%rsi), %r12d
+	WORD $0x0945; BYTE $0xdc                   // orl          %r11d, %r12d
+	WORD $0x8944; BYTE $0xe3                   // movl         %r12d, %ebx
+	WORD $0xd3f7                               // notl         %ebx
+	WORD $0xfb21                               // andl         %edi, %ebx
+	LONG $0xaaaae381; WORD $0xaaaa             // andl         $-1431655766, %ebx
+	WORD $0x3145; BYTE $0xdb                   // xorl         %r11d, %r11d
+	WORD $0xf301                               // addl         %esi, %ebx
+	LONG $0xc3920f41                           // setb         %r11b
+	WORD $0xdb01                               // addl         %ebx, %ebx
+	LONG $0x5555f381; WORD $0x5555             // xorl         $1431655765, %ebx
+	WORD $0x2144; BYTE $0xe3                   // andl         %r12d, %ebx
+	WORD $0xd3f7                               // notl         %ebx
+	WORD $0xd921                               // andl         %ebx, %ecx
+	WORD $0x8548; BYTE $0xc9                   // testq        %rcx, %rcx
+	LONG $0xff63840f; WORD $0xffff             // je           LBB32_24, $-157(%rip)
+
+LBB32_79:
+	WORD $0xbc0f; BYTE $0xc1     // bsfl         %ecx, %eax
+	WORD $0x0148; BYTE $0xd0     // addq         %rdx, %rax
+	WORD $0x014c; BYTE $0xe8     // addq         %r13, %rax
+	WORD $0xff48; BYTE $0xc0     // incq         %rax
+	WORD $0x8949; BYTE $0x06     // movq         %rax, (%r14)
+	WORD $0x894c; BYTE $0xc0     // movq         %r8, %rax
+	LONG $0xfffecce9; BYTE $0xff // jmp          LBB32_16, $-308(%rip)
+
+LBB32_28:
+	LONG $0x084f8b49               // movq         $8(%r15), %rcx
+	WORD $0x2948; BYTE $0xd1       // subq         %rdx, %rcx
+	WORD $0x0349; BYTE $0x17       // addq         (%r15), %rdx
+	WORD $0x3145; BYTE $0xc9       // xorl         %r9d, %r9d
+	QUAD $0xfffffd4b156f79c5       // vmovdqa      $-693(%rip), %xmm10  /* LCPI32_4(%rip) */
+	QUAD $0xfffffd330d6ff9c5       // vmovdqa      $-717(%rip), %xmm1  /* LCPI32_3(%rip) */
+	LONG $0x763141c4; BYTE $0xc9   // vpcmpeqd     %xmm9, %xmm9, %xmm9
+	QUAD $0xfffffd661d6ff9c5       // vmovdqa      $-666(%rip), %xmm3  /* LCPI32_7(%rip) */
+	QUAD $0xfffffd0e256ff9c5       // vmovdqa      $-754(%rip), %xmm4  /* LCPI32_2(%rip) */
+	LONG $0x573841c4; BYTE $0xc0   // vxorps       %xmm8, %xmm8, %xmm8
+	WORD $0x3145; BYTE $0xdb       // xorl         %r11d, %r11d
+	WORD $0x3145; BYTE $0xc0       // xorl         %r8d, %r8d
+	WORD $0xf631                   // xorl         %esi, %esi
+	LONG $0x2454894c; BYTE $0x18   // movq         %r10, $24(%rsp)
+	LONG $0x40f98348               // cmpq         $64, %rcx
+	LONG $0x244c8948; BYTE $0x08   // movq         %rcx, $8(%rsp)
+	LONG $0x011f8d0f; WORD $0x0000 // jge          LBB32_29, $287(%rip)
+
+LBB32_38:
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x06cc8e0f; WORD $0x0000 // jle          LBB32_83, $1740(%rip)
+	LONG $0x44297cc5; WORD $0x4024 // vmovaps      %ymm8, $64(%rsp)
+	LONG $0x44297cc5; WORD $0x2024 // vmovaps      %ymm8, $32(%rsp)
+	WORD $0xd189                   // movl         %edx, %ecx
+	LONG $0x0fffe181; WORD $0x0000 // andl         $4095, %ecx
+	LONG $0x0fc1f981; WORD $0x0000 // cmpl         $4033, %ecx
+	LONG $0x00f6820f; WORD $0x0000 // jb           LBB32_29, $246(%rip)
+	LONG $0x247c8348; WORD $0x2008 // cmpq         $32, $8(%rsp)
+	LONG $0x0021820f; WORD $0x0000 // jb           LBB32_42, $33(%rip)
+	LONG $0x026ffec5               // vmovdqu      (%rdx), %ymm0
+	LONG $0x447ffdc5; WORD $0x2024 // vmovdqa      %ymm0, $32(%rsp)
+	LONG $0x20c28348               // addq         $32, %rdx
+	LONG $0x244c8b48; BYTE $0x08   // movq         $8(%rsp), %rcx
+	LONG $0xe0798d48               // leaq         $-32(%rcx), %rdi
+	LONG $0x245c8d48; BYTE $0x40   // leaq         $64(%rsp), %rbx
+	LONG $0x00000ae9; BYTE $0x00   // jmp          LBB32_43, $10(%rip)
+
+LBB32_42:
+	LONG $0x245c8d48; BYTE $0x20 // leaq         $32(%rsp), %rbx
+	LONG $0x247c8b48; BYTE $0x08 // movq         $8(%rsp), %rdi
+
+LBB32_43:
+	LONG $0x10ff8348               // cmpq         $16, %rdi
+	LONG $0x0058820f; WORD $0x0000 // jb           LBB32_44, $88(%rip)
+	LONG $0x026ffac5               // vmovdqu      (%rdx), %xmm0
+	LONG $0x037ffac5               // vmovdqu      %xmm0, (%rbx)
+	LONG $0x10c28348               // addq         $16, %rdx
+	LONG $0x10c38348               // addq         $16, %rbx
+	LONG $0xf0c78348               // addq         $-16, %rdi
+	LONG $0x08ff8348               // cmpq         $8, %rdi
+	LONG $0x0044830f; WORD $0x0000 // jae          LBB32_49, $68(%rip)
+
+LBB32_45:
+	LONG $0x04ff8348               // cmpq         $4, %rdi
+	LONG $0x0056820f; WORD $0x0000 // jb           LBB32_46, $86(%rip)
+
+LBB32_50:
+	WORD $0x0a8b                   // movl         (%rdx), %ecx
+	WORD $0x0b89                   // movl         %ecx, (%rbx)
+	LONG $0x04c28348               // addq         $4, %rdx
+	LONG $0x04c38348               // addq         $4, %rbx
+	LONG $0xfcc78348               // addq         $-4, %rdi
+	LONG $0x02ff8348               // cmpq         $2, %rdi
+	LONG $0x0046830f; WORD $0x0000 // jae          LBB32_51, $70(%rip)
+
+LBB32_47:
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	LONG $0x24548d48; BYTE $0x20   // leaq         $32(%rsp), %rdx
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0x0058850f; WORD $0x0000 // jne          LBB32_52, $88(%rip)
+	LONG $0x00005de9; BYTE $0x00   // jmp          LBB32_29, $93(%rip)
+
+LBB32_44:
+	LONG $0x08ff8348               // cmpq         $8, %rdi
+	LONG $0xffbc820f; WORD $0xffff // jb           LBB32_45, $-68(%rip)
+
+LBB32_49:
+	WORD $0x8b48; BYTE $0x0a       // movq         (%rdx), %rcx
+	WORD $0x8948; BYTE $0x0b       // movq         %rcx, (%rbx)
+	LONG $0x08c28348               // addq         $8, %rdx
+	LONG $0x08c38348               // addq         $8, %rbx
+	LONG $0xf8c78348               // addq         $-8, %rdi
+	LONG $0x04ff8348               // cmpq         $4, %rdi
+	LONG $0xffaa830f; WORD $0xffff // jae          LBB32_50, $-86(%rip)
+
+LBB32_46:
+	LONG $0x02ff8348               // cmpq         $2, %rdi
+	LONG $0xffba820f; WORD $0xffff // jb           LBB32_47, $-70(%rip)
+
+LBB32_51:
+	WORD $0xb70f; BYTE $0x0a       // movzwl       (%rdx), %ecx
+	WORD $0x8966; BYTE $0x0b       // movw         %cx, (%rbx)
+	LONG $0x02c28348               // addq         $2, %rdx
+	LONG $0x02c38348               // addq         $2, %rbx
+	LONG $0xfec78348               // addq         $-2, %rdi
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	LONG $0x24548d48; BYTE $0x20   // leaq         $32(%rsp), %rdx
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0x000a840f; WORD $0x0000 // je           LBB32_29, $10(%rip)
+
+LBB32_52:
+	WORD $0xb60f; BYTE $0x09     // movzbl       (%rcx), %ecx
+	WORD $0x0b88                 // movb         %cl, (%rbx)
+	LONG $0x24548d48; BYTE $0x20 // leaq         $32(%rsp), %rdx
+
+LBB32_29:
+	LONG $0x126ffac5                           // vmovdqu      (%rdx), %xmm2
+	LONG $0x6a6ffac5; BYTE $0x10               // vmovdqu      $16(%rdx), %xmm5
+	LONG $0x7a6ffac5; BYTE $0x20               // vmovdqu      $32(%rdx), %xmm7
+	LONG $0x726ffac5; BYTE $0x30               // vmovdqu      $48(%rdx), %xmm6
+	LONG $0xc274a9c5                           // vpcmpeqb     %xmm2, %xmm10, %xmm0
+	LONG $0xe8d779c5                           // vpmovmskb    %xmm0, %r13d
+	LONG $0xc574a9c5                           // vpcmpeqb     %xmm5, %xmm10, %xmm0
+	LONG $0xf8d7f9c5                           // vpmovmskb    %xmm0, %edi
+	LONG $0xc774a9c5                           // vpcmpeqb     %xmm7, %xmm10, %xmm0
+	LONG $0xd8d7f9c5                           // vpmovmskb    %xmm0, %ebx
+	LONG $0xc674a9c5                           // vpcmpeqb     %xmm6, %xmm10, %xmm0
+	LONG $0xc8d7f9c5                           // vpmovmskb    %xmm0, %ecx
+	LONG $0x30e1c148                           // shlq         $48, %rcx
+	LONG $0x20e3c148                           // shlq         $32, %rbx
+	WORD $0x0948; BYTE $0xcb                   // orq          %rcx, %rbx
+	LONG $0x10e7c148                           // shlq         $16, %rdi
+	WORD $0x0948; BYTE $0xdf                   // orq          %rbx, %rdi
+	WORD $0x0949; BYTE $0xfd                   // orq          %rdi, %r13
+	WORD $0x894c; BYTE $0xe9                   // movq         %r13, %rcx
+	WORD $0x094c; BYTE $0xd9                   // orq          %r11, %rcx
+	LONG $0x0013850f; WORD $0x0000             // jne          LBB32_31, $19(%rip)
+	LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r13
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0x244c8948; BYTE $0x10               // movq         %rcx, $16(%rsp)
+	LONG $0x00004ae9; BYTE $0x00               // jmp          LBB32_32, $74(%rip)
+
+LBB32_31:
+	WORD $0x894c; BYTE $0xd9               // movq         %r11, %rcx
+	WORD $0xf748; BYTE $0xd1               // notq         %rcx
+	WORD $0x214c; BYTE $0xe9               // andq         %r13, %rcx
+	LONG $0x09148d4c                       // leaq         (%rcx,%rcx), %r10
+	WORD $0x094d; BYTE $0xda               // orq          %r11, %r10
+	WORD $0x894c; BYTE $0xd7               // movq         %r10, %rdi
+	WORD $0xf748; BYTE $0xd7               // notq         %rdi
+	QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq      $-6148914691236517206, %rbx
+	WORD $0x2149; BYTE $0xdd               // andq         %rbx, %r13
+	WORD $0x2149; BYTE $0xfd               // andq         %rdi, %r13
+	WORD $0xff31                           // xorl         %edi, %edi
+	WORD $0x0149; BYTE $0xcd               // addq         %rcx, %r13
+	LONG $0xc7920f40                       // setb         %dil
+	LONG $0x247c8948; BYTE $0x10           // movq         %rdi, $16(%rsp)
+	WORD $0x014d; BYTE $0xed               // addq         %r13, %r13
+	QUAD $0x555555555555b948; WORD $0x5555 // movabsq      $6148914691236517205, %rcx
+	WORD $0x3149; BYTE $0xcd               // xorq         %rcx, %r13
+	WORD $0x214d; BYTE $0xd5               // andq         %r10, %r13
+	WORD $0xf749; BYTE $0xd5               // notq         %r13
+
+LBB32_32:
+	LONG $0xc174c9c5               // vpcmpeqb     %xmm1, %xmm6, %xmm0
+	LONG $0xc8d7f9c5               // vpmovmskb    %xmm0, %ecx
+	LONG $0x30e1c148               // shlq         $48, %rcx
+	LONG $0xc174c1c5               // vpcmpeqb     %xmm1, %xmm7, %xmm0
+	LONG $0xf8d7f9c5               // vpmovmskb    %xmm0, %edi
+	LONG $0x20e7c148               // shlq         $32, %rdi
+	WORD $0x0948; BYTE $0xcf       // orq          %rcx, %rdi
+	LONG $0xc174d1c5               // vpcmpeqb     %xmm1, %xmm5, %xmm0
+	LONG $0xc8d7f9c5               // vpmovmskb    %xmm0, %ecx
+	LONG $0x10e1c148               // shlq         $16, %rcx
+	WORD $0x0948; BYTE $0xf9       // orq          %rdi, %rcx
+	LONG $0xc174e9c5               // vpcmpeqb     %xmm1, %xmm2, %xmm0
+	LONG $0xf8d7f9c5               // vpmovmskb    %xmm0, %edi
+	WORD $0x0948; BYTE $0xcf       // orq          %rcx, %rdi
+	WORD $0x214c; BYTE $0xef       // andq         %r13, %rdi
+	LONG $0x6ef9e1c4; BYTE $0xc7   // vmovq        %rdi, %xmm0
+	LONG $0x4479c3c4; WORD $0x00c1 // vpclmulqdq   $0, %xmm9, %xmm0, %xmm0
+	LONG $0x7ef9c1c4; BYTE $0xc5   // vmovq        %xmm0, %r13
+	WORD $0x314d; BYTE $0xcd       // xorq         %r9, %r13
+	LONG $0xc374e9c5               // vpcmpeqb     %xmm3, %xmm2, %xmm0
+	LONG $0xd0d779c5               // vpmovmskb    %xmm0, %r10d
+	LONG $0xc374d1c5               // vpcmpeqb     %xmm3, %xmm5, %xmm0
+	LONG $0xf8d7f9c5               // vpmovmskb    %xmm0, %edi
+	LONG $0xc374c1c5               // vpcmpeqb     %xmm3, %xmm7, %xmm0
+	LONG $0xd8d7f9c5               // vpmovmskb    %xmm0, %ebx
+	LONG $0xc374c9c5               // vpcmpeqb     %xmm3, %xmm6, %xmm0
+	LONG $0xc8d779c5               // vpmovmskb    %xmm0, %r9d
+	LONG $0x30e1c149               // shlq         $48, %r9
+	LONG $0x20e3c148               // shlq         $32, %rbx
+	WORD $0x094c; BYTE $0xcb       // orq          %r9, %rbx
+	LONG $0x10e7c148               // shlq         $16, %rdi
+	WORD $0x0948; BYTE $0xdf       // orq          %rbx, %rdi
+	WORD $0x0949; BYTE $0xfa       // orq          %rdi, %r10
+	WORD $0x894d; BYTE $0xe9       // movq         %r13, %r9
+	WORD $0xf749; BYTE $0xd1       // notq         %r9
+	WORD $0x214d; BYTE $0xca       // andq         %r9, %r10
+	LONG $0xc474e9c5               // vpcmpeqb     %xmm4, %xmm2, %xmm0
+	LONG $0xf8d7f9c5               // vpmovmskb    %xmm0, %edi
+	LONG $0xc474d1c5               // vpcmpeqb     %xmm4, %xmm5, %xmm0
+	LONG $0xd8d7f9c5               // vpmovmskb    %xmm0, %ebx
+	LONG $0xc474c1c5               // vpcmpeqb     %xmm4, %xmm7, %xmm0
+	LONG $0xd8d779c5               // vpmovmskb    %xmm0, %r11d
+	LONG $0xc474c9c5               // vpcmpeqb     %xmm4, %xmm6, %xmm0
+	LONG $0xe0d779c5               // vpmovmskb    %xmm0, %r12d
+	LONG $0x30e4c149               // shlq         $48, %r12
+	LONG $0x20e3c149               // shlq         $32, %r11
+	WORD $0x094d; BYTE $0xe3       // orq          %r12, %r11
+	LONG $0x10e3c148               // shlq         $16, %rbx
+	WORD $0x094c; BYTE $0xdb       // orq          %r11, %rbx
+	WORD $0x0948; BYTE $0xdf       // orq          %rbx, %rdi
+	WORD $0x214c; BYTE $0xcf       // andq         %r9, %rdi
+	LONG $0x0032840f; WORD $0x0000 // je           LBB32_36, $50(%rip)
+	LONG $0x245c8b4c; BYTE $0x10   // movq         $16(%rsp), %r11
+	BYTE $0x90                     // .p2align 4, 0x90
+
+LBB32_34:
+	LONG $0xff4f8d48               // leaq         $-1(%rdi), %rcx
+	WORD $0x8948; BYTE $0xcb       // movq         %rcx, %rbx
+	WORD $0x214c; BYTE $0xd3       // andq         %r10, %rbx
+	LONG $0xb80f48f3; BYTE $0xdb   // popcntq      %rbx, %rbx
+	WORD $0x014c; BYTE $0xc3       // addq         %r8, %rbx
+	WORD $0x3948; BYTE $0xf3       // cmpq         %rsi, %rbx
+	LONG $0x03a5860f; WORD $0x0000 // jbe          LBB32_78, $933(%rip)
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0x2148; BYTE $0xcf       // andq         %rcx, %rdi
+	LONG $0xffd9850f; WORD $0xffff // jne          LBB32_34, $-39(%rip)
+	LONG $0x000005e9; BYTE $0x00   // jmp          LBB32_37, $5(%rip)
+
+LBB32_36:
+	LONG $0x245c8b4c; BYTE $0x10 // movq         $16(%rsp), %r11
+
+LBB32_37:
+	LONG $0x3ffdc149               // sarq         $63, %r13
+	LONG $0xb80f49f3; BYTE $0xca   // popcntq      %r10, %rcx
+	WORD $0x0149; BYTE $0xc8       // addq         %rcx, %r8
+	LONG $0x40c28348               // addq         $64, %rdx
+	LONG $0x244c8b48; BYTE $0x08   // movq         $8(%rsp), %rcx
+	LONG $0xc0c18348               // addq         $-64, %rcx
+	WORD $0x894d; BYTE $0xe9       // movq         %r13, %r9
+	LONG $0x40f98348               // cmpq         $64, %rcx
+	LONG $0x244c8948; BYTE $0x08   // movq         %rcx, $8(%rsp)
+	LONG $0xfe268d0f; WORD $0xffff // jge          LBB32_29, $-474(%rip)
+	LONG $0xfffd02e9; BYTE $0xff   // jmp          LBB32_38, $-766(%rip)
+
+LBB32_53:
+	LONG $0x04c28348               // addq         $4, %rdx
+	LONG $0x08573b49               // cmpq         $8(%r15), %rdx
+	LONG $0xfb6d830f; WORD $0xffff // jae          LBB32_16, $-1171(%rip)
+	LONG $0x00038ee9; BYTE $0x00   // jmp          LBB32_81, $910(%rip)
+
+LBB32_54:
+	LONG $0x084f8b49             // movq         $8(%r15), %rcx
+	WORD $0x2948; BYTE $0xd1     // subq         %rdx, %rcx
+	WORD $0x0349; BYTE $0x17     // addq         (%r15), %rdx
+	WORD $0x3145; BYTE $0xc9     // xorl         %r9d, %r9d
+	QUAD $0xfffff9e7156f79c5     // vmovdqa      $-1561(%rip), %xmm10  /* LCPI32_4(%rip) */
+	QUAD $0xfffff9cf0d6ff9c5     // vmovdqa      $-1585(%rip), %xmm1  /* LCPI32_3(%rip) */
+	LONG $0x763141c4; BYTE $0xc9 // vpcmpeqd     %xmm9, %xmm9, %xmm9
+	QUAD $0xfffff9e21d6ff9c5     // vmovdqa      $-1566(%rip), %xmm3  /* LCPI32_5(%rip) */
+	QUAD $0xfffff9ea256ff9c5     // vmovdqa      $-1558(%rip), %xmm4  /* LCPI32_6(%rip) */
+	LONG $0x573841c4; BYTE $0xc0 // vxorps       %xmm8, %xmm8, %xmm8
+	WORD $0x3145; BYTE $0xdb     // xorl         %r11d, %r11d
+	WORD $0x3145; BYTE $0xc0     // xorl         %r8d, %r8d
+	WORD $0xf631                 // xorl         %esi, %esi
+	LONG $0x2454894c; BYTE $0x18 // movq         %r10, $24(%rsp)
+	LONG $0x000021e9; BYTE $0x00 // jmp          LBB32_56, $33(%rip)
+
+LBB32_55:
+	LONG $0x3ffdc149             // sarq         $63, %r13
+	LONG $0xb80f49f3; BYTE $0xca // popcntq      %r10, %rcx
+	WORD $0x0149; BYTE $0xc8     // addq         %rcx, %r8
+	LONG $0x40c28348             // addq         $64, %rdx
+	LONG $0x244c8b48; BYTE $0x08 // movq         $8(%rsp), %rcx
+	LONG $0xc0c18348             // addq         $-64, %rcx
+	WORD $0x894d; BYTE $0xe9     // movq         %r13, %r9
+	LONG $0x245c8b4c; BYTE $0x10 // movq         $16(%rsp), %r11
+
+LBB32_56:
+	LONG $0x40f98348               // cmpq         $64, %rcx
+	LONG $0x244c8948; BYTE $0x08   // movq         %rcx, $8(%rsp)
+	LONG $0x01af8c0f; WORD $0x0000 // jl           LBB32_63, $431(%rip)
+
+LBB32_57:
+	LONG $0x126ffac5                           // vmovdqu      (%rdx), %xmm2
+	LONG $0x6a6ffac5; BYTE $0x10               // vmovdqu      $16(%rdx), %xmm5
+	LONG $0x7a6ffac5; BYTE $0x20               // vmovdqu      $32(%rdx), %xmm7
+	LONG $0x726ffac5; BYTE $0x30               // vmovdqu      $48(%rdx), %xmm6
+	LONG $0xc274a9c5                           // vpcmpeqb     %xmm2, %xmm10, %xmm0
+	LONG $0xe0d779c5                           // vpmovmskb    %xmm0, %r12d
+	LONG $0xc574a9c5                           // vpcmpeqb     %xmm5, %xmm10, %xmm0
+	LONG $0xf8d7f9c5                           // vpmovmskb    %xmm0, %edi
+	LONG $0xc774a9c5                           // vpcmpeqb     %xmm7, %xmm10, %xmm0
+	LONG $0xd8d7f9c5                           // vpmovmskb    %xmm0, %ebx
+	LONG $0xc674a9c5                           // vpcmpeqb     %xmm6, %xmm10, %xmm0
+	LONG $0xc8d7f9c5                           // vpmovmskb    %xmm0, %ecx
+	LONG $0x30e1c148                           // shlq         $48, %rcx
+	LONG $0x20e3c148                           // shlq         $32, %rbx
+	WORD $0x0948; BYTE $0xcb                   // orq          %rcx, %rbx
+	LONG $0x10e7c148                           // shlq         $16, %rdi
+	WORD $0x0948; BYTE $0xdf                   // orq          %rbx, %rdi
+	WORD $0x0949; BYTE $0xfc                   // orq          %rdi, %r12
+	WORD $0x894c; BYTE $0xe1                   // movq         %r12, %rcx
+	WORD $0x094c; BYTE $0xd9                   // orq          %r11, %rcx
+	LONG $0x0013850f; WORD $0x0000             // jne          LBB32_59, $19(%rip)
+	LONG $0xffc4c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r12
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0x244c8948; BYTE $0x10               // movq         %rcx, $16(%rsp)
+	LONG $0x00004ae9; BYTE $0x00               // jmp          LBB32_60, $74(%rip)
+
+LBB32_59:
+	WORD $0x894c; BYTE $0xd9               // movq         %r11, %rcx
+	WORD $0xf748; BYTE $0xd1               // notq         %rcx
+	WORD $0x214c; BYTE $0xe1               // andq         %r12, %rcx
+	LONG $0x09148d4c                       // leaq         (%rcx,%rcx), %r10
+	WORD $0x094d; BYTE $0xda               // orq          %r11, %r10
+	WORD $0x894c; BYTE $0xd7               // movq         %r10, %rdi
+	WORD $0xf748; BYTE $0xd7               // notq         %rdi
+	QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq      $-6148914691236517206, %rbx
+	WORD $0x2149; BYTE $0xdc               // andq         %rbx, %r12
+	WORD $0x2149; BYTE $0xfc               // andq         %rdi, %r12
+	WORD $0xff31                           // xorl         %edi, %edi
+	WORD $0x0149; BYTE $0xcc               // addq         %rcx, %r12
+	LONG $0xc7920f40                       // setb         %dil
+	LONG $0x247c8948; BYTE $0x10           // movq         %rdi, $16(%rsp)
+	WORD $0x014d; BYTE $0xe4               // addq         %r12, %r12
+	QUAD $0x555555555555b948; WORD $0x5555 // movabsq      $6148914691236517205, %rcx
+	WORD $0x3149; BYTE $0xcc               // xorq         %rcx, %r12
+	WORD $0x214d; BYTE $0xd4               // andq         %r10, %r12
+	WORD $0xf749; BYTE $0xd4               // notq         %r12
+
+LBB32_60:
+	LONG $0xc174c9c5                                   // vpcmpeqb     %xmm1, %xmm6, %xmm0
+	LONG $0xc8d7f9c5                                   // vpmovmskb    %xmm0, %ecx
+	LONG $0x30e1c148                                   // shlq         $48, %rcx
+	LONG $0xc174c1c5                                   // vpcmpeqb     %xmm1, %xmm7, %xmm0
+	LONG $0xf8d7f9c5                                   // vpmovmskb    %xmm0, %edi
+	LONG $0x20e7c148                                   // shlq         $32, %rdi
+	WORD $0x0948; BYTE $0xcf                           // orq          %rcx, %rdi
+	LONG $0xc174d1c5                                   // vpcmpeqb     %xmm1, %xmm5, %xmm0
+	LONG $0xc8d7f9c5                                   // vpmovmskb    %xmm0, %ecx
+	LONG $0x10e1c148                                   // shlq         $16, %rcx
+	WORD $0x0948; BYTE $0xf9                           // orq          %rdi, %rcx
+	LONG $0xc174e9c5                                   // vpcmpeqb     %xmm1, %xmm2, %xmm0
+	LONG $0xf8d7f9c5                                   // vpmovmskb    %xmm0, %edi
+	WORD $0x0948; BYTE $0xcf                           // orq          %rcx, %rdi
+	WORD $0x214c; BYTE $0xe7                           // andq         %r12, %rdi
+	LONG $0x6ef9e1c4; BYTE $0xc7                       // vmovq        %rdi, %xmm0
+	LONG $0x4479c3c4; WORD $0x00c1                     // vpclmulqdq   $0, %xmm9, %xmm0, %xmm0
+	LONG $0x7ef9c1c4; BYTE $0xc5                       // vmovq        %xmm0, %r13
+	WORD $0x314d; BYTE $0xcd                           // xorq         %r9, %r13
+	LONG $0xc374e9c5                                   // vpcmpeqb     %xmm3, %xmm2, %xmm0
+	LONG $0xd0d779c5                                   // vpmovmskb    %xmm0, %r10d
+	LONG $0xc374d1c5                                   // vpcmpeqb     %xmm3, %xmm5, %xmm0
+	LONG $0xf8d7f9c5                                   // vpmovmskb    %xmm0, %edi
+	LONG $0xc374c1c5                                   // vpcmpeqb     %xmm3, %xmm7, %xmm0
+	LONG $0xd8d7f9c5                                   // vpmovmskb    %xmm0, %ebx
+	LONG $0xc374c9c5                                   // vpcmpeqb     %xmm3, %xmm6, %xmm0
+	LONG $0xc8d779c5                                   // vpmovmskb    %xmm0, %r9d
+	LONG $0x30e1c149                                   // shlq         $48, %r9
+	LONG $0x20e3c148                                   // shlq         $32, %rbx
+	WORD $0x094c; BYTE $0xcb                           // orq          %r9, %rbx
+	LONG $0x10e7c148                                   // shlq         $16, %rdi
+	WORD $0x0948; BYTE $0xdf                           // orq          %rbx, %rdi
+	WORD $0x0949; BYTE $0xfa                           // orq          %rdi, %r10
+	WORD $0x894d; BYTE $0xe9                           // movq         %r13, %r9
+	WORD $0xf749; BYTE $0xd1                           // notq         %r9
+	WORD $0x214d; BYTE $0xca                           // andq         %r9, %r10
+	LONG $0xc474e9c5                                   // vpcmpeqb     %xmm4, %xmm2, %xmm0
+	LONG $0xf8d7f9c5                                   // vpmovmskb    %xmm0, %edi
+	LONG $0xc474d1c5                                   // vpcmpeqb     %xmm4, %xmm5, %xmm0
+	LONG $0xe0d779c5                                   // vpmovmskb    %xmm0, %r12d
+	LONG $0xc474c1c5                                   // vpcmpeqb     %xmm4, %xmm7, %xmm0
+	LONG $0xd8d7f9c5                                   // vpmovmskb    %xmm0, %ebx
+	LONG $0xc474c9c5                                   // vpcmpeqb     %xmm4, %xmm6, %xmm0
+	LONG $0xd8d779c5                                   // vpmovmskb    %xmm0, %r11d
+	LONG $0x30e3c149                                   // shlq         $48, %r11
+	LONG $0x20e3c148                                   // shlq         $32, %rbx
+	WORD $0x094c; BYTE $0xdb                           // orq          %r11, %rbx
+	LONG $0x10e4c149                                   // shlq         $16, %r12
+	WORD $0x0949; BYTE $0xdc                           // orq          %rbx, %r12
+	WORD $0x094c; BYTE $0xe7                           // orq          %r12, %rdi
+	WORD $0x214c; BYTE $0xcf                           // andq         %r9, %rdi
+	LONG $0xfe58840f; WORD $0xffff                     // je           LBB32_55, $-424(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB32_61:
+	LONG $0xff4f8d48               // leaq         $-1(%rdi), %rcx
+	WORD $0x8948; BYTE $0xcb       // movq         %rcx, %rbx
+	WORD $0x214c; BYTE $0xd3       // andq         %r10, %rbx
+	LONG $0xb80f48f3; BYTE $0xdb   // popcntq      %rbx, %rbx
+	WORD $0x014c; BYTE $0xc3       // addq         %r8, %rbx
+	WORD $0x3948; BYTE $0xf3       // cmpq         %rsi, %rbx
+	LONG $0x0135860f; WORD $0x0000 // jbe          LBB32_78, $309(%rip)
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0x2148; BYTE $0xcf       // andq         %rcx, %rdi
+	LONG $0xffd9850f; WORD $0xffff // jne          LBB32_61, $-39(%rip)
+	LONG $0xfffe21e9; BYTE $0xff   // jmp          LBB32_55, $-479(%rip)
+
+LBB32_63:
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x01938e0f; WORD $0x0000 // jle          LBB32_83, $403(%rip)
+	LONG $0x44297cc5; WORD $0x4024 // vmovaps      %ymm8, $64(%rsp)
+	LONG $0x44297cc5; WORD $0x2024 // vmovaps      %ymm8, $32(%rsp)
+	WORD $0xd189                   // movl         %edx, %ecx
+	LONG $0x0fffe181; WORD $0x0000 // andl         $4095, %ecx
+	LONG $0x0fc1f981; WORD $0x0000 // cmpl         $4033, %ecx
+	LONG $0xfe28820f; WORD $0xffff // jb           LBB32_57, $-472(%rip)
+	LONG $0x247c8348; WORD $0x2008 // cmpq         $32, $8(%rsp)
+	LONG $0x0021820f; WORD $0x0000 // jb           LBB32_67, $33(%rip)
+	LONG $0x0210fcc5               // vmovups      (%rdx), %ymm0
+	LONG $0x4429fcc5; WORD $0x2024 // vmovaps      %ymm0, $32(%rsp)
+	LONG $0x20c28348               // addq         $32, %rdx
+	LONG $0x244c8b48; BYTE $0x08   // movq         $8(%rsp), %rcx
+	LONG $0xe0798d48               // leaq         $-32(%rcx), %rdi
+	LONG $0x245c8d48; BYTE $0x40   // leaq         $64(%rsp), %rbx
+	LONG $0x00000ae9; BYTE $0x00   // jmp          LBB32_68, $10(%rip)
+
+LBB32_67:
+	LONG $0x245c8d48; BYTE $0x20 // leaq         $32(%rsp), %rbx
+	LONG $0x247c8b48; BYTE $0x08 // movq         $8(%rsp), %rdi
+
+LBB32_68:
+	LONG $0x10ff8348               // cmpq         $16, %rdi
+	LONG $0x0058820f; WORD $0x0000 // jb           LBB32_69, $88(%rip)
+	LONG $0x0210f8c5               // vmovups      (%rdx), %xmm0
+	LONG $0x0311f8c5               // vmovups      %xmm0, (%rbx)
+	LONG $0x10c28348               // addq         $16, %rdx
+	LONG $0x10c38348               // addq         $16, %rbx
+	LONG $0xf0c78348               // addq         $-16, %rdi
+	LONG $0x08ff8348               // cmpq         $8, %rdi
+	LONG $0x0044830f; WORD $0x0000 // jae          LBB32_74, $68(%rip)
+
+LBB32_70:
+	LONG $0x04ff8348               // cmpq         $4, %rdi
+	LONG $0x0056820f; WORD $0x0000 // jb           LBB32_71, $86(%rip)
+
+LBB32_75:
+	WORD $0x0a8b                   // movl         (%rdx), %ecx
+	WORD $0x0b89                   // movl         %ecx, (%rbx)
+	LONG $0x04c28348               // addq         $4, %rdx
+	LONG $0x04c38348               // addq         $4, %rbx
+	LONG $0xfcc78348               // addq         $-4, %rdi
+	LONG $0x02ff8348               // cmpq         $2, %rdi
+	LONG $0x0046830f; WORD $0x0000 // jae          LBB32_76, $70(%rip)
+
+LBB32_72:
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	LONG $0x24548d48; BYTE $0x20   // leaq         $32(%rsp), %rdx
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0x0058850f; WORD $0x0000 // jne          LBB32_77, $88(%rip)
+	LONG $0xfffd8fe9; BYTE $0xff   // jmp          LBB32_57, $-625(%rip)
+
+LBB32_69:
+	LONG $0x08ff8348               // cmpq         $8, %rdi
+	LONG $0xffbc820f; WORD $0xffff // jb           LBB32_70, $-68(%rip)
+
+LBB32_74:
+	WORD $0x8b48; BYTE $0x0a       // movq         (%rdx), %rcx
+	WORD $0x8948; BYTE $0x0b       // movq         %rcx, (%rbx)
+	LONG $0x08c28348               // addq         $8, %rdx
+	LONG $0x08c38348               // addq         $8, %rbx
+	LONG $0xf8c78348               // addq         $-8, %rdi
+	LONG $0x04ff8348               // cmpq         $4, %rdi
+	LONG $0xffaa830f; WORD $0xffff // jae          LBB32_75, $-86(%rip)
+
+LBB32_71:
+	LONG $0x02ff8348               // cmpq         $2, %rdi
+	LONG $0xffba820f; WORD $0xffff // jb           LBB32_72, $-70(%rip)
+
+LBB32_76:
+	WORD $0xb70f; BYTE $0x0a       // movzwl       (%rdx), %ecx
+	WORD $0x8966; BYTE $0x0b       // movw         %cx, (%rbx)
+	LONG $0x02c28348               // addq         $2, %rdx
+	LONG $0x02c38348               // addq         $2, %rbx
+	LONG $0xfec78348               // addq         $-2, %rdi
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	LONG $0x24548d48; BYTE $0x20   // leaq         $32(%rsp), %rdx
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0xfd3c840f; WORD $0xffff // je           LBB32_57, $-708(%rip)
+
+LBB32_77:
+	WORD $0xb60f; BYTE $0x09     // movzbl       (%rcx), %ecx
+	WORD $0x0b88                 // movb         %cl, (%rbx)
+	LONG $0x24548d48; BYTE $0x20 // leaq         $32(%rsp), %rdx
+	LONG $0xfffd2de9; BYTE $0xff // jmp          LBB32_57, $-723(%rip)
+
+LBB32_78:
+	LONG $0x08478b49                           // movq         $8(%r15), %rax
+	LONG $0xcfbc0f48                           // bsfq         %rdi, %rcx
+	LONG $0x244c2b48; BYTE $0x08               // subq         $8(%rsp), %rcx
+	WORD $0x0148; BYTE $0xc8                   // addq         %rcx, %rax
+	WORD $0xff48; BYTE $0xc0                   // incq         %rax
+	WORD $0x8949; BYTE $0x06                   // movq         %rax, (%r14)
+	LONG $0x084f8b49                           // movq         $8(%r15), %rcx
+	WORD $0x3948; BYTE $0xc8                   // cmpq         %rcx, %rax
+	LONG $0xc8420f48                           // cmovbq       %rax, %rcx
+	WORD $0x8949; BYTE $0x0e                   // movq         %rcx, (%r14)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0x244c8b48; BYTE $0x18               // movq         $24(%rsp), %rcx
+	LONG $0xc8470f48                           // cmovaq       %rax, %rcx
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	LONG $0xfff7e0e9; BYTE $0xff               // jmp          LBB32_16, $-2080(%rip)
+
+LBB32_80:
+	WORD $0x2948; BYTE $0xc2 // subq         %rax, %rdx
+	WORD $0x0148; BYTE $0xf2 // addq         %rsi, %rdx
+
+LBB32_81:
+	WORD $0x8949; BYTE $0x16     // movq         %rdx, (%r14)
+	LONG $0xfff7cfe9; BYTE $0xff // jmp          LBB32_15, $-2097(%rip)
+
+LBB32_25:
+	WORD $0x854d; BYTE $0xdb       // testq        %r11, %r11
+	LONG $0x0031850f; WORD $0x0000 // jne          LBB32_84, $49(%rip)
+	WORD $0x014d; BYTE $0xea       // addq         %r13, %r10
+	WORD $0x014d; BYTE $0xf9       // addq         %r15, %r9
+
+LBB32_27:
+	WORD $0x854d; BYTE $0xc9       // testq        %r9, %r9
+	LONG $0x0064850f; WORD $0x0000 // jne          LBB32_88, $100(%rip)
+	LONG $0xfff7b5e9; BYTE $0xff   // jmp          LBB32_16, $-2123(%rip)
+
+LBB32_82:
+	WORD $0x0148; BYTE $0xc2       // addq         %rax, %rdx
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0xf75d850f; WORD $0xffff // jne          LBB32_7, $-2211(%rip)
+	LONG $0xfff78ce9; BYTE $0xff   // jmp          LBB32_13, $-2164(%rip)
+
+LBB32_83:
+	LONG $0x084f8b49             // movq         $8(%r15), %rcx
+	WORD $0x8949; BYTE $0x0e     // movq         %rcx, (%r14)
+	LONG $0xfff798e9; BYTE $0xff // jmp          LBB32_16, $-2152(%rip)
+
+LBB32_84:
+	WORD $0x394d; BYTE $0xe9       // cmpq         %r13, %r9
+	LONG $0xf78f840f; WORD $0xffff // je           LBB32_16, $-2161(%rip)
+	WORD $0x014d; BYTE $0xea       // addq         %r13, %r10
+	WORD $0xff49; BYTE $0xc2       // incq         %r10
+	WORD $0xf749; BYTE $0xd5       // notq         %r13
+	WORD $0x014d; BYTE $0xe9       // addq         %r13, %r9
+	WORD $0x854d; BYTE $0xc9       // testq        %r9, %r9
+	LONG $0x0024850f; WORD $0x0000 // jne          LBB32_88, $36(%rip)
+	LONG $0xfff775e9; BYTE $0xff   // jmp          LBB32_16, $-2187(%rip)
+
+LBB32_86:
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0x000002b8; BYTE $0x00               // movl         $2, %eax
+	WORD $0x0149; BYTE $0xc2                   // addq         %rax, %r10
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x0149; BYTE $0xc9                   // addq         %rcx, %r9
+	LONG $0xf756840f; WORD $0xffff             // je           LBB32_16, $-2218(%rip)
+
+LBB32_88:
+	LONG $0x02b60f41                           // movzbl       (%r10), %eax
+	WORD $0xf883; BYTE $0x5c                   // cmpl         $92, %eax
+	LONG $0xffd4840f; WORD $0xffff             // je           LBB32_86, $-44(%rip)
+	WORD $0xf883; BYTE $0x22                   // cmpl         $34, %eax
+	LONG $0x0024840f; WORD $0x0000             // je           LBB32_91, $36(%rip)
+	LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rcx
+	LONG $0x000001b8; BYTE $0x00               // movl         $1, %eax
+	WORD $0x0149; BYTE $0xc2                   // addq         %rax, %r10
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x0149; BYTE $0xc9                   // addq         %rcx, %r9
+	LONG $0xffcb850f; WORD $0xffff             // jne          LBB32_88, $-53(%rip)
+	LONG $0xfff71ce9; BYTE $0xff               // jmp          LBB32_16, $-2276(%rip)
+
+LBB32_91:
+	LONG $0x24542b4c; BYTE $0x08 // subq         $8(%rsp), %r10
+	WORD $0xff49; BYTE $0xc2     // incq         %r10
+	WORD $0x894d; BYTE $0x16     // movq         %r10, (%r14)
+	WORD $0x894c; BYTE $0xc0     // movq         %r8, %rax
+	LONG $0xfff709e9; BYTE $0xff // jmp          LBB32_16, $-2295(%rip)
+	BYTE $0x90                   // .p2align 2, 0x90
+
+	// .set L32_0_set_16, LBB32_16-LJTI32_0
+	// .set L32_0_set_18, LBB32_18-LJTI32_0
+	// .set L32_0_set_19, LBB32_19-LJTI32_0
+	// .set L32_0_set_2, LBB32_2-LJTI32_0
+	// .set L32_0_set_28, LBB32_28-LJTI32_0
+	// .set L32_0_set_53, LBB32_53-LJTI32_0
+	// .set L32_0_set_17, LBB32_17-LJTI32_0
+	// .set L32_0_set_54, LBB32_54-LJTI32_0
+LJTI32_0:
+	LONG $0xfffff708                           // .long L32_0_set_16
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff73c                           // .long L32_0_set_19
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff633                           // .long L32_0_set_2
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff633                           // .long L32_0_set_2
+	LONG $0xfffff633                           // .long L32_0_set_2
+	LONG $0xfffff633                           // .long L32_0_set_2
+	LONG $0xfffff633                           // .long L32_0_set_2
+	LONG $0xfffff633                           // .long L32_0_set_2
+	LONG $0xfffff633                           // .long L32_0_set_2
+	LONG $0xfffff633                           // .long L32_0_set_2
+	LONG $0xfffff633                           // .long L32_0_set_2
+	LONG $0xfffff633                           // .long L32_0_set_2
+	LONG $0xfffff633                           // .long L32_0_set_2
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff83c                           // .long L32_0_set_28
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffffb8d                           // .long L32_0_set_53
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff71a                           // .long L32_0_set_17
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff71a                           // .long L32_0_set_17
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffff72d                           // .long L32_0_set_18
+	LONG $0xfffffba0                           // .long L32_0_set_54
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+_get_by_path:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5741                   // pushq        %r15
+	WORD $0x5641                   // pushq        %r14
+	WORD $0x5541                   // pushq        %r13
+	WORD $0x5441                   // pushq        %r12
+	BYTE $0x53                     // pushq        %rbx
+	LONG $0x38ec8348               // subq         $56, %rsp
+	WORD $0x8949; BYTE $0xf4       // movq         %rsi, %r12
+	WORD $0x8949; BYTE $0xfe       // movq         %rdi, %r14
+	LONG $0x08428b48               // movq         $8(%rdx), %rax
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x038d840f; WORD $0x0000 // je           LBB33_53, $909(%rip)
+	WORD $0x8b4c; BYTE $0x3a       // movq         (%rdx), %r15
+	LONG $0x04e0c148               // shlq         $4, %rax
+	WORD $0x014c; BYTE $0xf8       // addq         %r15, %rax
+	LONG $0xa0458948               // movq         %rax, $-96(%rbp)
+
+LBB33_2:
+	WORD $0x8b49; BYTE $0x3e                   // movq         (%r14), %rdi
+	LONG $0x08768b49                           // movq         $8(%r14), %rsi
+	WORD $0x894c; BYTE $0xe2                   // movq         %r12, %rdx
+	LONG $0xffd40fe8; BYTE $0xff               // callq        _advance_ns, $-11249(%rip)
+	WORD $0x8b49; BYTE $0x0f                   // movq         (%r15), %rcx
+	LONG $0x1749b60f                           // movzbl       $23(%rcx), %ecx
+	WORD $0xe180; BYTE $0x1f                   // andb         $31, %cl
+	WORD $0xf980; BYTE $0x18                   // cmpb         $24, %cl
+	LONG $0x02ec850f; WORD $0x0000             // jne          LBB33_47, $748(%rip)
+	WORD $0x7b3c                               // cmpb         $123, %al
+	LONG $0xc865894c                           // movq         %r12, $-56(%rbp)
+	LONG $0xd07d894c                           // movq         %r15, $-48(%rbp)
+	LONG $0x035d850f; WORD $0x0000             // jne          LBB33_54, $861(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+LBB33_4:
+	WORD $0x8b49; BYTE $0x3e       // movq         (%r14), %rdi
+	LONG $0x08768b49               // movq         $8(%r14), %rsi
+	WORD $0x894c; BYTE $0xe2       // movq         %r12, %rdx
+	LONG $0xffd3d1e8; BYTE $0xff   // callq        _advance_ns, $-11311(%rip)
+	WORD $0x223c                   // cmpb         $34, %al
+	LONG $0x033a850f; WORD $0x0000 // jne          LBB33_54, $826(%rip)
+	LONG $0x08478b49               // movq         $8(%r15), %rax
+	WORD $0x8b4c; BYTE $0x28       // movq         (%rax), %r13
+	LONG $0x08788b4c               // movq         $8(%rax), %r15
+	QUAD $0xffffffffb045c748       // movq         $-1, $-80(%rbp)
+	WORD $0x894c; BYTE $0xe3       // movq         %r12, %rbx
+	LONG $0x24248b4d               // movq         (%r12), %r12
+	WORD $0x894c; BYTE $0xf7       // movq         %r14, %rdi
+	WORD $0x894c; BYTE $0xe6       // movq         %r12, %rsi
+	LONG $0xb0558d48               // leaq         $-80(%rbp), %rdx
+	LONG $0x001c40e8; BYTE $0x00   // callq        _advance_string_default, $7232(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0322880f; WORD $0x0000 // js           LBB33_56, $802(%rip)
+	WORD $0x8948; BYTE $0x03       // movq         %rax, (%rbx)
+	LONG $0xb04d8b48               // movq         $-80(%rbp), %rcx
+	LONG $0xfff98348               // cmpq         $-1, %rcx
+	LONG $0x0009840f; WORD $0x0000 // je           LBB33_8, $9(%rip)
+	WORD $0x3948; BYTE $0xc1       // cmpq         %rax, %rcx
+	LONG $0x01578e0f; WORD $0x0000 // jle          LBB33_27, $343(%rip)
+
+LBB33_8:
+	WORD $0x894c; BYTE $0xe1       // movq         %r12, %rcx
+	WORD $0xf748; BYTE $0xd1       // notq         %rcx
+	WORD $0x0148; BYTE $0xc8       // addq         %rcx, %rax
+	WORD $0x394c; BYTE $0xf8       // cmpq         %r15, %rax
+	LONG $0x003e850f; WORD $0x0000 // jne          LBB33_12, $62(%rip)
+	WORD $0x034d; BYTE $0x26       // addq         (%r14), %r12
+	WORD $0x894c; BYTE $0xe9       // movq         %r13, %rcx
+	WORD $0x894c; BYTE $0xe0       // movq         %r12, %rax
+	WORD $0x9090                   // .p2align 4, 0x90
+
+LBB33_10:
+	LONG $0x10ff8349               // cmpq         $16, %r15
+	LONG $0x0086820f; WORD $0x0000 // jb           LBB33_17, $134(%rip)
+	LONG $0x006ffac5               // vmovdqu      (%rax), %xmm0
+	LONG $0xf879c1c4; WORD $0x0045 // vpsubb       (%r13), %xmm0, %xmm0
+	LONG $0x10c08348               // addq         $16, %rax
+	LONG $0x10c58349               // addq         $16, %r13
+	LONG $0xf0c78349               // addq         $-16, %r15
+	LONG $0x10c18348               // addq         $16, %rcx
+	LONG $0x10c48349               // addq         $16, %r12
+	LONG $0x1779e2c4; BYTE $0xc0   // vptest       %xmm0, %xmm0
+	LONG $0xffcd840f; WORD $0xffff // je           LBB33_10, $-51(%rip)
+
+LBB33_12:
+	WORD $0xdb31 // xorl         %ebx, %ebx
+
+LBB33_13:
+	LONG $0xc8658b4c // movq         $-56(%rbp), %r12
+
+LBB33_14:
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	WORD $0x8b49; BYTE $0x3e                   // movq         (%r14), %rdi
+	LONG $0x08768b49                           // movq         $8(%r14), %rsi
+	WORD $0x894c; BYTE $0xe2                   // movq         %r12, %rdx
+	LONG $0xffd314e8; BYTE $0xff               // callq        _advance_ns, $-11500(%rip)
+	WORD $0x3a3c                               // cmpb         $58, %al
+	LONG $0x027d850f; WORD $0x0000             // jne          LBB33_54, $637(%rip)
+	WORD $0x8548; BYTE $0xdb                   // testq        %rbx, %rbx
+	LONG $0x0253850f; WORD $0x0000             // jne          LBB33_52, $595(%rip)
+	WORD $0x894c; BYTE $0xf7                   // movq         %r14, %rdi
+	WORD $0x894c; BYTE $0xe6                   // movq         %r12, %rsi
+	LONG $0xfff288e8; BYTE $0xff               // callq        _skip_one_fast, $-3448(%rip)
+	WORD $0x8b49; BYTE $0x3e                   // movq         (%r14), %rdi
+	LONG $0x08768b49                           // movq         $8(%r14), %rsi
+	WORD $0x894c; BYTE $0xe2                   // movq         %r12, %rdx
+	LONG $0xffd2e9e8; BYTE $0xff               // callq        _advance_ns, $-11543(%rip)
+	WORD $0x2c3c                               // cmpb         $44, %al
+	LONG $0xff01840f; WORD $0xffff             // je           LBB33_4, $-255(%rip)
+	LONG $0x00024de9; BYTE $0x00               // jmp          LBB33_54, $589(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+LBB33_17:
+	LONG $0xffe48141; WORD $0x000f; BYTE $0x00 // andl         $4095, %r12d
+	LONG $0xf0fc8141; WORD $0x000f; BYTE $0x00 // cmpl         $4080, %r12d
+	LONG $0x004d870f; WORD $0x0000             // ja           LBB33_21, $77(%rip)
+	LONG $0x0fffe181; WORD $0x0000             // andl         $4095, %ecx
+	LONG $0x0ff1f981; WORD $0x0000             // cmpl         $4081, %ecx
+	LONG $0x003b830f; WORD $0x0000             // jae          LBB33_21, $59(%rip)
+	LONG $0x006ffac5                           // vmovdqu      (%rax), %xmm0
+	LONG $0x6f7ac1c4; WORD $0x004d             // vmovdqu      (%r13), %xmm1
+	LONG $0xd1f8f9c5                           // vpsubb       %xmm1, %xmm0, %xmm2
+	LONG $0x1779e2c4; BYTE $0xd2               // vptest       %xmm2, %xmm2
+	LONG $0xc8658b4c                           // movq         $-56(%rbp), %r12
+	LONG $0x005d840f; WORD $0x0000             // je           LBB33_25, $93(%rip)
+	LONG $0xc174f9c5                           // vpcmpeqb     %xmm1, %xmm0, %xmm0
+	LONG $0xc0d7f9c5                           // vpmovmskb    %xmm0, %eax
+	WORD $0xd0f7                               // notl         %eax
+	LONG $0xc0bc0f66                           // bsfw         %ax, %ax
+	WORD $0xb70f; BYTE $0xc0                   // movzwl       %ax, %eax
+	WORD $0xdb31                               // xorl         %ebx, %ebx
+	WORD $0x3949; BYTE $0xc7                   // cmpq         %rax, %r15
+	WORD $0x960f; BYTE $0xc3                   // setbe        %bl
+	LONG $0xffff48e9; BYTE $0xff               // jmp          LBB33_14, $-184(%rip)
+
+LBB33_21:
+	LONG $0x000001bb; BYTE $0x00                       // movl         $1, %ebx
+	WORD $0x854d; BYTE $0xff                           // testq        %r15, %r15
+	LONG $0xc8658b4c                                   // movq         $-56(%rbp), %r12
+	LONG $0xff36840f; WORD $0xffff                     // je           LBB33_14, $-202(%rip)
+	WORD $0xc931                                       // xorl         %ecx, %ecx
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB33_23:
+	LONG $0x0814b60f               // movzbl       (%rax,%rcx), %edx
+	LONG $0x0d543a41; BYTE $0x00   // cmpb         (%r13,%rcx), %dl
+	LONG $0x011d850f; WORD $0x0000 // jne          LBB33_26, $285(%rip)
+	WORD $0xff48; BYTE $0xc1       // incq         %rcx
+	WORD $0x3949; BYTE $0xcf       // cmpq         %rcx, %r15
+	LONG $0xffe5850f; WORD $0xffff // jne          LBB33_23, $-27(%rip)
+	LONG $0xffff09e9; BYTE $0xff   // jmp          LBB33_14, $-247(%rip)
+
+LBB33_25:
+	LONG $0x000001bb; BYTE $0x00 // movl         $1, %ebx
+	LONG $0xfffeffe9; BYTE $0xff // jmp          LBB33_14, $-257(%rip)
+
+LBB33_27:
+	QUAD $0x00000000b845c748       // movq         $0, $-72(%rbp)
+	WORD $0x8b49; BYTE $0x0e       // movq         (%r14), %rcx
+	WORD $0x0149; BYTE $0xcc       // addq         %rcx, %r12
+	LONG $0xc065894c               // movq         %r12, $-64(%rbp)
+	LONG $0x01348d48               // leaq         (%rcx,%rax), %rsi
+	WORD $0xff48; BYTE $0xce       // decq         %rsi
+	LONG $0x2f3c8d4b               // leaq         (%r15,%r13), %rdi
+	WORD $0x3949; BYTE $0xf4       // cmpq         %rsi, %r12
+	LONG $0x00c9830f; WORD $0x0000 // jae          LBB33_44, $201(%rip)
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x00c08e0f; WORD $0x0000 // jle          LBB33_44, $192(%rip)
+	LONG $0xb8558d48               // leaq         $-72(%rbp), %rdx
+	LONG $0xa8758948               // movq         %rsi, $-88(%rbp)
+
+LBB33_30:
+	LONG $0x04b60f41; BYTE $0x24   // movzbl       (%r12), %eax
+	WORD $0x5c3c                   // cmpb         $92, %al
+	LONG $0x0069850f; WORD $0x0000 // jne          LBB33_37, $105(%rip)
+	WORD $0x8948; BYTE $0xfb       // movq         %rdi, %rbx
+	LONG $0xc07d8d48               // leaq         $-64(%rbp), %rdi
+	WORD $0x8949; BYTE $0xd7       // movq         %rdx, %r15
+	LONG $0x001e13e8; BYTE $0x00   // callq        _unescape, $7699(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0168880f; WORD $0x0000 // js           LBB33_57, $360(%rip)
+	LONG $0x280c8d48               // leaq         (%rax,%rbp), %rcx
+	LONG $0xb8c18348               // addq         $-72, %rcx
+	WORD $0x8948; BYTE $0xdf       // movq         %rbx, %rdi
+	WORD $0x3949; BYTE $0xdd       // cmpq         %rbx, %r13
+	LONG $0xc8658b4c               // movq         $-56(%rbp), %r12
+	LONG $0x0052830f; WORD $0x0000 // jae          LBB33_39, $82(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	WORD $0x894c; BYTE $0xfa       // movq         %r15, %rdx
+	WORD $0x894c; BYTE $0xf8       // movq         %r15, %rax
+	LONG $0x0049840f; WORD $0x0000 // je           LBB33_40, $73(%rip)
+
+LBB33_34:
+	LONG $0x5db60f41; BYTE $0x00   // movzbl       (%r13), %ebx
+	WORD $0x183a                   // cmpb         (%rax), %bl
+	LONG $0x003c850f; WORD $0x0000 // jne          LBB33_40, $60(%rip)
+	WORD $0xff49; BYTE $0xc5       // incq         %r13
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3949; BYTE $0xfd       // cmpq         %rdi, %r13
+	LONG $0x002d830f; WORD $0x0000 // jae          LBB33_40, $45(%rip)
+	WORD $0x3948; BYTE $0xc8       // cmpq         %rcx, %rax
+	LONG $0xffdb820f; WORD $0xffff // jb           LBB33_34, $-37(%rip)
+	LONG $0x00001fe9; BYTE $0x00   // jmp          LBB33_40, $31(%rip)
+
+LBB33_37:
+	LONG $0x00453a41               // cmpb         (%r13), %al
+	LONG $0xfe42850f; WORD $0xffff // jne          LBB33_12, $-446(%rip)
+	WORD $0xff49; BYTE $0xc4       // incq         %r12
+	LONG $0xc065894c               // movq         %r12, $-64(%rbp)
+	WORD $0xff49; BYTE $0xc5       // incq         %r13
+	LONG $0x000017e9; BYTE $0x00   // jmp          LBB33_42, $23(%rip)
+
+LBB33_39:
+	WORD $0x894c; BYTE $0xfa // movq         %r15, %rdx
+	WORD $0x894c; BYTE $0xf8 // movq         %r15, %rax
+
+LBB33_40:
+	WORD $0x3948; BYTE $0xc8       // cmpq         %rcx, %rax
+	LONG $0x002d850f; WORD $0x0000 // jne          LBB33_26, $45(%rip)
+	LONG $0xc0658b4c               // movq         $-64(%rbp), %r12
+	LONG $0xa8758b48               // movq         $-88(%rbp), %rsi
+
+LBB33_42:
+	WORD $0x3949; BYTE $0xf4       // cmpq         %rsi, %r12
+	LONG $0x0009830f; WORD $0x0000 // jae          LBB33_44, $9(%rip)
+	WORD $0x3949; BYTE $0xfd       // cmpq         %rdi, %r13
+	LONG $0xff48820f; WORD $0xffff // jb           LBB33_30, $-184(%rip)
+
+LBB33_44:
+	WORD $0x3149; BYTE $0xf4     // xorq         %rsi, %r12
+	WORD $0x3149; BYTE $0xfd     // xorq         %rdi, %r13
+	WORD $0xdb31                 // xorl         %ebx, %ebx
+	WORD $0x094d; BYTE $0xe5     // orq          %r12, %r13
+	WORD $0x940f; BYTE $0xc3     // sete         %bl
+	LONG $0xfffdf9e9; BYTE $0xff // jmp          LBB33_13, $-519(%rip)
+
+LBB33_26:
+	WORD $0xdb31                                           // xorl         %ebx, %ebx
+	LONG $0xfffdf6e9; BYTE $0xff                           // jmp          LBB33_14, $-522(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB33_47:
+	WORD $0xf980; BYTE $0x02       // cmpb         $2, %cl
+	LONG $0x0078850f; WORD $0x0000 // jne          LBB33_54, $120(%rip)
+	WORD $0x5b3c                   // cmpb         $91, %al
+	LONG $0x0070850f; WORD $0x0000 // jne          LBB33_54, $112(%rip)
+	LONG $0x08478b49               // movq         $8(%r15), %rax
+	WORD $0x8b48; BYTE $0x18       // movq         (%rax), %rbx
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	LONG $0x90909090; BYTE $0x90   // .p2align 4, 0x90
+
+LBB33_50:
+	WORD $0xff48; BYTE $0xcb                               // decq         %rbx
+	WORD $0x8548; BYTE $0xdb                               // testq        %rbx, %rbx
+	LONG $0x00348e0f; WORD $0x0000                         // jle          LBB33_52, $52(%rip)
+	WORD $0x894c; BYTE $0xf7                               // movq         %r14, %rdi
+	WORD $0x894c; BYTE $0xe6                               // movq         %r12, %rsi
+	LONG $0xfff069e8; BYTE $0xff                           // callq        _skip_one_fast, $-3991(%rip)
+	WORD $0x8b49; BYTE $0x3e                               // movq         (%r14), %rdi
+	LONG $0x08768b49                                       // movq         $8(%r14), %rsi
+	WORD $0x894c; BYTE $0xe2                               // movq         %r12, %rdx
+	LONG $0xffd0cae8; BYTE $0xff                           // callq        _advance_ns, $-12086(%rip)
+	WORD $0x2c3c                                           // cmpb         $44, %al
+	LONG $0xffd2840f; WORD $0xffff                         // je           LBB33_50, $-46(%rip)
+	LONG $0x00002ee9; BYTE $0x00                           // jmp          LBB33_54, $46(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB33_52:
+	LONG $0x10c78349               // addq         $16, %r15
+	LONG $0xa0458b48               // movq         $-96(%rbp), %rax
+	WORD $0x3949; BYTE $0xc7       // cmpq         %rax, %r15
+	LONG $0xfc81850f; WORD $0xffff // jne          LBB33_2, $-895(%rip)
+
+LBB33_53:
+	WORD $0x894c; BYTE $0xf7     // movq         %r14, %rdi
+	WORD $0x894c; BYTE $0xe6     // movq         %r12, %rsi
+	LONG $0xfff024e8; BYTE $0xff // callq        _skip_one_fast, $-4060(%rip)
+	LONG $0x00000be9; BYTE $0x00 // jmp          LBB33_55, $11(%rip)
+
+LBB33_54:
+	LONG $0x240cff49                           // decq         (%r12)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+
+LBB33_55:
+	LONG $0x38c48348 // addq         $56, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5d41     // popq         %r13
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB33_56:
+	LONG $0x08468b49                           // movq         $8(%r14), %rax
+	WORD $0x8948; BYTE $0x03                   // movq         %rax, (%rbx)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xffffdee9; BYTE $0xff               // jmp          LBB33_55, $-34(%rip)
+
+LBB33_57:
+	LONG $0xc04d8b48                                                     // movq         $-64(%rbp), %rcx
+	WORD $0x2b49; BYTE $0x0e                                             // subq         (%r14), %rcx
+	LONG $0xc8558b48                                                     // movq         $-56(%rbp), %rdx
+	WORD $0x8948; BYTE $0x0a                                             // movq         %rcx, (%rdx)
+	LONG $0xffffcbe9; BYTE $0xff                                         // jmp          LBB33_55, $-53(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+_validate_utf8:
+	BYTE $0x55                             // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5               // movq         %rsp, %rbp
+	WORD $0x5741                           // pushq        %r15
+	WORD $0x5641                           // pushq        %r14
+	WORD $0x5441                           // pushq        %r12
+	BYTE $0x53                             // pushq        %rbx
+	BYTE $0x50                             // pushq        %rax
+	WORD $0x8b4c; BYTE $0x17               // movq         (%rdi), %r10
+	LONG $0x085f8b4c                       // movq         $8(%rdi), %r11
+	WORD $0x8b48; BYTE $0x0e               // movq         (%rsi), %rcx
+	WORD $0x014c; BYTE $0xd1               // addq         %r10, %rcx
+	LONG $0x1a048d4f                       // leaq         (%r10,%r11), %r8
+	LONG $0xfdc08349                       // addq         $-3, %r8
+	LONG $0x00000de9; BYTE $0x00           // jmp          LBB34_1, $13(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB34_19:
+	WORD $0x0148; BYTE $0xd9 // addq         %rbx, %rcx
+
+LBB34_1:
+	WORD $0x394c; BYTE $0xc1                                             // cmpq         %r8, %rcx
+	LONG $0x00e1830f; WORD $0x0000                                       // jae          LBB34_2, $225(%rip)
+	LONG $0x000001bb; BYTE $0x00                                         // movl         $1, %ebx
+	WORD $0x3980; BYTE $0x00                                             // cmpb         $0, (%rcx)
+	LONG $0xffe6890f; WORD $0xffff                                       // jns          LBB34_19, $-26(%rip)
+	WORD $0x018b                                                         // movl         (%rcx), %eax
+	WORD $0xc789                                                         // movl         %eax, %edi
+	LONG $0xc0f0e781; WORD $0x00c0                                       // andl         $12632304, %edi
+	LONG $0x80e0ff81; WORD $0x0080                                       // cmpl         $8421600, %edi
+	LONG $0x0030850f; WORD $0x0000                                       // jne          LBB34_10, $48(%rip)
+	WORD $0xc789                                                         // movl         %eax, %edi
+	LONG $0x200fe781; WORD $0x0000                                       // andl         $8207, %edi
+	LONG $0x200dff81; WORD $0x0000                                       // cmpl         $8205, %edi
+	LONG $0x001c840f; WORD $0x0000                                       // je           LBB34_10, $28(%rip)
+	LONG $0x000003bb; BYTE $0x00                                         // movl         $3, %ebx
+	WORD $0xff85                                                         // testl        %edi, %edi
+	LONG $0xffaf850f; WORD $0xffff                                       // jne          LBB34_19, $-81(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB34_10:
+	WORD $0xc789                   // movl         %eax, %edi
+	LONG $0xc0e0e781; WORD $0x0000 // andl         $49376, %edi
+	LONG $0x80c0ff81; WORD $0x0000 // cmpl         $32960, %edi
+	LONG $0x0010850f; WORD $0x0000 // jne          LBB34_12, $16(%rip)
+	WORD $0xc789                   // movl         %eax, %edi
+	LONG $0x000002bb; BYTE $0x00   // movl         $2, %ebx
+	WORD $0xe783; BYTE $0x1e       // andl         $30, %edi
+	LONG $0xff7c850f; WORD $0xffff // jne          LBB34_19, $-132(%rip)
+
+LBB34_12:
+	WORD $0xc789                   // movl         %eax, %edi
+	LONG $0xc0f8e781; WORD $0xc0c0 // andl         $-1061109512, %edi
+	LONG $0x80f0ff81; WORD $0x8080 // cmpl         $-2139062032, %edi
+	LONG $0x0026850f; WORD $0x0000 // jne          LBB34_16, $38(%rip)
+	WORD $0xc789                   // movl         %eax, %edi
+	LONG $0x3007e781; WORD $0x0000 // andl         $12295, %edi
+	LONG $0x0018840f; WORD $0x0000 // je           LBB34_16, $24(%rip)
+	LONG $0x000004bb; BYTE $0x00   // movl         $4, %ebx
+	WORD $0x04a8                   // testb        $4, %al
+	LONG $0xff4d840f; WORD $0xffff // je           LBB34_19, $-179(%rip)
+	LONG $0x00300325; BYTE $0x00   // andl         $12291, %eax
+	LONG $0xff42840f; WORD $0xffff // je           LBB34_19, $-190(%rip)
+
+LBB34_16:
+	WORD $0x8948; BYTE $0xcf                   // movq         %rcx, %rdi
+	WORD $0x294c; BYTE $0xd7                   // subq         %r10, %rdi
+	WORD $0x8b48; BYTE $0x1a                   // movq         (%rdx), %rbx
+	LONG $0x00fb8148; WORD $0x0010; BYTE $0x00 // cmpq         $4096, %rbx
+	LONG $0x0187830f; WORD $0x0000             // jae          LBB34_17, $391(%rip)
+	WORD $0x6348; BYTE $0xc7                   // movslq       %edi, %rax
+	LONG $0x017b8d48                           // leaq         $1(%rbx), %rdi
+	WORD $0x8948; BYTE $0x3a                   // movq         %rdi, (%rdx)
+	LONG $0xda448948; BYTE $0x08               // movq         %rax, $8(%rdx,%rbx,8)
+	LONG $0x000001bb; BYTE $0x00               // movl         $1, %ebx
+	LONG $0xffff13e9; BYTE $0xff               // jmp          LBB34_19, $-237(%rip)
+
+LBB34_2:
+	WORD $0x014d; BYTE $0xd3               // addq         %r10, %r11
+	WORD $0x394c; BYTE $0xd9               // cmpq         %r11, %rcx
+	LONG $0x013e830f; WORD $0x0000         // jae          LBB34_36, $318(%rip)
+	LONG $0xdc458d4c                       // leaq         $-36(%rbp), %r8
+	LONG $0xda4d8d4c                       // leaq         $-38(%rbp), %r9
+	LONG $0x000016e9; BYTE $0x00           // jmp          LBB34_4, $22(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB34_5:
+	WORD $0xff48; BYTE $0xc1       // incq         %rcx
+	WORD $0x394c; BYTE $0xd9       // cmpq         %r11, %rcx
+	LONG $0x011b830f; WORD $0x0000 // jae          LBB34_36, $283(%rip)
+
+LBB34_4:
+	WORD $0x3980; BYTE $0x00       // cmpb         $0, (%rcx)
+	LONG $0xffeb890f; WORD $0xffff // jns          LBB34_5, $-21(%rip)
+	LONG $0x00dc45c6               // movb         $0, $-36(%rbp)
+	LONG $0x00da45c6               // movb         $0, $-38(%rbp)
+	WORD $0x894c; BYTE $0xdb       // movq         %r11, %rbx
+	WORD $0x2948; BYTE $0xcb       // subq         %rcx, %rbx
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0x0035820f; WORD $0x0000 // jb           LBB34_21, $53(%rip)
+	LONG $0x21b60f44               // movzbl       (%rcx), %r12d
+	LONG $0x71b60f44; BYTE $0x01   // movzbl       $1(%rcx), %r14d
+	LONG $0xdc658844               // movb         %r12b, $-36(%rbp)
+	LONG $0x02798d4c               // leaq         $2(%rcx), %r15
+	LONG $0xfec38348               // addq         $-2, %rbx
+	WORD $0x894c; BYTE $0xcf       // movq         %r9, %rdi
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0029840f; WORD $0x0000 // je           LBB34_24, $41(%rip)
+
+LBB34_25:
+	LONG $0x07b60f41             // movzbl       (%r15), %eax
+	WORD $0x0788                 // movb         %al, (%rdi)
+	LONG $0x65b60f44; BYTE $0xdc // movzbl       $-36(%rbp), %r12d
+	LONG $0xda7db60f             // movzbl       $-38(%rbp), %edi
+	LONG $0x000017e9; BYTE $0x00 // jmp          LBB34_26, $23(%rip)
+
+LBB34_21:
+	WORD $0x3145; BYTE $0xe4       // xorl         %r12d, %r12d
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	WORD $0x894c; BYTE $0xc7       // movq         %r8, %rdi
+	WORD $0x8949; BYTE $0xcf       // movq         %rcx, %r15
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0xffd7850f; WORD $0xffff // jne          LBB34_25, $-41(%rip)
+
+LBB34_24:
+	WORD $0xff31 // xorl         %edi, %edi
+
+LBB34_26:
+	LONG $0xc7b60f40               // movzbl       %dil, %eax
+	WORD $0xe0c1; BYTE $0x10       // shll         $16, %eax
+	LONG $0xdeb60f41               // movzbl       %r14b, %ebx
+	WORD $0xe3c1; BYTE $0x08       // shll         $8, %ebx
+	WORD $0xc309                   // orl          %eax, %ebx
+	LONG $0xfcb60f41               // movzbl       %r12b, %edi
+	WORD $0xdf09                   // orl          %ebx, %edi
+	WORD $0xf889                   // movl         %edi, %eax
+	LONG $0xc0c0f025; BYTE $0x00   // andl         $12632304, %eax
+	LONG $0x8080e03d; BYTE $0x00   // cmpl         $8421600, %eax
+	LONG $0x001f850f; WORD $0x0000 // jne          LBB34_29, $31(%rip)
+	WORD $0xf889                   // movl         %edi, %eax
+	LONG $0x00200f25; BYTE $0x00   // andl         $8207, %eax
+	LONG $0x00200d3d; BYTE $0x00   // cmpl         $8205, %eax
+	LONG $0x000d840f; WORD $0x0000 // je           LBB34_29, $13(%rip)
+	LONG $0x000003bb; BYTE $0x00   // movl         $3, %ebx
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x0021850f; WORD $0x0000 // jne          LBB34_34, $33(%rip)
+
+	// .p2align 4, 0x90
+LBB34_29:
+	LONG $0x1ec4f641               // testb        $30, %r12b
+	LONG $0x0028840f; WORD $0x0000 // je           LBB34_31, $40(%rip)
+	LONG $0xc0e0e781; WORD $0x0000 // andl         $49376, %edi
+	LONG $0x000002bb; BYTE $0x00   // movl         $2, %ebx
+	LONG $0x80c0ff81; WORD $0x0000 // cmpl         $32960, %edi
+	LONG $0x0011850f; WORD $0x0000 // jne          LBB34_31, $17(%rip)
+
+LBB34_34:
+	WORD $0x0148; BYTE $0xd9       // addq         %rbx, %rcx
+	WORD $0x394c; BYTE $0xd9       // cmpq         %r11, %rcx
+	LONG $0xff1f820f; WORD $0xffff // jb           LBB34_4, $-225(%rip)
+	LONG $0x000035e9; BYTE $0x00   // jmp          LBB34_36, $53(%rip)
+
+LBB34_31:
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	WORD $0x294c; BYTE $0xd0                   // subq         %r10, %rax
+	WORD $0x8b48; BYTE $0x3a                   // movq         (%rdx), %rdi
+	LONG $0x00ff8148; WORD $0x0010; BYTE $0x00 // cmpq         $4096, %rdi
+	LONG $0x0034830f; WORD $0x0000             // jae          LBB34_32, $52(%rip)
+	WORD $0x9848                               // cltq
+	LONG $0x015f8d48                           // leaq         $1(%rdi), %rbx
+	WORD $0x8948; BYTE $0x1a                   // movq         %rbx, (%rdx)
+	LONG $0xfa448948; BYTE $0x08               // movq         %rax, $8(%rdx,%rdi,8)
+	LONG $0x000001bb; BYTE $0x00               // movl         $1, %ebx
+	WORD $0x0148; BYTE $0xd9                   // addq         %rbx, %rcx
+	WORD $0x394c; BYTE $0xd9                   // cmpq         %r11, %rcx
+	LONG $0xfee5820f; WORD $0xffff             // jb           LBB34_4, $-283(%rip)
+
+LBB34_36:
+	WORD $0x294c; BYTE $0xd1 // subq         %r10, %rcx
+	WORD $0x8948; BYTE $0x0e // movq         %rcx, (%rsi)
+	WORD $0xc031             // xorl         %eax, %eax
+
+LBB34_37:
+	LONG $0x08c48348 // addq         $8, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB34_32:
+	WORD $0x8948; BYTE $0x06                   // movq         %rax, (%rsi)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xffffe4e9; BYTE $0xff               // jmp          LBB34_37, $-28(%rip)
+
+LBB34_17:
+	WORD $0x8948; BYTE $0x3e                   // movq         %rdi, (%rsi)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xffffd5e9; BYTE $0xff               // jmp          LBB34_37, $-43(%rip)
+	LONG $0x90909090; WORD $0x9090             // .p2align 4, 0x90
+
+_validate_utf8_fast:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	BYTE $0x53                                 // pushq        %rbx
+	BYTE $0x50                                 // pushq        %rax
+	WORD $0x8b4c; BYTE $0x17                   // movq         (%rdi), %r10
+	LONG $0x085f8b4c                           // movq         $8(%rdi), %r11
+	LONG $0x1a348d4b                           // leaq         (%r10,%r11), %rsi
+	LONG $0xfdc68348                           // addq         $-3, %rsi
+	WORD $0x894c; BYTE $0xd0                   // movq         %r10, %rax
+	WORD $0x394c; BYTE $0xd6                   // cmpq         %r10, %rsi
+	LONG $0x00dd860f; WORD $0x0000             // jbe          LBB35_14, $221(%rip)
+	WORD $0x894c; BYTE $0xd0                   // movq         %r10, %rax
+	LONG $0x000013e9; BYTE $0x00               // jmp          LBB35_3, $19(%rip)
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB35_2:
+	WORD $0x0148; BYTE $0xd0       // addq         %rdx, %rax
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0x00c2830f; WORD $0x0000 // jae          LBB35_14, $194(%rip)
+
+LBB35_3:
+	LONG $0x000001ba; BYTE $0x00                                         // movl         $1, %edx
+	WORD $0x3880; BYTE $0x00                                             // cmpb         $0, (%rax)
+	LONG $0xffe6890f; WORD $0xffff                                       // jns          LBB35_2, $-26(%rip)
+	WORD $0x388b                                                         // movl         (%rax), %edi
+	WORD $0xf989                                                         // movl         %edi, %ecx
+	LONG $0xc0f0e181; WORD $0x00c0                                       // andl         $12632304, %ecx
+	LONG $0x80e0f981; WORD $0x0080                                       // cmpl         $8421600, %ecx
+	LONG $0x0030850f; WORD $0x0000                                       // jne          LBB35_7, $48(%rip)
+	WORD $0xf989                                                         // movl         %edi, %ecx
+	LONG $0x200fe181; WORD $0x0000                                       // andl         $8207, %ecx
+	LONG $0x200df981; WORD $0x0000                                       // cmpl         $8205, %ecx
+	LONG $0x001c840f; WORD $0x0000                                       // je           LBB35_7, $28(%rip)
+	LONG $0x000003ba; BYTE $0x00                                         // movl         $3, %edx
+	WORD $0xc985                                                         // testl        %ecx, %ecx
+	LONG $0xffaf850f; WORD $0xffff                                       // jne          LBB35_2, $-81(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB35_7:
+	WORD $0xf989                   // movl         %edi, %ecx
+	LONG $0xc0e0e181; WORD $0x0000 // andl         $49376, %ecx
+	LONG $0x80c0f981; WORD $0x0000 // cmpl         $32960, %ecx
+	LONG $0x0010850f; WORD $0x0000 // jne          LBB35_9, $16(%rip)
+	WORD $0xf989                   // movl         %edi, %ecx
+	LONG $0x000002ba; BYTE $0x00   // movl         $2, %edx
+	WORD $0xe183; BYTE $0x1e       // andl         $30, %ecx
+	LONG $0xff7c850f; WORD $0xffff // jne          LBB35_2, $-132(%rip)
+
+LBB35_9:
+	WORD $0xf989                   // movl         %edi, %ecx
+	LONG $0xc0f8e181; WORD $0xc0c0 // andl         $-1061109512, %ecx
+	LONG $0x80f0f981; WORD $0x8080 // cmpl         $-2139062032, %ecx
+	LONG $0x0029850f; WORD $0x0000 // jne          LBB35_13, $41(%rip)
+	WORD $0xf989                   // movl         %edi, %ecx
+	LONG $0x3007e181; WORD $0x0000 // andl         $12295, %ecx
+	LONG $0x001b840f; WORD $0x0000 // je           LBB35_13, $27(%rip)
+	LONG $0x000004ba; BYTE $0x00   // movl         $4, %edx
+	LONG $0x04c7f640               // testb        $4, %dil
+	LONG $0xff4b840f; WORD $0xffff // je           LBB35_2, $-181(%rip)
+	LONG $0x3003e781; WORD $0x0000 // andl         $12291, %edi
+	LONG $0xff3f840f; WORD $0xffff // je           LBB35_2, $-193(%rip)
+
+LBB35_13:
+	WORD $0xf748; BYTE $0xd0 // notq         %rax
+	WORD $0x014c; BYTE $0xd0 // addq         %r10, %rax
+	LONG $0x08c48348         // addq         $8, %rsp
+	BYTE $0x5b               // popq         %rbx
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB35_14:
+	WORD $0x014d; BYTE $0xd3             // addq         %r10, %r11
+	WORD $0x394c; BYTE $0xd8             // cmpq         %r11, %rax
+	LONG $0x0103830f; WORD $0x0000       // jae          LBB35_30, $259(%rip)
+	LONG $0xf4458d4c                     // leaq         $-12(%rbp), %r8
+	LONG $0xf24d8d4c                     // leaq         $-14(%rbp), %r9
+	LONG $0x000015e9; BYTE $0x00         // jmp          LBB35_17, $21(%rip)
+	QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB35_16:
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x394c; BYTE $0xd8       // cmpq         %r11, %rax
+	LONG $0x00e1830f; WORD $0x0000 // jae          LBB35_30, $225(%rip)
+
+LBB35_17:
+	WORD $0x3880; BYTE $0x00       // cmpb         $0, (%rax)
+	LONG $0xffeb890f; WORD $0xffff // jns          LBB35_16, $-21(%rip)
+	LONG $0x00f445c6               // movb         $0, $-12(%rbp)
+	LONG $0x00f245c6               // movb         $0, $-14(%rbp)
+	WORD $0x894c; BYTE $0xda       // movq         %r11, %rdx
+	WORD $0x2948; BYTE $0xc2       // subq         %rax, %rdx
+	LONG $0x02fa8348               // cmpq         $2, %rdx
+	LONG $0x0031820f; WORD $0x0000 // jb           LBB35_21, $49(%rip)
+	WORD $0xb60f; BYTE $0x30       // movzbl       (%rax), %esi
+	LONG $0x0178b60f               // movzbl       $1(%rax), %edi
+	LONG $0xf4758840               // movb         %sil, $-12(%rbp)
+	LONG $0x02488d48               // leaq         $2(%rax), %rcx
+	LONG $0xfec28348               // addq         $-2, %rdx
+	WORD $0x894c; BYTE $0xcb       // movq         %r9, %rbx
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0x0025840f; WORD $0x0000 // je           LBB35_22, $37(%rip)
+
+LBB35_20:
+	WORD $0xb60f; BYTE $0x09     // movzbl       (%rcx), %ecx
+	WORD $0x0b88                 // movb         %cl, (%rbx)
+	LONG $0xf475b60f             // movzbl       $-12(%rbp), %esi
+	LONG $0xf24db60f             // movzbl       $-14(%rbp), %ecx
+	LONG $0x000015e9; BYTE $0x00 // jmp          LBB35_23, $21(%rip)
+
+LBB35_21:
+	WORD $0xf631                   // xorl         %esi, %esi
+	WORD $0xff31                   // xorl         %edi, %edi
+	WORD $0x894c; BYTE $0xc3       // movq         %r8, %rbx
+	WORD $0x8948; BYTE $0xc1       // movq         %rax, %rcx
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0xffdb850f; WORD $0xffff // jne          LBB35_20, $-37(%rip)
+
+LBB35_22:
+	WORD $0xc931 // xorl         %ecx, %ecx
+
+LBB35_23:
+	WORD $0xb60f; BYTE $0xc9       // movzbl       %cl, %ecx
+	WORD $0xe1c1; BYTE $0x10       // shll         $16, %ecx
+	LONG $0xffb60f40               // movzbl       %dil, %edi
+	WORD $0xe7c1; BYTE $0x08       // shll         $8, %edi
+	WORD $0xcf09                   // orl          %ecx, %edi
+	LONG $0xd6b60f40               // movzbl       %sil, %edx
+	WORD $0xfa09                   // orl          %edi, %edx
+	WORD $0xd189                   // movl         %edx, %ecx
+	LONG $0xc0f0e181; WORD $0x00c0 // andl         $12632304, %ecx
+	LONG $0x80e0f981; WORD $0x0080 // cmpl         $8421600, %ecx
+	LONG $0x0024850f; WORD $0x0000 // jne          LBB35_26, $36(%rip)
+	WORD $0xd789                   // movl         %edx, %edi
+	LONG $0x200fe781; WORD $0x0000 // andl         $8207, %edi
+	LONG $0x200dff81; WORD $0x0000 // cmpl         $8205, %edi
+	LONG $0x0010840f; WORD $0x0000 // je           LBB35_26, $16(%rip)
+	LONG $0x000003b9; BYTE $0x00   // movl         $3, %ecx
+	WORD $0xff85                   // testl        %edi, %edi
+	LONG $0x0024850f; WORD $0x0000 // jne          LBB35_28, $36(%rip)
+	WORD $0x9090; BYTE $0x90       // .p2align 4, 0x90
+
+LBB35_26:
+	LONG $0x1ec6f640               // testb        $30, %sil
+	LONG $0xff07840f; WORD $0xffff // je           LBB35_13, $-249(%rip)
+	LONG $0xc0e0e281; WORD $0x0000 // andl         $49376, %edx
+	LONG $0x000002b9; BYTE $0x00   // movl         $2, %ecx
+	LONG $0x80c0fa81; WORD $0x0000 // cmpl         $32960, %edx
+	LONG $0xfef0850f; WORD $0xffff // jne          LBB35_13, $-272(%rip)
+
+LBB35_28:
+	WORD $0x0148; BYTE $0xc8       // addq         %rcx, %rax
+	WORD $0x394c; BYTE $0xd8       // cmpq         %r11, %rax
+	LONG $0xff1f820f; WORD $0xffff // jb           LBB35_17, $-225(%rip)
+
+LBB35_30:
+	WORD $0xc031                                                                               // xorl         %eax, %eax
+	LONG $0x08c48348                                                                           // addq         $8, %rsp
+	BYTE $0x5b                                                                                 // popq         %rbx
+	BYTE $0x5d                                                                                 // popq         %rbp
+	BYTE $0xc3                                                                                 // retq
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000; QUAD $0x0000000000000000; WORD $0x0000 // .p2align 5, 0x00
+
+LCPI36_0:
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+
+	// .p2align 4, 0x00
+LCPI36_1:
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+
+	// .p2align 4, 0x90
+_f32toa:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	BYTE $0x50                                 // pushq        %rax
+	LONG $0xc07ef9c5                           // vmovd        %xmm0, %eax
+	WORD $0xc189                               // movl         %eax, %ecx
+	WORD $0xe9c1; BYTE $0x17                   // shrl         $23, %ecx
+	WORD $0xb60f; BYTE $0xd1                   // movzbl       %cl, %edx
+	LONG $0x00fffa81; WORD $0x0000             // cmpl         $255, %edx
+	LONG $0x0df0840f; WORD $0x0000             // je           LBB36_141, $3568(%rip)
+	WORD $0x07c6; BYTE $0x2d                   // movb         $45, (%rdi)
+	WORD $0x8941; BYTE $0xc1                   // movl         %eax, %r9d
+	LONG $0x1fe9c141                           // shrl         $31, %r9d
+	LONG $0x0f2c8d4e                           // leaq         (%rdi,%r9), %r13
+	LONG $0xffffffa9; BYTE $0x7f               // testl        $2147483647, %eax
+	LONG $0x01cd840f; WORD $0x0000             // je           LBB36_6, $461(%rip)
+	LONG $0x7fffff25; BYTE $0x00               // andl         $8388607, %eax
+	WORD $0xd285                               // testl        %edx, %edx
+	LONG $0x0dd1840f; WORD $0x0000             // je           LBB36_142, $3537(%rip)
+	LONG $0x00b88d44; WORD $0x8000; BYTE $0x00 // leal         $8388608(%rax), %r15d
+	LONG $0x6a828d44; WORD $0xffff; BYTE $0xff // leal         $-150(%rdx), %r8d
+	WORD $0x4a8d; BYTE $0x81                   // leal         $-127(%rdx), %ecx
+	WORD $0xf983; BYTE $0x17                   // cmpl         $23, %ecx
+	LONG $0x001c870f; WORD $0x0000             // ja           LBB36_7, $28(%rip)
+	LONG $0x000096b9; BYTE $0x00               // movl         $150, %ecx
+	WORD $0xd129                               // subl         %edx, %ecx
+	LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rbx
+	WORD $0xd348; BYTE $0xe3                   // shlq         %cl, %rbx
+	WORD $0xd3f7                               // notl         %ebx
+	WORD $0x8544; BYTE $0xfb                   // testl        %r15d, %ebx
+	LONG $0x043c840f; WORD $0x0000             // je           LBB36_33, $1084(%rip)
+
+LBB36_7:
+	LONG $0xd07d8948 // movq         %rdi, $-48(%rbp)
+
+LBB36_8:
+	WORD $0x8945; BYTE $0xfe                   // movl         %r15d, %r14d
+	LONG $0x01e68341                           // andl         $1, %r14d
+	WORD $0xc085                               // testl        %eax, %eax
+	WORD $0x940f; BYTE $0xc0                   // sete         %al
+	WORD $0xfa83; BYTE $0x02                   // cmpl         $2, %edx
+	WORD $0x930f; BYTE $0xc1                   // setae        %cl
+	WORD $0xc120                               // andb         %al, %cl
+	WORD $0xb60f; BYTE $0xc9                   // movzbl       %cl, %ecx
+	WORD $0x8945; BYTE $0xfa                   // movl         %r15d, %r10d
+	LONG $0x02e2c141                           // shll         $2, %r10d
+	LONG $0xb9048d42                           // leal         (%rcx,%r15,4), %eax
+	WORD $0xc083; BYTE $0xfe                   // addl         $-2, %eax
+	LONG $0x13d06941; WORD $0x1344; BYTE $0x00 // imull        $1262611, %r8d, %edx
+	LONG $0x019a8d44; WORD $0xf801; BYTE $0xff // leal         $-524031(%rdx), %r11d
+	WORD $0xc984                               // testb        %cl, %cl
+	LONG $0xda440f44                           // cmovel       %edx, %r11d
+	LONG $0x16fbc141                           // sarl         $22, %r11d
+	LONG $0xb1cb6941; WORD $0xe56c; BYTE $0xff // imull        $-1741647, %r11d, %ecx
+	WORD $0xe9c1; BYTE $0x13                   // shrl         $19, %ecx
+	WORD $0x0144; BYTE $0xc1                   // addl         %r8d, %ecx
+	LONG $0x00001fba; BYTE $0x00               // movl         $31, %edx
+	WORD $0x2944; BYTE $0xda                   // subl         %r11d, %edx
+	LONG $0xc13d8d48; WORD $0x00b8; BYTE $0x00 // leaq         $47297(%rip), %rdi  /* _pow10_ceil_sig_f32.g(%rip) */
+	WORD $0xc1fe                               // incb         %cl
+	WORD $0xe0d3                               // shll         %cl, %eax
+	LONG $0xd7248b4c                           // movq         (%rdi,%rdx,8), %r12
+	WORD $0xf749; BYTE $0xe4                   // mulq         %r12
+	QUAD $0x00000002bd048d46                   // leal         $2(,%r15,4), %r8d
+	WORD $0xf631                               // xorl         %esi, %esi
+	LONG $0x21e8c148                           // shrq         $33, %rax
+	LONG $0xc6950f40                           // setne        %sil
+	WORD $0xd609                               // orl          %edx, %esi
+	WORD $0xd341; BYTE $0xe2                   // shll         %cl, %r10d
+	WORD $0x894c; BYTE $0xd0                   // movq         %r10, %rax
+	WORD $0xf749; BYTE $0xe4                   // mulq         %r12
+	WORD $0x8949; BYTE $0xd2                   // movq         %rdx, %r10
+	WORD $0x3145; BYTE $0xff                   // xorl         %r15d, %r15d
+	LONG $0x21e8c148                           // shrq         $33, %rax
+	LONG $0xc7950f41                           // setne        %r15b
+	WORD $0x0945; BYTE $0xd7                   // orl          %r10d, %r15d
+	WORD $0xd341; BYTE $0xe0                   // shll         %cl, %r8d
+	WORD $0x894c; BYTE $0xc0                   // movq         %r8, %rax
+	WORD $0xf749; BYTE $0xe4                   // mulq         %r12
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0x21e8c148                           // shrq         $33, %rax
+	WORD $0x950f; BYTE $0xc1                   // setne        %cl
+	WORD $0xd109                               // orl          %edx, %ecx
+	WORD $0x0144; BYTE $0xf6                   // addl         %r14d, %esi
+	WORD $0x2944; BYTE $0xf1                   // subl         %r14d, %ecx
+	LONG $0x28ff8341                           // cmpl         $40, %r15d
+	LONG $0x0041820f; WORD $0x0000             // jb           LBB36_10, $65(%rip)
+	WORD $0x8944; BYTE $0xd0                   // movl         %r10d, %eax
+	LONG $0xcccccdba; BYTE $0xcc               // movl         $3435973837, %edx
+	LONG $0xd0af0f48                           // imulq        %rax, %rdx
+	LONG $0x25eac148                           // shrq         $37, %rdx
+	WORD $0xf089                               // movl         %esi, %eax
+	QUAD $0x00000000d53c8d48                   // leaq         (,%rdx,8), %rdi
+	LONG $0xbf1c8d48                           // leaq         (%rdi,%rdi,4), %rbx
+	WORD $0x3948; BYTE $0xc3                   // cmpq         %rax, %rbx
+	LONG $0xc6920f41                           // setb         %r14b
+	LONG $0xbf3c8d48                           // leaq         (%rdi,%rdi,4), %rdi
+	LONG $0x28c78348                           // addq         $40, %rdi
+	WORD $0xcb89                               // movl         %ecx, %ebx
+	WORD $0xc031                               // xorl         %eax, %eax
+	WORD $0x3948; BYTE $0xdf                   // cmpq         %rbx, %rdi
+	LONG $0xc0960f41                           // setbe        %r8b
+	WORD $0x3845; BYTE $0xc6                   // cmpb         %r8b, %r14b
+	LONG $0x01f9840f; WORD $0x0000             // je           LBB36_18, $505(%rip)
+
+LBB36_10:
+	WORD $0x8945; BYTE $0xd0       // movl         %r10d, %r8d
+	LONG $0x02e8c141               // shrl         $2, %r8d
+	WORD $0x8944; BYTE $0xd2       // movl         %r10d, %edx
+	WORD $0xe283; BYTE $0xfc       // andl         $-4, %edx
+	WORD $0xd639                   // cmpl         %edx, %esi
+	LONG $0xc6970f40               // seta         %sil
+	WORD $0x428d; BYTE $0x04       // leal         $4(%rdx), %eax
+	WORD $0xc839                   // cmpl         %ecx, %eax
+	WORD $0x960f; BYTE $0xc3       // setbe        %bl
+	WORD $0x3040; BYTE $0xf3       // xorb         %sil, %bl
+	LONG $0x007e840f; WORD $0x0000 // je           LBB36_14, $126(%rip)
+	WORD $0xca83; BYTE $0x02       // orl          $2, %edx
+	LONG $0x000001b8; BYTE $0x00   // movl         $1, %eax
+	WORD $0x3941; BYTE $0xd7       // cmpl         %edx, %r15d
+	LONG $0x000e870f; WORD $0x0000 // ja           LBB36_13, $14(%rip)
+	WORD $0x940f; BYTE $0xc0       // sete         %al
+	LONG $0x02eac041               // shrb         $2, %r10b
+	WORD $0x2041; BYTE $0xc2       // andb         %al, %r10b
+	LONG $0xc2b60f41               // movzbl       %r10b, %eax
+
+LBB36_13:
+	WORD $0x0144; BYTE $0xc0       // addl         %r8d, %eax
+	WORD $0x894d; BYTE $0xef       // movq         %r13, %r15
+	LONG $0x0186a03d; BYTE $0x00   // cmpl         $100000, %eax
+	LONG $0xd06d8b4c               // movq         $-48(%rbp), %r13
+	LONG $0x0065820f; WORD $0x0000 // jb           LBB36_19, $101(%rip)
+
+LBB36_15:
+	LONG $0x0006bc41; WORD $0x0000 // movl         $6, %r12d
+	LONG $0x0f42403d; BYTE $0x00   // cmpl         $1000000, %eax
+	LONG $0x0093820f; WORD $0x0000 // jb           LBB36_23, $147(%rip)
+	LONG $0x0007bc41; WORD $0x0000 // movl         $7, %r12d
+	LONG $0x9896803d; BYTE $0x00   // cmpl         $10000000, %eax
+	LONG $0x0082820f; WORD $0x0000 // jb           LBB36_23, $130(%rip)
+	WORD $0x3145; BYTE $0xe4       // xorl         %r12d, %r12d
+	LONG $0xf5e1003d; BYTE $0x05   // cmpl         $100000000, %eax
+	LONG $0xc4920f41               // setb         %r12b
+	LONG $0x09f48341               // xorl         $9, %r12d
+	LONG $0x00006de9; BYTE $0x00   // jmp          LBB36_23, $109(%rip)
+
+LBB36_6:
+	LONG $0x0045c641; BYTE $0x30 // movb         $48, (%r13)
+	WORD $0x2941; BYTE $0xfd     // subl         %edi, %r13d
+	WORD $0xff41; BYTE $0xc5     // incl         %r13d
+	WORD $0x8944; BYTE $0xe8     // movl         %r13d, %eax
+	LONG $0x000be5e9; BYTE $0x00 // jmp          LBB36_93, $3045(%rip)
+
+LBB36_14:
+	WORD $0xc139                   // cmpl         %eax, %ecx
+	LONG $0xffd88341               // sbbl         $-1, %r8d
+	WORD $0x8944; BYTE $0xc0       // movl         %r8d, %eax
+	WORD $0x894d; BYTE $0xef       // movq         %r13, %r15
+	LONG $0x0186a03d; BYTE $0x00   // cmpl         $100000, %eax
+	LONG $0xd06d8b4c               // movq         $-48(%rbp), %r13
+	LONG $0xff9b830f; WORD $0xffff // jae          LBB36_15, $-101(%rip)
+
+LBB36_19:
+	LONG $0x0001bc41; WORD $0x0000 // movl         $1, %r12d
+	WORD $0xf883; BYTE $0x0a       // cmpl         $10, %eax
+	LONG $0x0030820f; WORD $0x0000 // jb           LBB36_23, $48(%rip)
+	LONG $0x0002bc41; WORD $0x0000 // movl         $2, %r12d
+	WORD $0xf883; BYTE $0x64       // cmpl         $100, %eax
+	LONG $0x0021820f; WORD $0x0000 // jb           LBB36_23, $33(%rip)
+	LONG $0x0003bc41; WORD $0x0000 // movl         $3, %r12d
+	LONG $0x0003e83d; BYTE $0x00   // cmpl         $1000, %eax
+	LONG $0x0010820f; WORD $0x0000 // jb           LBB36_23, $16(%rip)
+	WORD $0x3145; BYTE $0xe4       // xorl         %r12d, %r12d
+	LONG $0x0027103d; BYTE $0x00   // cmpl         $10000, %eax
+	LONG $0xc4920f41               // setb         %r12b
+	LONG $0x05f48341               // xorl         $5, %r12d
+
+LBB36_23:
+	LONG $0x1c148d47                           // leal         (%r12,%r11), %r10d
+	LONG $0x1c0c8d43                           // leal         (%r12,%r11), %ecx
+	WORD $0xc183; BYTE $0xea                   // addl         $-22, %ecx
+	WORD $0xf983; BYTE $0xe4                   // cmpl         $-28, %ecx
+	LONG $0x0077870f; WORD $0x0000             // ja           LBB36_27, $119(%rip)
+	WORD $0x8944; BYTE $0xe1                   // movl         %r12d, %ecx
+	LONG $0x0f148d49                           // leaq         (%r15,%rcx), %rdx
+	WORD $0xff48; BYTE $0xc2                   // incq         %rdx
+	LONG $0x0027103d; BYTE $0x00               // cmpl         $10000, %eax
+	LONG $0x00f3820f; WORD $0x0000             // jb           LBB36_31, $243(%rip)
+	WORD $0xc789                               // movl         %eax, %edi
+	LONG $0xb71759be; BYTE $0xd1               // movl         $3518437209, %esi
+	LONG $0xf7af0f48                           // imulq        %rdi, %rsi
+	LONG $0x2deec148                           // shrq         $45, %rsi
+	LONG $0xf0c66944; WORD $0xffd8; BYTE $0xff // imull        $-10000, %esi, %r8d
+	WORD $0x0141; BYTE $0xc0                   // addl         %eax, %r8d
+	LONG $0x0464840f; WORD $0x0000             // je           LBB36_59, $1124(%rip)
+	WORD $0x8944; BYTE $0xc0                   // movl         %r8d, %eax
+	LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xf86b; BYTE $0x64                   // imull        $100, %eax, %edi
+	WORD $0x2941; BYTE $0xf8                   // subl         %edi, %r8d
+	LONG $0x443d8d48; WORD $0x0043; BYTE $0x00 // leaq         $17220(%rip), %rdi  /* _Digits(%rip) */
+	LONG $0x1cb70f42; BYTE $0x47               // movzwl       (%rdi,%r8,2), %ebx
+	LONG $0xfe5a8966                           // movw         %bx, $-2(%rdx)
+	LONG $0x4704b70f                           // movzwl       (%rdi,%rax,2), %eax
+	LONG $0xfc428966                           // movw         %ax, $-4(%rdx)
+	WORD $0x3145; BYTE $0xc0                   // xorl         %r8d, %r8d
+	LONG $0xfcc28348                           // addq         $-4, %rdx
+	WORD $0xfe83; BYTE $0x64                   // cmpl         $100, %esi
+	LONG $0x00a6830f; WORD $0x0000             // jae          LBB36_61, $166(%rip)
+
+LBB36_32:
+	WORD $0xf089                 // movl         %esi, %eax
+	LONG $0x0000dbe9; BYTE $0x00 // jmp          LBB36_63, $219(%rip)
+
+LBB36_27:
+	WORD $0x8945; BYTE $0xe0                   // movl         %r12d, %r8d
+	WORD $0x8545; BYTE $0xdb                   // testl        %r11d, %r11d
+	LONG $0x023a880f; WORD $0x0000             // js           LBB36_36, $570(%rip)
+	LONG $0x070c8d4b                           // leaq         (%r15,%r8), %rcx
+	LONG $0x0027103d; BYTE $0x00               // cmpl         $10000, %eax
+	LONG $0x0295820f; WORD $0x0000             // jb           LBB36_41, $661(%rip)
+	WORD $0xc289                               // movl         %eax, %edx
+	LONG $0xb71759be; BYTE $0xd1               // movl         $3518437209, %esi
+	LONG $0xf2af0f48                           // imulq        %rdx, %rsi
+	LONG $0x2deec148                           // shrq         $45, %rsi
+	LONG $0xd8f0d669; WORD $0xffff             // imull        $-10000, %esi, %edx
+	WORD $0xc201                               // addl         %eax, %edx
+	LONG $0x1fc26948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rdx, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xf86b; BYTE $0x64                   // imull        $100, %eax, %edi
+	WORD $0xfa29                               // subl         %edi, %edx
+	LONG $0xd33d8d48; WORD $0x0042; BYTE $0x00 // leaq         $17107(%rip), %rdi  /* _Digits(%rip) */
+	LONG $0x5714b70f                           // movzwl       (%rdi,%rdx,2), %edx
+	LONG $0xfe518966                           // movw         %dx, $-2(%rcx)
+	LONG $0xfc518d48                           // leaq         $-4(%rcx), %rdx
+	LONG $0x4704b70f                           // movzwl       (%rdi,%rax,2), %eax
+	LONG $0xfc418966                           // movw         %ax, $-4(%rcx)
+	WORD $0xf089                               // movl         %esi, %eax
+	WORD $0x8945; BYTE $0xd3                   // movl         %r10d, %r11d
+	WORD $0xf883; BYTE $0x64                   // cmpl         $100, %eax
+	LONG $0x0254830f; WORD $0x0000             // jae          LBB36_42, $596(%rip)
+
+LBB36_30:
+	WORD $0xc689                 // movl         %eax, %esi
+	LONG $0x000288e9; BYTE $0x00 // jmp          LBB36_44, $648(%rip)
+
+LBB36_18:
+	WORD $0x8844; BYTE $0xc0       // movb         %r8b, %al
+	WORD $0xd001                   // addl         %edx, %eax
+	WORD $0xff41; BYTE $0xc3       // incl         %r11d
+	WORD $0x894d; BYTE $0xef       // movq         %r13, %r15
+	LONG $0x0186a03d; BYTE $0x00   // cmpl         $100000, %eax
+	LONG $0xd06d8b4c               // movq         $-48(%rbp), %r13
+	LONG $0xfe45830f; WORD $0xffff // jae          LBB36_15, $-443(%rip)
+	LONG $0xfffea5e9; BYTE $0xff   // jmp          LBB36_19, $-347(%rip)
+
+LBB36_31:
+	WORD $0x3145; BYTE $0xc0       // xorl         %r8d, %r8d
+	WORD $0xc689                   // movl         %eax, %esi
+	WORD $0xfe83; BYTE $0x64       // cmpl         $100, %esi
+	LONG $0xff5a820f; WORD $0xffff // jb           LBB36_32, $-166(%rip)
+
+LBB36_61:
+	WORD $0xff48; BYTE $0xca                   // decq         %rdx
+	LONG $0x731d8d4c; WORD $0x0042; BYTE $0x00 // leaq         $17011(%rip), %r11  /* _Digits(%rip) */
+	WORD $0x9090; BYTE $0x90                   // .p2align 4, 0x90
+
+LBB36_62:
+	WORD $0xf089                               // movl         %esi, %eax
+	LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xf86b; BYTE $0x64                   // imull        $100, %eax, %edi
+	WORD $0xf389                               // movl         %esi, %ebx
+	WORD $0xfb29                               // subl         %edi, %ebx
+	LONG $0x3cb70f41; BYTE $0x5b               // movzwl       (%r11,%rbx,2), %edi
+	LONG $0xff7a8966                           // movw         %di, $-1(%rdx)
+	LONG $0xfec28348                           // addq         $-2, %rdx
+	LONG $0x270ffe81; WORD $0x0000             // cmpl         $9999, %esi
+	WORD $0xc689                               // movl         %eax, %esi
+	LONG $0xffd1870f; WORD $0xffff             // ja           LBB36_62, $-47(%rip)
+
+LBB36_63:
+	LONG $0x01578d49                           // leaq         $1(%r15), %rdx
+	WORD $0xf883; BYTE $0x0a                   // cmpl         $10, %eax
+	LONG $0x001f820f; WORD $0x0000             // jb           LBB36_65, $31(%rip)
+	WORD $0xc689                               // movl         %eax, %esi
+	LONG $0x2b3d8d48; WORD $0x0042; BYTE $0x00 // leaq         $16939(%rip), %rdi  /* _Digits(%rip) */
+	LONG $0x7704b60f                           // movzbl       (%rdi,%rsi,2), %eax
+	LONG $0x775cb60f; BYTE $0x01               // movzbl       $1(%rdi,%rsi,2), %ebx
+	LONG $0x01478841                           // movb         %al, $1(%r15)
+	LONG $0x025f8841                           // movb         %bl, $2(%r15)
+	LONG $0x000004e9; BYTE $0x00               // jmp          LBB36_66, $4(%rip)
+
+LBB36_65:
+	WORD $0x3004 // addb         $48, %al
+	WORD $0x0288 // movb         %al, (%rdx)
+
+LBB36_66:
+	WORD $0x294d; BYTE $0xc1     // subq         %r8, %r9
+	WORD $0x014d; BYTE $0xe9     // addq         %r13, %r9
+	LONG $0x000001be; BYTE $0x00 // movl         $1, %esi
+	WORD $0x294c; BYTE $0xc6     // subq         %r8, %rsi
+	WORD $0x9090; BYTE $0x90     // .p2align 4, 0x90
+
+LBB36_67:
+	WORD $0xff48; BYTE $0xce       // decq         %rsi
+	LONG $0x093c8041; BYTE $0x30   // cmpb         $48, (%r9,%rcx)
+	LONG $0xff498d4d               // leaq         $-1(%r9), %r9
+	LONG $0xffee840f; WORD $0xffff // je           LBB36_67, $-18(%rip)
+	WORD $0x8841; BYTE $0x07       // movb         %al, (%r15)
+	WORD $0x0148; BYTE $0xce       // addq         %rcx, %rsi
+	LONG $0x02fe8348               // cmpq         $2, %rsi
+	LONG $0x00458c0f; WORD $0x0000 // jl           LBB36_72, $69(%rip)
+	LONG $0x09048d49               // leaq         (%r9,%rcx), %rax
+	LONG $0x02c08348               // addq         $2, %rax
+	WORD $0x02c6; BYTE $0x2e       // movb         $46, (%rdx)
+	WORD $0x00c6; BYTE $0x65       // movb         $101, (%rax)
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0x00418e0f; WORD $0x0000 // jle          LBB36_73, $65(%rip)
+
+LBB36_70:
+	WORD $0xff41; BYTE $0xca       // decl         %r10d
+	LONG $0x2b0140c6               // movb         $43, $1(%rax)
+	WORD $0x8944; BYTE $0xd1       // movl         %r10d, %ecx
+	WORD $0xf983; BYTE $0x0a       // cmpl         $10, %ecx
+	LONG $0x0043820f; WORD $0x0000 // jb           LBB36_74, $67(%rip)
+
+LBB36_71:
+	WORD $0x6348; BYTE $0xc9                   // movslq       %ecx, %rcx
+	LONG $0xaa158d48; WORD $0x0041; BYTE $0x00 // leaq         $16810(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x4a0cb70f                           // movzwl       (%rdx,%rcx,2), %ecx
+	LONG $0x02488966                           // movw         %cx, $2(%rax)
+	LONG $0x04c08348                           // addq         $4, %rax
+	LONG $0x00097ae9; BYTE $0x00               // jmp          LBB36_92, $2426(%rip)
+
+LBB36_72:
+	LONG $0x09048d49               // leaq         (%r9,%rcx), %rax
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x00c6; BYTE $0x65       // movb         $101, (%rax)
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0xffbf8f0f; WORD $0xffff // jg           LBB36_70, $-65(%rip)
+
+LBB36_73:
+	LONG $0x2d0140c6               // movb         $45, $1(%rax)
+	LONG $0x000001b9; BYTE $0x00   // movl         $1, %ecx
+	WORD $0x2944; BYTE $0xd1       // subl         %r10d, %ecx
+	WORD $0xf983; BYTE $0x0a       // cmpl         $10, %ecx
+	LONG $0xffbd830f; WORD $0xffff // jae          LBB36_71, $-67(%rip)
+
+LBB36_74:
+	WORD $0xc180; BYTE $0x30     // addb         $48, %cl
+	WORD $0x4888; BYTE $0x02     // movb         %cl, $2(%rax)
+	LONG $0x03c08348             // addq         $3, %rax
+	LONG $0x000943e9; BYTE $0x00 // jmp          LBB36_92, $2371(%rip)
+
+LBB36_33:
+	WORD $0xd341; BYTE $0xef                   // shrl         %cl, %r15d
+	LONG $0xa0ff8141; WORD $0x0186; BYTE $0x00 // cmpl         $100000, %r15d
+	LONG $0x01a8820f; WORD $0x0000             // jb           LBB36_50, $424(%rip)
+	LONG $0x80ff8141; WORD $0x9896; BYTE $0x00 // cmpl         $10000000, %r15d
+	LONG $0x000008b8; BYTE $0x00               // movl         $8, %eax
+	LONG $0x00d88348                           // sbbq         $0, %rax
+	LONG $0x40ff8141; WORD $0x0f42; BYTE $0x00 // cmpl         $1000000, %r15d
+	LONG $0x000006b9; BYTE $0x00               // movl         $6, %ecx
+	LONG $0xc8430f48                           // cmovaeq      %rax, %rcx
+	WORD $0x014c; BYTE $0xe9                   // addq         %r13, %rcx
+
+LBB36_35:
+	WORD $0x8944; BYTE $0xf8                   // movl         %r15d, %eax
+	LONG $0xb71759ba; BYTE $0xd1               // movl         $3518437209, %edx
+	LONG $0xd0af0f48                           // imulq        %rax, %rdx
+	LONG $0x2deac148                           // shrq         $45, %rdx
+	LONG $0xd8f0c269; WORD $0xffff             // imull        $-10000, %edx, %eax
+	WORD $0x0144; BYTE $0xf8                   // addl         %r15d, %eax
+	LONG $0x1ff06948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rsi
+	LONG $0x25eec148                           // shrq         $37, %rsi
+	WORD $0xde6b; BYTE $0x64                   // imull        $100, %esi, %ebx
+	WORD $0xd829                               // subl         %ebx, %eax
+	LONG $0xff1d8d48; WORD $0x0040; BYTE $0x00 // leaq         $16639(%rip), %rbx  /* _Digits(%rip) */
+	LONG $0x4304b70f                           // movzwl       (%rbx,%rax,2), %eax
+	LONG $0xfe418966                           // movw         %ax, $-2(%rcx)
+	LONG $0x7304b70f                           // movzwl       (%rbx,%rsi,2), %eax
+	LONG $0xfc418966                           // movw         %ax, $-4(%rcx)
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	LONG $0xfcc18348                           // addq         $-4, %rcx
+	WORD $0x8941; BYTE $0xd7                   // movl         %edx, %r15d
+	LONG $0x64ff8341                           // cmpl         $100, %r15d
+	LONG $0x0171830f; WORD $0x0000             // jae          LBB36_54, $369(%rip)
+	LONG $0x0001a8e9; BYTE $0x00               // jmp          LBB36_56, $424(%rip)
+
+LBB36_36:
+	WORD $0x8545; BYTE $0xd2                   // testl        %r10d, %r10d
+	LONG $0x04dc8f0f; WORD $0x0000             // jg           LBB36_102, $1244(%rip)
+	LONG $0x07c74166; WORD $0x2e30             // movw         $11824, (%r15)
+	LONG $0x02c78349                           // addq         $2, %r15
+	WORD $0x8545; BYTE $0xd2                   // testl        %r10d, %r10d
+	LONG $0x04c9890f; WORD $0x0000             // jns          LBB36_102, $1225(%rip)
+	WORD $0x8945; BYTE $0xe6                   // movl         %r12d, %r14d
+	WORD $0xf741; BYTE $0xd6                   // notl         %r14d
+	WORD $0x2945; BYTE $0xde                   // subl         %r11d, %r14d
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0x7ffe8341                           // cmpl         $127, %r14d
+	LONG $0x049d820f; WORD $0x0000             // jb           LBB36_100, $1181(%rip)
+	WORD $0x894c; BYTE $0xfb                   // movq         %r15, %rbx
+	WORD $0x894c; BYTE $0xef                   // movq         %r13, %rdi
+	WORD $0xff49; BYTE $0xc6                   // incq         %r14
+	WORD $0x894c; BYTE $0xf1                   // movq         %r14, %rcx
+	LONG $0x80e18348                           // andq         $-128, %rcx
+	LONG $0x80518d48                           // leaq         $-128(%rcx), %rdx
+	WORD $0x8949; BYTE $0xd5                   // movq         %rdx, %r13
+	LONG $0x07edc149                           // shrq         $7, %r13
+	WORD $0xff49; BYTE $0xc5                   // incq         %r13
+	WORD $0x8945; BYTE $0xef                   // movl         %r13d, %r15d
+	LONG $0x03e78341                           // andl         $3, %r15d
+	LONG $0x80fa8148; WORD $0x0001; BYTE $0x00 // cmpq         $384, %rdx
+	LONG $0x036a830f; WORD $0x0000             // jae          LBB36_94, $874(%rip)
+	WORD $0xd231                               // xorl         %edx, %edx
+	LONG $0x00040de9; BYTE $0x00               // jmp          LBB36_96, $1037(%rip)
+
+LBB36_41:
+	WORD $0x8948; BYTE $0xca       // movq         %rcx, %rdx
+	WORD $0x8945; BYTE $0xd3       // movl         %r10d, %r11d
+	WORD $0xf883; BYTE $0x64       // cmpl         $100, %eax
+	LONG $0xfdac820f; WORD $0xffff // jb           LBB36_30, $-596(%rip)
+
+LBB36_42:
+	WORD $0xff48; BYTE $0xca                   // decq         %rdx
+	LONG $0x53358d4c; WORD $0x0040; BYTE $0x00 // leaq         $16467(%rip), %r14  /* _Digits(%rip) */
+	WORD $0x9090; BYTE $0x90                   // .p2align 4, 0x90
+
+LBB36_43:
+	WORD $0xc689                               // movl         %eax, %esi
+	LONG $0x1ff66948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rsi, %rsi
+	LONG $0x25eec148                           // shrq         $37, %rsi
+	WORD $0xfe6b; BYTE $0x64                   // imull        $100, %esi, %edi
+	WORD $0xc389                               // movl         %eax, %ebx
+	WORD $0xfb29                               // subl         %edi, %ebx
+	LONG $0x3cb70f41; BYTE $0x5e               // movzwl       (%r14,%rbx,2), %edi
+	LONG $0xff7a8966                           // movw         %di, $-1(%rdx)
+	LONG $0xfec28348                           // addq         $-2, %rdx
+	LONG $0x00270f3d; BYTE $0x00               // cmpl         $9999, %eax
+	WORD $0xf089                               // movl         %esi, %eax
+	LONG $0xffd2870f; WORD $0xffff             // ja           LBB36_43, $-46(%rip)
+
+LBB36_44:
+	WORD $0xfe83; BYTE $0x0a                   // cmpl         $10, %esi
+	LONG $0x0022820f; WORD $0x0000             // jb           LBB36_46, $34(%rip)
+	WORD $0xf089                               // movl         %esi, %eax
+	LONG $0x10158d48; WORD $0x0040; BYTE $0x00 // leaq         $16400(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x4204b70f                           // movzwl       (%rdx,%rax,2), %eax
+	LONG $0x07894166                           // movw         %ax, (%r15)
+	WORD $0x014d; BYTE $0xdf                   // addq         %r11, %r15
+	WORD $0x3945; BYTE $0xd4                   // cmpl         %r10d, %r12d
+	LONG $0x0018820f; WORD $0x0000             // jb           LBB36_47, $24(%rip)
+	LONG $0x0002e6e9; BYTE $0x00               // jmp          LBB36_91, $742(%rip)
+
+LBB36_46:
+	LONG $0x30c68040               // addb         $48, %sil
+	WORD $0x8841; BYTE $0x37       // movb         %sil, (%r15)
+	WORD $0x014d; BYTE $0xdf       // addq         %r11, %r15
+	WORD $0x3945; BYTE $0xd4       // cmpl         %r10d, %r12d
+	LONG $0x02d3830f; WORD $0x0000 // jae          LBB36_91, $723(%rip)
+
+LBB36_47:
+	LONG $0x29048d4b                           // leaq         (%r9,%r13), %rax
+	LONG $0x00148d49                           // leaq         (%r8,%rax), %rdx
+	WORD $0xff48; BYTE $0xc2                   // incq         %rdx
+	WORD $0x0149; BYTE $0xc3                   // addq         %rax, %r11
+	WORD $0x394c; BYTE $0xda                   // cmpq         %r11, %rdx
+	LONG $0xda470f4c                           // cmovaq       %rdx, %r11
+	WORD $0x014c; BYTE $0xc0                   // addq         %r8, %rax
+	WORD $0x2949; BYTE $0xc3                   // subq         %rax, %r11
+	LONG $0x10fb8349                           // cmpq         $16, %r11
+	LONG $0x029f820f; WORD $0x0000             // jb           LBB36_90, $671(%rip)
+	LONG $0x80fb8149; WORD $0x0000; BYTE $0x00 // cmpq         $128, %r11
+	LONG $0x00cf830f; WORD $0x0000             // jae          LBB36_75, $207(%rip)
+	WORD $0x3145; BYTE $0xd2                   // xorl         %r10d, %r10d
+	LONG $0x000211e9; BYTE $0x00               // jmp          LBB36_84, $529(%rip)
+
+LBB36_50:
+	LONG $0x000001b8; BYTE $0x00               // movl         $1, %eax
+	LONG $0x0aff8341                           // cmpl         $10, %r15d
+	LONG $0x0021820f; WORD $0x0000             // jb           LBB36_53, $33(%rip)
+	LONG $0x000002b8; BYTE $0x00               // movl         $2, %eax
+	LONG $0x64ff8341                           // cmpl         $100, %r15d
+	LONG $0x0012820f; WORD $0x0000             // jb           LBB36_53, $18(%rip)
+	LONG $0x000003b8; BYTE $0x00               // movl         $3, %eax
+	LONG $0xe7ff8141; WORD $0x0003; BYTE $0x00 // cmpl         $999, %r15d
+	LONG $0x022b870f; WORD $0x0000             // ja           LBB36_87, $555(%rip)
+
+LBB36_53:
+	WORD $0x014c; BYTE $0xe8       // addq         %r13, %rax
+	WORD $0x8948; BYTE $0xc1       // movq         %rax, %rcx
+	LONG $0x64ff8341               // cmpl         $100, %r15d
+	LONG $0x003c820f; WORD $0x0000 // jb           LBB36_56, $60(%rip)
+
+LBB36_54:
+	WORD $0xff48; BYTE $0xc9                   // decq         %rcx
+	LONG $0x60058d4c; WORD $0x003f; BYTE $0x00 // leaq         $16224(%rip), %r8  /* _Digits(%rip) */
+
+	// .p2align 4, 0x90
+LBB36_55:
+	WORD $0x8944; BYTE $0xfb                   // movl         %r15d, %ebx
+	WORD $0x8944; BYTE $0xfe                   // movl         %r15d, %esi
+	LONG $0x1ffe694c; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rsi, %r15
+	LONG $0x25efc149                           // shrq         $37, %r15
+	LONG $0x64f76b41                           // imull        $100, %r15d, %esi
+	WORD $0xda89                               // movl         %ebx, %edx
+	WORD $0xf229                               // subl         %esi, %edx
+	LONG $0x14b70f41; BYTE $0x50               // movzwl       (%r8,%rdx,2), %edx
+	LONG $0xff518966                           // movw         %dx, $-1(%rcx)
+	LONG $0xfec18348                           // addq         $-2, %rcx
+	LONG $0x270ffb81; WORD $0x0000             // cmpl         $9999, %ebx
+	LONG $0xffce870f; WORD $0xffff             // ja           LBB36_55, $-50(%rip)
+
+LBB36_56:
+	LONG $0x0aff8341                           // cmpl         $10, %r15d
+	LONG $0x001a820f; WORD $0x0000             // jb           LBB36_58, $26(%rip)
+	WORD $0x8944; BYTE $0xf9                   // movl         %r15d, %ecx
+	LONG $0x1a158d48; WORD $0x003f; BYTE $0x00 // leaq         $16154(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x4a0cb70f                           // movzwl       (%rdx,%rcx,2), %ecx
+	LONG $0x4d894166; BYTE $0x00               // movw         %cx, (%r13)
+	WORD $0xf829                               // subl         %edi, %eax
+	LONG $0x0006eee9; BYTE $0x00               // jmp          LBB36_93, $1774(%rip)
+
+LBB36_58:
+	LONG $0x30c78041             // addb         $48, %r15b
+	LONG $0x007d8845             // movb         %r15b, (%r13)
+	WORD $0xf829                 // subl         %edi, %eax
+	LONG $0x0006dfe9; BYTE $0x00 // jmp          LBB36_93, $1759(%rip)
+
+LBB36_59:
+	LONG $0x0004b841; WORD $0x0000 // movl         $4, %r8d
+	LONG $0xfcc28348               // addq         $-4, %rdx
+	WORD $0xfe83; BYTE $0x64       // cmpl         $100, %esi
+	LONG $0xfbc5820f; WORD $0xffff // jb           LBB36_32, $-1083(%rip)
+	LONG $0xfffc66e9; BYTE $0xff   // jmp          LBB36_61, $-922(%rip)
+
+LBB36_75:
+	WORD $0x894d; BYTE $0xda       // movq         %r11, %r10
+	LONG $0x80e28349               // andq         $-128, %r10
+	LONG $0x80428d49               // leaq         $-128(%r10), %rax
+	WORD $0x8948; BYTE $0xc2       // movq         %rax, %rdx
+	LONG $0x07eac148               // shrq         $7, %rdx
+	WORD $0xff48; BYTE $0xc2       // incq         %rdx
+	WORD $0x8941; BYTE $0xd6       // movl         %edx, %r14d
+	LONG $0x03e68341               // andl         $3, %r14d
+	LONG $0x01803d48; WORD $0x0000 // cmpq         $384, %rax
+	LONG $0x0007830f; WORD $0x0000 // jae          LBB36_77, $7(%rip)
+	WORD $0xf631                   // xorl         %esi, %esi
+	LONG $0x0000b5e9; BYTE $0x00   // jmp          LBB36_79, $181(%rip)
+
+LBB36_77:
+	LONG $0xfce28348                     // andq         $-4, %rdx
+	LONG $0x01048d4b                     // leaq         (%r9,%r8), %rax
+	WORD $0x014c; BYTE $0xe8             // addq         %r13, %rax
+	LONG $0x01e00548; WORD $0x0000       // addq         $480, %rax
+	WORD $0xf631                         // xorl         %esi, %esi
+	QUAD $0xfffff849056ffdc5             // vmovdqa      $-1975(%rip), %ymm0  /* LCPI36_0(%rip) */
+	QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB36_78:
+	QUAD $0xfffe2030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-480(%rax,%rsi)
+	QUAD $0xfffe4030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-448(%rax,%rsi)
+	QUAD $0xfffe6030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-416(%rax,%rsi)
+	QUAD $0xfffe8030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-384(%rax,%rsi)
+	QUAD $0xfffea030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-352(%rax,%rsi)
+	QUAD $0xfffec030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-320(%rax,%rsi)
+	QUAD $0xfffee030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-288(%rax,%rsi)
+	QUAD $0xffff0030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-256(%rax,%rsi)
+	QUAD $0xffff2030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-224(%rax,%rsi)
+	QUAD $0xffff4030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-192(%rax,%rsi)
+	QUAD $0xffff6030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-160(%rax,%rsi)
+	LONG $0x447ffec5; WORD $0x8030             // vmovdqu      %ymm0, $-128(%rax,%rsi)
+	LONG $0x447ffec5; WORD $0xa030             // vmovdqu      %ymm0, $-96(%rax,%rsi)
+	LONG $0x447ffec5; WORD $0xc030             // vmovdqu      %ymm0, $-64(%rax,%rsi)
+	LONG $0x447ffec5; WORD $0xe030             // vmovdqu      %ymm0, $-32(%rax,%rsi)
+	LONG $0x047ffec5; BYTE $0x30               // vmovdqu      %ymm0, (%rax,%rsi)
+	LONG $0x00c68148; WORD $0x0002; BYTE $0x00 // addq         $512, %rsi
+	LONG $0xfcc28348                           // addq         $-4, %rdx
+	LONG $0xff6f850f; WORD $0xffff             // jne          LBB36_78, $-145(%rip)
+
+LBB36_79:
+	WORD $0x854d; BYTE $0xf6               // testq        %r14, %r14
+	LONG $0x004a840f; WORD $0x0000         // je           LBB36_82, $74(%rip)
+	WORD $0x014c; BYTE $0xce               // addq         %r9, %rsi
+	WORD $0x014c; BYTE $0xc6               // addq         %r8, %rsi
+	LONG $0x2e048d4a                       // leaq         (%rsi,%r13), %rax
+	LONG $0x60c08348                       // addq         $96, %rax
+	LONG $0x07e6c149                       // shlq         $7, %r14
+	WORD $0xd231                           // xorl         %edx, %edx
+	QUAD $0xfffff78a056ffdc5               // vmovdqa      $-2166(%rip), %ymm0  /* LCPI36_0(%rip) */
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB36_81:
+	LONG $0x447ffec5; WORD $0xa010 // vmovdqu      %ymm0, $-96(%rax,%rdx)
+	LONG $0x447ffec5; WORD $0xc010 // vmovdqu      %ymm0, $-64(%rax,%rdx)
+	LONG $0x447ffec5; WORD $0xe010 // vmovdqu      %ymm0, $-32(%rax,%rdx)
+	LONG $0x047ffec5; BYTE $0x10   // vmovdqu      %ymm0, (%rax,%rdx)
+	LONG $0x80ea8348               // subq         $-128, %rdx
+	WORD $0x3949; BYTE $0xd6       // cmpq         %rdx, %r14
+	LONG $0xffdc850f; WORD $0xffff // jne          LBB36_81, $-36(%rip)
+
+LBB36_82:
+	WORD $0x394d; BYTE $0xd3       // cmpq         %r10, %r11
+	LONG $0x0092840f; WORD $0x0000 // je           LBB36_91, $146(%rip)
+	LONG $0x70c3f641               // testb        $112, %r11b
+	LONG $0x0071840f; WORD $0x0000 // je           LBB36_89, $113(%rip)
+
+LBB36_84:
+	WORD $0x894c; BYTE $0xd8       // movq         %r11, %rax
+	LONG $0xf0e08348               // andq         $-16, %rax
+	WORD $0x0148; BYTE $0xc1       // addq         %rax, %rcx
+	WORD $0x014d; BYTE $0xd1       // addq         %r10, %r9
+	WORD $0x014d; BYTE $0xc1       // addq         %r8, %r9
+	WORD $0x014d; BYTE $0xe9       // addq         %r13, %r9
+	WORD $0x8948; BYTE $0xc2       // movq         %rax, %rdx
+	WORD $0x294c; BYTE $0xd2       // subq         %r10, %rdx
+	WORD $0xf631                   // xorl         %esi, %esi
+	QUAD $0xfffff746056ff9c5       // vmovdqa      $-2234(%rip), %xmm0  /* LCPI36_1(%rip) */
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB36_85:
+	LONG $0x7f7ac1c4; WORD $0x3104 // vmovdqu      %xmm0, (%r9,%rsi)
+	LONG $0x10c68348               // addq         $16, %rsi
+	WORD $0x3948; BYTE $0xf2       // cmpq         %rsi, %rdx
+	LONG $0xffed850f; WORD $0xffff // jne          LBB36_85, $-19(%rip)
+	WORD $0x3949; BYTE $0xc3       // cmpq         %rax, %r11
+	LONG $0x0034850f; WORD $0x0000 // jne          LBB36_90, $52(%rip)
+	LONG $0x00003ee9; BYTE $0x00   // jmp          LBB36_91, $62(%rip)
+
+LBB36_87:
+	LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl         $10000, %r15d
+	WORD $0x894c; BYTE $0xe9                   // movq         %r13, %rcx
+	LONG $0x00d98348                           // sbbq         $0, %rcx
+	LONG $0x05c18348                           // addq         $5, %rcx
+	LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl         $10000, %r15d
+	LONG $0xfc01830f; WORD $0xffff             // jae          LBB36_35, $-1023(%rip)
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	LONG $0xfffdbee9; BYTE $0xff               // jmp          LBB36_54, $-578(%rip)
+
+LBB36_89:
+	WORD $0x014c; BYTE $0xd1     // addq         %r10, %rcx
+	LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB36_90:
+	WORD $0x01c6; BYTE $0x30       // movb         $48, (%rcx)
+	WORD $0xff48; BYTE $0xc1       // incq         %rcx
+	WORD $0x394c; BYTE $0xf9       // cmpq         %r15, %rcx
+	LONG $0xfff1820f; WORD $0xffff // jb           LBB36_90, $-15(%rip)
+
+LBB36_91:
+	WORD $0x894c; BYTE $0xf8     // movq         %r15, %rax
+	LONG $0x0004eae9; BYTE $0x00 // jmp          LBB36_92, $1258(%rip)
+
+LBB36_94:
+	LONG $0xfce58349                           // andq         $-4, %r13
+	LONG $0x39348d49                           // leaq         (%r9,%rdi), %rsi
+	LONG $0xe2c68148; WORD $0x0001; BYTE $0x00 // addq         $482, %rsi
+	WORD $0xd231                               // xorl         %edx, %edx
+	QUAD $0xfffff6a0056ffdc5                   // vmovdqa      $-2400(%rip), %ymm0  /* LCPI36_0(%rip) */
+
+LBB36_95:
+	QUAD $0xfffe2016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-480(%rsi,%rdx)
+	QUAD $0xfffe4016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-448(%rsi,%rdx)
+	QUAD $0xfffe6016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-416(%rsi,%rdx)
+	QUAD $0xfffe8016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-384(%rsi,%rdx)
+	QUAD $0xfffea016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-352(%rsi,%rdx)
+	QUAD $0xfffec016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-320(%rsi,%rdx)
+	QUAD $0xfffee016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-288(%rsi,%rdx)
+	QUAD $0xffff0016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-256(%rsi,%rdx)
+	QUAD $0xffff2016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-224(%rsi,%rdx)
+	QUAD $0xffff4016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-192(%rsi,%rdx)
+	QUAD $0xffff6016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-160(%rsi,%rdx)
+	LONG $0x447ffec5; WORD $0x8016             // vmovdqu      %ymm0, $-128(%rsi,%rdx)
+	LONG $0x447ffec5; WORD $0xa016             // vmovdqu      %ymm0, $-96(%rsi,%rdx)
+	LONG $0x447ffec5; WORD $0xc016             // vmovdqu      %ymm0, $-64(%rsi,%rdx)
+	LONG $0x447ffec5; WORD $0xe016             // vmovdqu      %ymm0, $-32(%rsi,%rdx)
+	LONG $0x047ffec5; BYTE $0x16               // vmovdqu      %ymm0, (%rsi,%rdx)
+	LONG $0x00c28148; WORD $0x0002; BYTE $0x00 // addq         $512, %rdx
+	LONG $0xfcc58349                           // addq         $-4, %r13
+	LONG $0xff6f850f; WORD $0xffff             // jne          LBB36_95, $-145(%rip)
+
+LBB36_96:
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	WORD $0x8949; BYTE $0xfd       // movq         %rdi, %r13
+	LONG $0x003c840f; WORD $0x0000 // je           LBB36_99, $60(%rip)
+	WORD $0x014c; BYTE $0xca       // addq         %r9, %rdx
+	WORD $0x014c; BYTE $0xea       // addq         %r13, %rdx
+	LONG $0x62c28348               // addq         $98, %rdx
+	LONG $0x07e7c149               // shlq         $7, %r15
+	WORD $0xf631                   // xorl         %esi, %esi
+	QUAD $0xfffff5eb056ffdc5       // vmovdqa      $-2581(%rip), %ymm0  /* LCPI36_0(%rip) */
+
+LBB36_98:
+	LONG $0x447ffec5; WORD $0xa032 // vmovdqu      %ymm0, $-96(%rdx,%rsi)
+	LONG $0x447ffec5; WORD $0xc032 // vmovdqu      %ymm0, $-64(%rdx,%rsi)
+	LONG $0x447ffec5; WORD $0xe032 // vmovdqu      %ymm0, $-32(%rdx,%rsi)
+	LONG $0x047ffec5; BYTE $0x32   // vmovdqu      %ymm0, (%rdx,%rsi)
+	LONG $0x80ee8348               // subq         $-128, %rsi
+	WORD $0x3949; BYTE $0xf7       // cmpq         %rsi, %r15
+	LONG $0xffdc850f; WORD $0xffff // jne          LBB36_98, $-36(%rip)
+
+LBB36_99:
+	WORD $0x8949; BYTE $0xdf       // movq         %rbx, %r15
+	WORD $0x0149; BYTE $0xcf       // addq         %rcx, %r15
+	WORD $0x3949; BYTE $0xce       // cmpq         %rcx, %r14
+	LONG $0x0017840f; WORD $0x0000 // je           LBB36_102, $23(%rip)
+
+LBB36_100:
+	WORD $0x0144; BYTE $0xd1 // addl         %r10d, %ecx
+	WORD $0xd9f7             // negl         %ecx
+	WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB36_101:
+	LONG $0x3007c641               // movb         $48, (%r15)
+	WORD $0xff49; BYTE $0xc7       // incq         %r15
+	WORD $0xc9ff                   // decl         %ecx
+	LONG $0xfff1850f; WORD $0xffff // jne          LBB36_101, $-15(%rip)
+
+LBB36_102:
+	LONG $0xd07d894c                           // movq         %r15, $-48(%rbp)
+	WORD $0x014d; BYTE $0xc7                   // addq         %r8, %r15
+	LONG $0x0027103d; BYTE $0x00               // cmpl         $10000, %eax
+	LONG $0x005f820f; WORD $0x0000             // jb           LBB36_105, $95(%rip)
+	WORD $0xc289                               // movl         %eax, %edx
+	LONG $0xb71759bb; BYTE $0xd1               // movl         $3518437209, %ebx
+	LONG $0xdaaf0f48                           // imulq        %rdx, %rbx
+	LONG $0x2debc148                           // shrq         $45, %rbx
+	LONG $0xd8f0d369; WORD $0xffff             // imull        $-10000, %ebx, %edx
+	WORD $0xc201                               // addl         %eax, %edx
+	LONG $0x01c3840f; WORD $0x0000             // je           LBB36_107, $451(%rip)
+	WORD $0xd089                               // movl         %edx, %eax
+	LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xf06b; BYTE $0x64                   // imull        $100, %eax, %esi
+	WORD $0xf229                               // subl         %esi, %edx
+	LONG $0xa9358d48; WORD $0x003b; BYTE $0x00 // leaq         $15273(%rip), %rsi  /* _Digits(%rip) */
+	LONG $0x5614b70f                           // movzwl       (%rsi,%rdx,2), %edx
+	LONG $0x57894166; BYTE $0xfe               // movw         %dx, $-2(%r15)
+	LONG $0x4604b70f                           // movzwl       (%rsi,%rax,2), %eax
+	LONG $0x47894166; BYTE $0xfc               // movw         %ax, $-4(%r15)
+	WORD $0x3145; BYTE $0xf6                   // xorl         %r14d, %r14d
+	LONG $0xfc578d49                           // leaq         $-4(%r15), %rdx
+	WORD $0xfb83; BYTE $0x64                   // cmpl         $100, %ebx
+	LONG $0x0018830f; WORD $0x0000             // jae          LBB36_109, $24(%rip)
+
+LBB36_106:
+	WORD $0xd889                 // movl         %ebx, %eax
+	LONG $0x00004ee9; BYTE $0x00 // jmp          LBB36_111, $78(%rip)
+
+LBB36_105:
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	WORD $0x894c; BYTE $0xfa       // movq         %r15, %rdx
+	WORD $0xc389                   // movl         %eax, %ebx
+	WORD $0xfb83; BYTE $0x64       // cmpl         $100, %ebx
+	LONG $0xffe8820f; WORD $0xffff // jb           LBB36_106, $-24(%rip)
+
+LBB36_109:
+	WORD $0xff48; BYTE $0xca                   // decq         %rdx
+	LONG $0x65358d48; WORD $0x003b; BYTE $0x00 // leaq         $15205(%rip), %rsi  /* _Digits(%rip) */
+	LONG $0x90909090; BYTE $0x90               // .p2align 4, 0x90
+
+LBB36_110:
+	WORD $0xd889                               // movl         %ebx, %eax
+	LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xf86b; BYTE $0x64                   // imull        $100, %eax, %edi
+	WORD $0xd989                               // movl         %ebx, %ecx
+	WORD $0xf929                               // subl         %edi, %ecx
+	LONG $0x4e0cb70f                           // movzwl       (%rsi,%rcx,2), %ecx
+	LONG $0xff4a8966                           // movw         %cx, $-1(%rdx)
+	LONG $0xfec28348                           // addq         $-2, %rdx
+	LONG $0x270ffb81; WORD $0x0000             // cmpl         $9999, %ebx
+	WORD $0xc389                               // movl         %eax, %ebx
+	LONG $0xffd2870f; WORD $0xffff             // ja           LBB36_110, $-46(%rip)
+
+LBB36_111:
+	WORD $0x894d; BYTE $0xe9                   // movq         %r13, %r9
+	WORD $0xf883; BYTE $0x0a                   // cmpl         $10, %eax
+	LONG $0x0019820f; WORD $0x0000             // jb           LBB36_113, $25(%rip)
+	WORD $0xc089                               // movl         %eax, %eax
+	LONG $0x1d0d8d48; WORD $0x003b; BYTE $0x00 // leaq         $15133(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	LONG $0xd04d8b48                           // movq         $-48(%rbp), %rcx
+	WORD $0x8966; BYTE $0x01                   // movw         %ax, (%rcx)
+	LONG $0x000008e9; BYTE $0x00               // jmp          LBB36_114, $8(%rip)
+
+LBB36_113:
+	WORD $0x3004     // addb         $48, %al
+	LONG $0xd04d8b48 // movq         $-48(%rbp), %rcx
+	WORD $0x0188     // movb         %al, (%rcx)
+
+LBB36_114:
+	WORD $0x294d; BYTE $0xf7 // subq         %r14, %r15
+	WORD $0x294d; BYTE $0xf0 // subq         %r14, %r8
+	WORD $0xff49; BYTE $0xc0 // incq         %r8
+	LONG $0x1e048d43         // leal         (%r14,%r11), %eax
+	WORD $0xd8f6             // negb         %al
+	LONG $0x33148d43         // leal         (%r11,%r14), %edx
+	WORD $0xdaf7             // negl         %edx
+	LONG $0x332c8d47         // leal         (%r11,%r14), %r13d
+	WORD $0xff41; BYTE $0xcd // decl         %r13d
+	LONG $0x33348d43         // leal         (%r11,%r14), %esi
+	WORD $0xc683; BYTE $0xfe // addl         $-2, %esi
+	WORD $0xc931             // xorl         %ecx, %ecx
+
+	// .p2align 4, 0x90
+LBB36_115:
+	WORD $0xc389                   // movl         %eax, %ebx
+	WORD $0x438d; BYTE $0x03       // leal         $3(%rbx), %eax
+	WORD $0xc6ff                   // incl         %esi
+	LONG $0x0f7c8041; WORD $0x30ff // cmpb         $48, $-1(%r15,%rcx)
+	LONG $0xff498d48               // leaq         $-1(%rcx), %rcx
+	LONG $0xffe9840f; WORD $0xffff // je           LBB36_115, $-23(%rip)
+	LONG $0x0f048d49               // leaq         (%r15,%rcx), %rax
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0x00b28e0f; WORD $0x0000 // jle          LBB36_121, $178(%rip)
+	WORD $0x2945; BYTE $0xf4       // subl         %r14d, %r12d
+	LONG $0x0c3c8d41               // leal         (%r12,%rcx), %edi
+	WORD $0xc7ff                   // incl         %edi
+	WORD $0x3941; BYTE $0xfa       // cmpl         %edi, %r10d
+	LONG $0x002d8d0f; WORD $0x0000 // jge          LBB36_122, $45(%rip)
+	WORD $0x6348; BYTE $0xc2       // movslq       %edx, %rax
+	LONG $0x08348d48               // leaq         (%rax,%rcx), %rsi
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0xf685                   // testl        %esi, %esi
+	WORD $0x894d; BYTE $0xcd       // movq         %r9, %r13
+	LONG $0x011a8e0f; WORD $0x0000 // jle          LBB36_133, $282(%rip)
+	WORD $0x8941; BYTE $0xf0       // movl         %esi, %r8d
+	LONG $0xff508d49               // leaq         $-1(%r8), %rdx
+	LONG $0x03fa8348               // cmpq         $3, %rdx
+	LONG $0x009a830f; WORD $0x0000 // jae          LBB36_127, $154(%rip)
+	WORD $0xd231                   // xorl         %edx, %edx
+	LONG $0x0000c6e9; BYTE $0x00   // jmp          LBB36_130, $198(%rip)
+
+LBB36_122:
+	WORD $0x8945; BYTE $0xea                   // movl         %r13d, %r10d
+	WORD $0x2949; BYTE $0xca                   // subq         %rcx, %r10
+	WORD $0x8545; BYTE $0xd2                   // testl        %r10d, %r10d
+	LONG $0x00648e0f; WORD $0x0000             // jle          LBB36_121, $100(%rip)
+	LONG $0x331c8d43                           // leal         (%r11,%r14), %ebx
+	WORD $0xc383; BYTE $0xfe                   // addl         $-2, %ebx
+	WORD $0x2948; BYTE $0xcb                   // subq         %rcx, %rbx
+	WORD $0xd231                               // xorl         %edx, %edx
+	WORD $0xfb83; BYTE $0x7f                   // cmpl         $127, %ebx
+	WORD $0x894d; BYTE $0xcd                   // movq         %r9, %r13
+	LONG $0x0223820f; WORD $0x0000             // jb           LBB36_140, $547(%rip)
+	WORD $0x0145; BYTE $0xde                   // addl         %r11d, %r14d
+	LONG $0xfec68341                           // addl         $-2, %r14d
+	WORD $0x2949; BYTE $0xce                   // subq         %rcx, %r14
+	WORD $0x8941; BYTE $0xdb                   // movl         %ebx, %r11d
+	WORD $0xff49; BYTE $0xc3                   // incq         %r11
+	WORD $0x894c; BYTE $0xda                   // movq         %r11, %rdx
+	LONG $0x80e28348                           // andq         $-128, %rdx
+	LONG $0xd07d8b48                           // movq         $-48(%rbp), %rdi
+	WORD $0x014c; BYTE $0xc7                   // addq         %r8, %rdi
+	WORD $0xf089                               // movl         %esi, %eax
+	WORD $0xff48; BYTE $0xc0                   // incq         %rax
+	LONG $0x80e08348                           // andq         $-128, %rax
+	WORD $0x0148; BYTE $0xf8                   // addq         %rdi, %rax
+	LONG $0x80728d48                           // leaq         $-128(%rdx), %rsi
+	WORD $0x8949; BYTE $0xf0                   // movq         %rsi, %r8
+	LONG $0x07e8c149                           // shrq         $7, %r8
+	WORD $0xff49; BYTE $0xc0                   // incq         %r8
+	LONG $0x80fe8148; WORD $0x0001; BYTE $0x00 // cmpq         $384, %rsi
+	LONG $0x00ae830f; WORD $0x0000             // jae          LBB36_134, $174(%rip)
+	WORD $0xf631                               // xorl         %esi, %esi
+	LONG $0x000163e9; BYTE $0x00               // jmp          LBB36_136, $355(%rip)
+
+LBB36_121:
+	WORD $0x894d; BYTE $0xcd     // movq         %r9, %r13
+	LONG $0x0001e0e9; BYTE $0x00 // jmp          LBB36_92, $480(%rip)
+
+LBB36_107:
+	LONG $0x0004be41; WORD $0x0000 // movl         $4, %r14d
+	LONG $0xfc578d49               // leaq         $-4(%r15), %rdx
+	WORD $0xfb83; BYTE $0x64       // cmpl         $100, %ebx
+	LONG $0xfe65820f; WORD $0xffff // jb           LBB36_106, $-411(%rip)
+	LONG $0xfffe78e9; BYTE $0xff   // jmp          LBB36_109, $-392(%rip)
+
+LBB36_127:
+	WORD $0xe683; BYTE $0xfc                                             // andl         $-4, %esi
+	WORD $0xf748; BYTE $0xde                                             // negq         %rsi
+	WORD $0xd231                                                         // xorl         %edx, %edx
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB36_128:
+	LONG $0x173c8d49               // leaq         (%r15,%rdx), %rdi
+	LONG $0xfd39448b               // movl         $-3(%rcx,%rdi), %eax
+	LONG $0xfe394489               // movl         %eax, $-2(%rcx,%rdi)
+	LONG $0xfcc28348               // addq         $-4, %rdx
+	WORD $0x3948; BYTE $0xd6       // cmpq         %rdx, %rsi
+	LONG $0xffe7850f; WORD $0xffff // jne          LBB36_128, $-25(%rip)
+	WORD $0xf748; BYTE $0xda       // negq         %rdx
+
+LBB36_130:
+	LONG $0x03c0f641                     // testb        $3, %r8b
+	LONG $0x0032840f; WORD $0x0000       // je           LBB36_133, $50(%rip)
+	WORD $0xb60f; BYTE $0xc3             // movzbl       %bl, %eax
+	WORD $0xe083; BYTE $0x03             // andl         $3, %eax
+	WORD $0xf748; BYTE $0xd8             // negq         %rax
+	WORD $0x894c; BYTE $0xfe             // movq         %r15, %rsi
+	WORD $0x2948; BYTE $0xd6             // subq         %rdx, %rsi
+	WORD $0xd231                         // xorl         %edx, %edx
+	QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB36_132:
+	LONG $0x163c8d48               // leaq         (%rsi,%rdx), %rdi
+	LONG $0x391cb60f               // movzbl       (%rcx,%rdi), %ebx
+	LONG $0x01395c88               // movb         %bl, $1(%rcx,%rdi)
+	WORD $0xff48; BYTE $0xca       // decq         %rdx
+	WORD $0x3948; BYTE $0xd0       // cmpq         %rdx, %rax
+	LONG $0xffe8850f; WORD $0xffff // jne          LBB36_132, $-24(%rip)
+
+LBB36_133:
+	WORD $0x8944; BYTE $0xd0     // movl         %r10d, %eax
+	LONG $0xd0558b48             // movq         $-48(%rbp), %rdx
+	LONG $0x2e0204c6             // movb         $46, (%rdx,%rax)
+	LONG $0x0f048d49             // leaq         (%r15,%rcx), %rax
+	LONG $0x02c08348             // addq         $2, %rax
+	LONG $0x000141e9; BYTE $0x00 // jmp          LBB36_92, $321(%rip)
+
+LBB36_134:
+	WORD $0x8944; BYTE $0xf3 // movl         %r14d, %ebx
+	WORD $0xff48; BYTE $0xc3 // incq         %rbx
+	LONG $0x80e38348         // andq         $-128, %rbx
+	LONG $0x80c38348         // addq         $-128, %rbx
+	LONG $0x07ebc148         // shrq         $7, %rbx
+	WORD $0xff48; BYTE $0xc3 // incq         %rbx
+	LONG $0xfce38348         // andq         $-4, %rbx
+	WORD $0xf631             // xorl         %esi, %esi
+	QUAD $0xfffff2ed056ffdc5 // vmovdqa      $-3347(%rip), %ymm0  /* LCPI36_0(%rip) */
+
+LBB36_135:
+	LONG $0x373c8d49                           // leaq         (%r15,%rsi), %rdi
+	LONG $0x447ffec5; WORD $0x0139             // vmovdqu      %ymm0, $1(%rcx,%rdi)
+	LONG $0x447ffec5; WORD $0x2139             // vmovdqu      %ymm0, $33(%rcx,%rdi)
+	LONG $0x447ffec5; WORD $0x4139             // vmovdqu      %ymm0, $65(%rcx,%rdi)
+	LONG $0x447ffec5; WORD $0x6139             // vmovdqu      %ymm0, $97(%rcx,%rdi)
+	QUAD $0x00008139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $129(%rcx,%rdi)
+	QUAD $0x0000a139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $161(%rcx,%rdi)
+	QUAD $0x0000c139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $193(%rcx,%rdi)
+	QUAD $0x0000e139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $225(%rcx,%rdi)
+	QUAD $0x00010139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $257(%rcx,%rdi)
+	QUAD $0x00012139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $289(%rcx,%rdi)
+	QUAD $0x00014139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $321(%rcx,%rdi)
+	QUAD $0x00016139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $353(%rcx,%rdi)
+	QUAD $0x00018139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $385(%rcx,%rdi)
+	QUAD $0x0001a139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $417(%rcx,%rdi)
+	QUAD $0x0001c139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $449(%rcx,%rdi)
+	QUAD $0x0001e139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $481(%rcx,%rdi)
+	LONG $0x00c68148; WORD $0x0002; BYTE $0x00 // addq         $512, %rsi
+	LONG $0xfcc38348                           // addq         $-4, %rbx
+	LONG $0xff67850f; WORD $0xffff             // jne          LBB36_135, $-153(%rip)
+
+LBB36_136:
+	WORD $0x0148; BYTE $0xc8                   // addq         %rcx, %rax
+	LONG $0x03c0f641                           // testb        $3, %r8b
+	LONG $0x005a840f; WORD $0x0000             // je           LBB36_139, $90(%rip)
+	WORD $0xff41; BYTE $0xc6                   // incl         %r14d
+	LONG $0x80e68141; WORD $0x0001; BYTE $0x00 // andl         $384, %r14d
+	LONG $0x80c68341                           // addl         $-128, %r14d
+	LONG $0x07eec141                           // shrl         $7, %r14d
+	WORD $0xfe41; BYTE $0xc6                   // incb         %r14b
+	LONG $0xc6b60f45                           // movzbl       %r14b, %r8d
+	LONG $0x03e08341                           // andl         $3, %r8d
+	LONG $0x07e0c149                           // shlq         $7, %r8
+	WORD $0x014c; BYTE $0xfe                   // addq         %r15, %rsi
+	LONG $0x61c68348                           // addq         $97, %rsi
+	WORD $0xdb31                               // xorl         %ebx, %ebx
+	QUAD $0xfffff215056ffdc5                   // vmovdqa      $-3563(%rip), %ymm0  /* LCPI36_0(%rip) */
+
+LBB36_138:
+	LONG $0x1e3c8d48               // leaq         (%rsi,%rbx), %rdi
+	LONG $0x447ffec5; WORD $0xa039 // vmovdqu      %ymm0, $-96(%rcx,%rdi)
+	LONG $0x447ffec5; WORD $0xc039 // vmovdqu      %ymm0, $-64(%rcx,%rdi)
+	LONG $0x447ffec5; WORD $0xe039 // vmovdqu      %ymm0, $-32(%rcx,%rdi)
+	LONG $0x047ffec5; BYTE $0x39   // vmovdqu      %ymm0, (%rcx,%rdi)
+	LONG $0x80eb8348               // subq         $-128, %rbx
+	WORD $0x3949; BYTE $0xd8       // cmpq         %rbx, %r8
+	LONG $0xffd8850f; WORD $0xffff // jne          LBB36_138, $-40(%rip)
+
+LBB36_139:
+	WORD $0x3949; BYTE $0xd3       // cmpq         %rdx, %r11
+	LONG $0x0015840f; WORD $0x0000 // je           LBB36_92, $21(%rip)
+	LONG $0x90909090               // .p2align 4, 0x90
+
+LBB36_140:
+	WORD $0x00c6; BYTE $0x30       // movb         $48, (%rax)
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0xc2ff                   // incl         %edx
+	WORD $0x3944; BYTE $0xd2       // cmpl         %r10d, %edx
+	LONG $0xffef8c0f; WORD $0xffff // jl           LBB36_140, $-17(%rip)
+
+LBB36_92:
+	WORD $0x2944; BYTE $0xe8 // subl         %r13d, %eax
+
+LBB36_93:
+	LONG $0x08c48348         // addq         $8, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	BYTE $0xc3               // retq
+
+LBB36_141:
+	WORD $0xc031                 // xorl         %eax, %eax
+	LONG $0xffffe7e9; BYTE $0xff // jmp          LBB36_93, $-25(%rip)
+
+LBB36_142:
+	LONG $0xd07d8948               // movq         %rdi, $-48(%rbp)
+	LONG $0xff6bb841; WORD $0xffff // movl         $-149, %r8d
+	WORD $0x8941; BYTE $0xc7       // movl         %eax, %r15d
+	LONG $0xfff257e9; BYTE $0xff   // jmp          LBB36_8, $-3497(%rip)
+	BYTE $0x90                     // .p2align 4, 0x90
+
+_format_significand:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5641                   // pushq        %r14
+	BYTE $0x53                     // pushq        %rbx
+	WORD $0x8941; BYTE $0xd0       // movl         %edx, %r8d
+	WORD $0x0149; BYTE $0xf0       // addq         %rsi, %r8
+	WORD $0x8948; BYTE $0xf8       // movq         %rdi, %rax
+	LONG $0x20e8c148               // shrq         $32, %rax
+	LONG $0x001c850f; WORD $0x0000 // jne          LBB37_2, $28(%rip)
+	WORD $0x3145; BYTE $0xc9       // xorl         %r9d, %r9d
+	WORD $0x894d; BYTE $0xc6       // movq         %r8, %r14
+	WORD $0x8948; BYTE $0xfa       // movq         %rdi, %rdx
+	LONG $0x2710fa81; WORD $0x0000 // cmpl         $10000, %edx
+	LONG $0x00e3830f; WORD $0x0000 // jae          LBB37_8, $227(%rip)
+
+LBB37_7:
+	WORD $0xd789                 // movl         %edx, %edi
+	LONG $0x000132e9; BYTE $0x00 // jmp          LBB37_10, $306(%rip)
+
+LBB37_2:
+	QUAD $0x77118461cefdb948; WORD $0xabcc     // movabsq      $-6067343680855748867, %rcx
+	WORD $0x8948; BYTE $0xf8                   // movq         %rdi, %rax
+	WORD $0xf748; BYTE $0xe1                   // mulq         %rcx
+	LONG $0x1aeac148                           // shrq         $26, %rdx
+	LONG $0x1f00ca69; WORD $0xfa0a             // imull        $-100000000, %edx, %ecx
+	WORD $0xf901                               // addl         %edi, %ecx
+	LONG $0x00a4840f; WORD $0x0000             // je           LBB37_3, $164(%rip)
+	WORD $0xc889                               // movl         %ecx, %eax
+	LONG $0x1759b941; WORD $0xd1b7             // movl         $3518437209, %r9d
+	LONG $0xc1af0f49                           // imulq        %r9, %rax
+	LONG $0x2de8c148                           // shrq         $45, %rax
+	LONG $0x2710f869; WORD $0x0000             // imull        $10000, %eax, %edi
+	WORD $0xf929                               // subl         %edi, %ecx
+	WORD $0x8948; BYTE $0xc7                   // movq         %rax, %rdi
+	LONG $0xf9af0f49                           // imulq        %r9, %rdi
+	LONG $0x2defc148                           // shrq         $45, %rdi
+	LONG $0x2710ff69; WORD $0x0000             // imull        $10000, %edi, %edi
+	WORD $0xf829                               // subl         %edi, %eax
+	WORD $0xb70f; BYTE $0xf9                   // movzwl       %cx, %edi
+	WORD $0xefc1; BYTE $0x02                   // shrl         $2, %edi
+	LONG $0x7bcf6944; WORD $0x0014; BYTE $0x00 // imull        $5243, %edi, %r9d
+	LONG $0x11e9c141                           // shrl         $17, %r9d
+	LONG $0x64f96b41                           // imull        $100, %r9d, %edi
+	WORD $0xf929                               // subl         %edi, %ecx
+	LONG $0xd1b70f44                           // movzwl       %cx, %r10d
+	WORD $0xb70f; BYTE $0xf8                   // movzwl       %ax, %edi
+	WORD $0xefc1; BYTE $0x02                   // shrl         $2, %edi
+	LONG $0x147bff69; WORD $0x0000             // imull        $5243, %edi, %edi
+	WORD $0xefc1; BYTE $0x11                   // shrl         $17, %edi
+	WORD $0xcf6b; BYTE $0x64                   // imull        $100, %edi, %ecx
+	WORD $0xc829                               // subl         %ecx, %eax
+	LONG $0xd8b70f44                           // movzwl       %ax, %r11d
+	LONG $0x330d8d48; WORD $0x0037; BYTE $0x00 // leaq         $14131(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x04b70f42; BYTE $0x51               // movzwl       (%rcx,%r10,2), %eax
+	LONG $0x40894166; BYTE $0xfe               // movw         %ax, $-2(%r8)
+	LONG $0x04b70f42; BYTE $0x49               // movzwl       (%rcx,%r9,2), %eax
+	LONG $0x40894166; BYTE $0xfc               // movw         %ax, $-4(%r8)
+	LONG $0x04b70f42; BYTE $0x59               // movzwl       (%rcx,%r11,2), %eax
+	LONG $0x40894166; BYTE $0xfa               // movw         %ax, $-6(%r8)
+	LONG $0x7904b70f                           // movzwl       (%rcx,%rdi,2), %eax
+	LONG $0x40894166; BYTE $0xf8               // movw         %ax, $-8(%r8)
+	WORD $0x3145; BYTE $0xc9                   // xorl         %r9d, %r9d
+	LONG $0xf8708d4d                           // leaq         $-8(%r8), %r14
+	LONG $0x2710fa81; WORD $0x0000             // cmpl         $10000, %edx
+	LONG $0xff38820f; WORD $0xffff             // jb           LBB37_7, $-200(%rip)
+	LONG $0x000016e9; BYTE $0x00               // jmp          LBB37_8, $22(%rip)
+
+LBB37_3:
+	LONG $0x0008b941; WORD $0x0000 // movl         $8, %r9d
+	LONG $0xf8708d4d               // leaq         $-8(%r8), %r14
+	LONG $0x2710fa81; WORD $0x0000 // cmpl         $10000, %edx
+	LONG $0xff1d820f; WORD $0xffff // jb           LBB37_7, $-227(%rip)
+
+LBB37_8:
+	LONG $0x1759ba41; WORD $0xd1b7             // movl         $3518437209, %r10d
+	LONG $0xd11d8d4c; WORD $0x0036; BYTE $0x00 // leaq         $14033(%rip), %r11  /* _Digits(%rip) */
+	BYTE $0x90                                 // .p2align 4, 0x90
+
+LBB37_9:
+	WORD $0xd789                               // movl         %edx, %edi
+	LONG $0xfaaf0f49                           // imulq        %r10, %rdi
+	LONG $0x2defc148                           // shrq         $45, %rdi
+	LONG $0xd8f0c769; WORD $0xffff             // imull        $-10000, %edi, %eax
+	WORD $0xd001                               // addl         %edx, %eax
+	LONG $0x1fd86948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rbx
+	LONG $0x25ebc148                           // shrq         $37, %rbx
+	WORD $0xcb6b; BYTE $0x64                   // imull        $100, %ebx, %ecx
+	WORD $0xc829                               // subl         %ecx, %eax
+	LONG $0x04b70f41; BYTE $0x43               // movzwl       (%r11,%rax,2), %eax
+	LONG $0x46894166; BYTE $0xfe               // movw         %ax, $-2(%r14)
+	LONG $0x04b70f41; BYTE $0x5b               // movzwl       (%r11,%rbx,2), %eax
+	LONG $0x46894166; BYTE $0xfc               // movw         %ax, $-4(%r14)
+	LONG $0xfcc68349                           // addq         $-4, %r14
+	LONG $0xe0fffa81; WORD $0x05f5             // cmpl         $99999999, %edx
+	WORD $0xfa89                               // movl         %edi, %edx
+	LONG $0xffb8870f; WORD $0xffff             // ja           LBB37_9, $-72(%rip)
+
+LBB37_10:
+	WORD $0xff83; BYTE $0x64       // cmpl         $100, %edi
+	LONG $0x0020830f; WORD $0x0000 // jae          LBB37_11, $32(%rip)
+	WORD $0xff83; BYTE $0x0a       // cmpl         $10, %edi
+	LONG $0x004d820f; WORD $0x0000 // jb           LBB37_14, $77(%rip)
+
+LBB37_13:
+	WORD $0xf889                               // movl         %edi, %eax
+	LONG $0x6d0d8d48; WORD $0x0036; BYTE $0x00 // leaq         $13933(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	LONG $0x46894166; BYTE $0xfe               // movw         %ax, $-2(%r14)
+	LONG $0x00003de9; BYTE $0x00               // jmp          LBB37_15, $61(%rip)
+
+LBB37_11:
+	WORD $0xb70f; BYTE $0xc7                   // movzwl       %di, %eax
+	WORD $0xe8c1; BYTE $0x02                   // shrl         $2, %eax
+	LONG $0x147bc069; WORD $0x0000             // imull        $5243, %eax, %eax
+	WORD $0xe8c1; BYTE $0x11                   // shrl         $17, %eax
+	WORD $0xc86b; BYTE $0x64                   // imull        $100, %eax, %ecx
+	WORD $0xcf29                               // subl         %ecx, %edi
+	WORD $0xb70f; BYTE $0xcf                   // movzwl       %di, %ecx
+	LONG $0x41158d48; WORD $0x0036; BYTE $0x00 // leaq         $13889(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x4a0cb70f                           // movzwl       (%rdx,%rcx,2), %ecx
+	LONG $0x4e894166; BYTE $0xfe               // movw         %cx, $-2(%r14)
+	LONG $0xfec68349                           // addq         $-2, %r14
+	WORD $0xc789                               // movl         %eax, %edi
+	WORD $0xff83; BYTE $0x0a                   // cmpl         $10, %edi
+	LONG $0xffb3830f; WORD $0xffff             // jae          LBB37_13, $-77(%rip)
+
+LBB37_14:
+	LONG $0x30c78040         // addb         $48, %dil
+	WORD $0x8840; BYTE $0x3e // movb         %dil, (%rsi)
+
+LBB37_15:
+	WORD $0x294d; BYTE $0xc8                   // subq         %r9, %r8
+	WORD $0x894c; BYTE $0xc0                   // movq         %r8, %rax
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5e41                               // popq         %r14
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+_left_shift:
+	BYTE $0x55                                             // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                               // movq         %rsp, %rbp
+	WORD $0x5741                                           // pushq        %r15
+	WORD $0x5641                                           // pushq        %r14
+	BYTE $0x53                                             // pushq        %rbx
+	WORD $0xf189                                           // movl         %esi, %ecx
+	LONG $0x68c16b48                                       // imulq        $104, %rcx, %rax
+	LONG $0xea158d48; WORD $0x008f; BYTE $0x00             // leaq         $36842(%rip), %rdx  /* _LSHIFT_TAB(%rip) */
+	LONG $0x10048b44                                       // movl         (%rax,%rdx), %r8d
+	WORD $0x8b4c; BYTE $0x0f                               // movq         (%rdi), %r9
+	WORD $0x0148; BYTE $0xc2                               // addq         %rax, %rdx
+	LONG $0x04c28348                                       // addq         $4, %rdx
+	LONG $0x10476348                                       // movslq       $16(%rdi), %rax
+	WORD $0xf631                                           // xorl         %esi, %esi
+	WORD $0x8548; BYTE $0xc0                               // testq        %rax, %rax
+	LONG $0x0031840f; WORD $0x0000                         // je           LBB38_6, $49(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB38_1:
+	LONG $0x321cb60f               // movzbl       (%rdx,%rsi), %ebx
+	WORD $0xdb84                   // testb        %bl, %bl
+	LONG $0x0025840f; WORD $0x0000 // je           LBB38_8, $37(%rip)
+	LONG $0x311c3841               // cmpb         %bl, (%r9,%rsi)
+	LONG $0x0189850f; WORD $0x0000 // jne          LBB38_3, $393(%rip)
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0xffde850f; WORD $0xffff // jne          LBB38_1, $-34(%rip)
+	WORD $0xc689                   // movl         %eax, %esi
+
+LBB38_6:
+	LONG $0x00323c80               // cmpb         $0, (%rdx,%rsi)
+	LONG $0x0003840f; WORD $0x0000 // je           LBB38_8, $3(%rip)
+
+LBB38_7:
+	WORD $0xff41; BYTE $0xc8 // decl         %r8d
+
+LBB38_8:
+	WORD $0xc085                               // testl        %eax, %eax
+	LONG $0x00968e0f; WORD $0x0000             // jle          LBB38_22, $150(%rip)
+	LONG $0x001c8d45                           // leal         (%r8,%rax), %r11d
+	WORD $0xc389                               // movl         %eax, %ebx
+	WORD $0x634d; BYTE $0xf3                   // movslq       %r11d, %r14
+	WORD $0xff49; BYTE $0xce                   // decq         %r14
+	WORD $0xff48; BYTE $0xc3                   // incq         %rbx
+	WORD $0xd231                               // xorl         %edx, %edx
+	QUAD $0xcccccccccccdba49; WORD $0xcccc     // movabsq      $-3689348814741910323, %r10
+	LONG $0x000023e9; BYTE $0x00               // jmp          LBB38_10, $35(%rip)
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB38_11:
+	WORD $0x3004             // addb         $48, %al
+	LONG $0x31048843         // movb         %al, (%r9,%r14)
+	WORD $0x8b4c; BYTE $0x0f // movq         (%rdi), %r9
+
+LBB38_18:
+	WORD $0xff41; BYTE $0xcb       // decl         %r11d
+	WORD $0xff49; BYTE $0xce       // decq         %r14
+	WORD $0xff48; BYTE $0xcb       // decq         %rbx
+	LONG $0x01fb8348               // cmpq         $1, %rbx
+	LONG $0x0049860f; WORD $0x0000 // jbe          LBB38_12, $73(%rip)
+
+LBB38_10:
+	WORD $0x438d; BYTE $0xfe                   // leal         $-2(%rbx), %eax
+	LONG $0x34be0f49; BYTE $0x01               // movsbq       (%r9,%rax), %rsi
+	LONG $0xd0c68348                           // addq         $-48, %rsi
+	WORD $0xd348; BYTE $0xe6                   // shlq         %cl, %rsi
+	WORD $0x0148; BYTE $0xd6                   // addq         %rdx, %rsi
+	WORD $0x8948; BYTE $0xf0                   // movq         %rsi, %rax
+	WORD $0xf749; BYTE $0xe2                   // mulq         %r10
+	LONG $0x03eac148                           // shrq         $3, %rdx
+	LONG $0x12048d48                           // leaq         (%rdx,%rdx), %rax
+	LONG $0x803c8d4c                           // leaq         (%rax,%rax,4), %r15
+	WORD $0x8948; BYTE $0xf0                   // movq         %rsi, %rax
+	WORD $0x294c; BYTE $0xf8                   // subq         %r15, %rax
+	LONG $0x0877394c                           // cmpq         %r14, $8(%rdi)
+	LONG $0xffb0870f; WORD $0xffff             // ja           LBB38_11, $-80(%rip)
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0xffb0840f; WORD $0xffff             // je           LBB38_18, $-80(%rip)
+	LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl         $1, $28(%rdi)
+	LONG $0xffffa4e9; BYTE $0xff               // jmp          LBB38_18, $-92(%rip)
+
+LBB38_12:
+	LONG $0x0afe8348               // cmpq         $10, %rsi
+	LONG $0x0070830f; WORD $0x0000 // jae          LBB38_13, $112(%rip)
+
+LBB38_22:
+	LONG $0x10476348               // movslq       $16(%rdi), %rax
+	WORD $0x6349; BYTE $0xc8       // movslq       %r8d, %rcx
+	WORD $0x0148; BYTE $0xc1       // addq         %rax, %rcx
+	WORD $0x4f89; BYTE $0x10       // movl         %ecx, $16(%rdi)
+	LONG $0x08478b48               // movq         $8(%rdi), %rax
+	WORD $0x3948; BYTE $0xc8       // cmpq         %rcx, %rax
+	LONG $0x0005870f; WORD $0x0000 // ja           LBB38_24, $5(%rip)
+	WORD $0x4789; BYTE $0x10       // movl         %eax, $16(%rdi)
+	WORD $0xc189                   // movl         %eax, %ecx
+
+LBB38_24:
+	LONG $0x14470144               // addl         %r8d, $20(%rdi)
+	WORD $0xc985                   // testl        %ecx, %ecx
+	LONG $0x00318e0f; WORD $0x0000 // jle          LBB38_28, $49(%rip)
+	WORD $0x8b48; BYTE $0x07       // movq         (%rdi), %rax
+	WORD $0xc989                   // movl         %ecx, %ecx
+	BYTE $0x90                     // .p2align 4, 0x90
+
+LBB38_26:
+	LONG $0xff518d48               // leaq         $-1(%rcx), %rdx
+	WORD $0xd689                   // movl         %edx, %esi
+	LONG $0x30303c80               // cmpb         $48, (%rax,%rsi)
+	LONG $0x0028850f; WORD $0x0000 // jne          LBB38_30, $40(%rip)
+	WORD $0xc9ff                   // decl         %ecx
+	WORD $0x4f89; BYTE $0x10       // movl         %ecx, $16(%rdi)
+	LONG $0x01728d48               // leaq         $1(%rdx), %rsi
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	LONG $0x01fe8348               // cmpq         $1, %rsi
+	LONG $0xffda870f; WORD $0xffff // ja           LBB38_26, $-38(%rip)
+	LONG $0x000006e9; BYTE $0x00   // jmp          LBB38_29, $6(%rip)
+
+LBB38_28:
+	LONG $0x0007850f; WORD $0x0000 // jne          LBB38_30, $7(%rip)
+
+LBB38_29:
+	LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl         $0, $20(%rdi)
+
+LBB38_30:
+	BYTE $0x5b   // popq         %rbx
+	WORD $0x5e41 // popq         %r14
+	WORD $0x5f41 // popq         %r15
+	BYTE $0x5d   // popq         %rbp
+	BYTE $0xc3   // retq
+
+LBB38_13:
+	WORD $0x6349; BYTE $0xf3       // movslq       %r11d, %rsi
+	WORD $0xff48; BYTE $0xce       // decq         %rsi
+	LONG $0x00001be9; BYTE $0x00   // jmp          LBB38_14, $27(%rip)
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB38_15:
+	WORD $0x3004             // addb         $48, %al
+	WORD $0x8b48; BYTE $0x1f // movq         (%rdi), %rbx
+	WORD $0x0488; BYTE $0x33 // movb         %al, (%rbx,%rsi)
+
+LBB38_21:
+	WORD $0xff48; BYTE $0xce       // decq         %rsi
+	LONG $0x09f98348               // cmpq         $9, %rcx
+	LONG $0xff6a860f; WORD $0xffff // jbe          LBB38_22, $-150(%rip)
+
+LBB38_14:
+	WORD $0x8948; BYTE $0xd1                   // movq         %rdx, %rcx
+	WORD $0x8948; BYTE $0xd0                   // movq         %rdx, %rax
+	WORD $0xf749; BYTE $0xe2                   // mulq         %r10
+	LONG $0x03eac148                           // shrq         $3, %rdx
+	LONG $0x12048d48                           // leaq         (%rdx,%rdx), %rax
+	LONG $0x801c8d48                           // leaq         (%rax,%rax,4), %rbx
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	WORD $0x2948; BYTE $0xd8                   // subq         %rbx, %rax
+	LONG $0x08773948                           // cmpq         %rsi, $8(%rdi)
+	LONG $0xffc6870f; WORD $0xffff             // ja           LBB38_15, $-58(%rip)
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0xffc5840f; WORD $0xffff             // je           LBB38_21, $-59(%rip)
+	LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl         $1, $28(%rdi)
+	LONG $0xffffb9e9; BYTE $0xff               // jmp          LBB38_21, $-71(%rip)
+
+LBB38_3:
+	LONG $0xfe898c0f; WORD $0xffff // jl           LBB38_7, $-375(%rip)
+	LONG $0xfffe87e9; BYTE $0xff   // jmp          LBB38_8, $-377(%rip)
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+_right_shift:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	BYTE $0x53                     // pushq        %rbx
+	WORD $0xf189                   // movl         %esi, %ecx
+	LONG $0x10478b44               // movl         $16(%rdi), %r8d
+	WORD $0xd231                   // xorl         %edx, %edx
+	WORD $0x8545; BYTE $0xc0       // testl        %r8d, %r8d
+	LONG $0x0000bb41; WORD $0x0000 // movl         $0, %r11d
+	LONG $0xd84f0f45               // cmovgl       %r8d, %r11d
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x90909090               // .p2align 4, 0x90
+
+LBB39_1:
+	WORD $0x3949; BYTE $0xd3       // cmpq         %rdx, %r11
+	LONG $0x0132840f; WORD $0x0000 // je           LBB39_2, $306(%rip)
+	LONG $0x80048d48               // leaq         (%rax,%rax,4), %rax
+	WORD $0x8b48; BYTE $0x37       // movq         (%rdi), %rsi
+	LONG $0x34be0f48; BYTE $0x16   // movsbq       (%rsi,%rdx), %rsi
+	LONG $0x46048d48               // leaq         (%rsi,%rax,2), %rax
+	LONG $0xd0c08348               // addq         $-48, %rax
+	WORD $0xff48; BYTE $0xc2       // incq         %rdx
+	WORD $0x8948; BYTE $0xc6       // movq         %rax, %rsi
+	WORD $0xd348; BYTE $0xee       // shrq         %cl, %rsi
+	WORD $0x8548; BYTE $0xf6       // testq        %rsi, %rsi
+	LONG $0xffd1840f; WORD $0xffff // je           LBB39_1, $-47(%rip)
+	WORD $0x8941; BYTE $0xd3       // movl         %edx, %r11d
+
+LBB39_7:
+	WORD $0x578b; BYTE $0x14                   // movl         $20(%rdi), %edx
+	WORD $0x2944; BYTE $0xda                   // subl         %r11d, %edx
+	WORD $0xc2ff                               // incl         %edx
+	LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r9
+	WORD $0xd349; BYTE $0xe1                   // shlq         %cl, %r9
+	WORD $0x5789; BYTE $0x14                   // movl         %edx, $20(%rdi)
+	WORD $0xf749; BYTE $0xd1                   // notq         %r9
+	WORD $0x3145; BYTE $0xd2                   // xorl         %r10d, %r10d
+	WORD $0x3945; BYTE $0xc3                   // cmpl         %r8d, %r11d
+	LONG $0x00718d0f; WORD $0x0000             // jge          LBB39_10, $113(%rip)
+	WORD $0x634d; BYTE $0xc3                   // movslq       %r11d, %r8
+	WORD $0x8b48; BYTE $0x37                   // movq         (%rdi), %rsi
+	WORD $0x3145; BYTE $0xd2                   // xorl         %r10d, %r10d
+	BYTE $0x90                                 // .p2align 4, 0x90
+
+LBB39_9:
+	WORD $0x8948; BYTE $0xc2                                 // movq         %rax, %rdx
+	WORD $0xd348; BYTE $0xea                                 // shrq         %cl, %rdx
+	WORD $0x214c; BYTE $0xc8                                 // andq         %r9, %rax
+	WORD $0xc280; BYTE $0x30                                 // addb         $48, %dl
+	LONG $0x16148842                                         // movb         %dl, (%rsi,%r10)
+	WORD $0x8b48; BYTE $0x37                                 // movq         (%rdi), %rsi
+	LONG $0x06148d4a                                         // leaq         (%rsi,%r8), %rdx
+	LONG $0x1cbe0f4d; BYTE $0x12                             // movsbq       (%r10,%rdx), %r11
+	LONG $0x105c8d4b; BYTE $0x01                             // leaq         $1(%r8,%r10), %rbx
+	WORD $0xff49; BYTE $0xc2                                 // incq         %r10
+	LONG $0x80048d48                                         // leaq         (%rax,%rax,4), %rax
+	LONG $0x43048d49                                         // leaq         (%r11,%rax,2), %rax
+	LONG $0xd0c08348                                         // addq         $-48, %rax
+	LONG $0x10576348                                         // movslq       $16(%rdi), %rdx
+	WORD $0x3948; BYTE $0xd3                                 // cmpq         %rdx, %rbx
+	LONG $0xffc38c0f; WORD $0xffff                           // jl           LBB39_9, $-61(%rip)
+	LONG $0x000025e9; BYTE $0x00                             // jmp          LBB39_10, $37(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB39_12:
+	LONG $0x30c68040         // addb         $48, %sil
+	WORD $0x8b48; BYTE $0x1f // movq         (%rdi), %rbx
+	LONG $0x13348840         // movb         %sil, (%rbx,%rdx)
+	WORD $0xc2ff             // incl         %edx
+	WORD $0x8941; BYTE $0xd2 // movl         %edx, %r10d
+
+LBB39_15:
+	WORD $0x0148; BYTE $0xc0 // addq         %rax, %rax
+	LONG $0x80048d48         // leaq         (%rax,%rax,4), %rax
+
+LBB39_10:
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0x002b840f; WORD $0x0000             // je           LBB39_16, $43(%rip)
+	WORD $0x8948; BYTE $0xc6                   // movq         %rax, %rsi
+	WORD $0xd348; BYTE $0xee                   // shrq         %cl, %rsi
+	WORD $0x214c; BYTE $0xc8                   // andq         %r9, %rax
+	WORD $0x6349; BYTE $0xd2                   // movslq       %r10d, %rdx
+	LONG $0x08573948                           // cmpq         %rdx, $8(%rdi)
+	LONG $0xffca870f; WORD $0xffff             // ja           LBB39_12, $-54(%rip)
+	WORD $0x8548; BYTE $0xf6                   // testq        %rsi, %rsi
+	LONG $0xffd1840f; WORD $0xffff             // je           LBB39_15, $-47(%rip)
+	LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl         $1, $28(%rdi)
+	LONG $0xffffc5e9; BYTE $0xff               // jmp          LBB39_15, $-59(%rip)
+
+LBB39_16:
+	LONG $0x10578944               // movl         %r10d, $16(%rdi)
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0x00758e0f; WORD $0x0000 // jle          LBB39_20, $117(%rip)
+	WORD $0x8b48; BYTE $0x07       // movq         (%rdi), %rax
+	WORD $0x8944; BYTE $0xd1       // movl         %r10d, %ecx
+	WORD $0x9090                   // .p2align 4, 0x90
+
+LBB39_18:
+	LONG $0xff518d48               // leaq         $-1(%rcx), %rdx
+	WORD $0xd689                   // movl         %edx, %esi
+	LONG $0x30303c80               // cmpb         $48, (%rax,%rsi)
+	LONG $0x0063850f; WORD $0x0000 // jne          LBB39_22, $99(%rip)
+	WORD $0xc9ff                   // decl         %ecx
+	WORD $0x4f89; BYTE $0x10       // movl         %ecx, $16(%rdi)
+	LONG $0x01728d48               // leaq         $1(%rdx), %rsi
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	LONG $0x01fe8348               // cmpq         $1, %rsi
+	LONG $0xffda870f; WORD $0xffff // ja           LBB39_18, $-38(%rip)
+	LONG $0x00004be9; BYTE $0x00   // jmp          LBB39_21, $75(%rip)
+
+LBB39_2:
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0x004c840f; WORD $0x0000             // je           LBB39_23, $76(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+	WORD $0x8948; BYTE $0xc2                   // movq         %rax, %rdx
+	WORD $0xd348; BYTE $0xea                   // shrq         %cl, %rdx
+	WORD $0x8548; BYTE $0xd2                   // testq        %rdx, %rdx
+	LONG $0xfed3850f; WORD $0xffff             // jne          LBB39_7, $-301(%rip)
+
+LBB39_4:
+	WORD $0x0148; BYTE $0xc0       // addq         %rax, %rax
+	LONG $0x80048d48               // leaq         (%rax,%rax,4), %rax
+	WORD $0xff41; BYTE $0xc3       // incl         %r11d
+	WORD $0x8948; BYTE $0xc2       // movq         %rax, %rdx
+	WORD $0xd348; BYTE $0xea       // shrq         %cl, %rdx
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0xffe7840f; WORD $0xffff // je           LBB39_4, $-25(%rip)
+	LONG $0xfffeb5e9; BYTE $0xff   // jmp          LBB39_7, $-331(%rip)
+
+LBB39_20:
+	LONG $0x0003840f; WORD $0x0000 // je           LBB39_21, $3(%rip)
+
+LBB39_22:
+	BYTE $0x5b // popq         %rbx
+	BYTE $0x5d // popq         %rbp
+	BYTE $0xc3 // retq
+
+LBB39_21:
+	LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl         $0, $20(%rdi)
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB39_23:
+	LONG $0x001047c7; WORD $0x0000; BYTE $0x00 // movl         $0, $16(%rdi)
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+	LONG $0x00000000; WORD $0x0000             // .p2align 4, 0x00
+
+LCPI40_0:
+	QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
+
+LCPI40_1:
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+
+	// .p2align 4, 0x90
+_advance_string_default:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	BYTE $0x50                                 // pushq        %rax
+	LONG $0x087f8b4c                           // movq         $8(%rdi), %r15
+	WORD $0x2949; BYTE $0xf7                   // subq         %rsi, %r15
+	LONG $0x0364840f; WORD $0x0000             // je           LBB40_17, $868(%rip)
+	WORD $0x8b4c; BYTE $0x0f                   // movq         (%rdi), %r9
+	LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq         $-1, (%rdx)
+	LONG $0x40ff8349                           // cmpq         $64, %r15
+	LONG $0x01de820f; WORD $0x0000             // jb           LBB40_18, $478(%rip)
+	WORD $0x8948; BYTE $0xf7                   // movq         %rsi, %rdi
+	WORD $0xf748; BYTE $0xd7                   // notq         %rdi
+	QUAD $0xffffffffd045c748                   // movq         $-1, $-48(%rbp)
+	WORD $0x3145; BYTE $0xf6                   // xorl         %r14d, %r14d
+	QUAD $0xffffff98056ff9c5                   // vmovdqa      $-104(%rip), %xmm0  /* LCPI40_0(%rip) */
+	QUAD $0xffffffa00d6ff9c5                   // vmovdqa      $-96(%rip), %xmm1  /* LCPI40_1(%rip) */
+
+	// .p2align 4, 0x90
+LBB40_3:
+	LONG $0x6f7ac1c4; WORD $0x3114             // vmovdqu      (%r9,%rsi), %xmm2
+	LONG $0x6f7ac1c4; WORD $0x315c; BYTE $0x10 // vmovdqu      $16(%r9,%rsi), %xmm3
+	LONG $0x6f7ac1c4; WORD $0x3164; BYTE $0x20 // vmovdqu      $32(%r9,%rsi), %xmm4
+	LONG $0x6f7ac1c4; WORD $0x316c; BYTE $0x30 // vmovdqu      $48(%r9,%rsi), %xmm5
+	LONG $0xf074e9c5                           // vpcmpeqb     %xmm0, %xmm2, %xmm6
+	LONG $0xe6d779c5                           // vpmovmskb    %xmm6, %r12d
+	LONG $0xf074e1c5                           // vpcmpeqb     %xmm0, %xmm3, %xmm6
+	LONG $0xc6d7f9c5                           // vpmovmskb    %xmm6, %eax
+	LONG $0xf074d9c5                           // vpcmpeqb     %xmm0, %xmm4, %xmm6
+	LONG $0xc6d779c5                           // vpmovmskb    %xmm6, %r8d
+	LONG $0xf074d1c5                           // vpcmpeqb     %xmm0, %xmm5, %xmm6
+	LONG $0xd6d779c5                           // vpmovmskb    %xmm6, %r10d
+	LONG $0xd174e9c5                           // vpcmpeqb     %xmm1, %xmm2, %xmm2
+	LONG $0xead779c5                           // vpmovmskb    %xmm2, %r13d
+	LONG $0xd174e1c5                           // vpcmpeqb     %xmm1, %xmm3, %xmm2
+	LONG $0xcad7f9c5                           // vpmovmskb    %xmm2, %ecx
+	LONG $0xd174d9c5                           // vpcmpeqb     %xmm1, %xmm4, %xmm2
+	LONG $0xdad7f9c5                           // vpmovmskb    %xmm2, %ebx
+	LONG $0xd174d1c5                           // vpcmpeqb     %xmm1, %xmm5, %xmm2
+	LONG $0xdad779c5                           // vpmovmskb    %xmm2, %r11d
+	LONG $0x30e2c149                           // shlq         $48, %r10
+	LONG $0x20e0c149                           // shlq         $32, %r8
+	WORD $0x094d; BYTE $0xd0                   // orq          %r10, %r8
+	LONG $0x10e0c148                           // shlq         $16, %rax
+	WORD $0x094c; BYTE $0xc0                   // orq          %r8, %rax
+	WORD $0x0949; BYTE $0xc4                   // orq          %rax, %r12
+	LONG $0x30e3c149                           // shlq         $48, %r11
+	LONG $0x20e3c148                           // shlq         $32, %rbx
+	WORD $0x094c; BYTE $0xdb                   // orq          %r11, %rbx
+	LONG $0x10e1c148                           // shlq         $16, %rcx
+	WORD $0x0948; BYTE $0xd9                   // orq          %rbx, %rcx
+	WORD $0x0949; BYTE $0xcd                   // orq          %rcx, %r13
+	LONG $0x0030850f; WORD $0x0000             // jne          LBB40_7, $48(%rip)
+	WORD $0x854d; BYTE $0xf6                   // testq        %r14, %r14
+	LONG $0x0040850f; WORD $0x0000             // jne          LBB40_9, $64(%rip)
+	WORD $0x3145; BYTE $0xf6                   // xorl         %r14d, %r14d
+	WORD $0x854d; BYTE $0xe4                   // testq        %r12, %r12
+	LONG $0x0086850f; WORD $0x0000             // jne          LBB40_10, $134(%rip)
+
+LBB40_6:
+	LONG $0xc0c78349               // addq         $-64, %r15
+	LONG $0xc0c78348               // addq         $-64, %rdi
+	LONG $0x40c68348               // addq         $64, %rsi
+	LONG $0x3fff8349               // cmpq         $63, %r15
+	LONG $0xff4a870f; WORD $0xffff // ja           LBB40_3, $-182(%rip)
+	LONG $0x000081e9; BYTE $0x00   // jmp          LBB40_12, $129(%rip)
+
+LBB40_7:
+	LONG $0xd07d8348; BYTE $0xff   // cmpq         $-1, $-48(%rbp)
+	LONG $0x000e850f; WORD $0x0000 // jne          LBB40_9, $14(%rip)
+	LONG $0xc5bc0f49               // bsfq         %r13, %rax
+	WORD $0x0148; BYTE $0xf0       // addq         %rsi, %rax
+	LONG $0xd0458948               // movq         %rax, $-48(%rbp)
+	WORD $0x8948; BYTE $0x02       // movq         %rax, (%rdx)
+
+LBB40_9:
+	WORD $0x894c; BYTE $0xf0               // movq         %r14, %rax
+	WORD $0xf748; BYTE $0xd0               // notq         %rax
+	WORD $0x214c; BYTE $0xe8               // andq         %r13, %rax
+	LONG $0x00048d4c                       // leaq         (%rax,%rax), %r8
+	WORD $0x094d; BYTE $0xf0               // orq          %r14, %r8
+	WORD $0x894c; BYTE $0xc1               // movq         %r8, %rcx
+	WORD $0xf748; BYTE $0xd1               // notq         %rcx
+	WORD $0x214c; BYTE $0xe9               // andq         %r13, %rcx
+	QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq      $-6148914691236517206, %rbx
+	WORD $0x2148; BYTE $0xd9               // andq         %rbx, %rcx
+	WORD $0x3145; BYTE $0xf6               // xorl         %r14d, %r14d
+	WORD $0x0148; BYTE $0xc1               // addq         %rax, %rcx
+	LONG $0xc6920f41                       // setb         %r14b
+	WORD $0x0148; BYTE $0xc9               // addq         %rcx, %rcx
+	QUAD $0x555555555555b848; WORD $0x5555 // movabsq      $6148914691236517205, %rax
+	WORD $0x3148; BYTE $0xc1               // xorq         %rax, %rcx
+	WORD $0x214c; BYTE $0xc1               // andq         %r8, %rcx
+	WORD $0xf748; BYTE $0xd1               // notq         %rcx
+	WORD $0x2149; BYTE $0xcc               // andq         %rcx, %r12
+	WORD $0x854d; BYTE $0xe4               // testq        %r12, %r12
+	LONG $0xff7a840f; WORD $0xffff         // je           LBB40_6, $-134(%rip)
+
+LBB40_10:
+	LONG $0xc4bc0f49         // bsfq         %r12, %rax
+	WORD $0x2948; BYTE $0xf8 // subq         %rdi, %rax
+
+LBB40_11:
+	LONG $0x08c48348 // addq         $8, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5d41     // popq         %r13
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB40_12:
+	WORD $0x014c; BYTE $0xce       // addq         %r9, %rsi
+	LONG $0x20ff8349               // cmpq         $32, %r15
+	LONG $0x00f1820f; WORD $0x0000 // jb           LBB40_23, $241(%rip)
+
+LBB40_13:
+	LONG $0x066ffac5               // vmovdqu      (%rsi), %xmm0
+	LONG $0x4e6ffac5; BYTE $0x10   // vmovdqu      $16(%rsi), %xmm1
+	QUAD $0xfffffe36156ff9c5       // vmovdqa      $-458(%rip), %xmm2  /* LCPI40_0(%rip) */
+	QUAD $0xfffffe3e1d6ff9c5       // vmovdqa      $-450(%rip), %xmm3  /* LCPI40_1(%rip) */
+	LONG $0xe274f9c5               // vpcmpeqb     %xmm2, %xmm0, %xmm4
+	LONG $0xfcd7f9c5               // vpmovmskb    %xmm4, %edi
+	LONG $0xd274f1c5               // vpcmpeqb     %xmm2, %xmm1, %xmm2
+	LONG $0xcad7f9c5               // vpmovmskb    %xmm2, %ecx
+	LONG $0xc374f9c5               // vpcmpeqb     %xmm3, %xmm0, %xmm0
+	LONG $0xc0d7f9c5               // vpmovmskb    %xmm0, %eax
+	LONG $0xc374f1c5               // vpcmpeqb     %xmm3, %xmm1, %xmm0
+	LONG $0xd8d7f9c5               // vpmovmskb    %xmm0, %ebx
+	LONG $0x10e1c148               // shlq         $16, %rcx
+	WORD $0x0948; BYTE $0xcf       // orq          %rcx, %rdi
+	LONG $0x10e3c148               // shlq         $16, %rbx
+	WORD $0x0948; BYTE $0xd8       // orq          %rbx, %rax
+	LONG $0x0044850f; WORD $0x0000 // jne          LBB40_19, $68(%rip)
+	WORD $0x854d; BYTE $0xf6       // testq        %r14, %r14
+	LONG $0x005a850f; WORD $0x0000 // jne          LBB40_21, $90(%rip)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0x0087840f; WORD $0x0000 // je           LBB40_22, $135(%rip)
+
+LBB40_16:
+	LONG $0xc7bc0f48             // bsfq         %rdi, %rax
+	WORD $0x294c; BYTE $0xce     // subq         %r9, %rsi
+	WORD $0x0148; BYTE $0xf0     // addq         %rsi, %rax
+	WORD $0xff48; BYTE $0xc0     // incq         %rax
+	LONG $0xffff70e9; BYTE $0xff // jmp          LBB40_11, $-144(%rip)
+
+LBB40_18:
+	WORD $0x014c; BYTE $0xce       // addq         %r9, %rsi
+	QUAD $0xffffffffd045c748       // movq         $-1, $-48(%rbp)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	LONG $0x20ff8349               // cmpq         $32, %r15
+	LONG $0xff74830f; WORD $0xffff // jae          LBB40_13, $-140(%rip)
+	LONG $0x000060e9; BYTE $0x00   // jmp          LBB40_23, $96(%rip)
+
+LBB40_19:
+	LONG $0xd07d8348; BYTE $0xff   // cmpq         $-1, $-48(%rbp)
+	LONG $0x0014850f; WORD $0x0000 // jne          LBB40_21, $20(%rip)
+	WORD $0x8948; BYTE $0xf1       // movq         %rsi, %rcx
+	WORD $0x294c; BYTE $0xc9       // subq         %r9, %rcx
+	LONG $0xd8bc0f48               // bsfq         %rax, %rbx
+	WORD $0x0148; BYTE $0xcb       // addq         %rcx, %rbx
+	LONG $0xd05d8948               // movq         %rbx, $-48(%rbp)
+	WORD $0x8948; BYTE $0x1a       // movq         %rbx, (%rdx)
+
+LBB40_21:
+	WORD $0x8944; BYTE $0xf1       // movl         %r14d, %ecx
+	WORD $0xd1f7                   // notl         %ecx
+	WORD $0xc121                   // andl         %eax, %ecx
+	WORD $0x1c8d; BYTE $0x09       // leal         (%rcx,%rcx), %ebx
+	LONG $0x4e048d45               // leal         (%r14,%rcx,2), %r8d
+	WORD $0xd3f7                   // notl         %ebx
+	WORD $0xc321                   // andl         %eax, %ebx
+	LONG $0xaaaae381; WORD $0xaaaa // andl         $-1431655766, %ebx
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	WORD $0xcb01                   // addl         %ecx, %ebx
+	LONG $0xc6920f41               // setb         %r14b
+	WORD $0xdb01                   // addl         %ebx, %ebx
+	LONG $0x5555f381; WORD $0x5555 // xorl         $1431655765, %ebx
+	WORD $0x2144; BYTE $0xc3       // andl         %r8d, %ebx
+	WORD $0xd3f7                   // notl         %ebx
+	WORD $0xdf21                   // andl         %ebx, %edi
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0xff79850f; WORD $0xffff // jne          LBB40_16, $-135(%rip)
+
+LBB40_22:
+	LONG $0x20c68348 // addq         $32, %rsi
+	LONG $0xe0c78349 // addq         $-32, %r15
+
+LBB40_23:
+	WORD $0x854d; BYTE $0xf6       // testq        %r14, %r14
+	LONG $0x00b4850f; WORD $0x0000 // jne          LBB40_38, $180(%rip)
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x0088840f; WORD $0x0000 // je           LBB40_35, $136(%rip)
+
+LBB40_25:
+	WORD $0x894c; BYTE $0xcf                   // movq         %r9, %rdi
+	WORD $0xf748; BYTE $0xdf                   // negq         %rdi
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+
+LBB40_26:
+	WORD $0xdb31 // xorl         %ebx, %ebx
+
+LBB40_27:
+	LONG $0x1e0cb60f               // movzbl       (%rsi,%rbx), %ecx
+	WORD $0xf983; BYTE $0x22       // cmpl         $34, %ecx
+	LONG $0x0066840f; WORD $0x0000 // je           LBB40_34, $102(%rip)
+	WORD $0xf983; BYTE $0x5c       // cmpl         $92, %ecx
+	LONG $0x0011840f; WORD $0x0000 // je           LBB40_30, $17(%rip)
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	WORD $0x3949; BYTE $0xdf       // cmpq         %rbx, %r15
+	LONG $0xffde850f; WORD $0xffff // jne          LBB40_27, $-34(%rip)
+	LONG $0x00005de9; BYTE $0x00   // jmp          LBB40_36, $93(%rip)
+
+LBB40_30:
+	LONG $0xff4f8d49               // leaq         $-1(%r15), %rcx
+	WORD $0x3948; BYTE $0xd9       // cmpq         %rbx, %rcx
+	LONG $0xfe9e840f; WORD $0xffff // je           LBB40_11, $-354(%rip)
+	LONG $0xd07d8348; BYTE $0xff   // cmpq         $-1, $-48(%rbp)
+	LONG $0x000e850f; WORD $0x0000 // jne          LBB40_33, $14(%rip)
+	LONG $0x370c8d48               // leaq         (%rdi,%rsi), %rcx
+	WORD $0x0148; BYTE $0xd9       // addq         %rbx, %rcx
+	LONG $0xd04d8948               // movq         %rcx, $-48(%rbp)
+	WORD $0x8948; BYTE $0x0a       // movq         %rcx, (%rdx)
+
+LBB40_33:
+	WORD $0x0148; BYTE $0xde       // addq         %rbx, %rsi
+	LONG $0x02c68348               // addq         $2, %rsi
+	WORD $0x894c; BYTE $0xf9       // movq         %r15, %rcx
+	WORD $0x2948; BYTE $0xd9       // subq         %rbx, %rcx
+	LONG $0xfec18348               // addq         $-2, %rcx
+	LONG $0xfec78349               // addq         $-2, %r15
+	WORD $0x3949; BYTE $0xdf       // cmpq         %rbx, %r15
+	WORD $0x8949; BYTE $0xcf       // movq         %rcx, %r15
+	LONG $0xff90850f; WORD $0xffff // jne          LBB40_26, $-112(%rip)
+	LONG $0xfffe5fe9; BYTE $0xff   // jmp          LBB40_11, $-417(%rip)
+
+LBB40_34:
+	WORD $0x0148; BYTE $0xde // addq         %rbx, %rsi
+	WORD $0xff48; BYTE $0xc6 // incq         %rsi
+
+LBB40_35:
+	WORD $0x294c; BYTE $0xce     // subq         %r9, %rsi
+	WORD $0x8948; BYTE $0xf0     // movq         %rsi, %rax
+	LONG $0xfffe4ee9; BYTE $0xff // jmp          LBB40_11, $-434(%rip)
+
+LBB40_36:
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0xf980; BYTE $0x22                   // cmpb         $34, %cl
+	LONG $0xfe3e850f; WORD $0xffff             // jne          LBB40_11, $-450(%rip)
+	WORD $0x0148; BYTE $0xde                   // addq         %rbx, %rsi
+	LONG $0xffffdde9; BYTE $0xff               // jmp          LBB40_35, $-35(%rip)
+
+LBB40_38:
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x002f840f; WORD $0x0000 // je           LBB40_17, $47(%rip)
+	LONG $0xd07d8348; BYTE $0xff   // cmpq         $-1, $-48(%rbp)
+	LONG $0x0010850f; WORD $0x0000 // jne          LBB40_41, $16(%rip)
+	WORD $0x894c; BYTE $0xc8       // movq         %r9, %rax
+	WORD $0xf748; BYTE $0xd0       // notq         %rax
+	WORD $0x0148; BYTE $0xf0       // addq         %rsi, %rax
+	LONG $0xd0458948               // movq         %rax, $-48(%rbp)
+	WORD $0x8948; BYTE $0x02       // movq         %rax, (%rdx)
+
+LBB40_41:
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0xff49; BYTE $0xcf       // decq         %r15
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0xff22850f; WORD $0xffff // jne          LBB40_25, $-222(%rip)
+	LONG $0xffffa5e9; BYTE $0xff   // jmp          LBB40_35, $-91(%rip)
+
+LBB40_17:
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xfffdf2e9; BYTE $0xff               // jmp          LBB40_11, $-526(%rip)
+	LONG $0x00000000; BYTE $0x00               // .p2align 4, 0x00
+
+LCPI41_0:
+	BYTE $0xf0 // .byte 240
+	BYTE $0x80 // .byte 128
+	BYTE $0x80 // .byte 128
+	BYTE $0x80 // .byte 128
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+
+	// .p2align 4, 0x90
+_unescape:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x18ec8348                           // subq         $24, %rsp
+	WORD $0x8b4c; BYTE $0x2f                   // movq         (%rdi), %r13
+	WORD $0x294c; BYTE $0xee                   // subq         %r13, %rsi
+	LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rbx
+	WORD $0x8548; BYTE $0xf6                   // testq        %rsi, %rsi
+	LONG $0x00d38e0f; WORD $0x0000             // jle          LBB41_13, $211(%rip)
+	WORD $0x8949; BYTE $0xd6                   // movq         %rdx, %r14
+	WORD $0x8949; BYTE $0xff                   // movq         %rdi, %r15
+	LONG $0x01458d49                           // leaq         $1(%r13), %rax
+	LONG $0x4db60f41; BYTE $0x01               // movzbl       $1(%r13), %ecx
+	LONG $0x53158d48; WORD $0x0077; BYTE $0x00 // leaq         $30547(%rip), %rdx  /* __UnquoteTab(%rip) */
+	LONG $0x110cb60f                           // movzbl       (%rcx,%rdx), %ecx
+	LONG $0x00fff981; WORD $0x0000             // cmpl         $255, %ecx
+	LONG $0x0017840f; WORD $0x0000             // je           LBB41_4, $23(%rip)
+	WORD $0xc985                               // testl        %ecx, %ecx
+	LONG $0x0021850f; WORD $0x0000             // jne          LBB41_6, $33(%rip)
+	WORD $0x8949; BYTE $0x07                   // movq         %rax, (%r15)
+	LONG $0xfdc3c748; WORD $0xffff; BYTE $0xff // movq         $-3, %rbx
+	LONG $0x000096e9; BYTE $0x00               // jmp          LBB41_13, $150(%rip)
+
+LBB41_4:
+	LONG $0x03fe8348               // cmpq         $3, %rsi
+	LONG $0x0019870f; WORD $0x0000 // ja           LBB41_7, $25(%rip)
+	WORD $0x8949; BYTE $0x07       // movq         %rax, (%r15)
+	LONG $0x000084e9; BYTE $0x00   // jmp          LBB41_13, $132(%rip)
+
+LBB41_6:
+	WORD $0x8841; BYTE $0x0e     // movb         %cl, (%r14)
+	LONG $0x02078349             // addq         $2, (%r15)
+	LONG $0x000001bb; BYTE $0x00 // movl         $1, %ebx
+	LONG $0x000073e9; BYTE $0x00 // jmp          LBB41_13, $115(%rip)
+
+LBB41_7:
+	LONG $0x024d8b41               // movl         $2(%r13), %ecx
+	WORD $0xc889                   // movl         %ecx, %eax
+	WORD $0xd0f7                   // notl         %eax
+	LONG $0xcfd0918d; WORD $0xcfcf // leal         $-808464432(%rcx), %edx
+	LONG $0x80808025; BYTE $0x80   // andl         $-2139062144, %eax
+	WORD $0xd085                   // testl        %edx, %eax
+	LONG $0x004a850f; WORD $0x0000 // jne          LBB41_11, $74(%rip)
+	LONG $0x1919918d; WORD $0x1919 // leal         $421075225(%rcx), %edx
+	WORD $0xca09                   // orl          %ecx, %edx
+	LONG $0x8080c2f7; WORD $0x8080 // testl        $-2139062144, %edx
+	LONG $0x0036850f; WORD $0x0000 // jne          LBB41_11, $54(%rip)
+	WORD $0xca89                   // movl         %ecx, %edx
+	LONG $0x7f7fe281; WORD $0x7f7f // andl         $2139062143, %edx
+	LONG $0xc0c0c0bf; BYTE $0xc0   // movl         $-1061109568, %edi
+	WORD $0xd729                   // subl         %edx, %edi
+	LONG $0x46469a8d; WORD $0x4646 // leal         $1179010630(%rdx), %ebx
+	WORD $0xc721                   // andl         %eax, %edi
+	WORD $0xdf85                   // testl        %ebx, %edi
+	LONG $0x0017850f; WORD $0x0000 // jne          LBB41_11, $23(%rip)
+	LONG $0xe0e0e0bf; BYTE $0xe0   // movl         $-522133280, %edi
+	WORD $0xd729                   // subl         %edx, %edi
+	LONG $0x3939c281; WORD $0x3939 // addl         $960051513, %edx
+	WORD $0xf821                   // andl         %edi, %eax
+	WORD $0xd085                   // testl        %edx, %eax
+	LONG $0x0020840f; WORD $0x0000 // je           LBB41_14, $32(%rip)
+
+LBB41_11:
+	LONG $0x02c58349         // addq         $2, %r13
+	WORD $0x894d; BYTE $0x2f // movq         %r13, (%r15)
+
+LBB41_12:
+	LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rbx
+
+LBB41_13:
+	WORD $0x8948; BYTE $0xd8 // movq         %rbx, %rax
+	LONG $0x18c48348         // addq         $24, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB41_14:
+	WORD $0xc90f                               // bswapl       %ecx
+	WORD $0xc889                               // movl         %ecx, %eax
+	WORD $0xd0f7                               // notl         %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	LONG $0x01010125; BYTE $0x01               // andl         $16843009, %eax
+	WORD $0x048d; BYTE $0xc0                   // leal         (%rax,%rax,8), %eax
+	LONG $0x0f0fe181; WORD $0x0f0f             // andl         $252645135, %ecx
+	WORD $0xc101                               // addl         %eax, %ecx
+	WORD $0xc889                               // movl         %ecx, %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	WORD $0xc809                               // orl          %ecx, %eax
+	WORD $0xc189                               // movl         %eax, %ecx
+	WORD $0xe9c1; BYTE $0x08                   // shrl         $8, %ecx
+	LONG $0xff00e181; WORD $0x0000             // andl         $65280, %ecx
+	LONG $0xe0b60f44                           // movzbl       %al, %r12d
+	WORD $0x0941; BYTE $0xcc                   // orl          %ecx, %r12d
+	LONG $0x06558d49                           // leaq         $6(%r13), %rdx
+	WORD $0x8949; BYTE $0x17                   // movq         %rdx, (%r15)
+	LONG $0x7ffc8341                           // cmpl         $127, %r12d
+	LONG $0x004c860f; WORD $0x0000             // jbe          LBB41_18, $76(%rip)
+	LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl         $2047, %r12d
+	LONG $0x004c860f; WORD $0x0000             // jbe          LBB41_19, $76(%rip)
+	QUAD $0xffff200024bc8d41                   // leal         $-57344(%r12), %edi
+	LONG $0xf7ffff81; WORD $0xffff             // cmpl         $-2049, %edi
+	LONG $0x0055870f; WORD $0x0000             // ja           LBB41_20, $85(%rip)
+	WORD $0xe9c1; BYTE $0x0c                   // shrl         $12, %ecx
+	WORD $0xc980; BYTE $0xe0                   // orb          $-32, %cl
+	WORD $0x8841; BYTE $0x0e                   // movb         %cl, (%r14)
+	LONG $0x06ecc141                           // shrl         $6, %r12d
+	LONG $0x3fe48041                           // andb         $63, %r12b
+	LONG $0x80cc8041                           // orb          $-128, %r12b
+	LONG $0x01668845                           // movb         %r12b, $1(%r14)
+	WORD $0x3f24                               // andb         $63, %al
+	WORD $0x800c                               // orb          $-128, %al
+	LONG $0x02468841                           // movb         %al, $2(%r14)
+	LONG $0x000003bb; BYTE $0x00               // movl         $3, %ebx
+	LONG $0xffff5fe9; BYTE $0xff               // jmp          LBB41_13, $-161(%rip)
+
+LBB41_18:
+	WORD $0x8841; BYTE $0x06     // movb         %al, (%r14)
+	LONG $0x000001bb; BYTE $0x00 // movl         $1, %ebx
+	LONG $0xffff52e9; BYTE $0xff // jmp          LBB41_13, $-174(%rip)
+
+LBB41_19:
+	LONG $0x06ecc141             // shrl         $6, %r12d
+	LONG $0xc0cc8041             // orb          $-64, %r12b
+	WORD $0x8845; BYTE $0x26     // movb         %r12b, (%r14)
+	WORD $0x3f24                 // andb         $63, %al
+	WORD $0x800c                 // orb          $-128, %al
+	LONG $0x01468841             // movb         %al, $1(%r14)
+	LONG $0x000002bb; BYTE $0x00 // movl         $2, %ebx
+	LONG $0xffff35e9; BYTE $0xff // jmp          LBB41_13, $-203(%rip)
+
+LBB41_20:
+	LONG $0xfcc3c748; WORD $0xffff; BYTE $0xff // movq         $-4, %rbx
+	LONG $0x06fe8348                           // cmpq         $6, %rsi
+	LONG $0xff24820f; WORD $0xffff             // jb           LBB41_13, $-220(%rip)
+	LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl         $56319, %r12d
+	LONG $0xff17870f; WORD $0xffff             // ja           LBB41_13, $-233(%rip)
+	WORD $0x3a80; BYTE $0x5c                   // cmpb         $92, (%rdx)
+	LONG $0xff0e850f; WORD $0xffff             // jne          LBB41_13, $-242(%rip)
+	LONG $0x077d8041; BYTE $0x75               // cmpb         $117, $7(%r13)
+	LONG $0xff03850f; WORD $0xffff             // jne          LBB41_13, $-253(%rip)
+	LONG $0x08458d49                           // leaq         $8(%r13), %rax
+	LONG $0xc8458948                           // movq         %rax, $-56(%rbp)
+	LONG $0x087d8b41                           // movl         $8(%r13), %edi
+	WORD $0x7d89; BYTE $0xd4                   // movl         %edi, $-44(%rbp)
+	LONG $0xff9875e8; BYTE $0xff               // callq        _unhex16_is, $-26507(%rip)
+	WORD $0xc084                               // testb        %al, %al
+	LONG $0x004f840f; WORD $0x0000             // je           LBB41_27, $79(%rip)
+	WORD $0x4d8b; BYTE $0xd4                   // movl         $-44(%rbp), %ecx
+	WORD $0xc90f                               // bswapl       %ecx
+	WORD $0xc889                               // movl         %ecx, %eax
+	WORD $0xd0f7                               // notl         %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	LONG $0x01010125; BYTE $0x01               // andl         $16843009, %eax
+	WORD $0x048d; BYTE $0xc0                   // leal         (%rax,%rax,8), %eax
+	LONG $0x0f0fe181; WORD $0x0f0f             // andl         $252645135, %ecx
+	WORD $0xc101                               // addl         %eax, %ecx
+	WORD $0xc889                               // movl         %ecx, %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	WORD $0xc809                               // orl          %ecx, %eax
+	WORD $0xb60f; BYTE $0xc8                   // movzbl       %al, %ecx
+	WORD $0xe8c1; BYTE $0x08                   // shrl         $8, %eax
+	LONG $0x00ff0025; BYTE $0x00               // andl         $65280, %eax
+	WORD $0x148d; BYTE $0x08                   // leal         (%rax,%rcx), %edx
+	LONG $0x2000c281; WORD $0xffff             // addl         $-57344, %edx
+	LONG $0xfbfffa81; WORD $0xffff             // cmpl         $-1025, %edx
+	LONG $0x0018870f; WORD $0x0000             // ja           LBB41_28, $24(%rip)
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	WORD $0x8949; BYTE $0x07                   // movq         %rax, (%r15)
+	LONG $0xfffe98e9; BYTE $0xff               // jmp          LBB41_13, $-360(%rip)
+
+LBB41_27:
+	LONG $0xc8458b48             // movq         $-56(%rbp), %rax
+	WORD $0x8949; BYTE $0x07     // movq         %rax, (%r15)
+	LONG $0xfffe85e9; BYTE $0xff // jmp          LBB41_12, $-379(%rip)
+
+LBB41_28:
+	WORD $0xc809                                       // orl          %ecx, %eax
+	LONG $0x0ae4c141                                   // shll         $10, %r12d
+	WORD $0xc189                                       // movl         %eax, %ecx
+	WORD $0x0144; BYTE $0xe1                           // addl         %r12d, %ecx
+	WORD $0x0144; BYTE $0xe0                           // addl         %r12d, %eax
+	LONG $0xa0240005; BYTE $0xfc                       // addl         $-56613888, %eax
+	WORD $0xc289                                       // movl         %eax, %edx
+	WORD $0xeac1; BYTE $0x12                           // shrl         $18, %edx
+	WORD $0xc689                                       // movl         %eax, %esi
+	WORD $0xeec1; BYTE $0x0c                           // shrl         $12, %esi
+	LONG $0x3fe68040                                   // andb         $63, %sil
+	WORD $0xe8c1; BYTE $0x06                           // shrl         $6, %eax
+	WORD $0x3f24                                       // andb         $63, %al
+	WORD $0xe180; BYTE $0x3f                           // andb         $63, %cl
+	LONG $0xc26ef9c5                                   // vmovd        %edx, %xmm0
+	LONG $0xd6b60f40                                   // movzbl       %sil, %edx
+	LONG $0x2079e3c4; WORD $0x01c2                     // vpinsrb      $1, %edx, %xmm0, %xmm0
+	WORD $0xb60f; BYTE $0xc0                           // movzbl       %al, %eax
+	LONG $0x2079e3c4; WORD $0x02c0                     // vpinsrb      $2, %eax, %xmm0, %xmm0
+	WORD $0xb60f; BYTE $0xc1                           // movzbl       %cl, %eax
+	LONG $0x2079e3c4; WORD $0x03c0                     // vpinsrb      $3, %eax, %xmm0, %xmm0
+	QUAD $0xfffffd3105ebf9c5                           // vpor         $-719(%rip), %xmm0, %xmm0  /* LCPI41_0(%rip) */
+	LONG $0x7e79c1c4; BYTE $0x06                       // vmovd        %xmm0, (%r14)
+	LONG $0x0cc58349                                   // addq         $12, %r13
+	WORD $0x894d; BYTE $0x2f                           // movq         %r13, (%r15)
+	LONG $0x000004bb; BYTE $0x00                       // movl         $4, %ebx
+	LONG $0xfffe25e9; BYTE $0xff                       // jmp          LBB41_13, $-475(%rip)
+	QUAD $0x0000000000000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00
+
+_POW10_M128_TAB:
+	QUAD $0x1732c869cd60e453                           // .quad 1671618768450675795
+	QUAD $0xfa8fd5a0081c0288                           // .quad -391859759250406776
+	QUAD $0x0e7fbd42205c8eb4                           // .quad 1044761730281672372
+	QUAD $0x9c99e58405118195                           // .quad -7162441377172586091
+	QUAD $0x521fac92a873b261                           // .quad 5917638181279478369
+	QUAD $0xc3c05ee50655e1fa                           // .quad -4341365703038344710
+	QUAD $0xe6a797b752909ef9                           // .quad -1826324310255427847
+	QUAD $0xf4b0769e47eb5a78                           // .quad -815021110370542984
+	QUAD $0x9028bed2939a635c                           // .quad -8058981721550724260
+	QUAD $0x98ee4a22ecf3188b                           // .quad -7426917221622671221
+	QUAD $0x7432ee873880fc33                           // .quad 8373016921771146291
+	QUAD $0xbf29dcaba82fdeae                           // .quad -4671960508600951122
+	QUAD $0x113faa2906a13b3f                           // .quad 1242899115359157055
+	QUAD $0xeef453d6923bd65a                           // .quad -1228264617323800998
+	QUAD $0x4ac7ca59a424c507                           // .quad 5388497965526861063
+	QUAD $0x9558b4661b6565f8                           // .quad -7685194413468457480
+	QUAD $0x5d79bcf00d2df649                           // .quad 6735622456908576329
+	QUAD $0xbaaee17fa23ebf76                           // .quad -4994806998408183946
+	QUAD $0xf4d82c2c107973dc                           // .quad -803843965719055396
+	QUAD $0xe95a99df8ace6f53                           // .quad -1631822729582842029
+	QUAD $0x79071b9b8a4be869                           // .quad 8720969558280366185
+	QUAD $0x91d8a02bb6c10594                           // .quad -7937418233630358124
+	QUAD $0x9748e2826cdee284                           // .quad -7545532125859093884
+	QUAD $0xb64ec836a47146f9                           // .quad -5310086773610559751
+	QUAD $0xfd1b1b2308169b25                           // .quad -208543120469091547
+	QUAD $0xe3e27a444d8d98b7                           // .quad -2025922448585811785
+	QUAD $0xfe30f0f5e50e20f7                           // .quad -130339450293182217
+	QUAD $0x8e6d8c6ab0787f72                           // .quad -8183730558007214222
+	QUAD $0xbdbd2d335e51a935                           // .quad -4774610331293865675
+	QUAD $0xb208ef855c969f4f                           // .quad -5617977179081629873
+	QUAD $0xad2c788035e61382                           // .quad -5968262914117332094
+	QUAD $0xde8b2b66b3bc4723                           // .quad -2410785455424649437
+	QUAD $0x4c3bcb5021afcc31                           // .quad 5493207715531443249
+	QUAD $0x8b16fb203055ac76                           // .quad -8424269937281487754
+	QUAD $0xdf4abe242a1bbf3d                           // .quad -2356862392440471747
+	QUAD $0xaddcb9e83c6b1793                           // .quad -5918651403174471789
+	QUAD $0xd71d6dad34a2af0d                           // .quad -2946077990550589683
+	QUAD $0xd953e8624b85dd78                           // .quad -2786628235540701832
+	QUAD $0x8672648c40e5ad68                           // .quad -8758827771735200408
+	QUAD $0x87d4713d6f33aa6b                           // .quad -8659171674854020501
+	QUAD $0x680efdaf511f18c2                           // .quad 7498209359040551106
+	QUAD $0xa9c98d8ccb009506                           // .quad -6212278575140137722
+	QUAD $0x0212bd1b2566def2                           // .quad 149389661945913074
+	QUAD $0xd43bf0effdc0ba48                           // .quad -3153662200497784248
+	QUAD $0x014bb630f7604b57                           // .quad 93368538716195671
+	QUAD $0x84a57695fe98746d                           // .quad -8888567902952197011
+	QUAD $0x419ea3bd35385e2d                           // .quad 4728396691822632493
+	QUAD $0xa5ced43b7e3e9188                           // .quad -6499023860262858360
+	QUAD $0x52064cac828675b9                           // .quad 5910495864778290617
+	QUAD $0xcf42894a5dce35ea                           // .quad -3512093806901185046
+	QUAD $0x7343efebd1940993                           // .quad 8305745933913819539
+	QUAD $0x818995ce7aa0e1b2                           // .quad -9112587656954322510
+	QUAD $0x1014ebe6c5f90bf8                           // .quad 1158810380537498616
+	QUAD $0xa1ebfb4219491a1f                           // .quad -6779048552765515233
+	QUAD $0xd41a26e077774ef6                           // .quad -3163173042755514634
+	QUAD $0xca66fa129f9b60a6                           // .quad -3862124672529506138
+	QUAD $0x8920b098955522b4                           // .quad -8565652321871781196
+	QUAD $0xfd00b897478238d0                           // .quad -215969822234494768
+	QUAD $0x55b46e5f5d5535b0                           // .quad 6175682344898606512
+	QUAD $0x9e20735e8cb16382                           // .quad -7052510166537641086
+	QUAD $0xeb2189f734aa831d                           // .quad -1503769105731517667
+	QUAD $0xc5a890362fddbc62                           // .quad -4203951689744663454
+	QUAD $0xa5e9ec7501d523e4                           // .quad -6491397400591784988
+	QUAD $0xf712b443bbd52b7b                           // .quad -643253593753441413
+	QUAD $0x47b233c92125366e                           // .quad 5166248661484910190
+	QUAD $0x9a6bb0aa55653b2d                           // .quad -7319562523736982739
+	QUAD $0x999ec0bb696e840a                           // .quad -7377247228426025974
+	QUAD $0xc1069cd4eabe89f8                           // .quad -4537767136243840520
+	QUAD $0xc00670ea43ca250d                           // .quad -4609873017105144563
+	QUAD $0xf148440a256e2c76                           // .quad -1060522901877412746
+	QUAD $0x380406926a5e5728                           // .quad 4036358391950366504
+	QUAD $0x96cd2a865764dbca                           // .quad -7580355841314464822
+	QUAD $0xc605083704f5ecf2                           // .quad -4177924046916817678
+	QUAD $0xbc807527ed3e12bc                           // .quad -4863758783215693124
+	QUAD $0xf7864a44c633682e                           // .quad -610719040218634194
+	QUAD $0xeba09271e88d976b                           // .quad -1468012460592228501
+	QUAD $0x7ab3ee6afbe0211d                           // .quad 8841672636718129437
+	QUAD $0x93445b8731587ea3                           // .quad -7835036815511224669
+	QUAD $0x5960ea05bad82964                           // .quad 6440404777470273892
+	QUAD $0xb8157268fdae9e4c                           // .quad -5182110000961642932
+	QUAD $0x6fb92487298e33bd                           // .quad 8050505971837842365
+	QUAD $0xe61acf033d1a45df                           // .quad -1865951482774665761
+	QUAD $0xa5d3b6d479f8e056                           // .quad -6497648813669818282
+	QUAD $0x8fd0c16206306bab                           // .quad -8083748704375247957
+	QUAD $0x8f48a4899877186c                           // .quad -8122061017087272852
+	QUAD $0xb3c4f1ba87bc8696                           // .quad -5492999862041672042
+	QUAD $0x331acdabfe94de87                           // .quad 3682481783923072647
+	QUAD $0xe0b62e2929aba83c                           // .quad -2254563809124702148
+	QUAD $0x9ff0c08b7f1d0b14                           // .quad -6921820921902855404
+	QUAD $0x8c71dcd9ba0b4925                           // .quad -8326631408344020699
+	QUAD $0x07ecf0ae5ee44dd9                           // .quad 571095884476206553
+	QUAD $0xaf8e5410288e1b6f                           // .quad -5796603242002637969
+	QUAD $0xc9e82cd9f69d6150                           // .quad -3897816162832129712
+	QUAD $0xdb71e91432b1a24a                           // .quad -2634068034075909558
+	QUAD $0xbe311c083a225cd2                           // .quad -4741978110983775022
+	QUAD $0x892731ac9faf056e                           // .quad -8563821548938525330
+	QUAD $0x6dbd630a48aaf406                           // .quad 7907585416552444934
+	QUAD $0xab70fe17c79ac6ca                           // .quad -6093090917745768758
+	QUAD $0x092cbbccdad5b108                           // .quad 661109733835780360
+	QUAD $0xd64d3d9db981787d                           // .quad -3004677628754823043
+	QUAD $0x25bbf56008c58ea5                           // .quad 2719036592861056677
+	QUAD $0x85f0468293f0eb4e                           // .quad -8795452545612846258
+	QUAD $0xaf2af2b80af6f24e                           // .quad -5824576295778454962
+	QUAD $0xa76c582338ed2621                           // .quad -6382629663588669919
+	QUAD $0x1af5af660db4aee1                           // .quad 1942651667131707105
+	QUAD $0xd1476e2c07286faa                           // .quad -3366601061058449494
+	QUAD $0x50d98d9fc890ed4d                           // .quad 5825843310384704845
+	QUAD $0x82cca4db847945ca                           // .quad -9021654690802612790
+	QUAD $0xe50ff107bab528a0                           // .quad -1941067898873894752
+	QUAD $0xa37fce126597973c                           // .quad -6665382345075878084
+	QUAD $0x1e53ed49a96272c8                           // .quad 2185351144835019464
+	QUAD $0xcc5fc196fefd7d0c                           // .quad -3720041912917459700
+	QUAD $0x25e8e89c13bb0f7a                           // .quad 2731688931043774330
+	QUAD $0xff77b1fcbebcdc4f                           // .quad -38366372719436721
+	QUAD $0x77b191618c54e9ac                           // .quad 8624834609543440812
+	QUAD $0x9faacf3df73609b1                           // .quad -6941508010590729807
+	QUAD $0xd59df5b9ef6a2417                           // .quad -3054014793352862697
+	QUAD $0xc795830d75038c1d                           // .quad -4065198994811024355
+	QUAD $0x4b0573286b44ad1d                           // .quad 5405853545163697437
+	QUAD $0xf97ae3d0d2446f25                           // .quad -469812725086392539
+	QUAD $0x4ee367f9430aec32                           // .quad 5684501474941004850
+	QUAD $0x9becce62836ac577                           // .quad -7211161980820077193
+	QUAD $0x229c41f793cda73f                           // .quad 2493940825248868159
+	QUAD $0xc2e801fb244576d5                           // .quad -4402266457597708587
+	QUAD $0x6b43527578c1110f                           // .quad 7729112049988473103
+	QUAD $0xf3a20279ed56d48a                           // .quad -891147053569747830
+	QUAD $0x830a13896b78aaa9                           // .quad -9004363024039368023
+	QUAD $0x9845418c345644d6                           // .quad -7474495936122174250
+	QUAD $0x23cc986bc656d553                           // .quad 2579604275232953683
+	QUAD $0xbe5691ef416bd60c                           // .quad -4731433901725329908
+	QUAD $0x2cbfbe86b7ec8aa8                           // .quad 3224505344041192104
+	QUAD $0xedec366b11c6cb8f                           // .quad -1302606358729274481
+	QUAD $0x7bf7d71432f3d6a9                           // .quad 8932844867666826921
+	QUAD $0x94b3a202eb1c3f39                           // .quad -7731658001846878407
+	QUAD $0xdaf5ccd93fb0cc53                           // .quad -2669001970698630061
+	QUAD $0xb9e08a83a5e34f07                           // .quad -5052886483881210105
+	QUAD $0xd1b3400f8f9cff68                           // .quad -3336252463373287576
+	QUAD $0xe858ad248f5c22c9                           // .quad -1704422086424124727
+	QUAD $0x23100809b9c21fa1                           // .quad 2526528228819083169
+	QUAD $0x91376c36d99995be                           // .quad -7982792831656159810
+	QUAD $0xabd40a0c2832a78a                           // .quad -6065211750830921846
+	QUAD $0xb58547448ffffb2d                           // .quad -5366805021142811859
+	QUAD $0x16c90c8f323f516c                           // .quad 1641857348316123500
+	QUAD $0xe2e69915b3fff9f9                           // .quad -2096820258001126919
+	QUAD $0xae3da7d97f6792e3                           // .quad -5891368184943504669
+	QUAD $0x8dd01fad907ffc3b                           // .quad -8228041688891786181
+	QUAD $0x99cd11cfdf41779c                           // .quad -7364210231179380836
+	QUAD $0xb1442798f49ffb4a                           // .quad -5673366092687344822
+	QUAD $0x40405643d711d583                           // .quad 4629795266307937667
+	QUAD $0xdd95317f31c7fa1d                           // .quad -2480021597431793123
+	QUAD $0x482835ea666b2572                           // .quad 5199465050656154994
+	QUAD $0x8a7d3eef7f1cfc52                           // .quad -8467542526035952558
+	QUAD $0xda3243650005eecf                           // .quad -2724040723534582065
+	QUAD $0xad1c8eab5ee43b66                           // .quad -5972742139117552794
+	QUAD $0x90bed43e40076a82                           // .quad -8016736922845615486
+	QUAD $0xd863b256369d4a40                           // .quad -2854241655469553088
+	QUAD $0x5a7744a6e804a291                           // .quad 6518754469289960081
+	QUAD $0x873e4f75e2224e68                           // .quad -8701430062309552536
+	QUAD $0x711515d0a205cb36                           // .quad 8148443086612450102
+	QUAD $0xa90de3535aaae202                           // .quad -6265101559459552766
+	QUAD $0x0d5a5b44ca873e03                           // .quad 962181821410786819
+	QUAD $0xd3515c2831559a83                           // .quad -3219690930897053053
+	QUAD $0xe858790afe9486c2                           // .quad -1704479370831952190
+	QUAD $0x8412d9991ed58091                           // .quad -8929835859451740015
+	QUAD $0x626e974dbe39a872                           // .quad 7092772823314835570
+	QUAD $0xa5178fff668ae0b6                           // .quad -6550608805887287114
+	QUAD $0xfb0a3d212dc8128f                           // .quad -357406007711231345
+	QUAD $0xce5d73ff402d98e3                           // .quad -3576574988931720989
+	QUAD $0x7ce66634bc9d0b99                           // .quad 8999993282035256217
+	QUAD $0x80fa687f881c7f8e                           // .quad -9152888395723407474
+	QUAD $0x1c1fffc1ebc44e80                           // .quad 2026619565689294464
+	QUAD $0xa139029f6a239f72                           // .quad -6829424476226871438
+	QUAD $0xa327ffb266b56220                           // .quad -6690097579743157728
+	QUAD $0xc987434744ac874e                           // .quad -3925094576856201394
+	QUAD $0x4bf1ff9f0062baa8                           // .quad 5472436080603216552
+	QUAD $0xfbe9141915d7a922                           // .quad -294682202642863838
+	QUAD $0x6f773fc3603db4a9                           // .quad 8031958568804398249
+	QUAD $0x9d71ac8fada6c9b5                           // .quad -7101705404292871755
+	QUAD $0xcb550fb4384d21d3                           // .quad -3795109844276665901
+	QUAD $0xc4ce17b399107c22                           // .quad -4265445736938701790
+	QUAD $0x7e2a53a146606a48                           // .quad 9091170749936331336
+	QUAD $0xf6019da07f549b2b                           // .quad -720121152745989333
+	QUAD $0x2eda7444cbfc426d                           // .quad 3376138709496513133
+	QUAD $0x99c102844f94e0fb                           // .quad -7367604748107325189
+	QUAD $0xfa911155fefb5308                           // .quad -391512631556746488
+	QUAD $0xc0314325637a1939                           // .quad -4597819916706768583
+	QUAD $0x793555ab7eba27ca                           // .quad 8733981247408842698
+	QUAD $0xf03d93eebc589f88                           // .quad -1135588877456072824
+	QUAD $0x4bc1558b2f3458de                           // .quad 5458738279630526686
+	QUAD $0x96267c7535b763b5                           // .quad -7627272076051127371
+	QUAD $0x9eb1aaedfb016f16                           // .quad -7011635205744005354
+	QUAD $0xbbb01b9283253ca2                           // .quad -4922404076636521310
+	QUAD $0x465e15a979c1cadc                           // .quad 5070514048102157020
+	QUAD $0xea9c227723ee8bcb                           // .quad -1541319077368263733
+	QUAD $0x0bfacd89ec191ec9                           // .quad 863228270850154185
+	QUAD $0x92a1958a7675175f                           // .quad -7880853450996246689
+	QUAD $0xcef980ec671f667b                           // .quad -3532650679864695173
+	QUAD $0xb749faed14125d36                           // .quad -5239380795317920458
+	QUAD $0x82b7e12780e7401a                           // .quad -9027499368258256870
+	QUAD $0xe51c79a85916f484                           // .quad -1937539975720012668
+	QUAD $0xd1b2ecb8b0908810                           // .quad -3336344095947716592
+	QUAD $0x8f31cc0937ae58d2                           // .quad -8128491512466089774
+	QUAD $0x861fa7e6dcb4aa15                           // .quad -8782116138362033643
+	QUAD $0xb2fe3f0b8599ef07                           // .quad -5548928372155224313
+	QUAD $0x67a791e093e1d49a                           // .quad 7469098900757009562
+	QUAD $0xdfbdcece67006ac9                           // .quad -2324474446766642487
+	QUAD $0xe0c8bb2c5c6d24e0                           // .quad -2249342214667950880
+	QUAD $0x8bd6a141006042bd                           // .quad -8370325556870233411
+	QUAD $0x58fae9f773886e18                           // .quad 6411694268519837208
+	QUAD $0xaecc49914078536d                           // .quad -5851220927660403859
+	QUAD $0xaf39a475506a899e                           // .quad -5820440219632367202
+	QUAD $0xda7f5bf590966848                           // .quad -2702340141148116920
+	QUAD $0x6d8406c952429603                           // .quad 7891439908798240259
+	QUAD $0x888f99797a5e012d                           // .quad -8606491615858654931
+	QUAD $0xc8e5087ba6d33b83                           // .quad -3970758169284363389
+	QUAD $0xaab37fd7d8f58178                           // .quad -6146428501395930760
+	QUAD $0xfb1e4a9a90880a64                           // .quad -351761693178066332
+	QUAD $0xd5605fcdcf32e1d6                           // .quad -3071349608317525546
+	QUAD $0x5cf2eea09a55067f                           // .quad 6697677969404790399
+	QUAD $0x855c3be0a17fcd26                           // .quad -8837122532839535322
+	QUAD $0xf42faa48c0ea481e                           // .quad -851274575098787810
+	QUAD $0xa6b34ad8c9dfc06f                           // .quad -6434717147622031249
+	QUAD $0xf13b94daf124da26                           // .quad -1064093218873484762
+	QUAD $0xd0601d8efc57b08b                           // .quad -3431710416100151157
+	QUAD $0x76c53d08d6b70858                           // .quad 8558313775058847832
+	QUAD $0x823c12795db6ce57                           // .quad -9062348037703676329
+	QUAD $0x54768c4b0c64ca6e                           // .quad 6086206200396171886
+	QUAD $0xa2cb1717b52481ed                           // .quad -6716249028702207507
+	QUAD $0xa9942f5dcf7dfd09                           // .quad -6227300304786948855
+	QUAD $0xcb7ddcdda26da268                           // .quad -3783625267450371480
+	QUAD $0xd3f93b35435d7c4c                           // .quad -3172439362556298164
+	QUAD $0xfe5d54150b090b02                           // .quad -117845565885576446
+	QUAD $0xc47bc5014a1a6daf                           // .quad -4288617610811380305
+	QUAD $0x9efa548d26e5a6e1                           // .quad -6991182506319567135
+	QUAD $0x359ab6419ca1091b                           // .quad 3862600023340550427
+	QUAD $0xc6b8e9b0709f109a                           // .quad -4127292114472071014
+	QUAD $0xc30163d203c94b62                           // .quad -4395122007679087774
+	QUAD $0xf867241c8cc6d4c0                           // .quad -547429124662700864
+	QUAD $0x79e0de63425dcf1d                           // .quad 8782263791269039901
+	QUAD $0x9b407691d7fc44f8                           // .quad -7259672230555269896
+	QUAD $0x985915fc12f542e4                           // .quad -7468914334623251740
+	QUAD $0xc21094364dfb5636                           // .quad -4462904269766699466
+	QUAD $0x3e6f5b7b17b2939d                           // .quad 4498915137003099037
+	QUAD $0xf294b943e17a2bc4                           // .quad -966944318780986428
+	QUAD $0xa705992ceecf9c42                           // .quad -6411550076227838910
+	QUAD $0x979cf3ca6cec5b5a                           // .quad -7521869226879198374
+	QUAD $0x50c6ff782a838353                           // .quad 5820620459997365075
+	QUAD $0xbd8430bd08277231                           // .quad -4790650515171610063
+	QUAD $0xa4f8bf5635246428                           // .quad -6559282480285457368
+	QUAD $0xece53cec4a314ebd                           // .quad -1376627125537124675
+	QUAD $0x871b7795e136be99                           // .quad -8711237568605798759
+	QUAD $0x940f4613ae5ed136                           // .quad -7777920981101784778
+	QUAD $0x28e2557b59846e3f                           // .quad 2946011094524915263
+	QUAD $0xb913179899f68584                           // .quad -5110715207949843068
+	QUAD $0x331aeada2fe589cf                           // .quad 3682513868156144079
+	QUAD $0xe757dd7ec07426e5                           // .quad -1776707991509915931
+	QUAD $0x3ff0d2c85def7621                           // .quad 4607414176811284001
+	QUAD $0x9096ea6f3848984f                           // .quad -8027971522334779313
+	QUAD $0x0fed077a756b53a9                           // .quad 1147581702586717097
+	QUAD $0xb4bca50b065abe63                           // .quad -5423278384491086237
+	QUAD $0xd3e8495912c62894                           // .quad -3177208890193991532
+	QUAD $0xe1ebce4dc7f16dfb                           // .quad -2167411962186469893
+	QUAD $0x64712dd7abbbd95c                           // .quad 7237616480483531100
+	QUAD $0x8d3360f09cf6e4bd                           // .quad -8272161504007625539
+	QUAD $0xbd8d794d96aacfb3                           // .quad -4788037454677749837
+	QUAD $0xb080392cc4349dec                           // .quad -5728515861582144020
+	QUAD $0xecf0d7a0fc5583a0                           // .quad -1373360799919799392
+	QUAD $0xdca04777f541c567                           // .quad -2548958808550292121
+	QUAD $0xf41686c49db57244                           // .quad -858350499949874620
+	QUAD $0x89e42caaf9491b60                           // .quad -8510628282985014432
+	QUAD $0x311c2875c522ced5                           // .quad 3538747893490044629
+	QUAD $0xac5d37d5b79b6239                           // .quad -6026599335303880135
+	QUAD $0x7d633293366b828b                           // .quad 9035120885289943691
+	QUAD $0xd77485cb25823ac7                           // .quad -2921563150702462265
+	QUAD $0xae5dff9c02033197                           // .quad -5882264492762254953
+	QUAD $0x86a8d39ef77164bc                           // .quad -8743505996830120772
+	QUAD $0xd9f57f830283fdfc                           // .quad -2741144597525430788
+	QUAD $0xa8530886b54dbdeb                           // .quad -6317696477610263061
+	QUAD $0xd072df63c324fd7b                           // .quad -3426430746906788485
+	QUAD $0xd267caa862a12d66                           // .quad -3285434578585440922
+	QUAD $0x4247cb9e59f71e6d                           // .quad 4776009810824339053
+	QUAD $0x8380dea93da4bc60                           // .quad -8970925639256982432
+	QUAD $0x52d9be85f074e608                           // .quad 5970012263530423816
+	QUAD $0xa46116538d0deb78                           // .quad -6601971030643840136
+	QUAD $0x67902e276c921f8b                           // .quad 7462515329413029771
+	QUAD $0xcd795be870516656                           // .quad -3640777769877412266
+	QUAD $0x00ba1cd8a3db53b6                           // .quad 52386062455755702
+	QUAD $0x806bd9714632dff6                           // .quad -9193015133814464522
+	QUAD $0x80e8a40eccd228a4                           // .quad -9157889458785081180
+	QUAD $0xa086cfcd97bf97f3                           // .quad -6879582898840692749
+	QUAD $0x6122cd128006b2cd                           // .quad 6999382250228200141
+	QUAD $0xc8a883c0fdaf7df0                           // .quad -3987792605123478032
+	QUAD $0x796b805720085f81                           // .quad 8749227812785250177
+	QUAD $0xfad2a4b13d1b5d6c                           // .quad -373054737976959636
+	QUAD $0xcbe3303674053bb0                           // .quad -3755104653863994448
+	QUAD $0x9cc3a6eec6311a63                           // .quad -7150688238876681629
+	QUAD $0xbedbfc4411068a9c                           // .quad -4693880817329993060
+	QUAD $0xc3f490aa77bd60fc                           // .quad -4326674280168464132
+	QUAD $0xee92fb5515482d44                           // .quad -1255665003235103420
+	QUAD $0xf4f1b4d515acb93b                           // .quad -796656831783192261
+	QUAD $0x751bdd152d4d1c4a                           // .quad 8438581409832836170
+	QUAD $0x991711052d8bf3c5                           // .quad -7415439547505577019
+	QUAD $0xd262d45a78a0635d                           // .quad -3286831292991118499
+	QUAD $0xbf5cd54678eef0b6                           // .quad -4657613415954583370
+	QUAD $0x86fb897116c87c34                           // .quad -8720225134666286028
+	QUAD $0xef340a98172aace4                           // .quad -1210330751515841308
+	QUAD $0xd45d35e6ae3d4da0                           // .quad -3144297699952734816
+	QUAD $0x9580869f0e7aac0e                           // .quad -7673985747338482674
+	QUAD $0x8974836059cca109                           // .quad -8542058143368306423
+	QUAD $0xbae0a846d2195712                           // .quad -4980796165745715438
+	QUAD $0x2bd1a438703fc94b                           // .quad 3157485376071780683
+	QUAD $0xe998d258869facd7                           // .quad -1614309188754756393
+	QUAD $0x7b6306a34627ddcf                           // .quad 8890957387685944783
+	QUAD $0x91ff83775423cc06                           // .quad -7926472270612804602
+	QUAD $0x1a3bc84c17b1d542                           // .quad 1890324697752655170
+	QUAD $0xb67f6455292cbf08                           // .quad -5296404319838617848
+	QUAD $0x20caba5f1d9e4a93                           // .quad 2362905872190818963
+	QUAD $0xe41f3d6a7377eeca                           // .quad -2008819381370884406
+	QUAD $0x547eb47b7282ee9c                           // .quad 6088502188546649756
+	QUAD $0x8e938662882af53e                           // .quad -8173041140997884610
+	QUAD $0xe99e619a4f23aa43                           // .quad -1612744301171463613
+	QUAD $0xb23867fb2a35b28d                           // .quad -5604615407819967859
+	QUAD $0x6405fa00e2ec94d4                           // .quad 7207441660390446292
+	QUAD $0xdec681f9f4c31f31                           // .quad -2394083241347571919
+	QUAD $0xde83bc408dd3dd04                           // .quad -2412877989897052924
+	QUAD $0x8b3c113c38f9f37e                           // .quad -8413831053483314306
+	QUAD $0x9624ab50b148d445                           // .quad -7627783505798704059
+	QUAD $0xae0b158b4738705e                           // .quad -5905602798426754978
+	QUAD $0x3badd624dd9b0957                           // .quad 4300328673033783639
+	QUAD $0xd98ddaee19068c76                           // .quad -2770317479606055818
+	QUAD $0xe54ca5d70a80e5d6                           // .quad -1923980597781273130
+	QUAD $0x87f8a8d4cfa417c9                           // .quad -8648977452394866743
+	QUAD $0x5e9fcf4ccd211f4c                           // .quad 6818396289628184396
+	QUAD $0xa9f6d30a038d1dbc                           // .quad -6199535797066195524
+	QUAD $0x7647c3200069671f                           // .quad 8522995362035230495
+	QUAD $0xd47487cc8470652b                           // .quad -3137733727905356501
+	QUAD $0x29ecd9f40041e073                           // .quad 3021029092058325107
+	QUAD $0x84c8d4dfd2c63f3b                           // .quad -8878612607581929669
+	QUAD $0xf468107100525890                           // .quad -835399653354481520
+	QUAD $0xa5fb0a17c777cf09                           // .quad -6486579741050024183
+	QUAD $0x7182148d4066eeb4                           // .quad 8179122470161673908
+	QUAD $0xcf79cc9db955c2cc                           // .quad -3496538657885142324
+	QUAD $0xc6f14cd848405530                           // .quad -4111420493003729616
+	QUAD $0x81ac1fe293d599bf                           // .quad -9102865688819295809
+	QUAD $0xb8ada00e5a506a7c                           // .quad -5139275616254662020
+	QUAD $0xa21727db38cb002f                           // .quad -6766896092596731857
+	QUAD $0xa6d90811f0e4851c                           // .quad -6424094520318327524
+	QUAD $0xca9cf1d206fdc03b                           // .quad -3846934097318526917
+	QUAD $0x908f4a166d1da663                           // .quad -8030118150397909405
+	QUAD $0xfd442e4688bd304a                           // .quad -196981603220770742
+	QUAD $0x9a598e4e043287fe                           // .quad -7324666853212387330
+	QUAD $0x9e4a9cec15763e2e                           // .quad -7040642529654063570
+	QUAD $0x40eff1e1853f29fd                           // .quad 4679224488766679549
+	QUAD $0xc5dd44271ad3cdba                           // .quad -4189117143640191558
+	QUAD $0xd12bee59e68ef47c                           // .quad -3374341425896426372
+	QUAD $0xf7549530e188c128                           // .quad -624710411122851544
+	QUAD $0x82bb74f8301958ce                           // .quad -9026492418826348338
+	QUAD $0x9a94dd3e8cf578b9                           // .quad -7307973034592864071
+	QUAD $0xe36a52363c1faf01                           // .quad -2059743486678159615
+	QUAD $0xc13a148e3032d6e7                           // .quad -4523280274813692185
+	QUAD $0xdc44e6c3cb279ac1                           // .quad -2574679358347699519
+	QUAD $0xf18899b1bc3f8ca1                           // .quad -1042414325089727327
+	QUAD $0x29ab103a5ef8c0b9                           // .quad 3002511419460075705
+	QUAD $0x96f5600f15a7b7e5                           // .quad -7569037980822161435
+	QUAD $0x7415d448f6b6f0e7                           // .quad 8364825292752482535
+	QUAD $0xbcb2b812db11a5de                           // .quad -4849611457600313890
+	QUAD $0x111b495b3464ad21                           // .quad 1232659579085827361
+	QUAD $0xebdf661791d60f56                           // .quad -1450328303573004458
+	QUAD $0xcab10dd900beec34                           // .quad -3841273781498745804
+	QUAD $0x936b9fcebb25c995                           // .quad -7823984217374209643
+	QUAD $0x3d5d514f40eea742                           // .quad 4421779809981343554
+	QUAD $0xb84687c269ef3bfb                           // .quad -5168294253290374149
+	QUAD $0x0cb4a5a3112a5112                           // .quad 915538744049291538
+	QUAD $0xe65829b3046b0afa                           // .quad -1848681798185579782
+	QUAD $0x47f0e785eaba72ab                           // .quad 5183897733458195115
+	QUAD $0x8ff71a0fe2c2e6dc                           // .quad -8072955151507069220
+	QUAD $0x59ed216765690f56                           // .quad 6479872166822743894
+	QUAD $0xb3f4e093db73a093                           // .quad -5479507920956448621
+	QUAD $0x306869c13ec3532c                           // .quad 3488154190101041964
+	QUAD $0xe0f218b8d25088b8                           // .quad -2237698882768172872
+	QUAD $0x1e414218c73a13fb                           // .quad 2180096368813151227
+	QUAD $0x8c974f7383725573                           // .quad -8316090829371189901
+	QUAD $0xe5d1929ef90898fa                           // .quad -1886565557410948870
+	QUAD $0xafbd2350644eeacf                           // .quad -5783427518286599473
+	QUAD $0xdf45f746b74abf39                           // .quad -2358206946763686087
+	QUAD $0xdbac6c247d62a583                           // .quad -2617598379430861437
+	QUAD $0x6b8bba8c328eb783                           // .quad 7749492695127472003
+	QUAD $0x894bc396ce5da772                           // .quad -8553528014785370254
+	QUAD $0x066ea92f3f326564                           // .quad 463493832054564196
+	QUAD $0xab9eb47c81f5114f                           // .quad -6080224000054324913
+	QUAD $0xc80a537b0efefebd                           // .quad -4032318728359182659
+	QUAD $0xd686619ba27255a2                           // .quad -2988593981640518238
+	QUAD $0xbd06742ce95f5f36                           // .quad -4826042214438183114
+	QUAD $0x8613fd0145877585                           // .quad -8785400266166405755
+	QUAD $0x2c48113823b73704                           // .quad 3190819268807046916
+	QUAD $0xa798fc4196e952e7                           // .quad -6370064314280619289
+	QUAD $0xf75a15862ca504c5                           // .quad -623161932418579259
+	QUAD $0xd17f3b51fca3a7a0                           // .quad -3350894374423386208
+	QUAD $0x9a984d73dbe722fb                           // .quad -7307005235402693893
+	QUAD $0x82ef85133de648c4                           // .quad -9011838011655698236
+	QUAD $0xc13e60d0d2e0ebba                           // .quad -4522070525825979462
+	QUAD $0xa3ab66580d5fdaf5                           // .quad -6653111496142234891
+	QUAD $0x318df905079926a8                           // .quad 3570783879572301480
+	QUAD $0xcc963fee10b7d1b3                           // .quad -3704703351750405709
+	QUAD $0xfdf17746497f7052                           // .quad -148206168962011054
+	QUAD $0xffbbcfe994e5c61f                           // .quad -19193171260619233
+	QUAD $0xfeb6ea8bedefa633                           // .quad -92628855601256909
+	QUAD $0x9fd561f1fd0f9bd3                           // .quad -6929524759678968877
+	QUAD $0xfe64a52ee96b8fc0                           // .quad -115786069501571136
+	QUAD $0xc7caba6e7c5382c8                           // .quad -4050219931171323192
+	QUAD $0x3dfdce7aa3c673b0                           // .quad 4466953431550423984
+	QUAD $0xf9bd690a1b68637b                           // .quad -451088895536766085
+	QUAD $0x06bea10ca65c084e                           // .quad 486002885505321038
+	QUAD $0x9c1661a651213e2d                           // .quad -7199459587351560659
+	QUAD $0x486e494fcff30a62                           // .quad 5219189625309039202
+	QUAD $0xc31bfa0fe5698db8                           // .quad -4387638465762062920
+	QUAD $0x5a89dba3c3efccfa                           // .quad 6523987031636299002
+	QUAD $0xf3e2f893dec3f126                           // .quad -872862063775190746
+	QUAD $0xf89629465a75e01c                           // .quad -534194123654701028
+	QUAD $0x986ddb5c6b3a76b7                           // .quad -7463067817500576073
+	QUAD $0xf6bbb397f1135823                           // .quad -667742654568376285
+	QUAD $0xbe89523386091465                           // .quad -4717148753448332187
+	QUAD $0x746aa07ded582e2c                           // .quad 8388693718644305452
+	QUAD $0xee2ba6c0678b597f                           // .quad -1284749923383027329
+	QUAD $0xa8c2a44eb4571cdc                           // .quad -6286281471915778852
+	QUAD $0x94db483840b717ef                           // .quad -7720497729755473937
+	QUAD $0x92f34d62616ce413                           // .quad -7857851839894723565
+	QUAD $0xba121a4650e4ddeb                           // .quad -5038936143766954517
+	QUAD $0x77b020baf9c81d17                           // .quad 8624429273841147159
+	QUAD $0xe896a0d7e51e1566                           // .quad -1686984161281305242
+	QUAD $0x0ace1474dc1d122e                           // .quad 778582277723329070
+	QUAD $0x915e2486ef32cd60                           // .quad -7971894128441897632
+	QUAD $0x0d819992132456ba                           // .quad 973227847154161338
+	QUAD $0xb5b5ada8aaff80b8                           // .quad -5353181642124984136
+	QUAD $0x10e1fff697ed6c69                           // .quad 1216534808942701673
+	QUAD $0xe3231912d5bf60e6                           // .quad -2079791034228842266
+	QUAD $0xca8d3ffa1ef463c1                           // .quad -3851351762838199359
+	QUAD $0x8df5efabc5979c8f                           // .quad -8217398424034108273
+	QUAD $0xbd308ff8a6b17cb2                           // .quad -4814189703547749198
+	QUAD $0xb1736b96b6fd83b3                           // .quad -5660062011615247437
+	QUAD $0xac7cb3f6d05ddbde                           // .quad -6017737129434686498
+	QUAD $0xddd0467c64bce4a0                           // .quad -2463391496091671392
+	QUAD $0x6bcdf07a423aa96b                           // .quad 7768129340171790699
+	QUAD $0x8aa22c0dbef60ee4                           // .quad -8457148712698376476
+	QUAD $0x86c16c98d2c953c6                           // .quad -8736582398494813242
+	QUAD $0xad4ab7112eb3929d                           // .quad -5959749872445582691
+	QUAD $0xe871c7bf077ba8b7                           // .quad -1697355961263740745
+	QUAD $0xd89d64d57a607744                           // .quad -2838001322129590460
+	QUAD $0x11471cd764ad4972                           // .quad 1244995533423855986
+	QUAD $0x87625f056c7c4a8b                           // .quad -8691279853972075893
+	QUAD $0xd598e40d3dd89bcf                           // .quad -3055441601647567921
+	QUAD $0xa93af6c6c79b5d2d                           // .quad -6252413799037706963
+	QUAD $0x4aff1d108d4ec2c3                           // .quad 5404070034795315907
+	QUAD $0xd389b47879823479                           // .quad -3203831230369745799
+	QUAD $0xcedf722a585139ba                           // .quad -3539985255894009414
+	QUAD $0x843610cb4bf160cb                           // .quad -8919923546622172981
+	QUAD $0xc2974eb4ee658828                           // .quad -4424981569867511768
+	QUAD $0xa54394fe1eedb8fe                           // .quad -6538218414850328322
+	QUAD $0x733d226229feea32                           // .quad 8303831092947774002
+	QUAD $0xce947a3da6a9273e                           // .quad -3561087000135522498
+	QUAD $0x0806357d5a3f525f                           // .quad 578208414664970847
+	QUAD $0x811ccc668829b887                           // .quad -9143208402725783417
+	QUAD $0xca07c2dcb0cf26f7                           // .quad -3888925500096174345
+	QUAD $0xa163ff802a3426a8                           // .quad -6817324484979841368
+	QUAD $0xfc89b393dd02f0b5                           // .quad -249470856692830027
+	QUAD $0xc9bcff6034c13052                           // .quad -3909969587797413806
+	QUAD $0xbbac2078d443ace2                           // .quad -4923524589293425438
+	QUAD $0xfc2c3f3841f17c67                           // .quad -275775966319379353
+	QUAD $0xd54b944b84aa4c0d                           // .quad -3077202868308390899
+	QUAD $0x9d9ba7832936edc0                           // .quad -7089889006590693952
+	QUAD $0x0a9e795e65d4df11                           // .quad 765182433041899281
+	QUAD $0xc5029163f384a931                           // .quad -4250675239810979535
+	QUAD $0x4d4617b5ff4a16d5                           // .quad 5568164059729762005
+	QUAD $0xf64335bcf065d37d                           // .quad -701658031336336515
+	QUAD $0x504bced1bf8e4e45                           // .quad 5785945546544795205
+	QUAD $0x99ea0196163fa42e                           // .quad -7356065297226292178
+	QUAD $0xe45ec2862f71e1d6                           // .quad -1990940103673781802
+	QUAD $0xc06481fb9bcf8d39                           // .quad -4583395603105477319
+	QUAD $0x5d767327bb4e5a4c                           // .quad 6734696907262548556
+	QUAD $0xf07da27a82c37088                           // .quad -1117558485454458744
+	QUAD $0x3a6a07f8d510f86f                           // .quad 4209185567039092847
+	QUAD $0x964e858c91ba2655                           // .quad -7616003081050118571
+	QUAD $0x890489f70a55368b                           // .quad -8573576096483297653
+	QUAD $0xbbe226efb628afea                           // .quad -4908317832885260310
+	QUAD $0x2b45ac74ccea842e                           // .quad 3118087934678041646
+	QUAD $0xeadab0aba3b2dbe5                           // .quad -1523711272679187483
+	QUAD $0x3b0b8bc90012929d                           // .quad 4254647968387469981
+	QUAD $0x92c8ae6b464fc96f                           // .quad -7869848573065574033
+	QUAD $0x09ce6ebb40173744                           // .quad 706623942056949572
+	QUAD $0xb77ada0617e3bbcb                           // .quad -5225624697904579637
+	QUAD $0xcc420a6a101d0515                           // .quad -3728406090856200939
+	QUAD $0xe55990879ddcaabd                           // .quad -1920344853953336643
+	QUAD $0x9fa946824a12232d                           // .quad -6941939825212513491
+	QUAD $0x8f57fa54c2a9eab6                           // .quad -8117744561361917258
+	QUAD $0x47939822dc96abf9                           // .quad 5157633273766521849
+	QUAD $0xb32df8e9f3546564                           // .quad -5535494683275008668
+	QUAD $0x59787e2b93bc56f7                           // .quad 6447041592208152311
+	QUAD $0xdff9772470297ebd                           // .quad -2307682335666372931
+	QUAD $0x57eb4edb3c55b65a                           // .quad 6335244004343789146
+	QUAD $0x8bfbea76c619ef36                           // .quad -8359830487432564938
+	QUAD $0xede622920b6b23f1                           // .quad -1304317031425039375
+	QUAD $0xaefae51477a06b03                           // .quad -5838102090863318269
+	QUAD $0xe95fab368e45eced                           // .quad -1630396289281299219
+	QUAD $0xdab99e59958885c4                           // .quad -2685941595151759932
+	QUAD $0x11dbcb0218ebb414                           // .quad 1286845328412881940
+	QUAD $0x88b402f7fd75539b                           // .quad -8596242524610931813
+	QUAD $0xd652bdc29f26a119                           // .quad -3003129357911285479
+	QUAD $0xaae103b5fcd2a881                           // .quad -6133617137336276863
+	QUAD $0x4be76d3346f0495f                           // .quad 5469460339465668959
+	QUAD $0xd59944a37c0752a2                           // .quad -3055335403242958174
+	QUAD $0x6f70a4400c562ddb                           // .quad 8030098730593431003
+	QUAD $0x857fcae62d8493a5                           // .quad -8827113654667930715
+	QUAD $0xcb4ccd500f6bb952                           // .quad -3797434642040374958
+	QUAD $0xa6dfbd9fb8e5b88e                           // .quad -6422206049907525490
+	QUAD $0x7e2000a41346a7a7                           // .quad 9088264752731695015
+	QUAD $0xd097ad07a71f26b2                           // .quad -3416071543957018958
+	QUAD $0x8ed400668c0c28c8                           // .quad -8154892584824854328
+	QUAD $0x825ecc24c873782f                           // .quad -9052573742614218705
+	QUAD $0x728900802f0f32fa                           // .quad 8253128342678483706
+	QUAD $0xa2f67f2dfa90563b                           // .quad -6704031159840385477
+	QUAD $0x4f2b40a03ad2ffb9                           // .quad 5704724409920716729
+	QUAD $0xcbb41ef979346bca                           // .quad -3768352931373093942
+	QUAD $0xe2f610c84987bfa8                           // .quad -2092466524453879896
+	QUAD $0xfea126b7d78186bc                           // .quad -98755145788979524
+	QUAD $0x0dd9ca7d2df4d7c9                           // .quad 998051431430019017
+	QUAD $0x9f24b832e6b0f436                           // .quad -6979250993759194058
+	QUAD $0x91503d1c79720dbb                           // .quad -7975807747567252037
+	QUAD $0xc6ede63fa05d3143                           // .quad -4112377723771604669
+	QUAD $0x75a44c6397ce912a                           // .quad 8476984389250486570
+	QUAD $0xf8a95fcf88747d94                           // .quad -528786136287117932
+	QUAD $0xc986afbe3ee11aba                           // .quad -3925256793573221702
+	QUAD $0x9b69dbe1b548ce7c                           // .quad -7248020362820530564
+	QUAD $0xfbe85badce996168                           // .quad -294884973539139224
+	QUAD $0xc24452da229b021b                           // .quad -4448339435098275301
+	QUAD $0xfae27299423fb9c3                           // .quad -368606216923924029
+	QUAD $0xf2d56790ab41c2a2                           // .quad -948738275445456222
+	QUAD $0xdccd879fc967d41a                           // .quad -2536221894791146470
+	QUAD $0x97c560ba6b0919a5                           // .quad -7510490449794491995
+	QUAD $0x5400e987bbc1c920                           // .quad 6053094668365842720
+	QUAD $0xbdb6b8e905cb600f                           // .quad -4776427043815727089
+	QUAD $0x290123e9aab23b68                           // .quad 2954682317029915496
+	QUAD $0xed246723473e3813                           // .quad -1358847786342270957
+	QUAD $0xf9a0b6720aaf6521                           // .quad -459166561069996767
+	QUAD $0x9436c0760c86e30b                           // .quad -7766808894105001205
+	QUAD $0xf808e40e8d5b3e69                           // .quad -573958201337495959
+	QUAD $0xb94470938fa89bce                           // .quad -5096825099203863602
+	QUAD $0xb60b1d1230b20e04                           // .quad -5329133770099257852
+	QUAD $0xe7958cb87392c2c2                           // .quad -1759345355577441598
+	QUAD $0xb1c6f22b5e6f48c2                           // .quad -5636551615525730110
+	QUAD $0x90bd77f3483bb9b9                           // .quad -8017119874876982855
+	QUAD $0x1e38aeb6360b1af3                           // .quad 2177682517447613171
+	QUAD $0xb4ecd5f01a4aa828                           // .quad -5409713825168840664
+	QUAD $0x25c6da63c38de1b0                           // .quad 2722103146809516464
+	QUAD $0xe2280b6c20dd5232                           // .quad -2150456263033662926
+	QUAD $0x579c487e5a38ad0e                           // .quad 6313000485183335694
+	QUAD $0x8d590723948a535f                           // .quad -8261564192037121185
+	QUAD $0x2d835a9df0c6d851                           // .quad 3279564588051781713
+	QUAD $0xb0af48ec79ace837                           // .quad -5715269221619013577
+	QUAD $0xf8e431456cf88e65                           // .quad -512230283362660763
+	QUAD $0xdcdb1b2798182244                           // .quad -2532400508596379068
+	QUAD $0x1b8e9ecb641b58ff                           // .quad 1985699082112030975
+	QUAD $0x8a08f0f8bf0f156b                           // .quad -8500279345513818773
+	QUAD $0xe272467e3d222f3f                           // .quad -2129562165787349185
+	QUAD $0xac8b2d36eed2dac5                           // .quad -6013663163464885563
+	QUAD $0x5b0ed81dcc6abb0f                           // .quad 6561419329620589327
+	QUAD $0xd7adf884aa879177                           // .quad -2905392935903719049
+	QUAD $0x98e947129fc2b4e9                           // .quad -7428327965055601431
+	QUAD $0x86ccbb52ea94baea                           // .quad -8733399612580906262
+	QUAD $0x3f2398d747b36224                           // .quad 4549648098962661924
+	QUAD $0xa87fea27a539e9a5                           // .quad -6305063497298744923
+	QUAD $0x8eec7f0d19a03aad                           // .quad -8147997931578836307
+	QUAD $0xd29fe4b18e88640e                           // .quad -3269643353196043250
+	QUAD $0x1953cf68300424ac                           // .quad 1825030320404309164
+	QUAD $0x83a3eeeef9153e89                           // .quad -8961056123388608887
+	QUAD $0x5fa8c3423c052dd7                           // .quad 6892973918932774359
+	QUAD $0xa48ceaaab75a8e2b                           // .quad -6589634135808373205
+	QUAD $0x3792f412cb06794d                           // .quad 4004531380238580045
+	QUAD $0xcdb02555653131b6                           // .quad -3625356651333078602
+	QUAD $0xe2bbd88bbee40bd0                           // .quad -2108853905778275376
+	QUAD $0x808e17555f3ebf11                           // .quad -9183376934724255983
+	QUAD $0x5b6aceaeae9d0ec4                           // .quad 6587304654631931588
+	QUAD $0xa0b19d2ab70e6ed6                           // .quad -6867535149977932074
+	QUAD $0xf245825a5a445275                           // .quad -989241218564861323
+	QUAD $0xc8de047564d20a8b                           // .quad -3972732919045027189
+	QUAD $0xeed6e2f0f0d56712                           // .quad -1236551523206076654
+	QUAD $0xfb158592be068d2e                           // .quad -354230130378896082
+	QUAD $0x55464dd69685606b                           // .quad 6144684325637283947
+	QUAD $0x9ced737bb6c4183d                           // .quad -7138922859127891907
+	QUAD $0xaa97e14c3c26b886                           // .quad -6154202648235558778
+	QUAD $0xc428d05aa4751e4c                           // .quad -4311967555482476980
+	QUAD $0xd53dd99f4b3066a8                           // .quad -3081067291867060568
+	QUAD $0xf53304714d9265df                           // .quad -778273425925708321
+	QUAD $0xe546a8038efe4029                           // .quad -1925667057416912855
+	QUAD $0x993fe2c6d07b7fab                           // .quad -7403949918844649557
+	QUAD $0xde98520472bdd033                           // .quad -2407083821771141069
+	QUAD $0xbf8fdb78849a5f96                           // .quad -4643251380128424042
+	QUAD $0x963e66858f6d4440                           // .quad -7620540795641314240
+	QUAD $0xef73d256a5c0f77c                           // .quad -1192378206733142148
+	QUAD $0xdde7001379a44aa8                           // .quad -2456994988062127448
+	QUAD $0x95a8637627989aad                           // .quad -7662765406849295699
+	QUAD $0x5560c018580d5d52                           // .quad 6152128301777116498
+	QUAD $0xbb127c53b17ec159                           // .quad -4966770740134231719
+	QUAD $0xaab8f01e6e10b4a6                           // .quad -6144897678060768090
+	QUAD $0xe9d71b689dde71af                           // .quad -1596777406740401745
+	QUAD $0xcab3961304ca70e8                           // .quad -3840561048787980056
+	QUAD $0x9226712162ab070d                           // .quad -7915514906853832947
+	QUAD $0x3d607b97c5fd0d22                           // .quad 4422670725869800738
+	QUAD $0xb6b00d69bb55c8d1                           // .quad -5282707615139903279
+	QUAD $0x8cb89a7db77c506a                           // .quad -8306719647944912790
+	QUAD $0xe45c10c42a2b3b05                           // .quad -1991698500497491195
+	QUAD $0x77f3608e92adb242                           // .quad 8643358275316593218
+	QUAD $0x8eb98a7a9a5b04e3                           // .quad -8162340590452013853
+	QUAD $0x55f038b237591ed3                           // .quad 6192511825718353619
+	QUAD $0xb267ed1940f1c61c                           // .quad -5591239719637629412
+	QUAD $0x6b6c46dec52f6688                           // .quad 7740639782147942024
+	QUAD $0xdf01e85f912e37a3                           // .quad -2377363631119648861
+	QUAD $0x2323ac4b3b3da015                           // .quad 2532056854628769813
+	QUAD $0x8b61313bbabce2c6                           // .quad -8403381297090862394
+	QUAD $0xabec975e0a0d081a                           // .quad -6058300968568813542
+	QUAD $0xae397d8aa96c1b77                           // .quad -5892540602936190089
+	QUAD $0x96e7bd358c904a21                           // .quad -7572876210711016927
+	QUAD $0xd9c7dced53c72255                           // .quad -2753989735242849707
+	QUAD $0x7e50d64177da2e54                           // .quad 9102010423587778132
+	QUAD $0x881cea14545c7575                           // .quad -8638772612167862923
+	QUAD $0xdde50bd1d5d0b9e9                           // .quad -2457545025797441047
+	QUAD $0xaa242499697392d2                           // .quad -6186779746782440750
+	QUAD $0x955e4ec64b44e864                           // .quad -7683617300674189212
+	QUAD $0xd4ad2dbfc3d07787                           // .quad -3121788665050663033
+	QUAD $0xbd5af13bef0b113e                           // .quad -4802260812921368258
+	QUAD $0x84ec3c97da624ab4                           // .quad -8868646943297746252
+	QUAD $0xecb1ad8aeacdd58e                           // .quad -1391139997724322418
+	QUAD $0xa6274bbdd0fadd61                           // .quad -6474122660694794911
+	QUAD $0x67de18eda5814af2                           // .quad 7484447039699372786
+	QUAD $0xcfb11ead453994ba                           // .quad -3480967307441105734
+	QUAD $0x80eacf948770ced7                           // .quad -9157278655470055721
+	QUAD $0x81ceb32c4b43fcf4                           // .quad -9093133594791772940
+	QUAD $0xa1258379a94d028d                           // .quad -6834912300910181747
+	QUAD $0xa2425ff75e14fc31                           // .quad -6754730975062328271
+	QUAD $0x096ee45813a04330                           // .quad 679731660717048624
+	QUAD $0xcad2f7f5359a3b3e                           // .quad -3831727700400522434
+	QUAD $0x8bca9d6e188853fc                           // .quad -8373707460958465028
+	QUAD $0xfd87b5f28300ca0d                           // .quad -177973607073265139
+	QUAD $0x775ea264cf55347d                           // .quad 8601490892183123069
+	QUAD $0x9e74d1b791e07e48                           // .quad -7028762532061872568
+	QUAD $0x95364afe032a819d                           // .quad -7694880458480647779
+	QUAD $0xc612062576589dda                           // .quad -4174267146649952806
+	QUAD $0x3a83ddbd83f52204                           // .quad 4216457482181353988
+	QUAD $0xf79687aed3eec551                           // .quad -606147914885053103
+	QUAD $0xc4926a9672793542                           // .quad -4282243101277735614
+	QUAD $0x9abe14cd44753b52                           // .quad -7296371474444240046
+	QUAD $0x75b7053c0f178293                           // .quad 8482254178684994195
+	QUAD $0xc16d9a0095928a27                           // .quad -4508778324627912153
+	QUAD $0x5324c68b12dd6338                           // .quad 5991131704928854840
+	QUAD $0xf1c90080baf72cb1                           // .quad -1024286887357502287
+	QUAD $0xd3f6fc16ebca5e03                           // .quad -3173071712060547581
+	QUAD $0x971da05074da7bee                           // .quad -7557708332239520786
+	QUAD $0x88f4bb1ca6bcf584                           // .quad -8578025658503072380
+	QUAD $0xbce5086492111aea                           // .quad -4835449396872013078
+	QUAD $0x2b31e9e3d06c32e5                           // .quad 3112525982153323237
+	QUAD $0xec1e4a7db69561a5                           // .quad -1432625727662628443
+	QUAD $0x3aff322e62439fcf                           // .quad 4251171748059520975
+	QUAD $0x9392ee8e921d5d07                           // .quad -7812920107430224633
+	QUAD $0x09befeb9fad487c2                           // .quad 702278666647013314
+	QUAD $0xb877aa3236a4b449                           // .quad -5154464115860392887
+	QUAD $0x4c2ebe687989a9b3                           // .quad 5489534351736154547
+	QUAD $0xe69594bec44de15b                           // .quad -1831394126398103205
+	QUAD $0x0f9d37014bf60a10                           // .quad 1125115960621402640
+	QUAD $0x901d7cf73ab0acd9                           // .quad -8062150356639896359
+	QUAD $0x538484c19ef38c94                           // .quad 6018080969204141204
+	QUAD $0xb424dc35095cd80f                           // .quad -5466001927372482545
+	QUAD $0x2865a5f206b06fb9                           // .quad 2910915193077788601
+	QUAD $0xe12e13424bb40e13                           // .quad -2220816390788215277
+	QUAD $0xf93f87b7442e45d3                           // .quad -486521013540076077
+	QUAD $0x8cbccc096f5088cb                           // .quad -8305539271883716405
+	QUAD $0xf78f69a51539d748                           // .quad -608151266925095096
+	QUAD $0xafebff0bcb24aafe                           // .quad -5770238071427257602
+	QUAD $0xb573440e5a884d1b                           // .quad -5371875102083756773
+	QUAD $0xdbe6fecebdedd5be                           // .quad -2601111570856684098
+	QUAD $0x31680a88f8953030                           // .quad 3560107088838733872
+	QUAD $0x89705f4136b4a597                           // .quad -8543223759426509417
+	QUAD $0xfdc20d2b36ba7c3d                           // .quad -161552157378970563
+	QUAD $0xabcc77118461cefc                           // .quad -6067343680855748868
+	QUAD $0x3d32907604691b4c                           // .quad 4409745821703674700
+	QUAD $0xd6bf94d5e57a42bc                           // .quad -2972493582642298180
+	QUAD $0xa63f9a49c2c1b10f                           // .quad -6467280898289979121
+	QUAD $0x8637bd05af6c69b5                           // .quad -8775337516792518219
+	QUAD $0x0fcf80dc33721d53                           // .quad 1139270913992301907
+	QUAD $0xa7c5ac471b478423                           // .quad -6357485877563259869
+	QUAD $0xd3c36113404ea4a8                           // .quad -3187597375937010520
+	QUAD $0xd1b71758e219652b                           // .quad -3335171328526686933
+	QUAD $0x645a1cac083126e9                           // .quad 7231123676894144233
+	QUAD $0x83126e978d4fdf3b                           // .quad -9002011107970261189
+	QUAD $0x3d70a3d70a3d70a3                           // .quad 4427218577690292387
+	QUAD $0xa3d70a3d70a3d70a                           // .quad -6640827866535438582
+	QUAD $0xcccccccccccccccc; QUAD $0xcccccccccccccccc // .space 16, '\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc'
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x8000000000000000                           // .quad -9223372036854775808
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xa000000000000000                           // .quad -6917529027641081856
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xc800000000000000                           // .quad -4035225266123964416
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xfa00000000000000                           // .quad -432345564227567616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x9c40000000000000                           // .quad -7187745005283311616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xc350000000000000                           // .quad -4372995238176751616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xf424000000000000                           // .quad -854558029293551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x9896800000000000                           // .quad -7451627795949551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xbebc200000000000                           // .quad -4702848726509551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xee6b280000000000                           // .quad -1266874889709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x9502f90000000000                           // .quad -7709325833709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xba43b74000000000                           // .quad -5024971273709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xe8d4a51000000000                           // .quad -1669528073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x9184e72a00000000                           // .quad -7960984073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xb5e620f480000000                           // .quad -5339544073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xe35fa931a0000000                           // .quad -2062744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x8e1bc9bf04000000                           // .quad -8206744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xb1a2bc2ec5000000                           // .quad -5646744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xde0b6b3a76400000                           // .quad -2446744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x8ac7230489e80000                           // .quad -8446744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xad78ebc5ac620000                           // .quad -5946744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xd8d726b7177a8000                           // .quad -2821744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x878678326eac9000                           // .quad -8681119073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xa968163f0a57b400                           // .quad -6239712823709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xd3c21bcecceda100                           // .quad -3187955011209551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x84595161401484a0                           // .quad -8910000909647051616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xa56fa5b99019a5c8                           // .quad -6525815118631426616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xcecb8f27f4200f3a                           // .quad -3545582879861895366
+	QUAD $0x4000000000000000                           // .quad 4611686018427387904
+	QUAD $0x813f3978f8940984                           // .quad -9133518327554766460
+	QUAD $0x5000000000000000                           // .quad 5764607523034234880
+	QUAD $0xa18f07d736b90be5                           // .quad -6805211891016070171
+	QUAD $0xa400000000000000                           // .quad -6629298651489370112
+	QUAD $0xc9f2c9cd04674ede                           // .quad -3894828845342699810
+	QUAD $0x4d00000000000000                           // .quad 5548434740920451072
+	QUAD $0xfc6f7c4045812296                           // .quad -256850038250986858
+	QUAD $0xf020000000000000                           // .quad -1143914305352105984
+	QUAD $0x9dc5ada82b70b59d                           // .quad -7078060301547948643
+	QUAD $0x6c28000000000000                           // .quad 7793479155164643328
+	QUAD $0xc5371912364ce305                           // .quad -4235889358507547899
+	QUAD $0xc732000000000000                           // .quad -4093209111326359552
+	QUAD $0xf684df56c3e01bc6                           // .quad -683175679707046970
+	QUAD $0x3c7f400000000000                           // .quad 4359273333062107136
+	QUAD $0x9a130b963a6c115c                           // .quad -7344513827457986212
+	QUAD $0x4b9f100000000000                           // .quad 5449091666327633920
+	QUAD $0xc097ce7bc90715b3                           // .quad -4568956265895094861
+	QUAD $0x1e86d40000000000                           // .quad 2199678564482154496
+	QUAD $0xf0bdc21abb48db20                           // .quad -1099509313941480672
+	QUAD $0x1314448000000000                           // .quad 1374799102801346560
+	QUAD $0x96769950b50d88f4                           // .quad -7604722348854507276
+	QUAD $0x17d955a000000000                           // .quad 1718498878501683200
+	QUAD $0xbc143fa4e250eb31                           // .quad -4894216917640746191
+	QUAD $0x5dcfab0800000000                           // .quad 6759809616554491904
+	QUAD $0xeb194f8e1ae525fd                           // .quad -1506085128623544835
+	QUAD $0x5aa1cae500000000                           // .quad 6530724019560251392
+	QUAD $0x92efd1b8d0cf37be                           // .quad -7858832233030797378
+	QUAD $0xf14a3d9e40000000                           // .quad -1059967012404461568
+	QUAD $0xb7abc627050305ad                           // .quad -5211854272861108819
+	QUAD $0x6d9ccd05d0000000                           // .quad 7898413271349198848
+	QUAD $0xe596b7b0c643c719                           // .quad -1903131822648998119
+	QUAD $0xe4820023a2000000                           // .quad -1981020733047832576
+	QUAD $0x8f7e32ce7bea5c6f                           // .quad -8106986416796705681
+	QUAD $0xdda2802c8a800000                           // .quad -2476275916309790720
+	QUAD $0xb35dbf821ae4f38b                           // .quad -5522047002568494197
+	QUAD $0xd50b2037ad200000                           // .quad -3095344895387238400
+	QUAD $0xe0352f62a19e306e                           // .quad -2290872734783229842
+	QUAD $0x4526f422cc340000                           // .quad 4982938468024057856
+	QUAD $0x8c213d9da502de45                           // .quad -8349324486880600507
+	QUAD $0x9670b12b7f410000                           // .quad -7606384970252091392
+	QUAD $0xaf298d050e4395d6                           // .quad -5824969590173362730
+	QUAD $0x3c0cdd765f114000                           // .quad 4327076842467049472
+	QUAD $0xdaf3f04651d47b4c                           // .quad -2669525969289315508
+	QUAD $0xa5880a69fb6ac800                           // .quad -6518949010312869888
+	QUAD $0x88d8762bf324cd0f                           // .quad -8585982758446904049
+	QUAD $0x8eea0d047a457a00                           // .quad -8148686262891087360
+	QUAD $0xab0e93b6efee0053                           // .quad -6120792429631242157
+	QUAD $0x72a4904598d6d880                           // .quad 8260886245095692416
+	QUAD $0xd5d238a4abe98068                           // .quad -3039304518611664792
+	QUAD $0x47a6da2b7f864750                           // .quad 5163053903184807760
+	QUAD $0x85a36366eb71f041                           // .quad -8817094351773372351
+	QUAD $0x999090b65f67d924                           // .quad -7381240676301154012
+	QUAD $0xa70c3c40a64e6c51                           // .quad -6409681921289327535
+	QUAD $0xfff4b4e3f741cf6d                           // .quad -3178808521666707
+	QUAD $0xd0cf4b50cfe20765                           // .quad -3400416383184271515
+	QUAD $0xbff8f10e7a8921a4                           // .quad -4613672773753429596
+	QUAD $0x82818f1281ed449f                           // .quad -9042789267131251553
+	QUAD $0xaff72d52192b6a0d                           // .quad -5767090967191786995
+	QUAD $0xa321f2d7226895c7                           // .quad -6691800565486676537
+	QUAD $0x9bf4f8a69f764490                           // .quad -7208863708989733744
+	QUAD $0xcbea6f8ceb02bb39                           // .quad -3753064688430957767
+	QUAD $0x02f236d04753d5b4                           // .quad 212292400617608628
+	QUAD $0xfee50b7025c36a08                           // .quad -79644842111309304
+	QUAD $0x01d762422c946590                           // .quad 132682750386005392
+	QUAD $0x9f4f2726179a2245                           // .quad -6967307053960650171
+	QUAD $0x424d3ad2b7b97ef5                           // .quad 4777539456409894645
+	QUAD $0xc722f0ef9d80aad6                           // .quad -4097447799023424810
+	QUAD $0xd2e0898765a7deb2                           // .quad -3251447716342407502
+	QUAD $0xf8ebad2b84e0d58b                           // .quad -510123730351893109
+	QUAD $0x63cc55f49f88eb2f                           // .quad 7191217214140771119
+	QUAD $0x9b934c3b330c8577                           // .quad -7236356359111015049
+	QUAD $0x3cbf6b71c76b25fb                           // .quad 4377335499248575995
+	QUAD $0xc2781f49ffcfa6d5                           // .quad -4433759430461380907
+	QUAD $0x8bef464e3945ef7a                           // .quad -8363388681221443718
+	QUAD $0xf316271c7fc3908a                           // .quad -930513269649338230
+	QUAD $0x97758bf0e3cbb5ac                           // .quad -7532960934977096276
+	QUAD $0x97edd871cfda3a56                           // .quad -7499099821171918250
+	QUAD $0x3d52eeed1cbea317                           // .quad 4418856886560793367
+	QUAD $0xbde94e8e43d0c8ec                           // .quad -4762188758037509908
+	QUAD $0x4ca7aaa863ee4bdd                           // .quad 5523571108200991709
+	QUAD $0xed63a231d4c4fb27                           // .quad -1341049929119499481
+	QUAD $0x8fe8caa93e74ef6a                           // .quad -8076983103442849942
+	QUAD $0x945e455f24fb1cf8                           // .quad -7755685233340769032
+	QUAD $0xb3e2fd538e122b44                           // .quad -5484542860876174524
+	QUAD $0xb975d6b6ee39e436                           // .quad -5082920523248573386
+	QUAD $0x60dbbca87196b616                           // .quad 6979379479186945558
+	QUAD $0xe7d34c64a9c85d44                           // .quad -1741964635633328828
+	QUAD $0xbc8955e946fe31cd                           // .quad -4861259862362934835
+	QUAD $0x90e40fbeea1d3a4a                           // .quad -8006256924911912374
+	QUAD $0x6babab6398bdbe41                           // .quad 7758483227328495169
+	QUAD $0xb51d13aea4a488dd                           // .quad -5396135137712502563
+	QUAD $0xc696963c7eed2dd1                           // .quad -4136954021121544751
+	QUAD $0xe264589a4dcdab14                           // .quad -2133482903713240300
+	QUAD $0xfc1e1de5cf543ca2                           // .quad -279753253987271518
+	QUAD $0x8d7eb76070a08aec                           // .quad -8250955842461857044
+	QUAD $0x3b25a55f43294bcb                           // .quad 4261994450943298507
+	QUAD $0xb0de65388cc8ada8                           // .quad -5702008784649933400
+	QUAD $0x49ef0eb713f39ebe                           // .quad 5327493063679123134
+	QUAD $0xdd15fe86affad912                           // .quad -2515824962385028846
+	QUAD $0x6e3569326c784337                           // .quad 7941369183226839863
+	QUAD $0x8a2dbf142dfcc7ab                           // .quad -8489919629131724885
+	QUAD $0x49c2c37f07965404                           // .quad 5315025460606161924
+	QUAD $0xacb92ed9397bf996                           // .quad -6000713517987268202
+	QUAD $0xdc33745ec97be906                           // .quad -2579590211097073402
+	QUAD $0xd7e77a8f87daf7fb                           // .quad -2889205879056697349
+	QUAD $0x69a028bb3ded71a3                           // .quad 7611128154919104931
+	QUAD $0x86f0ac99b4e8dafd                           // .quad -8723282702051517699
+	QUAD $0xc40832ea0d68ce0c                           // .quad -4321147861633282548
+	QUAD $0xa8acd7c0222311bc                           // .quad -6292417359137009220
+	QUAD $0xf50a3fa490c30190                           // .quad -789748808614215280
+	QUAD $0xd2d80db02aabd62b                           // .quad -3253835680493873621
+	QUAD $0x792667c6da79e0fa                           // .quad 8729779031470891258
+	QUAD $0x83c7088e1aab65db                           // .quad -8951176327949752869
+	QUAD $0x577001b891185938                           // .quad 6300537770911226168
+	QUAD $0xa4b8cab1a1563f52                           // .quad -6577284391509803182
+	QUAD $0xed4c0226b55e6f86                           // .quad -1347699823215743098
+	QUAD $0xcde6fd5e09abcf26                           // .quad -3609919470959866074
+	QUAD $0x544f8158315b05b4                           // .quad 6075216638131242420
+	QUAD $0x80b05e5ac60b6178                           // .quad -9173728696990998152
+	QUAD $0x696361ae3db1c721                           // .quad 7594020797664053025
+	QUAD $0xa0dc75f1778e39d6                           // .quad -6855474852811359786
+	QUAD $0x03bc3a19cd1e38e9                           // .quad 269153960225290473
+	QUAD $0xc913936dd571c84c                           // .quad -3957657547586811828
+	QUAD $0x04ab48a04065c723                           // .quad 336442450281613091
+	QUAD $0xfb5878494ace3a5f                           // .quad -335385916056126881
+	QUAD $0x62eb0d64283f9c76                           // .quad 7127805559067090038
+	QUAD $0x9d174b2dcec0e47b                           // .quad -7127145225176161157
+	QUAD $0x3ba5d0bd324f8394                           // .quad 4298070930406474644
+	QUAD $0xc45d1df942711d9a                           // .quad -4297245513042813542
+	QUAD $0xca8f44ec7ee36479                           // .quad -3850783373846682503
+	QUAD $0xf5746577930d6500                           // .quad -759870872876129024
+	QUAD $0x7e998b13cf4e1ecb                           // .quad 9122475437414293195
+	QUAD $0x9968bf6abbe85f20                           // .quad -7392448323188662496
+	QUAD $0x9e3fedd8c321a67e                           // .quad -7043649776941685122
+	QUAD $0xbfc2ef456ae276e8                           // .quad -4628874385558440216
+	QUAD $0xc5cfe94ef3ea101e                           // .quad -4192876202749718498
+	QUAD $0xefb3ab16c59b14a2                           // .quad -1174406963520662366
+	QUAD $0xbba1f1d158724a12                           // .quad -4926390635932268014
+	QUAD $0x95d04aee3b80ece5                           // .quad -7651533379841495835
+	QUAD $0x2a8a6e45ae8edc97                           // .quad 3065383741939440791
+	QUAD $0xbb445da9ca61281f                           // .quad -4952730706374481889
+	QUAD $0xf52d09d71a3293bd                           // .quad -779956341003086915
+	QUAD $0xea1575143cf97226                           // .quad -1579227364540714458
+	QUAD $0x593c2626705f9c56                           // .quad 6430056314514152534
+	QUAD $0x924d692ca61be758                           // .quad -7904546130479028392
+	QUAD $0x6f8b2fb00c77836c                           // .quad 8037570393142690668
+	QUAD $0xb6e0c377cfa2e12e                           // .quad -5268996644671397586
+	QUAD $0x0b6dfb9c0f956447                           // .quad 823590954573587527
+	QUAD $0xe498f455c38b997a                           // .quad -1974559787411859078
+	QUAD $0x4724bd4189bd5eac                           // .quad 5126430365035880108
+	QUAD $0x8edf98b59a373fec                           // .quad -8151628894773493780
+	QUAD $0x58edec91ec2cb657                           // .quad 6408037956294850135
+	QUAD $0xb2977ee300c50fe7                           // .quad -5577850100039479321
+	QUAD $0x2f2967b66737e3ed                           // .quad 3398361426941174765
+	QUAD $0xdf3d5e9bc0f653e1                           // .quad -2360626606621961247
+	QUAD $0xbd79e0d20082ee74                           // .quad -4793553135802847628
+	QUAD $0x8b865b215899f46c                           // .quad -8392920656779807636
+	QUAD $0xecd8590680a3aa11                           // .quad -1380255401326171631
+	QUAD $0xae67f1e9aec07187                           // .quad -5879464802547371641
+	QUAD $0xe80e6f4820cc9495                           // .quad -1725319251657714539
+	QUAD $0xda01ee641a708de9                           // .quad -2737644984756826647
+	QUAD $0x3109058d147fdcdd                           // .quad 3533361486141316317
+	QUAD $0x884134fe908658b2                           // .quad -8628557143114098510
+	QUAD $0xbd4b46f0599fd415                           // .quad -4806670179178130411
+	QUAD $0xaa51823e34a7eede                           // .quad -6174010410465235234
+	QUAD $0x6c9e18ac7007c91a                           // .quad 7826720331309500698
+	QUAD $0xd4e5e2cdc1d1ea96                           // .quad -3105826994654156138
+	QUAD $0x03e2cf6bc604ddb0                           // .quad 280014188641050032
+	QUAD $0x850fadc09923329e                           // .quad -8858670899299929442
+	QUAD $0x84db8346b786151c                           // .quad -8873354301053463268
+	QUAD $0xa6539930bf6bff45                           // .quad -6461652605697523899
+	QUAD $0xe612641865679a63                           // .quad -1868320839462053277
+	QUAD $0xcfe87f7cef46ff16                           // .quad -3465379738694516970
+	QUAD $0x4fcb7e8f3f60c07e                           // .quad 5749828502977298558
+	QUAD $0x81f14fae158c5f6e                           // .quad -9083391364325154962
+	QUAD $0xe3be5e330f38f09d                           // .quad -2036086408133152611
+	QUAD $0xa26da3999aef7749                           // .quad -6742553186979055799
+	QUAD $0x5cadf5bfd3072cc5                           // .quad 6678264026688335045
+	QUAD $0xcb090c8001ab551c                           // .quad -3816505465296431844
+	QUAD $0x73d9732fc7c8f7f6                           // .quad 8347830033360418806
+	QUAD $0xfdcb4fa002162a63                           // .quad -158945813193151901
+	QUAD $0x2867e7fddcdd9afa                           // .quad 2911550761636567802
+	QUAD $0x9e9f11c4014dda7e                           // .quad -7016870160886801794
+	QUAD $0xb281e1fd541501b8                           // .quad -5583933584809066056
+	QUAD $0xc646d63501a1511d                           // .quad -4159401682681114339
+	QUAD $0x1f225a7ca91a4226                           // .quad 2243455055843443238
+	QUAD $0xf7d88bc24209a565                           // .quad -587566084924005019
+	QUAD $0x3375788de9b06958                           // .quad 3708002419115845976
+	QUAD $0x9ae757596946075f                           // .quad -7284757830718584993
+	QUAD $0x0052d6b1641c83ae                           // .quad 23317005467419566
+	QUAD $0xc1a12d2fc3978937                           // .quad -4494261269970843337
+	QUAD $0xc0678c5dbd23a49a                           // .quad -4582539761593113446
+	QUAD $0xf209787bb47d6b84                           // .quad -1006140569036166268
+	QUAD $0xf840b7ba963646e0                           // .quad -558244341782001952
+	QUAD $0x9745eb4d50ce6332                           // .quad -7546366883288685774
+	QUAD $0xb650e5a93bc3d898                           // .quad -5309491445654890344
+	QUAD $0xbd176620a501fbff                           // .quad -4821272585683469313
+	QUAD $0xa3e51f138ab4cebe                           // .quad -6636864307068612930
+	QUAD $0xec5d3fa8ce427aff                           // .quad -1414904713676948737
+	QUAD $0xc66f336c36b10137                           // .quad -4148040191917883081
+	QUAD $0x93ba47c980e98cdf                           // .quad -7801844473689174817
+	QUAD $0xb80b0047445d4184                           // .quad -5185050239897353852
+	QUAD $0xb8a8d9bbe123f017                           // .quad -5140619573684080617
+	QUAD $0xa60dc059157491e5                           // .quad -6481312799871692315
+	QUAD $0xe6d3102ad96cec1d                           // .quad -1814088448677712867
+	QUAD $0x87c89837ad68db2f                           // .quad -8662506518347195601
+	QUAD $0x9043ea1ac7e41392                           // .quad -8051334308064652398
+	QUAD $0x29babe4598c311fb                           // .quad 3006924907348169211
+	QUAD $0xb454e4a179dd1877                           // .quad -5452481866653427593
+	QUAD $0xf4296dd6fef3d67a                           // .quad -853029884242176390
+	QUAD $0xe16a1dc9d8545e94                           // .quad -2203916314889396588
+	QUAD $0x1899e4a65f58660c                           // .quad 1772699331562333708
+	QUAD $0x8ce2529e2734bb1d                           // .quad -8294976724446954723
+	QUAD $0x5ec05dcff72e7f8f                           // .quad 6827560182880305039
+	QUAD $0xb01ae745b101e9e4                           // .quad -5757034887131305500
+	QUAD $0x76707543f4fa1f73                           // .quad 8534450228600381299
+	QUAD $0xdc21a1171d42645d                           // .quad -2584607590486743971
+	QUAD $0x6a06494a791c53a8                           // .quad 7639874402088932264
+	QUAD $0x899504ae72497eba                           // .quad -8532908771695296838
+	QUAD $0x0487db9d17636892                           // .quad 326470965756389522
+	QUAD $0xabfa45da0edbde69                           // .quad -6054449946191733143
+	QUAD $0x45a9d2845d3c42b6                           // .quad 5019774725622874806
+	QUAD $0xd6f8d7509292d603                           // .quad -2956376414312278525
+	QUAD $0x0b8a2392ba45a9b2                           // .quad 831516194300602802
+	QUAD $0x865b86925b9bc5c2                           // .quad -8765264286586255934
+	QUAD $0x8e6cac7768d7141e                           // .quad -8183976793979022306
+	QUAD $0xa7f26836f282b732                           // .quad -6344894339805432014
+	QUAD $0x3207d795430cd926                           // .quad 3605087062808385830
+	QUAD $0xd1ef0244af2364ff                           // .quad -3319431906329402113
+	QUAD $0x7f44e6bd49e807b8                           // .quad 9170708441896323000
+	QUAD $0x8335616aed761f1f                           // .quad -8992173969096958177
+	QUAD $0x5f16206c9c6209a6                           // .quad 6851699533943015846
+	QUAD $0xa402b9c5a8d3a6e7                           // .quad -6628531442943809817
+	QUAD $0x36dba887c37a8c0f                           // .quad 3952938399001381903
+	QUAD $0xcd036837130890a1                           // .quad -3673978285252374367
+	QUAD $0xc2494954da2c9789                           // .quad -4446942528265218167
+	QUAD $0x802221226be55a64                           // .quad -9213765455923815836
+	QUAD $0xf2db9baa10b7bd6c                           // .quad -946992141904134804
+	QUAD $0xa02aa96b06deb0fd                           // .quad -6905520801477381891
+	QUAD $0x6f92829494e5acc7                           // .quad 8039631859474607303
+	QUAD $0xc83553c5c8965d3d                           // .quad -4020214983419339459
+	QUAD $0xcb772339ba1f17f9                           // .quad -3785518230938904583
+	QUAD $0xfa42a8b73abbf48c                           // .quad -413582710846786420
+	QUAD $0xff2a760414536efb                           // .quad -60105885123121413
+	QUAD $0x9c69a97284b578d7                           // .quad -7176018221920323369
+	QUAD $0xfef5138519684aba                           // .quad -75132356403901766
+	QUAD $0xc38413cf25e2d70d                           // .quad -4358336758973016307
+	QUAD $0x7eb258665fc25d69                           // .quad 9129456591349898601
+	QUAD $0xf46518c2ef5b8cd1                           // .quad -836234930288882479
+	QUAD $0xef2f773ffbd97a61                           // .quad -1211618658047395231
+	QUAD $0x98bf2f79d5993802                           // .quad -7440175859071633406
+	QUAD $0xaafb550ffacfd8fa                           // .quad -6126209340986631942
+	QUAD $0xbeeefb584aff8603                           // .quad -4688533805412153853
+	QUAD $0x95ba2a53f983cf38                           // .quad -7657761676233289928
+	QUAD $0xeeaaba2e5dbf6784                           // .quad -1248981238337804412
+	QUAD $0xdd945a747bf26183                           // .quad -2480258038432112253
+	QUAD $0x952ab45cfa97a0b2                           // .quad -7698142301602209614
+	QUAD $0x94f971119aeef9e4                           // .quad -7712008566467528220
+	QUAD $0xba756174393d88df                           // .quad -5010991858575374113
+	QUAD $0x7a37cd5601aab85d                           // .quad 8806733365625141341
+	QUAD $0xe912b9d1478ceb17                           // .quad -1652053804791829737
+	QUAD $0xac62e055c10ab33a                           // .quad -6025006692552756422
+	QUAD $0x91abb422ccb812ee                           // .quad -7950062655635975442
+	QUAD $0x577b986b314d6009                           // .quad 6303799689591218185
+	QUAD $0xb616a12b7fe617aa                           // .quad -5325892301117581398
+	QUAD $0xed5a7e85fda0b80b                           // .quad -1343622424865753077
+	QUAD $0xe39c49765fdf9d94                           // .quad -2045679357969588844
+	QUAD $0x14588f13be847307                           // .quad 1466078993672598279
+	QUAD $0x8e41ade9fbebc27d                           // .quad -8196078626372074883
+	QUAD $0x596eb2d8ae258fc8                           // .quad 6444284760518135752
+	QUAD $0xb1d219647ae6b31c                           // .quad -5633412264537705700
+	QUAD $0x6fca5f8ed9aef3bb                           // .quad 8055355950647669691
+	QUAD $0xde469fbd99a05fe3                           // .quad -2430079312244744221
+	QUAD $0x25de7bb9480d5854                           // .quad 2728754459941099604
+	QUAD $0x8aec23d680043bee                           // .quad -8436328597794046994
+	QUAD $0xaf561aa79a10ae6a                           // .quad -5812428961928401302
+	QUAD $0xada72ccc20054ae9                           // .quad -5933724728815170839
+	QUAD $0x1b2ba1518094da04                           // .quad 1957835834444274180
+	QUAD $0xd910f7ff28069da4                           // .quad -2805469892591575644
+	QUAD $0x90fb44d2f05d0842                           // .quad -7999724640327104446
+	QUAD $0x87aa9aff79042286                           // .quad -8670947710510816634
+	QUAD $0x353a1607ac744a53                           // .quad 3835402254873283155
+	QUAD $0xa99541bf57452b28                           // .quad -6226998619711132888
+	QUAD $0x42889b8997915ce8                           // .quad 4794252818591603944
+	QUAD $0xd3fa922f2d1675f2                           // .quad -3172062256211528206
+	QUAD $0x69956135febada11                           // .quad 7608094030047140369
+	QUAD $0x847c9b5d7c2e09b7                           // .quad -8900067937773286985
+	QUAD $0x43fab9837e699095                           // .quad 4898431519131537557
+	QUAD $0xa59bc234db398c25                           // .quad -6513398903789220827
+	QUAD $0x94f967e45e03f4bb                           // .quad -7712018656367741765
+	QUAD $0xcf02b2c21207ef2e                           // .quad -3530062611309138130
+	QUAD $0x1d1be0eebac278f5                           // .quad 2097517367411243253
+	QUAD $0x8161afb94b44f57d                           // .quad -9123818159709293187
+	QUAD $0x6462d92a69731732                           // .quad 7233582727691441970
+	QUAD $0xa1ba1ba79e1632dc                           // .quad -6793086681209228580
+	QUAD $0x7d7b8f7503cfdcfe                           // .quad 9041978409614302462
+	QUAD $0xca28a291859bbf93                           // .quad -3879672333084147821
+	QUAD $0x5cda735244c3d43e                           // .quad 6690786993590490174
+	QUAD $0xfcb2cb35e702af78                           // .quad -237904397927796872
+	QUAD $0x3a0888136afa64a7                           // .quad 4181741870994056359
+	QUAD $0x9defbf01b061adab                           // .quad -7066219276345954901
+	QUAD $0x088aaa1845b8fdd0                           // .quad 615491320315182544
+	QUAD $0xc56baec21c7a1916                           // .quad -4221088077005055722
+	QUAD $0x8aad549e57273d45                           // .quad -8454007886460797627
+	QUAD $0xf6c69a72a3989f5b                           // .quad -664674077828931749
+	QUAD $0x36ac54e2f678864b                           // .quad 3939617107816777291
+	QUAD $0x9a3c2087a63f6399                           // .quad -7332950326284164199
+	QUAD $0x84576a1bb416a7dd                           // .quad -8910536670511192099
+	QUAD $0xc0cb28a98fcf3c7f                           // .quad -4554501889427817345
+	QUAD $0x656d44a2a11c51d5                           // .quad 7308573235570561493
+	QUAD $0xf0fdf2d3f3c30b9f                           // .quad -1081441343357383777
+	QUAD $0x9f644ae5a4b1b325                           // .quad -6961356773836868827
+	QUAD $0x969eb7c47859e743                           // .quad -7593429867239446717
+	QUAD $0x873d5d9f0dde1fee                           // .quad -8701695967296086034
+	QUAD $0xbc4665b596706114                           // .quad -4880101315621920492
+	QUAD $0xa90cb506d155a7ea                           // .quad -6265433940692719638
+	QUAD $0xeb57ff22fc0c7959                           // .quad -1488440626100012711
+	QUAD $0x09a7f12442d588f2                           // .quad 695789805494438130
+	QUAD $0x9316ff75dd87cbd8                           // .quad -7847804418953589800
+	QUAD $0x0c11ed6d538aeb2f                           // .quad 869737256868047663
+	QUAD $0xb7dcbf5354e9bece                           // .quad -5198069505264599346
+	QUAD $0x8f1668c8a86da5fa                           // .quad -8136200465769716230
+	QUAD $0xe5d3ef282a242e81                           // .quad -1885900863153361279
+	QUAD $0xf96e017d694487bc                           // .quad -473439272678684740
+	QUAD $0x8fa475791a569d10                           // .quad -8096217067111932656
+	QUAD $0x37c981dcc395a9ac                           // .quad 4019886927579031980
+	QUAD $0xb38d92d760ec4455                           // .quad -5508585315462527915
+	QUAD $0x85bbe253f47b1417                           // .quad -8810199395808373737
+	QUAD $0xe070f78d3927556a                           // .quad -2274045625900771990
+	QUAD $0x93956d7478ccec8e                           // .quad -7812217631593927538
+	QUAD $0x8c469ab843b89562                           // .quad -8338807543829064350
+	QUAD $0x387ac8d1970027b2                           // .quad 4069786015789754290
+	QUAD $0xaf58416654a6babb                           // .quad -5811823411358942533
+	QUAD $0x06997b05fcc0319e                           // .quad 475546501309804958
+	QUAD $0xdb2e51bfe9d0696a                           // .quad -2653093245771290262
+	QUAD $0x441fece3bdf81f03                           // .quad 4908902581746016003
+	QUAD $0x88fcf317f22241e2                           // .quad -8575712306248138270
+	QUAD $0xd527e81cad7626c3                           // .quad -3087243809672255805
+	QUAD $0xab3c2fddeeaad25a                           // .quad -6107954364382784934
+	QUAD $0x8a71e223d8d3b074                           // .quad -8470740780517707660
+	QUAD $0xd60b3bd56a5586f1                           // .quad -3023256937051093263
+	QUAD $0xf6872d5667844e49                           // .quad -682526969396179383
+	QUAD $0x85c7056562757456                           // .quad -8807064613298015146
+	QUAD $0xb428f8ac016561db                           // .quad -5464844730172612133
+	QUAD $0xa738c6bebb12d16c                           // .quad -6397144748195131028
+	QUAD $0xe13336d701beba52                           // .quad -2219369894288377262
+	QUAD $0xd106f86e69d785c7                           // .quad -3384744916816525881
+	QUAD $0xecc0024661173473                           // .quad -1387106183930235789
+	QUAD $0x82a45b450226b39c                           // .quad -9032994600651410532
+	QUAD $0x27f002d7f95d0190                           // .quad 2877803288514593168
+	QUAD $0xa34d721642b06084                           // .quad -6679557232386875260
+	QUAD $0x31ec038df7b441f4                           // .quad 3597254110643241460
+	QUAD $0xcc20ce9bd35c78a5                           // .quad -3737760522056206171
+	QUAD $0x7e67047175a15271                           // .quad 9108253656731439729
+	QUAD $0xff290242c83396ce                           // .quad -60514634142869810
+	QUAD $0x0f0062c6e984d386                           // .quad 1080972517029761926
+	QUAD $0x9f79a169bd203e41                           // .quad -6955350673980375487
+	QUAD $0x52c07b78a3e60868                           // .quad 5962901664714590312
+	QUAD $0xc75809c42c684dd1                           // .quad -4082502324048081455
+	QUAD $0xa7709a56ccdf8a82                           // .quad -6381430974388925822
+	QUAD $0xf92e0c3537826145                           // .quad -491441886632713915
+	QUAD $0x88a66076400bb691                           // .quad -8600080377420466543
+	QUAD $0x9bbcc7a142b17ccb                           // .quad -7224680206786528053
+	QUAD $0x6acff893d00ea435                           // .quad 7696643601933968437
+	QUAD $0xc2abf989935ddbfe                           // .quad -4419164240055772162
+	QUAD $0x0583f6b8c4124d43                           // .quad 397432465562684739
+	QUAD $0xf356f7ebf83552fe                           // .quad -912269281642327298
+	QUAD $0xc3727a337a8b704a                           // .quad -4363290727450709942
+	QUAD $0x98165af37b2153de                           // .quad -7487697328667536418
+	QUAD $0x744f18c0592e4c5c                           // .quad 8380944645968776284
+	QUAD $0xbe1bf1b059e9a8d6                           // .quad -4747935642407032618
+	QUAD $0x1162def06f79df73                           // .quad 1252808770606194547
+	QUAD $0xeda2ee1c7064130c                           // .quad -1323233534581402868
+	QUAD $0x8addcb5645ac2ba8                           // .quad -8440366555225904216
+	QUAD $0x9485d4d1c63e8be7                           // .quad -7744549986754458649
+	QUAD $0x6d953e2bd7173692                           // .quad 7896285879677171346
+	QUAD $0xb9a74a0637ce2ee1                           // .quad -5069001465015685407
+	QUAD $0xc8fa8db6ccdd0437                           // .quad -3964700705685699529
+	QUAD $0xe8111c87c5c1ba99                           // .quad -1724565812842218855
+	QUAD $0x1d9c9892400a22a2                           // .quad 2133748077373825698
+	QUAD $0x910ab1d4db9914a0                           // .quad -7995382660667468640
+	QUAD $0x2503beb6d00cab4b                           // .quad 2667185096717282123
+	QUAD $0xb54d5e4a127f59c8                           // .quad -5382542307406947896
+	QUAD $0x2e44ae64840fd61d                           // .quad 3333981370896602653
+	QUAD $0xe2a0b5dc971f303a                           // .quad -2116491865831296966
+	QUAD $0x5ceaecfed289e5d2                           // .quad 6695424375237764562
+	QUAD $0x8da471a9de737e24                           // .quad -8240336443785642460
+	QUAD $0x7425a83e872c5f47                           // .quad 8369280469047205703
+	QUAD $0xb10d8e1456105dad                           // .quad -5688734536304665171
+	QUAD $0xd12f124e28f77719                           // .quad -3373457468973156583
+	QUAD $0xdd50f1996b947518                           // .quad -2499232151953443560
+	QUAD $0x82bd6b70d99aaa6f                           // .quad -9025939945749304721
+	QUAD $0x8a5296ffe33cc92f                           // .quad -8479549122611984081
+	QUAD $0x636cc64d1001550b                           // .quad 7164319141522920715
+	QUAD $0xace73cbfdc0bfb7b                           // .quad -5987750384837592197
+	QUAD $0x3c47f7e05401aa4e                           // .quad 4343712908476262990
+	QUAD $0xd8210befd30efa5a                           // .quad -2873001962619602342
+	QUAD $0x65acfaec34810a71                           // .quad 7326506586225052273
+	QUAD $0x8714a775e3e95c78                           // .quad -8713155254278333320
+	QUAD $0x7f1839a741a14d0d                           // .quad 9158133232781315341
+	QUAD $0xa8d9d1535ce3b396                           // .quad -6279758049420528746
+	QUAD $0x1ede48111209a050                           // .quad 2224294504121868368
+	QUAD $0xd31045a8341ca07c                           // .quad -3238011543348273028
+	QUAD $0x934aed0aab460432                           // .quad -7833187971778608078
+	QUAD $0x83ea2b892091e44d                           // .quad -8941286242233752499
+	QUAD $0xf81da84d5617853f                           // .quad -568112927868484289
+	QUAD $0xa4e4b66b68b65d60                           // .quad -6564921784364802720
+	QUAD $0x36251260ab9d668e                           // .quad 3901544858591782542
+	QUAD $0xce1de40642e3f4b9                           // .quad -3594466212028615495
+	QUAD $0xc1d72b7c6b426019                           // .quad -4479063491021217767
+	QUAD $0x80d2ae83e9ce78f3                           // .quad -9164070410158966541
+	QUAD $0xb24cf65b8612f81f                           // .quad -5598829363776522209
+	QUAD $0xa1075a24e4421730                           // .quad -6843401994271320272
+	QUAD $0xdee033f26797b627                           // .quad -2386850686293264857
+	QUAD $0xc94930ae1d529cfc                           // .quad -3942566474411762436
+	QUAD $0x169840ef017da3b1                           // .quad 1628122660560806833
+	QUAD $0xfb9b7cd9a4a7443c                           // .quad -316522074587315140
+	QUAD $0x8e1f289560ee864e                           // .quad -8205795374004271538
+	QUAD $0x9d412e0806e88aa5                           // .quad -7115355324258153819
+	QUAD $0xf1a6f2bab92a27e2                           // .quad -1033872180650563614
+	QUAD $0xc491798a08a2ad4e                           // .quad -4282508136895304370
+	QUAD $0xae10af696774b1db                           // .quad -5904026244240592421
+	QUAD $0xf5b5d7ec8acb58a2                           // .quad -741449152691742558
+	QUAD $0xacca6da1e0a8ef29                           // .quad -5995859411864064215
+	QUAD $0x9991a6f3d6bf1765                           // .quad -7380934748073420955
+	QUAD $0x17fd090a58d32af3                           // .quad 1728547772024695539
+	QUAD $0xbff610b0cc6edd3f                           // .quad -4614482416664388289
+	QUAD $0xddfc4b4cef07f5b0                           // .quad -2451001303396518480
+	QUAD $0xeff394dcff8a948e                           // .quad -1156417002403097458
+	QUAD $0x4abdaf101564f98e                           // .quad 5385653213018257806
+	QUAD $0x95f83d0a1fb69cd9                           // .quad -7640289654143017767
+	QUAD $0x9d6d1ad41abe37f1                           // .quad -7102991539009341455
+	QUAD $0xbb764c4ca7a4440f                           // .quad -4938676049251384305
+	QUAD $0x84c86189216dc5ed                           // .quad -8878739423761676819
+	QUAD $0xea53df5fd18d5513                           // .quad -1561659043136842477
+	QUAD $0x32fd3cf5b4e49bb4                           // .quad 3674159897003727796
+	QUAD $0x92746b9be2f8552c                           // .quad -7893565929601608404
+	QUAD $0x3fbc8c33221dc2a1                           // .quad 4592699871254659745
+	QUAD $0xb7118682dbb66a77                           // .quad -5255271393574622601
+	QUAD $0x0fabaf3feaa5334a                           // .quad 1129188820640936778
+	QUAD $0xe4d5e82392a40515                           // .quad -1957403223540890347
+	QUAD $0x29cb4d87f2a7400e                           // .quad 3011586022114279438
+	QUAD $0x8f05b1163ba6832d                           // .quad -8140906042354138323
+	QUAD $0x743e20e9ef511012                           // .quad 8376168546070237202
+	QUAD $0xb2c71d5bca9023f8                           // .quad -5564446534515285000
+	QUAD $0x914da9246b255416                           // .quad -7976533391121755114
+	QUAD $0xdf78e4b2bd342cf6                           // .quad -2343872149716718346
+	QUAD $0x1ad089b6c2f7548e                           // .quad 1932195658189984910
+	QUAD $0x8bab8eefb6409c1a                           // .quad -8382449121214030822
+	QUAD $0xa184ac2473b529b1                           // .quad -6808127464117294671
+	QUAD $0xae9672aba3d0c320                           // .quad -5866375383090150624
+	QUAD $0xc9e5d72d90a2741e                           // .quad -3898473311719230434
+	QUAD $0xda3c0f568cc4f3e8                           // .quad -2721283210435300376
+	QUAD $0x7e2fa67c7a658892                           // .quad 9092669226243950738
+	QUAD $0x8865899617fb1871                           // .quad -8618331034163144591
+	QUAD $0xddbb901b98feeab7                           // .quad -2469221522477225289
+	QUAD $0xaa7eebfb9df9de8d                           // .quad -6161227774276542835
+	QUAD $0x552a74227f3ea565                           // .quad 6136845133758244197
+	QUAD $0xd51ea6fa85785631                           // .quad -3089848699418290639
+	QUAD $0xd53a88958f87275f                           // .quad -3082000819042179233
+	QUAD $0x8533285c936b35de                           // .quad -8848684464777513506
+	QUAD $0x8a892abaf368f137                           // .quad -8464187042230111945
+	QUAD $0xa67ff273b8460356                           // .quad -6449169562544503978
+	QUAD $0x2d2b7569b0432d85                           // .quad 3254824252494523781
+	QUAD $0xd01fef10a657842c                           // .quad -3449775934753242068
+	QUAD $0x9c3b29620e29fc73                           // .quad -7189106879045698445
+	QUAD $0x8213f56a67f6b29b                           // .quad -9073638986861858149
+	QUAD $0x8349f3ba91b47b8f                           // .quad -8986383598807123057
+	QUAD $0xa298f2c501f45f42                           // .quad -6730362715149934782
+	QUAD $0x241c70a936219a73                           // .quad 2602078556773259891
+	QUAD $0xcb3f2f7642717713                           // .quad -3801267375510030573
+	QUAD $0xed238cd383aa0110                           // .quad -1359087822460813040
+	QUAD $0xfe0efb53d30dd4d7                           // .quad -139898200960150313
+	QUAD $0xf4363804324a40aa                           // .quad -849429889038008150
+	QUAD $0x9ec95d1463e8a506                           // .quad -7004965403241175802
+	QUAD $0xb143c6053edcd0d5                           // .quad -5673473379724898091
+	QUAD $0xc67bb4597ce2ce48                           // .quad -4144520735624081848
+	QUAD $0xdd94b7868e94050a                           // .quad -2480155706228734710
+	QUAD $0xf81aa16fdc1b81da                           // .quad -568964901102714406
+	QUAD $0xca7cf2b4191c8326                           // .quad -3855940325606653146
+	QUAD $0x9b10a4e5e9913128                           // .quad -7273132090830278360
+	QUAD $0xfd1c2f611f63a3f0                           // .quad -208239388580928528
+	QUAD $0xc1d4ce1f63f57d72                           // .quad -4479729095110460046
+	QUAD $0xbc633b39673c8cec                           // .quad -4871985254153548564
+	QUAD $0xf24a01a73cf2dccf                           // .quad -987975350460687153
+	QUAD $0xd5be0503e085d813                           // .quad -3044990783845967853
+	QUAD $0x976e41088617ca01                           // .quad -7535013621679011327
+	QUAD $0x4b2d8644d8a74e18                           // .quad 5417133557047315992
+	QUAD $0xbd49d14aa79dbc82                           // .quad -4807081008671376254
+	QUAD $0xddf8e7d60ed1219e                           // .quad -2451955090545630818
+	QUAD $0xec9c459d51852ba2                           // .quad -1397165242411832414
+	QUAD $0xcabb90e5c942b503                           // .quad -3838314940804713213
+	QUAD $0x93e1ab8252f33b45                           // .quad -7790757304148477115
+	QUAD $0x3d6a751f3b936243                           // .quad 4425478360848884291
+	QUAD $0xb8da1662e7b00a17                           // .quad -5126760611758208489
+	QUAD $0x0cc512670a783ad4                           // .quad 920161932633717460
+	QUAD $0xe7109bfba19c0c9d                           // .quad -1796764746270372707
+	QUAD $0x27fb2b80668b24c5                           // .quad 2880944217109767365
+	QUAD $0x906a617d450187e2                           // .quad -8040506994060064798
+	QUAD $0xb1f9f660802dedf6                           // .quad -5622191765467566602
+	QUAD $0xb484f9dc9641e9da                           // .quad -5438947724147693094
+	QUAD $0x5e7873f8a0396973                           // .quad 6807318348447705459
+	QUAD $0xe1a63853bbd26451                           // .quad -2186998636757228463
+	QUAD $0xdb0b487b6423e1e8                           // .quad -2662955059861265944
+	QUAD $0x8d07e33455637eb2                           // .quad -8284403175614349646
+	QUAD $0x91ce1a9a3d2cda62                           // .quad -7940379843253970334
+	QUAD $0xb049dc016abc5e5f                           // .quad -5743817951090549153
+	QUAD $0x7641a140cc7810fb                           // .quad 8521269269642088699
+	QUAD $0xdc5c5301c56b75f7                           // .quad -2568086420435798537
+	QUAD $0xa9e904c87fcb0a9d                           // .quad -6203421752542164323
+	QUAD $0x89b9b3e11b6329ba                           // .quad -8522583040413455942
+	QUAD $0x546345fa9fbdcd44                           // .quad 6080780864604458308
+	QUAD $0xac2820d9623bf429                           // .quad -6041542782089432023
+	QUAD $0xa97c177947ad4095                           // .quad -6234081974526590827
+	QUAD $0xd732290fbacaf133                           // .quad -2940242459184402125
+	QUAD $0x49ed8eabcccc485d                           // .quad 5327070802775656541
+	QUAD $0x867f59a9d4bed6c0                           // .quad -8755180564631333184
+	QUAD $0x5c68f256bfff5a74                           // .quad 6658838503469570676
+	QUAD $0xa81f301449ee8c70                           // .quad -6332289687361778576
+	QUAD $0x73832eec6fff3111                           // .quad 8323548129336963345
+	QUAD $0xd226fc195c6a2f8c                           // .quad -3303676090774835316
+	QUAD $0xc831fd53c5ff7eab                           // .quad -4021154456019173717
+	QUAD $0x83585d8fd9c25db7                           // .quad -8982326584375353929
+	QUAD $0xba3e7ca8b77f5e55                           // .quad -5026443070023967147
+	QUAD $0xa42e74f3d032f525                           // .quad -6616222212041804507
+	QUAD $0x28ce1bd2e55f35eb                           // .quad 2940318199324816875
+	QUAD $0xcd3a1230c43fb26f                           // .quad -3658591746624867729
+	QUAD $0x7980d163cf5b81b3                           // .quad 8755227902219092403
+	QUAD $0x80444b5e7aa7cf85                           // .quad -9204148869281624187
+	QUAD $0xd7e105bcc332621f                           // .quad -2891023177508298209
+	QUAD $0xa0555e361951c366                           // .quad -6893500068174642330
+	QUAD $0x8dd9472bf3fefaa7                           // .quad -8225464990312760665
+	QUAD $0xc86ab5c39fa63440                           // .quad -4005189066790915008
+	QUAD $0xb14f98f6f0feb951                           // .quad -5670145219463562927
+	QUAD $0xfa856334878fc150                           // .quad -394800315061255856
+	QUAD $0x6ed1bf9a569f33d3                           // .quad 7985374283903742931
+	QUAD $0x9c935e00d4b9d8d2                           // .quad -7164279224554366766
+	QUAD $0x0a862f80ec4700c8                           // .quad 758345818024902856
+	QUAD $0xc3b8358109e84f07                           // .quad -4343663012265570553
+	QUAD $0xcd27bb612758c0fa                           // .quad -3663753745896259334
+	QUAD $0xf4a642e14c6262c8                           // .quad -817892746904575288
+	QUAD $0x8038d51cb897789c                           // .quad -9207375118826243940
+	QUAD $0x98e7e9cccfbd7dbd                           // .quad -7428711994456441411
+	QUAD $0xe0470a63e6bd56c3                           // .quad -2285846861678029117
+	QUAD $0xbf21e44003acdd2c                           // .quad -4674203974643163860
+	QUAD $0x1858ccfce06cac74                           // .quad 1754377441329851508
+	QUAD $0xeeea5d5004981478                           // .quad -1231068949876566920
+	QUAD $0x0f37801e0c43ebc8                           // .quad 1096485900831157192
+	QUAD $0x95527a5202df0ccb                           // .quad -7686947121313936181
+	QUAD $0xd30560258f54e6ba                           // .quad -3241078642388441414
+	QUAD $0xbaa718e68396cffd                           // .quad -4996997883215032323
+	QUAD $0x47c6b82ef32a2069                           // .quad 5172023733869224041
+	QUAD $0xe950df20247c83fd                           // .quad -1634561335591402499
+	QUAD $0x4cdc331d57fa5441                           // .quad 5538357842881958977
+	QUAD $0x91d28b7416cdd27e                           // .quad -7939129862385708418
+	QUAD $0xe0133fe4adf8e952                           // .quad -2300424733252327086
+	QUAD $0xb6472e511c81471d                           // .quad -5312226309554747619
+	QUAD $0x58180fddd97723a6                           // .quad 6347841120289366950
+	QUAD $0xe3d8f9e563a198e5                           // .quad -2028596868516046619
+	QUAD $0x570f09eaa7ea7648                           // .quad 6273243709394548296
+	QUAD $0x8e679c2f5e44ff8f                           // .quad -8185402070463610993
+	QUAD $0x2cd2cc6551e513da                           // .quad 3229868618315797466
+	QUAD $0xb201833b35d63f73                           // .quad -5620066569652125837
+	QUAD $0xf8077f7ea65e58d1                           // .quad -574350245532641071
+	QUAD $0xde81e40a034bcf4f                           // .quad -2413397193637769393
+	QUAD $0xfb04afaf27faf782                           // .quad -358968903457900670
+	QUAD $0x8b112e86420f6191                           // .quad -8425902273664687727
+	QUAD $0x79c5db9af1f9b563                           // .quad 8774660907532399971
+	QUAD $0xadd57a27d29339f6                           // .quad -5920691823653471754
+	QUAD $0x18375281ae7822bc                           // .quad 1744954097560724156
+	QUAD $0xd94ad8b1c7380874                           // .quad -2789178761139451788
+	QUAD $0x8f2293910d0b15b5                           // .quad -8132775725879323211
+	QUAD $0x87cec76f1c830548                           // .quad -8660765753353239224
+	QUAD $0xb2eb3875504ddb22                           // .quad -5554283638921766110
+	QUAD $0xa9c2794ae3a3c69a                           // .quad -6214271173264161126
+	QUAD $0x5fa60692a46151eb                           // .quad 6892203506629956075
+	QUAD $0xd433179d9c8cb841                           // .quad -3156152948152813503
+	QUAD $0xdbc7c41ba6bcd333                           // .quad -2609901835997359309
+	QUAD $0x849feec281d7f328                           // .quad -8890124620236590296
+	QUAD $0x12b9b522906c0800                           // .quad 1349308723430688768
+	QUAD $0xa5c7ea73224deff3                           // .quad -6500969756868349965
+	QUAD $0xd768226b34870a00                           // .quad -2925050114139026944
+	QUAD $0xcf39e50feae16bef                           // .quad -3514526177658049553
+	QUAD $0xe6a1158300d46640                           // .quad -1828156321336891840
+	QUAD $0x81842f29f2cce375                           // .quad -9114107888677362827
+	QUAD $0x60495ae3c1097fd0                           // .quad 6938176635183661008
+	QUAD $0xa1e53af46f801c53                           // .quad -6780948842419315629
+	QUAD $0x385bb19cb14bdfc4                           // .quad 4061034775552188356
+	QUAD $0xca5e89b18b602368                           // .quad -3864500034596756632
+	QUAD $0x46729e03dd9ed7b5                           // .quad 5076293469440235445
+	QUAD $0xfcf62c1dee382c42                           // .quad -218939024818557886
+	QUAD $0x6c07a2c26a8346d1                           // .quad 7784369436827535057
+	QUAD $0x9e19db92b4e31ba9                           // .quad -7054365918152680535
+	QUAD $0xc7098b7305241885                           // .quad -4104596259247744891
+	QUAD $0xc5a05277621be293                           // .quad -4206271379263462765
+	QUAD $0xb8cbee4fc66d1ea7                           // .quad -5130745324059681113
+	QUAD $0xf70867153aa2db38                           // .quad -646153205651940552
+	QUAD $0x737f74f1dc043328                           // .quad 8322499218531169064
+	QUAD $0x9a65406d44a5c903                           // .quad -7321374781173544701
+	QUAD $0x505f522e53053ff2                           // .quad 5791438004736573426
+	QUAD $0xc0fe908895cf3b44                           // .quad -4540032458039542972
+	QUAD $0x647726b9e7c68fef                           // .quad 7239297505920716783
+	QUAD $0xf13e34aabb430a15                           // .quad -1063354554122040811
+	QUAD $0x5eca783430dc19f5                           // .quad 6830403950414141941
+	QUAD $0x96c6e0eab509e64d                           // .quad -7582125623967357363
+	QUAD $0xb67d16413d132072                           // .quad -5297053117264486286
+	QUAD $0xbc789925624c5fe0                           // .quad -4865971011531808800
+	QUAD $0xe41c5bd18c57e88f                           // .quad -2009630378153219953
+	QUAD $0xeb96bf6ebadf77d8                           // .quad -1470777745987373096
+	QUAD $0x8e91b962f7b6f159                           // .quad -8173548013986844327
+	QUAD $0x933e37a534cbaae7                           // .quad -7836765118883190041
+	QUAD $0x723627bbb5a4adb0                           // .quad 8229809056225996208
+	QUAD $0xb80dc58e81fe95a1                           // .quad -5184270380176599647
+	QUAD $0xcec3b1aaa30dd91c                           // .quad -3547796734999668452
+	QUAD $0xe61136f2227e3b09                           // .quad -1868651956793361655
+	QUAD $0x213a4f0aa5e8a7b1                           // .quad 2394313059052595121
+	QUAD $0x8fcac257558ee4e6                           // .quad -8085436500636932890
+	QUAD $0xa988e2cd4f62d19d                           // .quad -6230480713039031907
+	QUAD $0xb3bd72ed2af29e1f                           // .quad -5495109607368778209
+	QUAD $0x93eb1b80a33b8605                           // .quad -7788100891298789883
+	QUAD $0xe0accfa875af45a7                           // .quad -2257200990783584857
+	QUAD $0xbc72f130660533c3                           // .quad -4867563057061743677
+	QUAD $0x8c6c01c9498d8b88                           // .quad -8328279646880822392
+	QUAD $0xeb8fad7c7f8680b4                           // .quad -1472767802899791692
+	QUAD $0xaf87023b9bf0ee6a                           // .quad -5798663540173640086
+	QUAD $0xa67398db9f6820e1                           // .quad -6452645772052127519
+	QUAD $0xdb68c2ca82ed2a05                           // .quad -2636643406789662203
+	QUAD $0x88083f8943a1148c                           // .quad -8644589625959967604
+	QUAD $0x892179be91d43a43                           // .quad -8565431156884620733
+	QUAD $0x6a0a4f6b948959b0                           // .quad 7641007041259592112
+	QUAD $0xab69d82e364948d4                           // .quad -6095102927678388012
+	QUAD $0x848ce34679abb01c                           // .quad -8895485272135061476
+	QUAD $0xd6444e39c3db9b09                           // .quad -3007192641170597111
+	QUAD $0xf2d80e0c0c0b4e11                           // .quad -947992276657025519
+	QUAD $0x85eab0e41a6940e5                           // .quad -8797024428372705051
+	QUAD $0x6f8e118f0f0e2195                           // .quad 8038381691033493909
+	QUAD $0xa7655d1d2103911f                           // .quad -6384594517038493409
+	QUAD $0x4b7195f2d2d1a9fb                           // .quad 5436291095364479483
+	QUAD $0xd13eb46469447567                           // .quad -3369057127870728857
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+	// .p2align 4, 0x00
+_POW_TAB:
+	LONG $0x00000001 // .long 1
+	LONG $0x00000003 // .long 3
+	LONG $0x00000006 // .long 6
+	LONG $0x00000009 // .long 9
+	LONG $0x0000000d // .long 13
+	LONG $0x00000010 // .long 16
+	LONG $0x00000013 // .long 19
+	LONG $0x00000017 // .long 23
+	LONG $0x0000001a // .long 26
+
+	// .p2align 2, 0x00
+_MASK_USE_NUMBER:
+	LONG $0x00000002         // .long 2
+	QUAD $0x0000000000000000 // .p2align 4, 0x00
+
+_Digits:
+	QUAD $0x3330323031303030; QUAD $0x3730363035303430 // .ascii 16, '0001020304050607'
+	QUAD $0x3131303139303830; QUAD $0x3531343133313231 // .ascii 16, '0809101112131415'
+	QUAD $0x3931383137313631; QUAD $0x3332323231323032 // .ascii 16, '1617181920212223'
+	QUAD $0x3732363235323432; QUAD $0x3133303339323832 // .ascii 16, '2425262728293031'
+	QUAD $0x3533343333333233; QUAD $0x3933383337333633 // .ascii 16, '3233343536373839'
+	QUAD $0x3334323431343034; QUAD $0x3734363435343434 // .ascii 16, '4041424344454647'
+	QUAD $0x3135303539343834; QUAD $0x3535343533353235 // .ascii 16, '4849505152535455'
+	QUAD $0x3935383537353635; QUAD $0x3336323631363036 // .ascii 16, '5657585960616263'
+	QUAD $0x3736363635363436; QUAD $0x3137303739363836 // .ascii 16, '6465666768697071'
+	QUAD $0x3537343733373237; QUAD $0x3937383737373637 // .ascii 16, '7273747576777879'
+	QUAD $0x3338323831383038; QUAD $0x3738363835383438 // .ascii 16, '8081828384858687'
+	QUAD $0x3139303939383838; QUAD $0x3539343933393239 // .ascii 16, '8889909192939495'
+	QUAD $0x3939383937393639                           // .ascii 8, '96979899'
+	QUAD $0x0000000000000000                           // .p2align 4, 0x00
+
+_LB_cf971573: // _pow10_ceil_sig.g
+	QUAD $0xff77b1fcbebcdc4f // .quad -38366372719436721
+	QUAD $0x25e8e89c13bb0f7b // .quad 2731688931043774331
+	QUAD $0x9faacf3df73609b1 // .quad -6941508010590729807
+	QUAD $0x77b191618c54e9ad // .quad 8624834609543440813
+	QUAD $0xc795830d75038c1d // .quad -4065198994811024355
+	QUAD $0xd59df5b9ef6a2418 // .quad -3054014793352862696
+	QUAD $0xf97ae3d0d2446f25 // .quad -469812725086392539
+	QUAD $0x4b0573286b44ad1e // .quad 5405853545163697438
+	QUAD $0x9becce62836ac577 // .quad -7211161980820077193
+	QUAD $0x4ee367f9430aec33 // .quad 5684501474941004851
+	QUAD $0xc2e801fb244576d5 // .quad -4402266457597708587
+	QUAD $0x229c41f793cda740 // .quad 2493940825248868160
+	QUAD $0xf3a20279ed56d48a // .quad -891147053569747830
+	QUAD $0x6b43527578c11110 // .quad 7729112049988473104
+	QUAD $0x9845418c345644d6 // .quad -7474495936122174250
+	QUAD $0x830a13896b78aaaa // .quad -9004363024039368022
+	QUAD $0xbe5691ef416bd60c // .quad -4731433901725329908
+	QUAD $0x23cc986bc656d554 // .quad 2579604275232953684
+	QUAD $0xedec366b11c6cb8f // .quad -1302606358729274481
+	QUAD $0x2cbfbe86b7ec8aa9 // .quad 3224505344041192105
+	QUAD $0x94b3a202eb1c3f39 // .quad -7731658001846878407
+	QUAD $0x7bf7d71432f3d6aa // .quad 8932844867666826922
+	QUAD $0xb9e08a83a5e34f07 // .quad -5052886483881210105
+	QUAD $0xdaf5ccd93fb0cc54 // .quad -2669001970698630060
+	QUAD $0xe858ad248f5c22c9 // .quad -1704422086424124727
+	QUAD $0xd1b3400f8f9cff69 // .quad -3336252463373287575
+	QUAD $0x91376c36d99995be // .quad -7982792831656159810
+	QUAD $0x23100809b9c21fa2 // .quad 2526528228819083170
+	QUAD $0xb58547448ffffb2d // .quad -5366805021142811859
+	QUAD $0xabd40a0c2832a78b // .quad -6065211750830921845
+	QUAD $0xe2e69915b3fff9f9 // .quad -2096820258001126919
+	QUAD $0x16c90c8f323f516d // .quad 1641857348316123501
+	QUAD $0x8dd01fad907ffc3b // .quad -8228041688891786181
+	QUAD $0xae3da7d97f6792e4 // .quad -5891368184943504668
+	QUAD $0xb1442798f49ffb4a // .quad -5673366092687344822
+	QUAD $0x99cd11cfdf41779d // .quad -7364210231179380835
+	QUAD $0xdd95317f31c7fa1d // .quad -2480021597431793123
+	QUAD $0x40405643d711d584 // .quad 4629795266307937668
+	QUAD $0x8a7d3eef7f1cfc52 // .quad -8467542526035952558
+	QUAD $0x482835ea666b2573 // .quad 5199465050656154995
+	QUAD $0xad1c8eab5ee43b66 // .quad -5972742139117552794
+	QUAD $0xda3243650005eed0 // .quad -2724040723534582064
+	QUAD $0xd863b256369d4a40 // .quad -2854241655469553088
+	QUAD $0x90bed43e40076a83 // .quad -8016736922845615485
+	QUAD $0x873e4f75e2224e68 // .quad -8701430062309552536
+	QUAD $0x5a7744a6e804a292 // .quad 6518754469289960082
+	QUAD $0xa90de3535aaae202 // .quad -6265101559459552766
+	QUAD $0x711515d0a205cb37 // .quad 8148443086612450103
+	QUAD $0xd3515c2831559a83 // .quad -3219690930897053053
+	QUAD $0x0d5a5b44ca873e04 // .quad 962181821410786820
+	QUAD $0x8412d9991ed58091 // .quad -8929835859451740015
+	QUAD $0xe858790afe9486c3 // .quad -1704479370831952189
+	QUAD $0xa5178fff668ae0b6 // .quad -6550608805887287114
+	QUAD $0x626e974dbe39a873 // .quad 7092772823314835571
+	QUAD $0xce5d73ff402d98e3 // .quad -3576574988931720989
+	QUAD $0xfb0a3d212dc81290 // .quad -357406007711231344
+	QUAD $0x80fa687f881c7f8e // .quad -9152888395723407474
+	QUAD $0x7ce66634bc9d0b9a // .quad 8999993282035256218
+	QUAD $0xa139029f6a239f72 // .quad -6829424476226871438
+	QUAD $0x1c1fffc1ebc44e81 // .quad 2026619565689294465
+	QUAD $0xc987434744ac874e // .quad -3925094576856201394
+	QUAD $0xa327ffb266b56221 // .quad -6690097579743157727
+	QUAD $0xfbe9141915d7a922 // .quad -294682202642863838
+	QUAD $0x4bf1ff9f0062baa9 // .quad 5472436080603216553
+	QUAD $0x9d71ac8fada6c9b5 // .quad -7101705404292871755
+	QUAD $0x6f773fc3603db4aa // .quad 8031958568804398250
+	QUAD $0xc4ce17b399107c22 // .quad -4265445736938701790
+	QUAD $0xcb550fb4384d21d4 // .quad -3795109844276665900
+	QUAD $0xf6019da07f549b2b // .quad -720121152745989333
+	QUAD $0x7e2a53a146606a49 // .quad 9091170749936331337
+	QUAD $0x99c102844f94e0fb // .quad -7367604748107325189
+	QUAD $0x2eda7444cbfc426e // .quad 3376138709496513134
+	QUAD $0xc0314325637a1939 // .quad -4597819916706768583
+	QUAD $0xfa911155fefb5309 // .quad -391512631556746487
+	QUAD $0xf03d93eebc589f88 // .quad -1135588877456072824
+	QUAD $0x793555ab7eba27cb // .quad 8733981247408842699
+	QUAD $0x96267c7535b763b5 // .quad -7627272076051127371
+	QUAD $0x4bc1558b2f3458df // .quad 5458738279630526687
+	QUAD $0xbbb01b9283253ca2 // .quad -4922404076636521310
+	QUAD $0x9eb1aaedfb016f17 // .quad -7011635205744005353
+	QUAD $0xea9c227723ee8bcb // .quad -1541319077368263733
+	QUAD $0x465e15a979c1cadd // .quad 5070514048102157021
+	QUAD $0x92a1958a7675175f // .quad -7880853450996246689
+	QUAD $0x0bfacd89ec191eca // .quad 863228270850154186
+	QUAD $0xb749faed14125d36 // .quad -5239380795317920458
+	QUAD $0xcef980ec671f667c // .quad -3532650679864695172
+	QUAD $0xe51c79a85916f484 // .quad -1937539975720012668
+	QUAD $0x82b7e12780e7401b // .quad -9027499368258256869
+	QUAD $0x8f31cc0937ae58d2 // .quad -8128491512466089774
+	QUAD $0xd1b2ecb8b0908811 // .quad -3336344095947716591
+	QUAD $0xb2fe3f0b8599ef07 // .quad -5548928372155224313
+	QUAD $0x861fa7e6dcb4aa16 // .quad -8782116138362033642
+	QUAD $0xdfbdcece67006ac9 // .quad -2324474446766642487
+	QUAD $0x67a791e093e1d49b // .quad 7469098900757009563
+	QUAD $0x8bd6a141006042bd // .quad -8370325556870233411
+	QUAD $0xe0c8bb2c5c6d24e1 // .quad -2249342214667950879
+	QUAD $0xaecc49914078536d // .quad -5851220927660403859
+	QUAD $0x58fae9f773886e19 // .quad 6411694268519837209
+	QUAD $0xda7f5bf590966848 // .quad -2702340141148116920
+	QUAD $0xaf39a475506a899f // .quad -5820440219632367201
+	QUAD $0x888f99797a5e012d // .quad -8606491615858654931
+	QUAD $0x6d8406c952429604 // .quad 7891439908798240260
+	QUAD $0xaab37fd7d8f58178 // .quad -6146428501395930760
+	QUAD $0xc8e5087ba6d33b84 // .quad -3970758169284363388
+	QUAD $0xd5605fcdcf32e1d6 // .quad -3071349608317525546
+	QUAD $0xfb1e4a9a90880a65 // .quad -351761693178066331
+	QUAD $0x855c3be0a17fcd26 // .quad -8837122532839535322
+	QUAD $0x5cf2eea09a550680 // .quad 6697677969404790400
+	QUAD $0xa6b34ad8c9dfc06f // .quad -6434717147622031249
+	QUAD $0xf42faa48c0ea481f // .quad -851274575098787809
+	QUAD $0xd0601d8efc57b08b // .quad -3431710416100151157
+	QUAD $0xf13b94daf124da27 // .quad -1064093218873484761
+	QUAD $0x823c12795db6ce57 // .quad -9062348037703676329
+	QUAD $0x76c53d08d6b70859 // .quad 8558313775058847833
+	QUAD $0xa2cb1717b52481ed // .quad -6716249028702207507
+	QUAD $0x54768c4b0c64ca6f // .quad 6086206200396171887
+	QUAD $0xcb7ddcdda26da268 // .quad -3783625267450371480
+	QUAD $0xa9942f5dcf7dfd0a // .quad -6227300304786948854
+	QUAD $0xfe5d54150b090b02 // .quad -117845565885576446
+	QUAD $0xd3f93b35435d7c4d // .quad -3172439362556298163
+	QUAD $0x9efa548d26e5a6e1 // .quad -6991182506319567135
+	QUAD $0xc47bc5014a1a6db0 // .quad -4288617610811380304
+	QUAD $0xc6b8e9b0709f109a // .quad -4127292114472071014
+	QUAD $0x359ab6419ca1091c // .quad 3862600023340550428
+	QUAD $0xf867241c8cc6d4c0 // .quad -547429124662700864
+	QUAD $0xc30163d203c94b63 // .quad -4395122007679087773
+	QUAD $0x9b407691d7fc44f8 // .quad -7259672230555269896
+	QUAD $0x79e0de63425dcf1e // .quad 8782263791269039902
+	QUAD $0xc21094364dfb5636 // .quad -4462904269766699466
+	QUAD $0x985915fc12f542e5 // .quad -7468914334623251739
+	QUAD $0xf294b943e17a2bc4 // .quad -966944318780986428
+	QUAD $0x3e6f5b7b17b2939e // .quad 4498915137003099038
+	QUAD $0x979cf3ca6cec5b5a // .quad -7521869226879198374
+	QUAD $0xa705992ceecf9c43 // .quad -6411550076227838909
+	QUAD $0xbd8430bd08277231 // .quad -4790650515171610063
+	QUAD $0x50c6ff782a838354 // .quad 5820620459997365076
+	QUAD $0xece53cec4a314ebd // .quad -1376627125537124675
+	QUAD $0xa4f8bf5635246429 // .quad -6559282480285457367
+	QUAD $0x940f4613ae5ed136 // .quad -7777920981101784778
+	QUAD $0x871b7795e136be9a // .quad -8711237568605798758
+	QUAD $0xb913179899f68584 // .quad -5110715207949843068
+	QUAD $0x28e2557b59846e40 // .quad 2946011094524915264
+	QUAD $0xe757dd7ec07426e5 // .quad -1776707991509915931
+	QUAD $0x331aeada2fe589d0 // .quad 3682513868156144080
+	QUAD $0x9096ea6f3848984f // .quad -8027971522334779313
+	QUAD $0x3ff0d2c85def7622 // .quad 4607414176811284002
+	QUAD $0xb4bca50b065abe63 // .quad -5423278384491086237
+	QUAD $0x0fed077a756b53aa // .quad 1147581702586717098
+	QUAD $0xe1ebce4dc7f16dfb // .quad -2167411962186469893
+	QUAD $0xd3e8495912c62895 // .quad -3177208890193991531
+	QUAD $0x8d3360f09cf6e4bd // .quad -8272161504007625539
+	QUAD $0x64712dd7abbbd95d // .quad 7237616480483531101
+	QUAD $0xb080392cc4349dec // .quad -5728515861582144020
+	QUAD $0xbd8d794d96aacfb4 // .quad -4788037454677749836
+	QUAD $0xdca04777f541c567 // .quad -2548958808550292121
+	QUAD $0xecf0d7a0fc5583a1 // .quad -1373360799919799391
+	QUAD $0x89e42caaf9491b60 // .quad -8510628282985014432
+	QUAD $0xf41686c49db57245 // .quad -858350499949874619
+	QUAD $0xac5d37d5b79b6239 // .quad -6026599335303880135
+	QUAD $0x311c2875c522ced6 // .quad 3538747893490044630
+	QUAD $0xd77485cb25823ac7 // .quad -2921563150702462265
+	QUAD $0x7d633293366b828c // .quad 9035120885289943692
+	QUAD $0x86a8d39ef77164bc // .quad -8743505996830120772
+	QUAD $0xae5dff9c02033198 // .quad -5882264492762254952
+	QUAD $0xa8530886b54dbdeb // .quad -6317696477610263061
+	QUAD $0xd9f57f830283fdfd // .quad -2741144597525430787
+	QUAD $0xd267caa862a12d66 // .quad -3285434578585440922
+	QUAD $0xd072df63c324fd7c // .quad -3426430746906788484
+	QUAD $0x8380dea93da4bc60 // .quad -8970925639256982432
+	QUAD $0x4247cb9e59f71e6e // .quad 4776009810824339054
+	QUAD $0xa46116538d0deb78 // .quad -6601971030643840136
+	QUAD $0x52d9be85f074e609 // .quad 5970012263530423817
+	QUAD $0xcd795be870516656 // .quad -3640777769877412266
+	QUAD $0x67902e276c921f8c // .quad 7462515329413029772
+	QUAD $0x806bd9714632dff6 // .quad -9193015133814464522
+	QUAD $0x00ba1cd8a3db53b7 // .quad 52386062455755703
+	QUAD $0xa086cfcd97bf97f3 // .quad -6879582898840692749
+	QUAD $0x80e8a40eccd228a5 // .quad -9157889458785081179
+	QUAD $0xc8a883c0fdaf7df0 // .quad -3987792605123478032
+	QUAD $0x6122cd128006b2ce // .quad 6999382250228200142
+	QUAD $0xfad2a4b13d1b5d6c // .quad -373054737976959636
+	QUAD $0x796b805720085f82 // .quad 8749227812785250178
+	QUAD $0x9cc3a6eec6311a63 // .quad -7150688238876681629
+	QUAD $0xcbe3303674053bb1 // .quad -3755104653863994447
+	QUAD $0xc3f490aa77bd60fc // .quad -4326674280168464132
+	QUAD $0xbedbfc4411068a9d // .quad -4693880817329993059
+	QUAD $0xf4f1b4d515acb93b // .quad -796656831783192261
+	QUAD $0xee92fb5515482d45 // .quad -1255665003235103419
+	QUAD $0x991711052d8bf3c5 // .quad -7415439547505577019
+	QUAD $0x751bdd152d4d1c4b // .quad 8438581409832836171
+	QUAD $0xbf5cd54678eef0b6 // .quad -4657613415954583370
+	QUAD $0xd262d45a78a0635e // .quad -3286831292991118498
+	QUAD $0xef340a98172aace4 // .quad -1210330751515841308
+	QUAD $0x86fb897116c87c35 // .quad -8720225134666286027
+	QUAD $0x9580869f0e7aac0e // .quad -7673985747338482674
+	QUAD $0xd45d35e6ae3d4da1 // .quad -3144297699952734815
+	QUAD $0xbae0a846d2195712 // .quad -4980796165745715438
+	QUAD $0x8974836059cca10a // .quad -8542058143368306422
+	QUAD $0xe998d258869facd7 // .quad -1614309188754756393
+	QUAD $0x2bd1a438703fc94c // .quad 3157485376071780684
+	QUAD $0x91ff83775423cc06 // .quad -7926472270612804602
+	QUAD $0x7b6306a34627ddd0 // .quad 8890957387685944784
+	QUAD $0xb67f6455292cbf08 // .quad -5296404319838617848
+	QUAD $0x1a3bc84c17b1d543 // .quad 1890324697752655171
+	QUAD $0xe41f3d6a7377eeca // .quad -2008819381370884406
+	QUAD $0x20caba5f1d9e4a94 // .quad 2362905872190818964
+	QUAD $0x8e938662882af53e // .quad -8173041140997884610
+	QUAD $0x547eb47b7282ee9d // .quad 6088502188546649757
+	QUAD $0xb23867fb2a35b28d // .quad -5604615407819967859
+	QUAD $0xe99e619a4f23aa44 // .quad -1612744301171463612
+	QUAD $0xdec681f9f4c31f31 // .quad -2394083241347571919
+	QUAD $0x6405fa00e2ec94d5 // .quad 7207441660390446293
+	QUAD $0x8b3c113c38f9f37e // .quad -8413831053483314306
+	QUAD $0xde83bc408dd3dd05 // .quad -2412877989897052923
+	QUAD $0xae0b158b4738705e // .quad -5905602798426754978
+	QUAD $0x9624ab50b148d446 // .quad -7627783505798704058
+	QUAD $0xd98ddaee19068c76 // .quad -2770317479606055818
+	QUAD $0x3badd624dd9b0958 // .quad 4300328673033783640
+	QUAD $0x87f8a8d4cfa417c9 // .quad -8648977452394866743
+	QUAD $0xe54ca5d70a80e5d7 // .quad -1923980597781273129
+	QUAD $0xa9f6d30a038d1dbc // .quad -6199535797066195524
+	QUAD $0x5e9fcf4ccd211f4d // .quad 6818396289628184397
+	QUAD $0xd47487cc8470652b // .quad -3137733727905356501
+	QUAD $0x7647c32000696720 // .quad 8522995362035230496
+	QUAD $0x84c8d4dfd2c63f3b // .quad -8878612607581929669
+	QUAD $0x29ecd9f40041e074 // .quad 3021029092058325108
+	QUAD $0xa5fb0a17c777cf09 // .quad -6486579741050024183
+	QUAD $0xf468107100525891 // .quad -835399653354481519
+	QUAD $0xcf79cc9db955c2cc // .quad -3496538657885142324
+	QUAD $0x7182148d4066eeb5 // .quad 8179122470161673909
+	QUAD $0x81ac1fe293d599bf // .quad -9102865688819295809
+	QUAD $0xc6f14cd848405531 // .quad -4111420493003729615
+	QUAD $0xa21727db38cb002f // .quad -6766896092596731857
+	QUAD $0xb8ada00e5a506a7d // .quad -5139275616254662019
+	QUAD $0xca9cf1d206fdc03b // .quad -3846934097318526917
+	QUAD $0xa6d90811f0e4851d // .quad -6424094520318327523
+	QUAD $0xfd442e4688bd304a // .quad -196981603220770742
+	QUAD $0x908f4a166d1da664 // .quad -8030118150397909404
+	QUAD $0x9e4a9cec15763e2e // .quad -7040642529654063570
+	QUAD $0x9a598e4e043287ff // .quad -7324666853212387329
+	QUAD $0xc5dd44271ad3cdba // .quad -4189117143640191558
+	QUAD $0x40eff1e1853f29fe // .quad 4679224488766679550
+	QUAD $0xf7549530e188c128 // .quad -624710411122851544
+	QUAD $0xd12bee59e68ef47d // .quad -3374341425896426371
+	QUAD $0x9a94dd3e8cf578b9 // .quad -7307973034592864071
+	QUAD $0x82bb74f8301958cf // .quad -9026492418826348337
+	QUAD $0xc13a148e3032d6e7 // .quad -4523280274813692185
+	QUAD $0xe36a52363c1faf02 // .quad -2059743486678159614
+	QUAD $0xf18899b1bc3f8ca1 // .quad -1042414325089727327
+	QUAD $0xdc44e6c3cb279ac2 // .quad -2574679358347699518
+	QUAD $0x96f5600f15a7b7e5 // .quad -7569037980822161435
+	QUAD $0x29ab103a5ef8c0ba // .quad 3002511419460075706
+	QUAD $0xbcb2b812db11a5de // .quad -4849611457600313890
+	QUAD $0x7415d448f6b6f0e8 // .quad 8364825292752482536
+	QUAD $0xebdf661791d60f56 // .quad -1450328303573004458
+	QUAD $0x111b495b3464ad22 // .quad 1232659579085827362
+	QUAD $0x936b9fcebb25c995 // .quad -7823984217374209643
+	QUAD $0xcab10dd900beec35 // .quad -3841273781498745803
+	QUAD $0xb84687c269ef3bfb // .quad -5168294253290374149
+	QUAD $0x3d5d514f40eea743 // .quad 4421779809981343555
+	QUAD $0xe65829b3046b0afa // .quad -1848681798185579782
+	QUAD $0x0cb4a5a3112a5113 // .quad 915538744049291539
+	QUAD $0x8ff71a0fe2c2e6dc // .quad -8072955151507069220
+	QUAD $0x47f0e785eaba72ac // .quad 5183897733458195116
+	QUAD $0xb3f4e093db73a093 // .quad -5479507920956448621
+	QUAD $0x59ed216765690f57 // .quad 6479872166822743895
+	QUAD $0xe0f218b8d25088b8 // .quad -2237698882768172872
+	QUAD $0x306869c13ec3532d // .quad 3488154190101041965
+	QUAD $0x8c974f7383725573 // .quad -8316090829371189901
+	QUAD $0x1e414218c73a13fc // .quad 2180096368813151228
+	QUAD $0xafbd2350644eeacf // .quad -5783427518286599473
+	QUAD $0xe5d1929ef90898fb // .quad -1886565557410948869
+	QUAD $0xdbac6c247d62a583 // .quad -2617598379430861437
+	QUAD $0xdf45f746b74abf3a // .quad -2358206946763686086
+	QUAD $0x894bc396ce5da772 // .quad -8553528014785370254
+	QUAD $0x6b8bba8c328eb784 // .quad 7749492695127472004
+	QUAD $0xab9eb47c81f5114f // .quad -6080224000054324913
+	QUAD $0x066ea92f3f326565 // .quad 463493832054564197
+	QUAD $0xd686619ba27255a2 // .quad -2988593981640518238
+	QUAD $0xc80a537b0efefebe // .quad -4032318728359182658
+	QUAD $0x8613fd0145877585 // .quad -8785400266166405755
+	QUAD $0xbd06742ce95f5f37 // .quad -4826042214438183113
+	QUAD $0xa798fc4196e952e7 // .quad -6370064314280619289
+	QUAD $0x2c48113823b73705 // .quad 3190819268807046917
+	QUAD $0xd17f3b51fca3a7a0 // .quad -3350894374423386208
+	QUAD $0xf75a15862ca504c6 // .quad -623161932418579258
+	QUAD $0x82ef85133de648c4 // .quad -9011838011655698236
+	QUAD $0x9a984d73dbe722fc // .quad -7307005235402693892
+	QUAD $0xa3ab66580d5fdaf5 // .quad -6653111496142234891
+	QUAD $0xc13e60d0d2e0ebbb // .quad -4522070525825979461
+	QUAD $0xcc963fee10b7d1b3 // .quad -3704703351750405709
+	QUAD $0x318df905079926a9 // .quad 3570783879572301481
+	QUAD $0xffbbcfe994e5c61f // .quad -19193171260619233
+	QUAD $0xfdf17746497f7053 // .quad -148206168962011053
+	QUAD $0x9fd561f1fd0f9bd3 // .quad -6929524759678968877
+	QUAD $0xfeb6ea8bedefa634 // .quad -92628855601256908
+	QUAD $0xc7caba6e7c5382c8 // .quad -4050219931171323192
+	QUAD $0xfe64a52ee96b8fc1 // .quad -115786069501571135
+	QUAD $0xf9bd690a1b68637b // .quad -451088895536766085
+	QUAD $0x3dfdce7aa3c673b1 // .quad 4466953431550423985
+	QUAD $0x9c1661a651213e2d // .quad -7199459587351560659
+	QUAD $0x06bea10ca65c084f // .quad 486002885505321039
+	QUAD $0xc31bfa0fe5698db8 // .quad -4387638465762062920
+	QUAD $0x486e494fcff30a63 // .quad 5219189625309039203
+	QUAD $0xf3e2f893dec3f126 // .quad -872862063775190746
+	QUAD $0x5a89dba3c3efccfb // .quad 6523987031636299003
+	QUAD $0x986ddb5c6b3a76b7 // .quad -7463067817500576073
+	QUAD $0xf89629465a75e01d // .quad -534194123654701027
+	QUAD $0xbe89523386091465 // .quad -4717148753448332187
+	QUAD $0xf6bbb397f1135824 // .quad -667742654568376284
+	QUAD $0xee2ba6c0678b597f // .quad -1284749923383027329
+	QUAD $0x746aa07ded582e2d // .quad 8388693718644305453
+	QUAD $0x94db483840b717ef // .quad -7720497729755473937
+	QUAD $0xa8c2a44eb4571cdd // .quad -6286281471915778851
+	QUAD $0xba121a4650e4ddeb // .quad -5038936143766954517
+	QUAD $0x92f34d62616ce414 // .quad -7857851839894723564
+	QUAD $0xe896a0d7e51e1566 // .quad -1686984161281305242
+	QUAD $0x77b020baf9c81d18 // .quad 8624429273841147160
+	QUAD $0x915e2486ef32cd60 // .quad -7971894128441897632
+	QUAD $0x0ace1474dc1d122f // .quad 778582277723329071
+	QUAD $0xb5b5ada8aaff80b8 // .quad -5353181642124984136
+	QUAD $0x0d819992132456bb // .quad 973227847154161339
+	QUAD $0xe3231912d5bf60e6 // .quad -2079791034228842266
+	QUAD $0x10e1fff697ed6c6a // .quad 1216534808942701674
+	QUAD $0x8df5efabc5979c8f // .quad -8217398424034108273
+	QUAD $0xca8d3ffa1ef463c2 // .quad -3851351762838199358
+	QUAD $0xb1736b96b6fd83b3 // .quad -5660062011615247437
+	QUAD $0xbd308ff8a6b17cb3 // .quad -4814189703547749197
+	QUAD $0xddd0467c64bce4a0 // .quad -2463391496091671392
+	QUAD $0xac7cb3f6d05ddbdf // .quad -6017737129434686497
+	QUAD $0x8aa22c0dbef60ee4 // .quad -8457148712698376476
+	QUAD $0x6bcdf07a423aa96c // .quad 7768129340171790700
+	QUAD $0xad4ab7112eb3929d // .quad -5959749872445582691
+	QUAD $0x86c16c98d2c953c7 // .quad -8736582398494813241
+	QUAD $0xd89d64d57a607744 // .quad -2838001322129590460
+	QUAD $0xe871c7bf077ba8b8 // .quad -1697355961263740744
+	QUAD $0x87625f056c7c4a8b // .quad -8691279853972075893
+	QUAD $0x11471cd764ad4973 // .quad 1244995533423855987
+	QUAD $0xa93af6c6c79b5d2d // .quad -6252413799037706963
+	QUAD $0xd598e40d3dd89bd0 // .quad -3055441601647567920
+	QUAD $0xd389b47879823479 // .quad -3203831230369745799
+	QUAD $0x4aff1d108d4ec2c4 // .quad 5404070034795315908
+	QUAD $0x843610cb4bf160cb // .quad -8919923546622172981
+	QUAD $0xcedf722a585139bb // .quad -3539985255894009413
+	QUAD $0xa54394fe1eedb8fe // .quad -6538218414850328322
+	QUAD $0xc2974eb4ee658829 // .quad -4424981569867511767
+	QUAD $0xce947a3da6a9273e // .quad -3561087000135522498
+	QUAD $0x733d226229feea33 // .quad 8303831092947774003
+	QUAD $0x811ccc668829b887 // .quad -9143208402725783417
+	QUAD $0x0806357d5a3f5260 // .quad 578208414664970848
+	QUAD $0xa163ff802a3426a8 // .quad -6817324484979841368
+	QUAD $0xca07c2dcb0cf26f8 // .quad -3888925500096174344
+	QUAD $0xc9bcff6034c13052 // .quad -3909969587797413806
+	QUAD $0xfc89b393dd02f0b6 // .quad -249470856692830026
+	QUAD $0xfc2c3f3841f17c67 // .quad -275775966319379353
+	QUAD $0xbbac2078d443ace3 // .quad -4923524589293425437
+	QUAD $0x9d9ba7832936edc0 // .quad -7089889006590693952
+	QUAD $0xd54b944b84aa4c0e // .quad -3077202868308390898
+	QUAD $0xc5029163f384a931 // .quad -4250675239810979535
+	QUAD $0x0a9e795e65d4df12 // .quad 765182433041899282
+	QUAD $0xf64335bcf065d37d // .quad -701658031336336515
+	QUAD $0x4d4617b5ff4a16d6 // .quad 5568164059729762006
+	QUAD $0x99ea0196163fa42e // .quad -7356065297226292178
+	QUAD $0x504bced1bf8e4e46 // .quad 5785945546544795206
+	QUAD $0xc06481fb9bcf8d39 // .quad -4583395603105477319
+	QUAD $0xe45ec2862f71e1d7 // .quad -1990940103673781801
+	QUAD $0xf07da27a82c37088 // .quad -1117558485454458744
+	QUAD $0x5d767327bb4e5a4d // .quad 6734696907262548557
+	QUAD $0x964e858c91ba2655 // .quad -7616003081050118571
+	QUAD $0x3a6a07f8d510f870 // .quad 4209185567039092848
+	QUAD $0xbbe226efb628afea // .quad -4908317832885260310
+	QUAD $0x890489f70a55368c // .quad -8573576096483297652
+	QUAD $0xeadab0aba3b2dbe5 // .quad -1523711272679187483
+	QUAD $0x2b45ac74ccea842f // .quad 3118087934678041647
+	QUAD $0x92c8ae6b464fc96f // .quad -7869848573065574033
+	QUAD $0x3b0b8bc90012929e // .quad 4254647968387469982
+	QUAD $0xb77ada0617e3bbcb // .quad -5225624697904579637
+	QUAD $0x09ce6ebb40173745 // .quad 706623942056949573
+	QUAD $0xe55990879ddcaabd // .quad -1920344853953336643
+	QUAD $0xcc420a6a101d0516 // .quad -3728406090856200938
+	QUAD $0x8f57fa54c2a9eab6 // .quad -8117744561361917258
+	QUAD $0x9fa946824a12232e // .quad -6941939825212513490
+	QUAD $0xb32df8e9f3546564 // .quad -5535494683275008668
+	QUAD $0x47939822dc96abfa // .quad 5157633273766521850
+	QUAD $0xdff9772470297ebd // .quad -2307682335666372931
+	QUAD $0x59787e2b93bc56f8 // .quad 6447041592208152312
+	QUAD $0x8bfbea76c619ef36 // .quad -8359830487432564938
+	QUAD $0x57eb4edb3c55b65b // .quad 6335244004343789147
+	QUAD $0xaefae51477a06b03 // .quad -5838102090863318269
+	QUAD $0xede622920b6b23f2 // .quad -1304317031425039374
+	QUAD $0xdab99e59958885c4 // .quad -2685941595151759932
+	QUAD $0xe95fab368e45ecee // .quad -1630396289281299218
+	QUAD $0x88b402f7fd75539b // .quad -8596242524610931813
+	QUAD $0x11dbcb0218ebb415 // .quad 1286845328412881941
+	QUAD $0xaae103b5fcd2a881 // .quad -6133617137336276863
+	QUAD $0xd652bdc29f26a11a // .quad -3003129357911285478
+	QUAD $0xd59944a37c0752a2 // .quad -3055335403242958174
+	QUAD $0x4be76d3346f04960 // .quad 5469460339465668960
+	QUAD $0x857fcae62d8493a5 // .quad -8827113654667930715
+	QUAD $0x6f70a4400c562ddc // .quad 8030098730593431004
+	QUAD $0xa6dfbd9fb8e5b88e // .quad -6422206049907525490
+	QUAD $0xcb4ccd500f6bb953 // .quad -3797434642040374957
+	QUAD $0xd097ad07a71f26b2 // .quad -3416071543957018958
+	QUAD $0x7e2000a41346a7a8 // .quad 9088264752731695016
+	QUAD $0x825ecc24c873782f // .quad -9052573742614218705
+	QUAD $0x8ed400668c0c28c9 // .quad -8154892584824854327
+	QUAD $0xa2f67f2dfa90563b // .quad -6704031159840385477
+	QUAD $0x728900802f0f32fb // .quad 8253128342678483707
+	QUAD $0xcbb41ef979346bca // .quad -3768352931373093942
+	QUAD $0x4f2b40a03ad2ffba // .quad 5704724409920716730
+	QUAD $0xfea126b7d78186bc // .quad -98755145788979524
+	QUAD $0xe2f610c84987bfa9 // .quad -2092466524453879895
+	QUAD $0x9f24b832e6b0f436 // .quad -6979250993759194058
+	QUAD $0x0dd9ca7d2df4d7ca // .quad 998051431430019018
+	QUAD $0xc6ede63fa05d3143 // .quad -4112377723771604669
+	QUAD $0x91503d1c79720dbc // .quad -7975807747567252036
+	QUAD $0xf8a95fcf88747d94 // .quad -528786136287117932
+	QUAD $0x75a44c6397ce912b // .quad 8476984389250486571
+	QUAD $0x9b69dbe1b548ce7c // .quad -7248020362820530564
+	QUAD $0xc986afbe3ee11abb // .quad -3925256793573221701
+	QUAD $0xc24452da229b021b // .quad -4448339435098275301
+	QUAD $0xfbe85badce996169 // .quad -294884973539139223
+	QUAD $0xf2d56790ab41c2a2 // .quad -948738275445456222
+	QUAD $0xfae27299423fb9c4 // .quad -368606216923924028
+	QUAD $0x97c560ba6b0919a5 // .quad -7510490449794491995
+	QUAD $0xdccd879fc967d41b // .quad -2536221894791146469
+	QUAD $0xbdb6b8e905cb600f // .quad -4776427043815727089
+	QUAD $0x5400e987bbc1c921 // .quad 6053094668365842721
+	QUAD $0xed246723473e3813 // .quad -1358847786342270957
+	QUAD $0x290123e9aab23b69 // .quad 2954682317029915497
+	QUAD $0x9436c0760c86e30b // .quad -7766808894105001205
+	QUAD $0xf9a0b6720aaf6522 // .quad -459166561069996766
+	QUAD $0xb94470938fa89bce // .quad -5096825099203863602
+	QUAD $0xf808e40e8d5b3e6a // .quad -573958201337495958
+	QUAD $0xe7958cb87392c2c2 // .quad -1759345355577441598
+	QUAD $0xb60b1d1230b20e05 // .quad -5329133770099257851
+	QUAD $0x90bd77f3483bb9b9 // .quad -8017119874876982855
+	QUAD $0xb1c6f22b5e6f48c3 // .quad -5636551615525730109
+	QUAD $0xb4ecd5f01a4aa828 // .quad -5409713825168840664
+	QUAD $0x1e38aeb6360b1af4 // .quad 2177682517447613172
+	QUAD $0xe2280b6c20dd5232 // .quad -2150456263033662926
+	QUAD $0x25c6da63c38de1b1 // .quad 2722103146809516465
+	QUAD $0x8d590723948a535f // .quad -8261564192037121185
+	QUAD $0x579c487e5a38ad0f // .quad 6313000485183335695
+	QUAD $0xb0af48ec79ace837 // .quad -5715269221619013577
+	QUAD $0x2d835a9df0c6d852 // .quad 3279564588051781714
+	QUAD $0xdcdb1b2798182244 // .quad -2532400508596379068
+	QUAD $0xf8e431456cf88e66 // .quad -512230283362660762
+	QUAD $0x8a08f0f8bf0f156b // .quad -8500279345513818773
+	QUAD $0x1b8e9ecb641b5900 // .quad 1985699082112030976
+	QUAD $0xac8b2d36eed2dac5 // .quad -6013663163464885563
+	QUAD $0xe272467e3d222f40 // .quad -2129562165787349184
+	QUAD $0xd7adf884aa879177 // .quad -2905392935903719049
+	QUAD $0x5b0ed81dcc6abb10 // .quad 6561419329620589328
+	QUAD $0x86ccbb52ea94baea // .quad -8733399612580906262
+	QUAD $0x98e947129fc2b4ea // .quad -7428327965055601430
+	QUAD $0xa87fea27a539e9a5 // .quad -6305063497298744923
+	QUAD $0x3f2398d747b36225 // .quad 4549648098962661925
+	QUAD $0xd29fe4b18e88640e // .quad -3269643353196043250
+	QUAD $0x8eec7f0d19a03aae // .quad -8147997931578836306
+	QUAD $0x83a3eeeef9153e89 // .quad -8961056123388608887
+	QUAD $0x1953cf68300424ad // .quad 1825030320404309165
+	QUAD $0xa48ceaaab75a8e2b // .quad -6589634135808373205
+	QUAD $0x5fa8c3423c052dd8 // .quad 6892973918932774360
+	QUAD $0xcdb02555653131b6 // .quad -3625356651333078602
+	QUAD $0x3792f412cb06794e // .quad 4004531380238580046
+	QUAD $0x808e17555f3ebf11 // .quad -9183376934724255983
+	QUAD $0xe2bbd88bbee40bd1 // .quad -2108853905778275375
+	QUAD $0xa0b19d2ab70e6ed6 // .quad -6867535149977932074
+	QUAD $0x5b6aceaeae9d0ec5 // .quad 6587304654631931589
+	QUAD $0xc8de047564d20a8b // .quad -3972732919045027189
+	QUAD $0xf245825a5a445276 // .quad -989241218564861322
+	QUAD $0xfb158592be068d2e // .quad -354230130378896082
+	QUAD $0xeed6e2f0f0d56713 // .quad -1236551523206076653
+	QUAD $0x9ced737bb6c4183d // .quad -7138922859127891907
+	QUAD $0x55464dd69685606c // .quad 6144684325637283948
+	QUAD $0xc428d05aa4751e4c // .quad -4311967555482476980
+	QUAD $0xaa97e14c3c26b887 // .quad -6154202648235558777
+	QUAD $0xf53304714d9265df // .quad -778273425925708321
+	QUAD $0xd53dd99f4b3066a9 // .quad -3081067291867060567
+	QUAD $0x993fe2c6d07b7fab // .quad -7403949918844649557
+	QUAD $0xe546a8038efe402a // .quad -1925667057416912854
+	QUAD $0xbf8fdb78849a5f96 // .quad -4643251380128424042
+	QUAD $0xde98520472bdd034 // .quad -2407083821771141068
+	QUAD $0xef73d256a5c0f77c // .quad -1192378206733142148
+	QUAD $0x963e66858f6d4441 // .quad -7620540795641314239
+	QUAD $0x95a8637627989aad // .quad -7662765406849295699
+	QUAD $0xdde7001379a44aa9 // .quad -2456994988062127447
+	QUAD $0xbb127c53b17ec159 // .quad -4966770740134231719
+	QUAD $0x5560c018580d5d53 // .quad 6152128301777116499
+	QUAD $0xe9d71b689dde71af // .quad -1596777406740401745
+	QUAD $0xaab8f01e6e10b4a7 // .quad -6144897678060768089
+	QUAD $0x9226712162ab070d // .quad -7915514906853832947
+	QUAD $0xcab3961304ca70e9 // .quad -3840561048787980055
+	QUAD $0xb6b00d69bb55c8d1 // .quad -5282707615139903279
+	QUAD $0x3d607b97c5fd0d23 // .quad 4422670725869800739
+	QUAD $0xe45c10c42a2b3b05 // .quad -1991698500497491195
+	QUAD $0x8cb89a7db77c506b // .quad -8306719647944912789
+	QUAD $0x8eb98a7a9a5b04e3 // .quad -8162340590452013853
+	QUAD $0x77f3608e92adb243 // .quad 8643358275316593219
+	QUAD $0xb267ed1940f1c61c // .quad -5591239719637629412
+	QUAD $0x55f038b237591ed4 // .quad 6192511825718353620
+	QUAD $0xdf01e85f912e37a3 // .quad -2377363631119648861
+	QUAD $0x6b6c46dec52f6689 // .quad 7740639782147942025
+	QUAD $0x8b61313bbabce2c6 // .quad -8403381297090862394
+	QUAD $0x2323ac4b3b3da016 // .quad 2532056854628769814
+	QUAD $0xae397d8aa96c1b77 // .quad -5892540602936190089
+	QUAD $0xabec975e0a0d081b // .quad -6058300968568813541
+	QUAD $0xd9c7dced53c72255 // .quad -2753989735242849707
+	QUAD $0x96e7bd358c904a22 // .quad -7572876210711016926
+	QUAD $0x881cea14545c7575 // .quad -8638772612167862923
+	QUAD $0x7e50d64177da2e55 // .quad 9102010423587778133
+	QUAD $0xaa242499697392d2 // .quad -6186779746782440750
+	QUAD $0xdde50bd1d5d0b9ea // .quad -2457545025797441046
+	QUAD $0xd4ad2dbfc3d07787 // .quad -3121788665050663033
+	QUAD $0x955e4ec64b44e865 // .quad -7683617300674189211
+	QUAD $0x84ec3c97da624ab4 // .quad -8868646943297746252
+	QUAD $0xbd5af13bef0b113f // .quad -4802260812921368257
+	QUAD $0xa6274bbdd0fadd61 // .quad -6474122660694794911
+	QUAD $0xecb1ad8aeacdd58f // .quad -1391139997724322417
+	QUAD $0xcfb11ead453994ba // .quad -3480967307441105734
+	QUAD $0x67de18eda5814af3 // .quad 7484447039699372787
+	QUAD $0x81ceb32c4b43fcf4 // .quad -9093133594791772940
+	QUAD $0x80eacf948770ced8 // .quad -9157278655470055720
+	QUAD $0xa2425ff75e14fc31 // .quad -6754730975062328271
+	QUAD $0xa1258379a94d028e // .quad -6834912300910181746
+	QUAD $0xcad2f7f5359a3b3e // .quad -3831727700400522434
+	QUAD $0x096ee45813a04331 // .quad 679731660717048625
+	QUAD $0xfd87b5f28300ca0d // .quad -177973607073265139
+	QUAD $0x8bca9d6e188853fd // .quad -8373707460958465027
+	QUAD $0x9e74d1b791e07e48 // .quad -7028762532061872568
+	QUAD $0x775ea264cf55347e // .quad 8601490892183123070
+	QUAD $0xc612062576589dda // .quad -4174267146649952806
+	QUAD $0x95364afe032a819e // .quad -7694880458480647778
+	QUAD $0xf79687aed3eec551 // .quad -606147914885053103
+	QUAD $0x3a83ddbd83f52205 // .quad 4216457482181353989
+	QUAD $0x9abe14cd44753b52 // .quad -7296371474444240046
+	QUAD $0xc4926a9672793543 // .quad -4282243101277735613
+	QUAD $0xc16d9a0095928a27 // .quad -4508778324627912153
+	QUAD $0x75b7053c0f178294 // .quad 8482254178684994196
+	QUAD $0xf1c90080baf72cb1 // .quad -1024286887357502287
+	QUAD $0x5324c68b12dd6339 // .quad 5991131704928854841
+	QUAD $0x971da05074da7bee // .quad -7557708332239520786
+	QUAD $0xd3f6fc16ebca5e04 // .quad -3173071712060547580
+	QUAD $0xbce5086492111aea // .quad -4835449396872013078
+	QUAD $0x88f4bb1ca6bcf585 // .quad -8578025658503072379
+	QUAD $0xec1e4a7db69561a5 // .quad -1432625727662628443
+	QUAD $0x2b31e9e3d06c32e6 // .quad 3112525982153323238
+	QUAD $0x9392ee8e921d5d07 // .quad -7812920107430224633
+	QUAD $0x3aff322e62439fd0 // .quad 4251171748059520976
+	QUAD $0xb877aa3236a4b449 // .quad -5154464115860392887
+	QUAD $0x09befeb9fad487c3 // .quad 702278666647013315
+	QUAD $0xe69594bec44de15b // .quad -1831394126398103205
+	QUAD $0x4c2ebe687989a9b4 // .quad 5489534351736154548
+	QUAD $0x901d7cf73ab0acd9 // .quad -8062150356639896359
+	QUAD $0x0f9d37014bf60a11 // .quad 1125115960621402641
+	QUAD $0xb424dc35095cd80f // .quad -5466001927372482545
+	QUAD $0x538484c19ef38c95 // .quad 6018080969204141205
+	QUAD $0xe12e13424bb40e13 // .quad -2220816390788215277
+	QUAD $0x2865a5f206b06fba // .quad 2910915193077788602
+	QUAD $0x8cbccc096f5088cb // .quad -8305539271883716405
+	QUAD $0xf93f87b7442e45d4 // .quad -486521013540076076
+	QUAD $0xafebff0bcb24aafe // .quad -5770238071427257602
+	QUAD $0xf78f69a51539d749 // .quad -608151266925095095
+	QUAD $0xdbe6fecebdedd5be // .quad -2601111570856684098
+	QUAD $0xb573440e5a884d1c // .quad -5371875102083756772
+	QUAD $0x89705f4136b4a597 // .quad -8543223759426509417
+	QUAD $0x31680a88f8953031 // .quad 3560107088838733873
+	QUAD $0xabcc77118461cefc // .quad -6067343680855748868
+	QUAD $0xfdc20d2b36ba7c3e // .quad -161552157378970562
+	QUAD $0xd6bf94d5e57a42bc // .quad -2972493582642298180
+	QUAD $0x3d32907604691b4d // .quad 4409745821703674701
+	QUAD $0x8637bd05af6c69b5 // .quad -8775337516792518219
+	QUAD $0xa63f9a49c2c1b110 // .quad -6467280898289979120
+	QUAD $0xa7c5ac471b478423 // .quad -6357485877563259869
+	QUAD $0x0fcf80dc33721d54 // .quad 1139270913992301908
+	QUAD $0xd1b71758e219652b // .quad -3335171328526686933
+	QUAD $0xd3c36113404ea4a9 // .quad -3187597375937010519
+	QUAD $0x83126e978d4fdf3b // .quad -9002011107970261189
+	QUAD $0x645a1cac083126ea // .quad 7231123676894144234
+	QUAD $0xa3d70a3d70a3d70a // .quad -6640827866535438582
+	QUAD $0x3d70a3d70a3d70a4 // .quad 4427218577690292388
+	QUAD $0xcccccccccccccccc // .quad -3689348814741910324
+	QUAD $0xcccccccccccccccd // .quad -3689348814741910323
+	QUAD $0x8000000000000000 // .quad -9223372036854775808
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xa000000000000000 // .quad -6917529027641081856
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xc800000000000000 // .quad -4035225266123964416
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xfa00000000000000 // .quad -432345564227567616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x9c40000000000000 // .quad -7187745005283311616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xc350000000000000 // .quad -4372995238176751616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xf424000000000000 // .quad -854558029293551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x9896800000000000 // .quad -7451627795949551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xbebc200000000000 // .quad -4702848726509551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xee6b280000000000 // .quad -1266874889709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x9502f90000000000 // .quad -7709325833709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xba43b74000000000 // .quad -5024971273709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xe8d4a51000000000 // .quad -1669528073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x9184e72a00000000 // .quad -7960984073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xb5e620f480000000 // .quad -5339544073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xe35fa931a0000000 // .quad -2062744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x8e1bc9bf04000000 // .quad -8206744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xb1a2bc2ec5000000 // .quad -5646744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xde0b6b3a76400000 // .quad -2446744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x8ac7230489e80000 // .quad -8446744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xad78ebc5ac620000 // .quad -5946744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xd8d726b7177a8000 // .quad -2821744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x878678326eac9000 // .quad -8681119073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xa968163f0a57b400 // .quad -6239712823709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xd3c21bcecceda100 // .quad -3187955011209551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x84595161401484a0 // .quad -8910000909647051616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xa56fa5b99019a5c8 // .quad -6525815118631426616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xcecb8f27f4200f3a // .quad -3545582879861895366
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x813f3978f8940984 // .quad -9133518327554766460
+	QUAD $0x4000000000000000 // .quad 4611686018427387904
+	QUAD $0xa18f07d736b90be5 // .quad -6805211891016070171
+	QUAD $0x5000000000000000 // .quad 5764607523034234880
+	QUAD $0xc9f2c9cd04674ede // .quad -3894828845342699810
+	QUAD $0xa400000000000000 // .quad -6629298651489370112
+	QUAD $0xfc6f7c4045812296 // .quad -256850038250986858
+	QUAD $0x4d00000000000000 // .quad 5548434740920451072
+	QUAD $0x9dc5ada82b70b59d // .quad -7078060301547948643
+	QUAD $0xf020000000000000 // .quad -1143914305352105984
+	QUAD $0xc5371912364ce305 // .quad -4235889358507547899
+	QUAD $0x6c28000000000000 // .quad 7793479155164643328
+	QUAD $0xf684df56c3e01bc6 // .quad -683175679707046970
+	QUAD $0xc732000000000000 // .quad -4093209111326359552
+	QUAD $0x9a130b963a6c115c // .quad -7344513827457986212
+	QUAD $0x3c7f400000000000 // .quad 4359273333062107136
+	QUAD $0xc097ce7bc90715b3 // .quad -4568956265895094861
+	QUAD $0x4b9f100000000000 // .quad 5449091666327633920
+	QUAD $0xf0bdc21abb48db20 // .quad -1099509313941480672
+	QUAD $0x1e86d40000000000 // .quad 2199678564482154496
+	QUAD $0x96769950b50d88f4 // .quad -7604722348854507276
+	QUAD $0x1314448000000000 // .quad 1374799102801346560
+	QUAD $0xbc143fa4e250eb31 // .quad -4894216917640746191
+	QUAD $0x17d955a000000000 // .quad 1718498878501683200
+	QUAD $0xeb194f8e1ae525fd // .quad -1506085128623544835
+	QUAD $0x5dcfab0800000000 // .quad 6759809616554491904
+	QUAD $0x92efd1b8d0cf37be // .quad -7858832233030797378
+	QUAD $0x5aa1cae500000000 // .quad 6530724019560251392
+	QUAD $0xb7abc627050305ad // .quad -5211854272861108819
+	QUAD $0xf14a3d9e40000000 // .quad -1059967012404461568
+	QUAD $0xe596b7b0c643c719 // .quad -1903131822648998119
+	QUAD $0x6d9ccd05d0000000 // .quad 7898413271349198848
+	QUAD $0x8f7e32ce7bea5c6f // .quad -8106986416796705681
+	QUAD $0xe4820023a2000000 // .quad -1981020733047832576
+	QUAD $0xb35dbf821ae4f38b // .quad -5522047002568494197
+	QUAD $0xdda2802c8a800000 // .quad -2476275916309790720
+	QUAD $0xe0352f62a19e306e // .quad -2290872734783229842
+	QUAD $0xd50b2037ad200000 // .quad -3095344895387238400
+	QUAD $0x8c213d9da502de45 // .quad -8349324486880600507
+	QUAD $0x4526f422cc340000 // .quad 4982938468024057856
+	QUAD $0xaf298d050e4395d6 // .quad -5824969590173362730
+	QUAD $0x9670b12b7f410000 // .quad -7606384970252091392
+	QUAD $0xdaf3f04651d47b4c // .quad -2669525969289315508
+	QUAD $0x3c0cdd765f114000 // .quad 4327076842467049472
+	QUAD $0x88d8762bf324cd0f // .quad -8585982758446904049
+	QUAD $0xa5880a69fb6ac800 // .quad -6518949010312869888
+	QUAD $0xab0e93b6efee0053 // .quad -6120792429631242157
+	QUAD $0x8eea0d047a457a00 // .quad -8148686262891087360
+	QUAD $0xd5d238a4abe98068 // .quad -3039304518611664792
+	QUAD $0x72a4904598d6d880 // .quad 8260886245095692416
+	QUAD $0x85a36366eb71f041 // .quad -8817094351773372351
+	QUAD $0x47a6da2b7f864750 // .quad 5163053903184807760
+	QUAD $0xa70c3c40a64e6c51 // .quad -6409681921289327535
+	QUAD $0x999090b65f67d924 // .quad -7381240676301154012
+	QUAD $0xd0cf4b50cfe20765 // .quad -3400416383184271515
+	QUAD $0xfff4b4e3f741cf6d // .quad -3178808521666707
+	QUAD $0x82818f1281ed449f // .quad -9042789267131251553
+	QUAD $0xbff8f10e7a8921a5 // .quad -4613672773753429595
+	QUAD $0xa321f2d7226895c7 // .quad -6691800565486676537
+	QUAD $0xaff72d52192b6a0e // .quad -5767090967191786994
+	QUAD $0xcbea6f8ceb02bb39 // .quad -3753064688430957767
+	QUAD $0x9bf4f8a69f764491 // .quad -7208863708989733743
+	QUAD $0xfee50b7025c36a08 // .quad -79644842111309304
+	QUAD $0x02f236d04753d5b5 // .quad 212292400617608629
+	QUAD $0x9f4f2726179a2245 // .quad -6967307053960650171
+	QUAD $0x01d762422c946591 // .quad 132682750386005393
+	QUAD $0xc722f0ef9d80aad6 // .quad -4097447799023424810
+	QUAD $0x424d3ad2b7b97ef6 // .quad 4777539456409894646
+	QUAD $0xf8ebad2b84e0d58b // .quad -510123730351893109
+	QUAD $0xd2e0898765a7deb3 // .quad -3251447716342407501
+	QUAD $0x9b934c3b330c8577 // .quad -7236356359111015049
+	QUAD $0x63cc55f49f88eb30 // .quad 7191217214140771120
+	QUAD $0xc2781f49ffcfa6d5 // .quad -4433759430461380907
+	QUAD $0x3cbf6b71c76b25fc // .quad 4377335499248575996
+	QUAD $0xf316271c7fc3908a // .quad -930513269649338230
+	QUAD $0x8bef464e3945ef7b // .quad -8363388681221443717
+	QUAD $0x97edd871cfda3a56 // .quad -7499099821171918250
+	QUAD $0x97758bf0e3cbb5ad // .quad -7532960934977096275
+	QUAD $0xbde94e8e43d0c8ec // .quad -4762188758037509908
+	QUAD $0x3d52eeed1cbea318 // .quad 4418856886560793368
+	QUAD $0xed63a231d4c4fb27 // .quad -1341049929119499481
+	QUAD $0x4ca7aaa863ee4bde // .quad 5523571108200991710
+	QUAD $0x945e455f24fb1cf8 // .quad -7755685233340769032
+	QUAD $0x8fe8caa93e74ef6b // .quad -8076983103442849941
+	QUAD $0xb975d6b6ee39e436 // .quad -5082920523248573386
+	QUAD $0xb3e2fd538e122b45 // .quad -5484542860876174523
+	QUAD $0xe7d34c64a9c85d44 // .quad -1741964635633328828
+	QUAD $0x60dbbca87196b617 // .quad 6979379479186945559
+	QUAD $0x90e40fbeea1d3a4a // .quad -8006256924911912374
+	QUAD $0xbc8955e946fe31ce // .quad -4861259862362934834
+	QUAD $0xb51d13aea4a488dd // .quad -5396135137712502563
+	QUAD $0x6babab6398bdbe42 // .quad 7758483227328495170
+	QUAD $0xe264589a4dcdab14 // .quad -2133482903713240300
+	QUAD $0xc696963c7eed2dd2 // .quad -4136954021121544750
+	QUAD $0x8d7eb76070a08aec // .quad -8250955842461857044
+	QUAD $0xfc1e1de5cf543ca3 // .quad -279753253987271517
+	QUAD $0xb0de65388cc8ada8 // .quad -5702008784649933400
+	QUAD $0x3b25a55f43294bcc // .quad 4261994450943298508
+	QUAD $0xdd15fe86affad912 // .quad -2515824962385028846
+	QUAD $0x49ef0eb713f39ebf // .quad 5327493063679123135
+	QUAD $0x8a2dbf142dfcc7ab // .quad -8489919629131724885
+	QUAD $0x6e3569326c784338 // .quad 7941369183226839864
+	QUAD $0xacb92ed9397bf996 // .quad -6000713517987268202
+	QUAD $0x49c2c37f07965405 // .quad 5315025460606161925
+	QUAD $0xd7e77a8f87daf7fb // .quad -2889205879056697349
+	QUAD $0xdc33745ec97be907 // .quad -2579590211097073401
+	QUAD $0x86f0ac99b4e8dafd // .quad -8723282702051517699
+	QUAD $0x69a028bb3ded71a4 // .quad 7611128154919104932
+	QUAD $0xa8acd7c0222311bc // .quad -6292417359137009220
+	QUAD $0xc40832ea0d68ce0d // .quad -4321147861633282547
+	QUAD $0xd2d80db02aabd62b // .quad -3253835680493873621
+	QUAD $0xf50a3fa490c30191 // .quad -789748808614215279
+	QUAD $0x83c7088e1aab65db // .quad -8951176327949752869
+	QUAD $0x792667c6da79e0fb // .quad 8729779031470891259
+	QUAD $0xa4b8cab1a1563f52 // .quad -6577284391509803182
+	QUAD $0x577001b891185939 // .quad 6300537770911226169
+	QUAD $0xcde6fd5e09abcf26 // .quad -3609919470959866074
+	QUAD $0xed4c0226b55e6f87 // .quad -1347699823215743097
+	QUAD $0x80b05e5ac60b6178 // .quad -9173728696990998152
+	QUAD $0x544f8158315b05b5 // .quad 6075216638131242421
+	QUAD $0xa0dc75f1778e39d6 // .quad -6855474852811359786
+	QUAD $0x696361ae3db1c722 // .quad 7594020797664053026
+	QUAD $0xc913936dd571c84c // .quad -3957657547586811828
+	QUAD $0x03bc3a19cd1e38ea // .quad 269153960225290474
+	QUAD $0xfb5878494ace3a5f // .quad -335385916056126881
+	QUAD $0x04ab48a04065c724 // .quad 336442450281613092
+	QUAD $0x9d174b2dcec0e47b // .quad -7127145225176161157
+	QUAD $0x62eb0d64283f9c77 // .quad 7127805559067090039
+	QUAD $0xc45d1df942711d9a // .quad -4297245513042813542
+	QUAD $0x3ba5d0bd324f8395 // .quad 4298070930406474645
+	QUAD $0xf5746577930d6500 // .quad -759870872876129024
+	QUAD $0xca8f44ec7ee3647a // .quad -3850783373846682502
+	QUAD $0x9968bf6abbe85f20 // .quad -7392448323188662496
+	QUAD $0x7e998b13cf4e1ecc // .quad 9122475437414293196
+	QUAD $0xbfc2ef456ae276e8 // .quad -4628874385558440216
+	QUAD $0x9e3fedd8c321a67f // .quad -7043649776941685121
+	QUAD $0xefb3ab16c59b14a2 // .quad -1174406963520662366
+	QUAD $0xc5cfe94ef3ea101f // .quad -4192876202749718497
+	QUAD $0x95d04aee3b80ece5 // .quad -7651533379841495835
+	QUAD $0xbba1f1d158724a13 // .quad -4926390635932268013
+	QUAD $0xbb445da9ca61281f // .quad -4952730706374481889
+	QUAD $0x2a8a6e45ae8edc98 // .quad 3065383741939440792
+	QUAD $0xea1575143cf97226 // .quad -1579227364540714458
+	QUAD $0xf52d09d71a3293be // .quad -779956341003086914
+	QUAD $0x924d692ca61be758 // .quad -7904546130479028392
+	QUAD $0x593c2626705f9c57 // .quad 6430056314514152535
+	QUAD $0xb6e0c377cfa2e12e // .quad -5268996644671397586
+	QUAD $0x6f8b2fb00c77836d // .quad 8037570393142690669
+	QUAD $0xe498f455c38b997a // .quad -1974559787411859078
+	QUAD $0x0b6dfb9c0f956448 // .quad 823590954573587528
+	QUAD $0x8edf98b59a373fec // .quad -8151628894773493780
+	QUAD $0x4724bd4189bd5ead // .quad 5126430365035880109
+	QUAD $0xb2977ee300c50fe7 // .quad -5577850100039479321
+	QUAD $0x58edec91ec2cb658 // .quad 6408037956294850136
+	QUAD $0xdf3d5e9bc0f653e1 // .quad -2360626606621961247
+	QUAD $0x2f2967b66737e3ee // .quad 3398361426941174766
+	QUAD $0x8b865b215899f46c // .quad -8392920656779807636
+	QUAD $0xbd79e0d20082ee75 // .quad -4793553135802847627
+	QUAD $0xae67f1e9aec07187 // .quad -5879464802547371641
+	QUAD $0xecd8590680a3aa12 // .quad -1380255401326171630
+	QUAD $0xda01ee641a708de9 // .quad -2737644984756826647
+	QUAD $0xe80e6f4820cc9496 // .quad -1725319251657714538
+	QUAD $0x884134fe908658b2 // .quad -8628557143114098510
+	QUAD $0x3109058d147fdcde // .quad 3533361486141316318
+	QUAD $0xaa51823e34a7eede // .quad -6174010410465235234
+	QUAD $0xbd4b46f0599fd416 // .quad -4806670179178130410
+	QUAD $0xd4e5e2cdc1d1ea96 // .quad -3105826994654156138
+	QUAD $0x6c9e18ac7007c91b // .quad 7826720331309500699
+	QUAD $0x850fadc09923329e // .quad -8858670899299929442
+	QUAD $0x03e2cf6bc604ddb1 // .quad 280014188641050033
+	QUAD $0xa6539930bf6bff45 // .quad -6461652605697523899
+	QUAD $0x84db8346b786151d // .quad -8873354301053463267
+	QUAD $0xcfe87f7cef46ff16 // .quad -3465379738694516970
+	QUAD $0xe612641865679a64 // .quad -1868320839462053276
+	QUAD $0x81f14fae158c5f6e // .quad -9083391364325154962
+	QUAD $0x4fcb7e8f3f60c07f // .quad 5749828502977298559
+	QUAD $0xa26da3999aef7749 // .quad -6742553186979055799
+	QUAD $0xe3be5e330f38f09e // .quad -2036086408133152610
+	QUAD $0xcb090c8001ab551c // .quad -3816505465296431844
+	QUAD $0x5cadf5bfd3072cc6 // .quad 6678264026688335046
+	QUAD $0xfdcb4fa002162a63 // .quad -158945813193151901
+	QUAD $0x73d9732fc7c8f7f7 // .quad 8347830033360418807
+	QUAD $0x9e9f11c4014dda7e // .quad -7016870160886801794
+	QUAD $0x2867e7fddcdd9afb // .quad 2911550761636567803
+	QUAD $0xc646d63501a1511d // .quad -4159401682681114339
+	QUAD $0xb281e1fd541501b9 // .quad -5583933584809066055
+	QUAD $0xf7d88bc24209a565 // .quad -587566084924005019
+	QUAD $0x1f225a7ca91a4227 // .quad 2243455055843443239
+	QUAD $0x9ae757596946075f // .quad -7284757830718584993
+	QUAD $0x3375788de9b06959 // .quad 3708002419115845977
+	QUAD $0xc1a12d2fc3978937 // .quad -4494261269970843337
+	QUAD $0x0052d6b1641c83af // .quad 23317005467419567
+	QUAD $0xf209787bb47d6b84 // .quad -1006140569036166268
+	QUAD $0xc0678c5dbd23a49b // .quad -4582539761593113445
+	QUAD $0x9745eb4d50ce6332 // .quad -7546366883288685774
+	QUAD $0xf840b7ba963646e1 // .quad -558244341782001951
+	QUAD $0xbd176620a501fbff // .quad -4821272585683469313
+	QUAD $0xb650e5a93bc3d899 // .quad -5309491445654890343
+	QUAD $0xec5d3fa8ce427aff // .quad -1414904713676948737
+	QUAD $0xa3e51f138ab4cebf // .quad -6636864307068612929
+	QUAD $0x93ba47c980e98cdf // .quad -7801844473689174817
+	QUAD $0xc66f336c36b10138 // .quad -4148040191917883080
+	QUAD $0xb8a8d9bbe123f017 // .quad -5140619573684080617
+	QUAD $0xb80b0047445d4185 // .quad -5185050239897353851
+	QUAD $0xe6d3102ad96cec1d // .quad -1814088448677712867
+	QUAD $0xa60dc059157491e6 // .quad -6481312799871692314
+	QUAD $0x9043ea1ac7e41392 // .quad -8051334308064652398
+	QUAD $0x87c89837ad68db30 // .quad -8662506518347195600
+	QUAD $0xb454e4a179dd1877 // .quad -5452481866653427593
+	QUAD $0x29babe4598c311fc // .quad 3006924907348169212
+	QUAD $0xe16a1dc9d8545e94 // .quad -2203916314889396588
+	QUAD $0xf4296dd6fef3d67b // .quad -853029884242176389
+	QUAD $0x8ce2529e2734bb1d // .quad -8294976724446954723
+	QUAD $0x1899e4a65f58660d // .quad 1772699331562333709
+	QUAD $0xb01ae745b101e9e4 // .quad -5757034887131305500
+	QUAD $0x5ec05dcff72e7f90 // .quad 6827560182880305040
+	QUAD $0xdc21a1171d42645d // .quad -2584607590486743971
+	QUAD $0x76707543f4fa1f74 // .quad 8534450228600381300
+	QUAD $0x899504ae72497eba // .quad -8532908771695296838
+	QUAD $0x6a06494a791c53a9 // .quad 7639874402088932265
+	QUAD $0xabfa45da0edbde69 // .quad -6054449946191733143
+	QUAD $0x0487db9d17636893 // .quad 326470965756389523
+	QUAD $0xd6f8d7509292d603 // .quad -2956376414312278525
+	QUAD $0x45a9d2845d3c42b7 // .quad 5019774725622874807
+	QUAD $0x865b86925b9bc5c2 // .quad -8765264286586255934
+	QUAD $0x0b8a2392ba45a9b3 // .quad 831516194300602803
+	QUAD $0xa7f26836f282b732 // .quad -6344894339805432014
+	QUAD $0x8e6cac7768d7141f // .quad -8183976793979022305
+	QUAD $0xd1ef0244af2364ff // .quad -3319431906329402113
+	QUAD $0x3207d795430cd927 // .quad 3605087062808385831
+	QUAD $0x8335616aed761f1f // .quad -8992173969096958177
+	QUAD $0x7f44e6bd49e807b9 // .quad 9170708441896323001
+	QUAD $0xa402b9c5a8d3a6e7 // .quad -6628531442943809817
+	QUAD $0x5f16206c9c6209a7 // .quad 6851699533943015847
+	QUAD $0xcd036837130890a1 // .quad -3673978285252374367
+	QUAD $0x36dba887c37a8c10 // .quad 3952938399001381904
+	QUAD $0x802221226be55a64 // .quad -9213765455923815836
+	QUAD $0xc2494954da2c978a // .quad -4446942528265218166
+	QUAD $0xa02aa96b06deb0fd // .quad -6905520801477381891
+	QUAD $0xf2db9baa10b7bd6d // .quad -946992141904134803
+	QUAD $0xc83553c5c8965d3d // .quad -4020214983419339459
+	QUAD $0x6f92829494e5acc8 // .quad 8039631859474607304
+	QUAD $0xfa42a8b73abbf48c // .quad -413582710846786420
+	QUAD $0xcb772339ba1f17fa // .quad -3785518230938904582
+	QUAD $0x9c69a97284b578d7 // .quad -7176018221920323369
+	QUAD $0xff2a760414536efc // .quad -60105885123121412
+	QUAD $0xc38413cf25e2d70d // .quad -4358336758973016307
+	QUAD $0xfef5138519684abb // .quad -75132356403901765
+	QUAD $0xf46518c2ef5b8cd1 // .quad -836234930288882479
+	QUAD $0x7eb258665fc25d6a // .quad 9129456591349898602
+	QUAD $0x98bf2f79d5993802 // .quad -7440175859071633406
+	QUAD $0xef2f773ffbd97a62 // .quad -1211618658047395230
+	QUAD $0xbeeefb584aff8603 // .quad -4688533805412153853
+	QUAD $0xaafb550ffacfd8fb // .quad -6126209340986631941
+	QUAD $0xeeaaba2e5dbf6784 // .quad -1248981238337804412
+	QUAD $0x95ba2a53f983cf39 // .quad -7657761676233289927
+	QUAD $0x952ab45cfa97a0b2 // .quad -7698142301602209614
+	QUAD $0xdd945a747bf26184 // .quad -2480258038432112252
+	QUAD $0xba756174393d88df // .quad -5010991858575374113
+	QUAD $0x94f971119aeef9e5 // .quad -7712008566467528219
+	QUAD $0xe912b9d1478ceb17 // .quad -1652053804791829737
+	QUAD $0x7a37cd5601aab85e // .quad 8806733365625141342
+	QUAD $0x91abb422ccb812ee // .quad -7950062655635975442
+	QUAD $0xac62e055c10ab33b // .quad -6025006692552756421
+	QUAD $0xb616a12b7fe617aa // .quad -5325892301117581398
+	QUAD $0x577b986b314d600a // .quad 6303799689591218186
+	QUAD $0xe39c49765fdf9d94 // .quad -2045679357969588844
+	QUAD $0xed5a7e85fda0b80c // .quad -1343622424865753076
+	QUAD $0x8e41ade9fbebc27d // .quad -8196078626372074883
+	QUAD $0x14588f13be847308 // .quad 1466078993672598280
+	QUAD $0xb1d219647ae6b31c // .quad -5633412264537705700
+	QUAD $0x596eb2d8ae258fc9 // .quad 6444284760518135753
+	QUAD $0xde469fbd99a05fe3 // .quad -2430079312244744221
+	QUAD $0x6fca5f8ed9aef3bc // .quad 8055355950647669692
+	QUAD $0x8aec23d680043bee // .quad -8436328597794046994
+	QUAD $0x25de7bb9480d5855 // .quad 2728754459941099605
+	QUAD $0xada72ccc20054ae9 // .quad -5933724728815170839
+	QUAD $0xaf561aa79a10ae6b // .quad -5812428961928401301
+	QUAD $0xd910f7ff28069da4 // .quad -2805469892591575644
+	QUAD $0x1b2ba1518094da05 // .quad 1957835834444274181
+	QUAD $0x87aa9aff79042286 // .quad -8670947710510816634
+	QUAD $0x90fb44d2f05d0843 // .quad -7999724640327104445
+	QUAD $0xa99541bf57452b28 // .quad -6226998619711132888
+	QUAD $0x353a1607ac744a54 // .quad 3835402254873283156
+	QUAD $0xd3fa922f2d1675f2 // .quad -3172062256211528206
+	QUAD $0x42889b8997915ce9 // .quad 4794252818591603945
+	QUAD $0x847c9b5d7c2e09b7 // .quad -8900067937773286985
+	QUAD $0x69956135febada12 // .quad 7608094030047140370
+	QUAD $0xa59bc234db398c25 // .quad -6513398903789220827
+	QUAD $0x43fab9837e699096 // .quad 4898431519131537558
+	QUAD $0xcf02b2c21207ef2e // .quad -3530062611309138130
+	QUAD $0x94f967e45e03f4bc // .quad -7712018656367741764
+	QUAD $0x8161afb94b44f57d // .quad -9123818159709293187
+	QUAD $0x1d1be0eebac278f6 // .quad 2097517367411243254
+	QUAD $0xa1ba1ba79e1632dc // .quad -6793086681209228580
+	QUAD $0x6462d92a69731733 // .quad 7233582727691441971
+	QUAD $0xca28a291859bbf93 // .quad -3879672333084147821
+	QUAD $0x7d7b8f7503cfdcff // .quad 9041978409614302463
+	QUAD $0xfcb2cb35e702af78 // .quad -237904397927796872
+	QUAD $0x5cda735244c3d43f // .quad 6690786993590490175
+	QUAD $0x9defbf01b061adab // .quad -7066219276345954901
+	QUAD $0x3a0888136afa64a8 // .quad 4181741870994056360
+	QUAD $0xc56baec21c7a1916 // .quad -4221088077005055722
+	QUAD $0x088aaa1845b8fdd1 // .quad 615491320315182545
+	QUAD $0xf6c69a72a3989f5b // .quad -664674077828931749
+	QUAD $0x8aad549e57273d46 // .quad -8454007886460797626
+	QUAD $0x9a3c2087a63f6399 // .quad -7332950326284164199
+	QUAD $0x36ac54e2f678864c // .quad 3939617107816777292
+	QUAD $0xc0cb28a98fcf3c7f // .quad -4554501889427817345
+	QUAD $0x84576a1bb416a7de // .quad -8910536670511192098
+	QUAD $0xf0fdf2d3f3c30b9f // .quad -1081441343357383777
+	QUAD $0x656d44a2a11c51d6 // .quad 7308573235570561494
+	QUAD $0x969eb7c47859e743 // .quad -7593429867239446717
+	QUAD $0x9f644ae5a4b1b326 // .quad -6961356773836868826
+	QUAD $0xbc4665b596706114 // .quad -4880101315621920492
+	QUAD $0x873d5d9f0dde1fef // .quad -8701695967296086033
+	QUAD $0xeb57ff22fc0c7959 // .quad -1488440626100012711
+	QUAD $0xa90cb506d155a7eb // .quad -6265433940692719637
+	QUAD $0x9316ff75dd87cbd8 // .quad -7847804418953589800
+	QUAD $0x09a7f12442d588f3 // .quad 695789805494438131
+	QUAD $0xb7dcbf5354e9bece // .quad -5198069505264599346
+	QUAD $0x0c11ed6d538aeb30 // .quad 869737256868047664
+	QUAD $0xe5d3ef282a242e81 // .quad -1885900863153361279
+	QUAD $0x8f1668c8a86da5fb // .quad -8136200465769716229
+	QUAD $0x8fa475791a569d10 // .quad -8096217067111932656
+	QUAD $0xf96e017d694487bd // .quad -473439272678684739
+	QUAD $0xb38d92d760ec4455 // .quad -5508585315462527915
+	QUAD $0x37c981dcc395a9ad // .quad 4019886927579031981
+	QUAD $0xe070f78d3927556a // .quad -2274045625900771990
+	QUAD $0x85bbe253f47b1418 // .quad -8810199395808373736
+	QUAD $0x8c469ab843b89562 // .quad -8338807543829064350
+	QUAD $0x93956d7478ccec8f // .quad -7812217631593927537
+	QUAD $0xaf58416654a6babb // .quad -5811823411358942533
+	QUAD $0x387ac8d1970027b3 // .quad 4069786015789754291
+	QUAD $0xdb2e51bfe9d0696a // .quad -2653093245771290262
+	QUAD $0x06997b05fcc0319f // .quad 475546501309804959
+	QUAD $0x88fcf317f22241e2 // .quad -8575712306248138270
+	QUAD $0x441fece3bdf81f04 // .quad 4908902581746016004
+	QUAD $0xab3c2fddeeaad25a // .quad -6107954364382784934
+	QUAD $0xd527e81cad7626c4 // .quad -3087243809672255804
+	QUAD $0xd60b3bd56a5586f1 // .quad -3023256937051093263
+	QUAD $0x8a71e223d8d3b075 // .quad -8470740780517707659
+	QUAD $0x85c7056562757456 // .quad -8807064613298015146
+	QUAD $0xf6872d5667844e4a // .quad -682526969396179382
+	QUAD $0xa738c6bebb12d16c // .quad -6397144748195131028
+	QUAD $0xb428f8ac016561dc // .quad -5464844730172612132
+	QUAD $0xd106f86e69d785c7 // .quad -3384744916816525881
+	QUAD $0xe13336d701beba53 // .quad -2219369894288377261
+	QUAD $0x82a45b450226b39c // .quad -9032994600651410532
+	QUAD $0xecc0024661173474 // .quad -1387106183930235788
+	QUAD $0xa34d721642b06084 // .quad -6679557232386875260
+	QUAD $0x27f002d7f95d0191 // .quad 2877803288514593169
+	QUAD $0xcc20ce9bd35c78a5 // .quad -3737760522056206171
+	QUAD $0x31ec038df7b441f5 // .quad 3597254110643241461
+	QUAD $0xff290242c83396ce // .quad -60514634142869810
+	QUAD $0x7e67047175a15272 // .quad 9108253656731439730
+	QUAD $0x9f79a169bd203e41 // .quad -6955350673980375487
+	QUAD $0x0f0062c6e984d387 // .quad 1080972517029761927
+	QUAD $0xc75809c42c684dd1 // .quad -4082502324048081455
+	QUAD $0x52c07b78a3e60869 // .quad 5962901664714590313
+	QUAD $0xf92e0c3537826145 // .quad -491441886632713915
+	QUAD $0xa7709a56ccdf8a83 // .quad -6381430974388925821
+	QUAD $0x9bbcc7a142b17ccb // .quad -7224680206786528053
+	QUAD $0x88a66076400bb692 // .quad -8600080377420466542
+	QUAD $0xc2abf989935ddbfe // .quad -4419164240055772162
+	QUAD $0x6acff893d00ea436 // .quad 7696643601933968438
+	QUAD $0xf356f7ebf83552fe // .quad -912269281642327298
+	QUAD $0x0583f6b8c4124d44 // .quad 397432465562684740
+	QUAD $0x98165af37b2153de // .quad -7487697328667536418
+	QUAD $0xc3727a337a8b704b // .quad -4363290727450709941
+	QUAD $0xbe1bf1b059e9a8d6 // .quad -4747935642407032618
+	QUAD $0x744f18c0592e4c5d // .quad 8380944645968776285
+	QUAD $0xeda2ee1c7064130c // .quad -1323233534581402868
+	QUAD $0x1162def06f79df74 // .quad 1252808770606194548
+	QUAD $0x9485d4d1c63e8be7 // .quad -7744549986754458649
+	QUAD $0x8addcb5645ac2ba9 // .quad -8440366555225904215
+	QUAD $0xb9a74a0637ce2ee1 // .quad -5069001465015685407
+	QUAD $0x6d953e2bd7173693 // .quad 7896285879677171347
+	QUAD $0xe8111c87c5c1ba99 // .quad -1724565812842218855
+	QUAD $0xc8fa8db6ccdd0438 // .quad -3964700705685699528
+	QUAD $0x910ab1d4db9914a0 // .quad -7995382660667468640
+	QUAD $0x1d9c9892400a22a3 // .quad 2133748077373825699
+	QUAD $0xb54d5e4a127f59c8 // .quad -5382542307406947896
+	QUAD $0x2503beb6d00cab4c // .quad 2667185096717282124
+	QUAD $0xe2a0b5dc971f303a // .quad -2116491865831296966
+	QUAD $0x2e44ae64840fd61e // .quad 3333981370896602654
+	QUAD $0x8da471a9de737e24 // .quad -8240336443785642460
+	QUAD $0x5ceaecfed289e5d3 // .quad 6695424375237764563
+	QUAD $0xb10d8e1456105dad // .quad -5688734536304665171
+	QUAD $0x7425a83e872c5f48 // .quad 8369280469047205704
+	QUAD $0xdd50f1996b947518 // .quad -2499232151953443560
+	QUAD $0xd12f124e28f7771a // .quad -3373457468973156582
+	QUAD $0x8a5296ffe33cc92f // .quad -8479549122611984081
+	QUAD $0x82bd6b70d99aaa70 // .quad -9025939945749304720
+	QUAD $0xace73cbfdc0bfb7b // .quad -5987750384837592197
+	QUAD $0x636cc64d1001550c // .quad 7164319141522920716
+	QUAD $0xd8210befd30efa5a // .quad -2873001962619602342
+	QUAD $0x3c47f7e05401aa4f // .quad 4343712908476262991
+	QUAD $0x8714a775e3e95c78 // .quad -8713155254278333320
+	QUAD $0x65acfaec34810a72 // .quad 7326506586225052274
+	QUAD $0xa8d9d1535ce3b396 // .quad -6279758049420528746
+	QUAD $0x7f1839a741a14d0e // .quad 9158133232781315342
+	QUAD $0xd31045a8341ca07c // .quad -3238011543348273028
+	QUAD $0x1ede48111209a051 // .quad 2224294504121868369
+	QUAD $0x83ea2b892091e44d // .quad -8941286242233752499
+	QUAD $0x934aed0aab460433 // .quad -7833187971778608077
+	QUAD $0xa4e4b66b68b65d60 // .quad -6564921784364802720
+	QUAD $0xf81da84d56178540 // .quad -568112927868484288
+	QUAD $0xce1de40642e3f4b9 // .quad -3594466212028615495
+	QUAD $0x36251260ab9d668f // .quad 3901544858591782543
+	QUAD $0x80d2ae83e9ce78f3 // .quad -9164070410158966541
+	QUAD $0xc1d72b7c6b42601a // .quad -4479063491021217766
+	QUAD $0xa1075a24e4421730 // .quad -6843401994271320272
+	QUAD $0xb24cf65b8612f820 // .quad -5598829363776522208
+	QUAD $0xc94930ae1d529cfc // .quad -3942566474411762436
+	QUAD $0xdee033f26797b628 // .quad -2386850686293264856
+	QUAD $0xfb9b7cd9a4a7443c // .quad -316522074587315140
+	QUAD $0x169840ef017da3b2 // .quad 1628122660560806834
+	QUAD $0x9d412e0806e88aa5 // .quad -7115355324258153819
+	QUAD $0x8e1f289560ee864f // .quad -8205795374004271537
+	QUAD $0xc491798a08a2ad4e // .quad -4282508136895304370
+	QUAD $0xf1a6f2bab92a27e3 // .quad -1033872180650563613
+	QUAD $0xf5b5d7ec8acb58a2 // .quad -741449152691742558
+	QUAD $0xae10af696774b1dc // .quad -5904026244240592420
+	QUAD $0x9991a6f3d6bf1765 // .quad -7380934748073420955
+	QUAD $0xacca6da1e0a8ef2a // .quad -5995859411864064214
+	QUAD $0xbff610b0cc6edd3f // .quad -4614482416664388289
+	QUAD $0x17fd090a58d32af4 // .quad 1728547772024695540
+	QUAD $0xeff394dcff8a948e // .quad -1156417002403097458
+	QUAD $0xddfc4b4cef07f5b1 // .quad -2451001303396518479
+	QUAD $0x95f83d0a1fb69cd9 // .quad -7640289654143017767
+	QUAD $0x4abdaf101564f98f // .quad 5385653213018257807
+	QUAD $0xbb764c4ca7a4440f // .quad -4938676049251384305
+	QUAD $0x9d6d1ad41abe37f2 // .quad -7102991539009341454
+	QUAD $0xea53df5fd18d5513 // .quad -1561659043136842477
+	QUAD $0x84c86189216dc5ee // .quad -8878739423761676818
+	QUAD $0x92746b9be2f8552c // .quad -7893565929601608404
+	QUAD $0x32fd3cf5b4e49bb5 // .quad 3674159897003727797
+	QUAD $0xb7118682dbb66a77 // .quad -5255271393574622601
+	QUAD $0x3fbc8c33221dc2a2 // .quad 4592699871254659746
+	QUAD $0xe4d5e82392a40515 // .quad -1957403223540890347
+	QUAD $0x0fabaf3feaa5334b // .quad 1129188820640936779
+	QUAD $0x8f05b1163ba6832d // .quad -8140906042354138323
+	QUAD $0x29cb4d87f2a7400f // .quad 3011586022114279439
+	QUAD $0xb2c71d5bca9023f8 // .quad -5564446534515285000
+	QUAD $0x743e20e9ef511013 // .quad 8376168546070237203
+	QUAD $0xdf78e4b2bd342cf6 // .quad -2343872149716718346
+	QUAD $0x914da9246b255417 // .quad -7976533391121755113
+	QUAD $0x8bab8eefb6409c1a // .quad -8382449121214030822
+	QUAD $0x1ad089b6c2f7548f // .quad 1932195658189984911
+	QUAD $0xae9672aba3d0c320 // .quad -5866375383090150624
+	QUAD $0xa184ac2473b529b2 // .quad -6808127464117294670
+	QUAD $0xda3c0f568cc4f3e8 // .quad -2721283210435300376
+	QUAD $0xc9e5d72d90a2741f // .quad -3898473311719230433
+	QUAD $0x8865899617fb1871 // .quad -8618331034163144591
+	QUAD $0x7e2fa67c7a658893 // .quad 9092669226243950739
+	QUAD $0xaa7eebfb9df9de8d // .quad -6161227774276542835
+	QUAD $0xddbb901b98feeab8 // .quad -2469221522477225288
+	QUAD $0xd51ea6fa85785631 // .quad -3089848699418290639
+	QUAD $0x552a74227f3ea566 // .quad 6136845133758244198
+	QUAD $0x8533285c936b35de // .quad -8848684464777513506
+	QUAD $0xd53a88958f872760 // .quad -3082000819042179232
+	QUAD $0xa67ff273b8460356 // .quad -6449169562544503978
+	QUAD $0x8a892abaf368f138 // .quad -8464187042230111944
+	QUAD $0xd01fef10a657842c // .quad -3449775934753242068
+	QUAD $0x2d2b7569b0432d86 // .quad 3254824252494523782
+	QUAD $0x8213f56a67f6b29b // .quad -9073638986861858149
+	QUAD $0x9c3b29620e29fc74 // .quad -7189106879045698444
+	QUAD $0xa298f2c501f45f42 // .quad -6730362715149934782
+	QUAD $0x8349f3ba91b47b90 // .quad -8986383598807123056
+	QUAD $0xcb3f2f7642717713 // .quad -3801267375510030573
+	QUAD $0x241c70a936219a74 // .quad 2602078556773259892
+	QUAD $0xfe0efb53d30dd4d7 // .quad -139898200960150313
+	QUAD $0xed238cd383aa0111 // .quad -1359087822460813039
+	QUAD $0x9ec95d1463e8a506 // .quad -7004965403241175802
+	QUAD $0xf4363804324a40ab // .quad -849429889038008149
+	QUAD $0xc67bb4597ce2ce48 // .quad -4144520735624081848
+	QUAD $0xb143c6053edcd0d6 // .quad -5673473379724898090
+	QUAD $0xf81aa16fdc1b81da // .quad -568964901102714406
+	QUAD $0xdd94b7868e94050b // .quad -2480155706228734709
+	QUAD $0x9b10a4e5e9913128 // .quad -7273132090830278360
+	QUAD $0xca7cf2b4191c8327 // .quad -3855940325606653145
+	QUAD $0xc1d4ce1f63f57d72 // .quad -4479729095110460046
+	QUAD $0xfd1c2f611f63a3f1 // .quad -208239388580928527
+	QUAD $0xf24a01a73cf2dccf // .quad -987975350460687153
+	QUAD $0xbc633b39673c8ced // .quad -4871985254153548563
+	QUAD $0x976e41088617ca01 // .quad -7535013621679011327
+	QUAD $0xd5be0503e085d814 // .quad -3044990783845967852
+	QUAD $0xbd49d14aa79dbc82 // .quad -4807081008671376254
+	QUAD $0x4b2d8644d8a74e19 // .quad 5417133557047315993
+	QUAD $0xec9c459d51852ba2 // .quad -1397165242411832414
+	QUAD $0xddf8e7d60ed1219f // .quad -2451955090545630817
+	QUAD $0x93e1ab8252f33b45 // .quad -7790757304148477115
+	QUAD $0xcabb90e5c942b504 // .quad -3838314940804713212
+	QUAD $0xb8da1662e7b00a17 // .quad -5126760611758208489
+	QUAD $0x3d6a751f3b936244 // .quad 4425478360848884292
+	QUAD $0xe7109bfba19c0c9d // .quad -1796764746270372707
+	QUAD $0x0cc512670a783ad5 // .quad 920161932633717461
+	QUAD $0x906a617d450187e2 // .quad -8040506994060064798
+	QUAD $0x27fb2b80668b24c6 // .quad 2880944217109767366
+	QUAD $0xb484f9dc9641e9da // .quad -5438947724147693094
+	QUAD $0xb1f9f660802dedf7 // .quad -5622191765467566601
+	QUAD $0xe1a63853bbd26451 // .quad -2186998636757228463
+	QUAD $0x5e7873f8a0396974 // .quad 6807318348447705460
+	QUAD $0x8d07e33455637eb2 // .quad -8284403175614349646
+	QUAD $0xdb0b487b6423e1e9 // .quad -2662955059861265943
+	QUAD $0xb049dc016abc5e5f // .quad -5743817951090549153
+	QUAD $0x91ce1a9a3d2cda63 // .quad -7940379843253970333
+	QUAD $0xdc5c5301c56b75f7 // .quad -2568086420435798537
+	QUAD $0x7641a140cc7810fc // .quad 8521269269642088700
+	QUAD $0x89b9b3e11b6329ba // .quad -8522583040413455942
+	QUAD $0xa9e904c87fcb0a9e // .quad -6203421752542164322
+	QUAD $0xac2820d9623bf429 // .quad -6041542782089432023
+	QUAD $0x546345fa9fbdcd45 // .quad 6080780864604458309
+	QUAD $0xd732290fbacaf133 // .quad -2940242459184402125
+	QUAD $0xa97c177947ad4096 // .quad -6234081974526590826
+	QUAD $0x867f59a9d4bed6c0 // .quad -8755180564631333184
+	QUAD $0x49ed8eabcccc485e // .quad 5327070802775656542
+	QUAD $0xa81f301449ee8c70 // .quad -6332289687361778576
+	QUAD $0x5c68f256bfff5a75 // .quad 6658838503469570677
+	QUAD $0xd226fc195c6a2f8c // .quad -3303676090774835316
+	QUAD $0x73832eec6fff3112 // .quad 8323548129336963346
+	QUAD $0x83585d8fd9c25db7 // .quad -8982326584375353929
+	QUAD $0xc831fd53c5ff7eac // .quad -4021154456019173716
+	QUAD $0xa42e74f3d032f525 // .quad -6616222212041804507
+	QUAD $0xba3e7ca8b77f5e56 // .quad -5026443070023967146
+	QUAD $0xcd3a1230c43fb26f // .quad -3658591746624867729
+	QUAD $0x28ce1bd2e55f35ec // .quad 2940318199324816876
+	QUAD $0x80444b5e7aa7cf85 // .quad -9204148869281624187
+	QUAD $0x7980d163cf5b81b4 // .quad 8755227902219092404
+	QUAD $0xa0555e361951c366 // .quad -6893500068174642330
+	QUAD $0xd7e105bcc3326220 // .quad -2891023177508298208
+	QUAD $0xc86ab5c39fa63440 // .quad -4005189066790915008
+	QUAD $0x8dd9472bf3fefaa8 // .quad -8225464990312760664
+	QUAD $0xfa856334878fc150 // .quad -394800315061255856
+	QUAD $0xb14f98f6f0feb952 // .quad -5670145219463562926
+	QUAD $0x9c935e00d4b9d8d2 // .quad -7164279224554366766
+	QUAD $0x6ed1bf9a569f33d4 // .quad 7985374283903742932
+	QUAD $0xc3b8358109e84f07 // .quad -4343663012265570553
+	QUAD $0x0a862f80ec4700c9 // .quad 758345818024902857
+	QUAD $0xf4a642e14c6262c8 // .quad -817892746904575288
+	QUAD $0xcd27bb612758c0fb // .quad -3663753745896259333
+	QUAD $0x98e7e9cccfbd7dbd // .quad -7428711994456441411
+	QUAD $0x8038d51cb897789d // .quad -9207375118826243939
+	QUAD $0xbf21e44003acdd2c // .quad -4674203974643163860
+	QUAD $0xe0470a63e6bd56c4 // .quad -2285846861678029116
+	QUAD $0xeeea5d5004981478 // .quad -1231068949876566920
+	QUAD $0x1858ccfce06cac75 // .quad 1754377441329851509
+	QUAD $0x95527a5202df0ccb // .quad -7686947121313936181
+	QUAD $0x0f37801e0c43ebc9 // .quad 1096485900831157193
+	QUAD $0xbaa718e68396cffd // .quad -4996997883215032323
+	QUAD $0xd30560258f54e6bb // .quad -3241078642388441413
+	QUAD $0xe950df20247c83fd // .quad -1634561335591402499
+	QUAD $0x47c6b82ef32a206a // .quad 5172023733869224042
+	QUAD $0x91d28b7416cdd27e // .quad -7939129862385708418
+	QUAD $0x4cdc331d57fa5442 // .quad 5538357842881958978
+	QUAD $0xb6472e511c81471d // .quad -5312226309554747619
+	QUAD $0xe0133fe4adf8e953 // .quad -2300424733252327085
+	QUAD $0xe3d8f9e563a198e5 // .quad -2028596868516046619
+	QUAD $0x58180fddd97723a7 // .quad 6347841120289366951
+	QUAD $0x8e679c2f5e44ff8f // .quad -8185402070463610993
+	QUAD $0x570f09eaa7ea7649 // .quad 6273243709394548297
+	QUAD $0xb201833b35d63f73 // .quad -5620066569652125837
+	QUAD $0x2cd2cc6551e513db // .quad 3229868618315797467
+	QUAD $0xde81e40a034bcf4f // .quad -2413397193637769393
+	QUAD $0xf8077f7ea65e58d2 // .quad -574350245532641070
+	QUAD $0x8b112e86420f6191 // .quad -8425902273664687727
+	QUAD $0xfb04afaf27faf783 // .quad -358968903457900669
+	QUAD $0xadd57a27d29339f6 // .quad -5920691823653471754
+	QUAD $0x79c5db9af1f9b564 // .quad 8774660907532399972
+	QUAD $0xd94ad8b1c7380874 // .quad -2789178761139451788
+	QUAD $0x18375281ae7822bd // .quad 1744954097560724157
+	QUAD $0x87cec76f1c830548 // .quad -8660765753353239224
+	QUAD $0x8f2293910d0b15b6 // .quad -8132775725879323210
+	QUAD $0xa9c2794ae3a3c69a // .quad -6214271173264161126
+	QUAD $0xb2eb3875504ddb23 // .quad -5554283638921766109
+	QUAD $0xd433179d9c8cb841 // .quad -3156152948152813503
+	QUAD $0x5fa60692a46151ec // .quad 6892203506629956076
+	QUAD $0x849feec281d7f328 // .quad -8890124620236590296
+	QUAD $0xdbc7c41ba6bcd334 // .quad -2609901835997359308
+	QUAD $0xa5c7ea73224deff3 // .quad -6500969756868349965
+	QUAD $0x12b9b522906c0801 // .quad 1349308723430688769
+	QUAD $0xcf39e50feae16bef // .quad -3514526177658049553
+	QUAD $0xd768226b34870a01 // .quad -2925050114139026943
+	QUAD $0x81842f29f2cce375 // .quad -9114107888677362827
+	QUAD $0xe6a1158300d46641 // .quad -1828156321336891839
+	QUAD $0xa1e53af46f801c53 // .quad -6780948842419315629
+	QUAD $0x60495ae3c1097fd1 // .quad 6938176635183661009
+	QUAD $0xca5e89b18b602368 // .quad -3864500034596756632
+	QUAD $0x385bb19cb14bdfc5 // .quad 4061034775552188357
+	QUAD $0xfcf62c1dee382c42 // .quad -218939024818557886
+	QUAD $0x46729e03dd9ed7b6 // .quad 5076293469440235446
+	QUAD $0x9e19db92b4e31ba9 // .quad -7054365918152680535
+	QUAD $0x6c07a2c26a8346d2 // .quad 7784369436827535058
+
+	// .p2align 4, 0x00
+_VecShiftShuffles:
+	QUAD $0x0706050403020100; QUAD $0x0f0e0d0c0b0a0908 // .ascii 16, '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f'
+	QUAD $0x0807060504030201; QUAD $0xff0f0e0d0c0b0a09 // .ascii 16, '\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff'
+	QUAD $0x0908070605040302; QUAD $0xffff0f0e0d0c0b0a // .ascii 16, '\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff'
+	QUAD $0x0a09080706050403; QUAD $0xffffff0f0e0d0c0b // .ascii 16, '\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff'
+	QUAD $0x0b0a090807060504; QUAD $0xffffffff0f0e0d0c // .ascii 16, '\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff'
+	QUAD $0x0c0b0a0908070605; QUAD $0xffffffffff0f0e0d // .ascii 16, '\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff'
+	QUAD $0x0d0c0b0a09080706; QUAD $0xffffffffffff0f0e // .ascii 16, '\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff'
+	QUAD $0x0e0d0c0b0a090807; QUAD $0xffffffffffffff0f // .ascii 16, '\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0x0f0e0d0c0b0a0908; QUAD $0xffffffffffffffff // .ascii 16, '\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff'
+
+	// .p2align 4, 0x00
+__SingleQuoteTab:
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000030303030755c                           // .asciz 8, '\\u0000\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000031303030755c                           // .asciz 8, '\\u0001\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000032303030755c                           // .asciz 8, '\\u0002\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000033303030755c                           // .asciz 8, '\\u0003\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000034303030755c                           // .asciz 8, '\\u0004\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000035303030755c                           // .asciz 8, '\\u0005\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000036303030755c                           // .asciz 8, '\\u0006\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000037303030755c                           // .asciz 8, '\\u0007\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000038303030755c                           // .asciz 8, '\\u0008\x00\x00'
+	QUAD $0x0000000000000002                           // .quad 2
+	QUAD $0x000000000000745c                           // .asciz 8, '\\t\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000002                           // .quad 2
+	QUAD $0x0000000000006e5c                           // .asciz 8, '\\n\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000062303030755c                           // .asciz 8, '\\u000b\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000063303030755c                           // .asciz 8, '\\u000c\x00\x00'
+	QUAD $0x0000000000000002                           // .quad 2
+	QUAD $0x000000000000725c                           // .asciz 8, '\\r\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000065303030755c                           // .asciz 8, '\\u000e\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000066303030755c                           // .asciz 8, '\\u000f\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000030313030755c                           // .asciz 8, '\\u0010\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000031313030755c                           // .asciz 8, '\\u0011\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000032313030755c                           // .asciz 8, '\\u0012\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000033313030755c                           // .asciz 8, '\\u0013\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000034313030755c                           // .asciz 8, '\\u0014\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000035313030755c                           // .asciz 8, '\\u0015\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000036313030755c                           // .asciz 8, '\\u0016\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000037313030755c                           // .asciz 8, '\\u0017\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000038313030755c                           // .asciz 8, '\\u0018\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000039313030755c                           // .asciz 8, '\\u0019\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000061313030755c                           // .asciz 8, '\\u001a\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000062313030755c                           // .asciz 8, '\\u001b\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000063313030755c                           // .asciz 8, '\\u001c\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000064313030755c                           // .asciz 8, '\\u001d\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000065313030755c                           // .asciz 8, '\\u001e\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000066313030755c                           // .asciz 8, '\\u001f\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000002                           // .quad 2
+	QUAD $0x000000000000225c                           // .asciz 8, '\\"\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000002                           // .quad 2
+	QUAD $0x0000000000005c5c                           // .asciz 8, '\\\\\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+	// .p2align 4, 0x00
+__DoubleQuoteTab:
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0030303030755c5c                           // .asciz 8, '\\\\u0000\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0031303030755c5c                           // .asciz 8, '\\\\u0001\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0032303030755c5c                           // .asciz 8, '\\\\u0002\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0033303030755c5c                           // .asciz 8, '\\\\u0003\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0034303030755c5c                           // .asciz 8, '\\\\u0004\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0035303030755c5c                           // .asciz 8, '\\\\u0005\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0036303030755c5c                           // .asciz 8, '\\\\u0006\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0037303030755c5c                           // .asciz 8, '\\\\u0007\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0038303030755c5c                           // .asciz 8, '\\\\u0008\x00'
+	QUAD $0x0000000000000003                           // .quad 3
+	QUAD $0x0000000000745c5c                           // .asciz 8, '\\\\t\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000003                           // .quad 3
+	QUAD $0x00000000006e5c5c                           // .asciz 8, '\\\\n\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0062303030755c5c                           // .asciz 8, '\\\\u000b\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0063303030755c5c                           // .asciz 8, '\\\\u000c\x00'
+	QUAD $0x0000000000000003                           // .quad 3
+	QUAD $0x0000000000725c5c                           // .asciz 8, '\\\\r\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0065303030755c5c                           // .asciz 8, '\\\\u000e\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0066303030755c5c                           // .asciz 8, '\\\\u000f\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0030313030755c5c                           // .asciz 8, '\\\\u0010\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0031313030755c5c                           // .asciz 8, '\\\\u0011\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0032313030755c5c                           // .asciz 8, '\\\\u0012\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0033313030755c5c                           // .asciz 8, '\\\\u0013\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0034313030755c5c                           // .asciz 8, '\\\\u0014\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0035313030755c5c                           // .asciz 8, '\\\\u0015\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0036313030755c5c                           // .asciz 8, '\\\\u0016\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0037313030755c5c                           // .asciz 8, '\\\\u0017\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0038313030755c5c                           // .asciz 8, '\\\\u0018\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0039313030755c5c                           // .asciz 8, '\\\\u0019\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0061313030755c5c                           // .asciz 8, '\\\\u001a\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0062313030755c5c                           // .asciz 8, '\\\\u001b\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0063313030755c5c                           // .asciz 8, '\\\\u001c\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0064313030755c5c                           // .asciz 8, '\\\\u001d\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0065313030755c5c                           // .asciz 8, '\\\\u001e\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0066313030755c5c                           // .asciz 8, '\\\\u001f\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000004                           // .quad 4
+	QUAD $0x00000000225c5c5c                           // .asciz 8, '\\\\\\"\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000004                           // .quad 4
+	QUAD $0x000000005c5c5c5c                           // .asciz 8, '\\\\\\\\\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+	// .p2align 4, 0x00
+__EscTab:
+	QUAD $0x0101010101010101; QUAD $0x0101010101010101     // .ascii 16, '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01'
+	QUAD $0x0101010101010101; QUAD $0x0101010101010101     // .ascii 16, '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01'
+	QUAD $0x0000000000010000; QUAD $0x0000000000000000     // .ascii 16, '\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; LONG $0x00000000; BYTE $0x01 // .ascii 13, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	WORD $0x0000; BYTE $0x00                               // .space 3, '\x00\x00\x00'
+
+	// .p2align 4, 0x00
+__UnquoteTab:
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000220000; QUAD $0x2f00000000000000 // .ascii 16, '\x00\x00"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00/'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000005c00000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\\\x00\x00\x00'
+	QUAD $0x000c000000080000; QUAD $0x000a000000000000 // .ascii 16, '\x00\x00\x08\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\n\x00'
+	LONG $0x000d0000; WORD $0xff09                     // .ascii 6, '\x00\x00\r\x00\t\xff'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; WORD $0x0000             // .space 10, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+	// .p2align 4, 0x00
+__HtmlQuoteTab:
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000036323030755c                           // .asciz 8, '\\u0026\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000063333030755c                           // .asciz 8, '\\u003c\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000065333030755c                           // .asciz 8, '\\u003e\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000038323032755c                           // .asciz 8, '\\u2028\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000039323032755c                           // .asciz 8, '\\u2029\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+	// .p2align 4, 0x00
+_LSHIFT_TAB:
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000                           // .space 8, '\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000001                                   // .long 1
+	QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000001                                   // .long 1
+	QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000001                                   // .long 1
+	QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000002                                   // .long 2
+	QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000002                                   // .long 2
+	QUAD $0x0000000035323133; QUAD $0x0000000000000000 // .asciz 16, '3125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000002                                   // .long 2
+	QUAD $0x0000003532363531; QUAD $0x0000000000000000 // .asciz 16, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000003                                   // .long 3
+	QUAD $0x0000003532313837; QUAD $0x0000000000000000 // .asciz 16, '78125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000003                                   // .long 3
+	QUAD $0x0000353236303933; QUAD $0x0000000000000000 // .asciz 16, '390625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000003                                   // .long 3
+	QUAD $0x0035323133353931; QUAD $0x0000000000000000 // .asciz 16, '1953125\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000004                                   // .long 4
+	QUAD $0x0035323635363739; QUAD $0x0000000000000000 // .asciz 16, '9765625\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000004                                   // .long 4
+	QUAD $0x3532313832383834; QUAD $0x0000000000000000 // .asciz 16, '48828125\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000004                                   // .long 4
+	QUAD $0x3236303431343432; QUAD $0x0000000000000035 // .asciz 16, '244140625\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000004                                   // .long 4
+	QUAD $0x3133303730323231; QUAD $0x0000000000003532 // .asciz 16, '1220703125\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000005                                   // .long 5
+	QUAD $0x3635313533303136; QUAD $0x0000000000003532 // .asciz 16, '6103515625\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000005                                   // .long 5
+	QUAD $0x3837353731353033; QUAD $0x0000000000353231 // .asciz 16, '30517578125\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000005                                   // .long 5
+	QUAD $0x3938373835323531; QUAD $0x0000000035323630 // .asciz 16, '152587890625\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000006                                   // .long 6
+	QUAD $0x3534393339323637; QUAD $0x0000000035323133 // .asciz 16, '762939453125\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000006                                   // .long 6
+	QUAD $0x3237393634313833; QUAD $0x0000003532363536 // .asciz 16, '3814697265625\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000006                                   // .long 6
+	QUAD $0x3638343337303931; QUAD $0x0000353231383233 // .asciz 16, '19073486328125\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000007                                   // .long 7
+	QUAD $0x3133343736333539; QUAD $0x0000353236303436 // .asciz 16, '95367431640625\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000007                                   // .long 7
+	QUAD $0x3531373338363734; QUAD $0x0035323133303238 // .asciz 16, '476837158203125\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000007                                   // .long 7
+	QUAD $0x3735383134383332; QUAD $0x3532363531303139 // .asciz 16, '2384185791015625'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000007                                   // .long 7
+	QUAD $0x3832393032393131; QUAD $0x3231383730353539 // .asciz 16, '1192092895507812'
+	QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000008                                   // .long 8
+	QUAD $0x3434363430363935; QUAD $0x3236303933353737 // .asciz 16, '5960464477539062'
+	QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000008                                   // .long 8
+	QUAD $0x3232333230383932; QUAD $0x3133353936373833 // .asciz 16, '2980232238769531'
+	QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000008                                   // .long 8
+	QUAD $0x3136313130393431; QUAD $0x3536373438333931 // .asciz 16, '1490116119384765'
+	QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000009                                   // .long 9
+	QUAD $0x3530383530353437; QUAD $0x3832383332393639 // .asciz 16, '7450580596923828'
+	QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000009                                   // .long 9
+	QUAD $0x3230393235323733; QUAD $0x3431393136343839 // .asciz 16, '3725290298461914'
+	QUAD $0x0000000035323630; QUAD $0x0000000000000000 // .asciz 16, '0625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000009                                   // .long 9
+	QUAD $0x3135343632363831; QUAD $0x3735393033323934 // .asciz 16, '1862645149230957'
+	QUAD $0x0000003532313330; QUAD $0x0000000000000000 // .asciz 16, '03125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000a                                   // .long 10
+	QUAD $0x3735323233313339; QUAD $0x3538373435313634 // .asciz 16, '9313225746154785'
+	QUAD $0x0000003532363531; QUAD $0x0000000000000000 // .asciz 16, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000a                                   // .long 10
+	QUAD $0x3832313636353634; QUAD $0x3239333737303337 // .asciz 16, '4656612873077392'
+	QUAD $0x0000353231383735; QUAD $0x0000000000000000 // .asciz 16, '578125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000a                                   // .long 10
+	QUAD $0x3436303338323332; QUAD $0x3639363833353633 // .asciz 16, '2328306436538696'
+	QUAD $0x0035323630393832; QUAD $0x0000000000000000 // .asciz 16, '2890625\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000a                                   // .long 10
+	QUAD $0x3233353134363131; QUAD $0x3834333936323831 // .asciz 16, '1164153218269348'
+	QUAD $0x3532313335343431; QUAD $0x0000000000000000 // .asciz 16, '14453125\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000b                                   // .long 11
+	QUAD $0x3036363730323835; QUAD $0x3034373634333139 // .asciz 16, '5820766091346740'
+	QUAD $0x3532363536323237; QUAD $0x0000000000000000 // .asciz 16, '72265625\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000b                                   // .long 11
+	QUAD $0x3033383330313932; QUAD $0x3037333337363534 // .asciz 16, '2910383045673370'
+	QUAD $0x3231383233313633; QUAD $0x0000000000000035 // .asciz 16, '361328125\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000b                                   // .long 11
+	QUAD $0x3531393135353431; QUAD $0x3538363633383232 // .asciz 16, '1455191522836685'
+	QUAD $0x3630343636303831; QUAD $0x0000000000003532 // .asciz 16, '1806640625\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000c                                   // .long 12
+	QUAD $0x3637353935373237; QUAD $0x3532343338313431 // .asciz 16, '7275957614183425'
+	QUAD $0x3133303233333039; QUAD $0x0000000000003532 // .asciz 16, '9033203125\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000c                                   // .long 12
+	QUAD $0x3838373937333633; QUAD $0x3231373139303730 // .asciz 16, '3637978807091712'
+	QUAD $0x3531303636313539; QUAD $0x0000000000353236 // .asciz 16, '95166015625\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000c                                   // .long 12
+	QUAD $0x3439383938313831; QUAD $0x3635383534353330 // .asciz 16, '1818989403545856'
+	QUAD $0x3730303338353734; QUAD $0x0000000035323138 // .asciz 16, '475830078125\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000d                                   // .long 13
+	QUAD $0x3037343934393039; QUAD $0x3238323932373731 // .asciz 16, '9094947017729282'
+	QUAD $0x3933303531393733; QUAD $0x0000000035323630 // .asciz 16, '379150390625\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000d                                   // .long 13
+	QUAD $0x3533373437343534; QUAD $0x3134363436383830 // .asciz 16, '4547473508864641'
+	QUAD $0x3931353735393831; QUAD $0x0000003532313335 // .asciz 16, '1895751953125\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000d                                   // .long 13
+	QUAD $0x3736333733373232; QUAD $0x3032333233343435 // .asciz 16, '2273736754432320'
+	QUAD $0x3935373837343935; QUAD $0x0000353236353637 // .asciz 16, '59478759765625\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000d                                   // .long 13
+	QUAD $0x3338363836333131; QUAD $0x3036313631323737 // .asciz 16, '1136868377216160'
+	QUAD $0x3937333933373932; QUAD $0x0035323138323838 // .asciz 16, '297393798828125\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000e                                   // .long 14
+	QUAD $0x3831343334383635; QUAD $0x3130383038303638 // .asciz 16, '5684341886080801'
+	QUAD $0x3939383639363834; QUAD $0x0035323630343134 // .asciz 16, '486968994140625\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000e                                   // .long 14
+	QUAD $0x3930373132343832; QUAD $0x3030343034303334 // .asciz 16, '2842170943040400'
+	QUAD $0x3934343834333437; QUAD $0x3532313330373037 // .asciz 16, '7434844970703125'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000e                                   // .long 14
+	QUAD $0x3435383031323431; QUAD $0x3030323032353137 // .asciz 16, '1421085471520200'
+	QUAD $0x3432323437313733; QUAD $0x3236353135333538 // .asciz 16, '3717422485351562'
+	QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000f                                   // .long 15
+	QUAD $0x3337323435303137; QUAD $0x3130303130363735 // .asciz 16, '7105427357601001'
+	QUAD $0x3432313137383538; QUAD $0x3231383735373632 // .asciz 16, '8587112426757812'
+	QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000f                                   // .long 15
+	QUAD $0x3633313732353533; QUAD $0x3030353030383837 // .asciz 16, '3552713678800500'
+	QUAD $0x3236353533393239; QUAD $0x3630393837333331 // .asciz 16, '9293556213378906'
+	QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000f                                   // .long 15
+	QUAD $0x3836353336373731; QUAD $0x3035323030343933 // .asciz 16, '1776356839400250'
+	QUAD $0x3138373736343634; QUAD $0x3335343938363630 // .asciz 16, '4646778106689453'
+	QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000010                                   // .long 16
+	QUAD $0x3134383731383838; QUAD $0x3235323130303739 // .asciz 16, '8881784197001252'
+	QUAD $0x3530393833333233; QUAD $0x3536323734343333 // .asciz 16, '3233890533447265'
+	QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000010                                   // .long 16
+	QUAD $0x3032393830343434; QUAD $0x3632363030353839 // .asciz 16, '4440892098500626'
+	QUAD $0x3235343936313631; QUAD $0x3233363332373636 // .asciz 16, '1616945266723632'
+	QUAD $0x0000000035323138; QUAD $0x0000000000000000 // .asciz 16, '8125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000010                                   // .long 16
+	QUAD $0x3036343430323232; QUAD $0x3331333035323934 // .asciz 16, '2220446049250313'
+	QUAD $0x3632373438303830; QUAD $0x3631383136333333 // .asciz 16, '0808472633361816'
+	QUAD $0x0000003532363034; QUAD $0x0000000000000000 // .asciz 16, '40625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000010                                   // .long 16
+	QUAD $0x3033323230313131; QUAD $0x3635313532363432 // .asciz 16, '1110223024625156'
+	QUAD $0x3336333234303435; QUAD $0x3830393038363631 // .asciz 16, '5404236316680908'
+	QUAD $0x0000353231333032; QUAD $0x0000000000000000 // .asciz 16, '203125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000011                                   // .long 17
+	QUAD $0x3135313131353535; QUAD $0x3238373532313332 // .asciz 16, '5551115123125782'
+	QUAD $0x3531383131323037; QUAD $0x3134353430343338 // .asciz 16, '7021181583404541'
+	QUAD $0x0000353236353130; QUAD $0x0000000000000000 // .asciz 16, '015625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000011                                   // .long 17
+	QUAD $0x3537353535373732; QUAD $0x3139383236353136 // .asciz 16, '2775557561562891'
+	QUAD $0x3730393530313533; QUAD $0x3037323230373139 // .asciz 16, '3510590791702270'
+	QUAD $0x0035323138373035; QUAD $0x0000000000000000 // .asciz 16, '5078125\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000011                                   // .long 17
+	QUAD $0x3738373737383331; QUAD $0x3534343138373038 // .asciz 16, '1387778780781445'
+	QUAD $0x3335393235353736; QUAD $0x3533313135383539 // .asciz 16, '6755295395851135'
+	QUAD $0x3532363039333532; QUAD $0x0000000000000000 // .asciz 16, '25390625\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000012                                   // .long 18
+	QUAD $0x3933393838333936; QUAD $0x3832323730393330 // .asciz 16, '6938893903907228'
+	QUAD $0x3936373436373733; QUAD $0x3637363535323937 // .asciz 16, '3776476979255676'
+	QUAD $0x3532313335393632; QUAD $0x0000000000000000 // .asciz 16, '26953125\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000012                                   // .long 18
+	QUAD $0x3936343439363433; QUAD $0x3431363335393135 // .asciz 16, '3469446951953614'
+	QUAD $0x3438333238383831; QUAD $0x3833383732363938 // .asciz 16, '1888238489627838'
+	QUAD $0x3236353637343331; QUAD $0x0000000000000035 // .asciz 16, '134765625\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000012                                   // .long 18
+	QUAD $0x3433323734333731; QUAD $0x3730383637393537 // .asciz 16, '1734723475976807'
+	QUAD $0x3239313134343930; QUAD $0x3931393331383434 // .asciz 16, '0944119244813919'
+	QUAD $0x3138323833373630; QUAD $0x0000000000003532 // .asciz 16, '0673828125\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000013                                   // .long 19
+	QUAD $0x3337313633373638; QUAD $0x3533303438383937 // .asciz 16, '8673617379884035'
+	QUAD $0x3236393530323734; QUAD $0x3539353936303432 // .asciz 16, '4720596224069595'
+	QUAD $0x3630343139363333; QUAD $0x0000000000003532 // .asciz 16, '3369140625\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	QUAD $0x0000000000000000                           // .p2align 4, 0x00
+
+_P10_TAB:
+	QUAD $0x3ff0000000000000 // .quad 0x3ff0000000000000
+	QUAD $0x4024000000000000 // .quad 0x4024000000000000
+	QUAD $0x4059000000000000 // .quad 0x4059000000000000
+	QUAD $0x408f400000000000 // .quad 0x408f400000000000
+	QUAD $0x40c3880000000000 // .quad 0x40c3880000000000
+	QUAD $0x40f86a0000000000 // .quad 0x40f86a0000000000
+	QUAD $0x412e848000000000 // .quad 0x412e848000000000
+	QUAD $0x416312d000000000 // .quad 0x416312d000000000
+	QUAD $0x4197d78400000000 // .quad 0x4197d78400000000
+	QUAD $0x41cdcd6500000000 // .quad 0x41cdcd6500000000
+	QUAD $0x4202a05f20000000 // .quad 0x4202a05f20000000
+	QUAD $0x42374876e8000000 // .quad 0x42374876e8000000
+	QUAD $0x426d1a94a2000000 // .quad 0x426d1a94a2000000
+	QUAD $0x42a2309ce5400000 // .quad 0x42a2309ce5400000
+	QUAD $0x42d6bcc41e900000 // .quad 0x42d6bcc41e900000
+	QUAD $0x430c6bf526340000 // .quad 0x430c6bf526340000
+	QUAD $0x4341c37937e08000 // .quad 0x4341c37937e08000
+	QUAD $0x4376345785d8a000 // .quad 0x4376345785d8a000
+	QUAD $0x43abc16d674ec800 // .quad 0x43abc16d674ec800
+	QUAD $0x43e158e460913d00 // .quad 0x43e158e460913d00
+	QUAD $0x4415af1d78b58c40 // .quad 0x4415af1d78b58c40
+	QUAD $0x444b1ae4d6e2ef50 // .quad 0x444b1ae4d6e2ef50
+	QUAD $0x4480f0cf064dd592 // .quad 0x4480f0cf064dd592
+	QUAD $0x0000000000000000 // .p2align 4, 0x00
+
+_LB_ff7ea7df: // _pow10_ceil_sig_f32.g
+	QUAD $0x81ceb32c4b43fcf5 // .quad -9093133594791772939
+	QUAD $0xa2425ff75e14fc32 // .quad -6754730975062328270
+	QUAD $0xcad2f7f5359a3b3f // .quad -3831727700400522433
+	QUAD $0xfd87b5f28300ca0e // .quad -177973607073265138
+	QUAD $0x9e74d1b791e07e49 // .quad -7028762532061872567
+	QUAD $0xc612062576589ddb // .quad -4174267146649952805
+	QUAD $0xf79687aed3eec552 // .quad -606147914885053102
+	QUAD $0x9abe14cd44753b53 // .quad -7296371474444240045
+	QUAD $0xc16d9a0095928a28 // .quad -4508778324627912152
+	QUAD $0xf1c90080baf72cb2 // .quad -1024286887357502286
+	QUAD $0x971da05074da7bef // .quad -7557708332239520785
+	QUAD $0xbce5086492111aeb // .quad -4835449396872013077
+	QUAD $0xec1e4a7db69561a6 // .quad -1432625727662628442
+	QUAD $0x9392ee8e921d5d08 // .quad -7812920107430224632
+	QUAD $0xb877aa3236a4b44a // .quad -5154464115860392886
+	QUAD $0xe69594bec44de15c // .quad -1831394126398103204
+	QUAD $0x901d7cf73ab0acda // .quad -8062150356639896358
+	QUAD $0xb424dc35095cd810 // .quad -5466001927372482544
+	QUAD $0xe12e13424bb40e14 // .quad -2220816390788215276
+	QUAD $0x8cbccc096f5088cc // .quad -8305539271883716404
+	QUAD $0xafebff0bcb24aaff // .quad -5770238071427257601
+	QUAD $0xdbe6fecebdedd5bf // .quad -2601111570856684097
+	QUAD $0x89705f4136b4a598 // .quad -8543223759426509416
+	QUAD $0xabcc77118461cefd // .quad -6067343680855748867
+	QUAD $0xd6bf94d5e57a42bd // .quad -2972493582642298179
+	QUAD $0x8637bd05af6c69b6 // .quad -8775337516792518218
+	QUAD $0xa7c5ac471b478424 // .quad -6357485877563259868
+	QUAD $0xd1b71758e219652c // .quad -3335171328526686932
+	QUAD $0x83126e978d4fdf3c // .quad -9002011107970261188
+	QUAD $0xa3d70a3d70a3d70b // .quad -6640827866535438581
+	QUAD $0xcccccccccccccccd // .quad -3689348814741910323
+	QUAD $0x8000000000000000 // .quad -9223372036854775808
+	QUAD $0xa000000000000000 // .quad -6917529027641081856
+	QUAD $0xc800000000000000 // .quad -4035225266123964416
+	QUAD $0xfa00000000000000 // .quad -432345564227567616
+	QUAD $0x9c40000000000000 // .quad -7187745005283311616
+	QUAD $0xc350000000000000 // .quad -4372995238176751616
+	QUAD $0xf424000000000000 // .quad -854558029293551616
+	QUAD $0x9896800000000000 // .quad -7451627795949551616
+	QUAD $0xbebc200000000000 // .quad -4702848726509551616
+	QUAD $0xee6b280000000000 // .quad -1266874889709551616
+	QUAD $0x9502f90000000000 // .quad -7709325833709551616
+	QUAD $0xba43b74000000000 // .quad -5024971273709551616
+	QUAD $0xe8d4a51000000000 // .quad -1669528073709551616
+	QUAD $0x9184e72a00000000 // .quad -7960984073709551616
+	QUAD $0xb5e620f480000000 // .quad -5339544073709551616
+	QUAD $0xe35fa931a0000000 // .quad -2062744073709551616
+	QUAD $0x8e1bc9bf04000000 // .quad -8206744073709551616
+	QUAD $0xb1a2bc2ec5000000 // .quad -5646744073709551616
+	QUAD $0xde0b6b3a76400000 // .quad -2446744073709551616
+	QUAD $0x8ac7230489e80000 // .quad -8446744073709551616
+	QUAD $0xad78ebc5ac620000 // .quad -5946744073709551616
+	QUAD $0xd8d726b7177a8000 // .quad -2821744073709551616
+	QUAD $0x878678326eac9000 // .quad -8681119073709551616
+	QUAD $0xa968163f0a57b400 // .quad -6239712823709551616
+	QUAD $0xd3c21bcecceda100 // .quad -3187955011209551616
+	QUAD $0x84595161401484a0 // .quad -8910000909647051616
+	QUAD $0xa56fa5b99019a5c8 // .quad -6525815118631426616
+	QUAD $0xcecb8f27f4200f3a // .quad -3545582879861895366
+	QUAD $0x813f3978f8940985 // .quad -9133518327554766459
+	QUAD $0xa18f07d736b90be6 // .quad -6805211891016070170
+	QUAD $0xc9f2c9cd04674edf // .quad -3894828845342699809
+	QUAD $0xfc6f7c4045812297 // .quad -256850038250986857
+	QUAD $0x9dc5ada82b70b59e // .quad -7078060301547948642
+	QUAD $0xc5371912364ce306 // .quad -4235889358507547898
+	QUAD $0xf684df56c3e01bc7 // .quad -683175679707046969
+	QUAD $0x9a130b963a6c115d // .quad -7344513827457986211
+	QUAD $0xc097ce7bc90715b4 // .quad -4568956265895094860
+	QUAD $0xf0bdc21abb48db21 // .quad -1099509313941480671
+	QUAD $0x96769950b50d88f5 // .quad -7604722348854507275
+	QUAD $0xbc143fa4e250eb32 // .quad -4894216917640746190
+	QUAD $0xeb194f8e1ae525fe // .quad -1506085128623544834
+	QUAD $0x92efd1b8d0cf37bf // .quad -7858832233030797377
+	QUAD $0xb7abc627050305ae // .quad -5211854272861108818
+	QUAD $0xe596b7b0c643c71a // .quad -1903131822648998118
+	QUAD $0x8f7e32ce7bea5c70 // .quad -8106986416796705680
+	QUAD $0xb35dbf821ae4f38c // .quad -5522047002568494196
+
+TEXT ·__f32toa(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -56(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_f32toa:
+	MOVQ  out+0(FP), DI
+	MOVSD val+8(FP), X0
+	CALL  ·__native_entry__+29744(SB) // _f32toa
+	MOVQ  AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__f64toa(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -80(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_f64toa:
+	MOVQ  out+0(FP), DI
+	MOVSD val+8(FP), X0
+	CALL  ·__native_entry__+496(SB) // _f64toa
+	MOVQ  AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__get_by_path(SB), NOSPLIT | NOFRAME, $0 - 32
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -312(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_get_by_path:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ path+16(FP), DX
+	CALL ·__native_entry__+27424(SB) // _get_by_path
+	MOVQ AX, ret+24(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__html_escape(SB), NOSPLIT | NOFRAME, $0 - 40
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -64(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_html_escape:
+	MOVQ sp+0(FP), DI
+	MOVQ nb+8(FP), SI
+	MOVQ dp+16(FP), DX
+	MOVQ dn+24(FP), CX
+	CALL ·__native_entry__+9968(SB) // _html_escape
+	MOVQ AX, ret+32(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__i64toa(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -16(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_i64toa:
+	MOVQ out+0(FP), DI
+	MOVQ val+8(FP), SI
+	CALL ·__native_entry__+4112(SB) // _i64toa
+	MOVQ AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__lspace(SB), NOSPLIT | NOFRAME, $0 - 32
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -8(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_lspace:
+	MOVQ sp+0(FP), DI
+	MOVQ nb+8(FP), SI
+	MOVQ off+16(FP), DX
+	CALL ·__native_entry__+80(SB) // _lspace
+	MOVQ AX, ret+24(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__quote(SB), NOSPLIT | NOFRAME, $0 - 48
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -80(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_quote:
+	MOVQ sp+0(FP), DI
+	MOVQ nb+8(FP), SI
+	MOVQ dp+16(FP), DX
+	MOVQ dn+24(FP), CX
+	MOVQ flags+32(FP), R8
+	CALL ·__native_entry__+5792(SB) // _quote
+	MOVQ AX, ret+40(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__skip_array(SB), NOSPLIT | NOFRAME, $0 - 40
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -128(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_skip_array:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ m+16(FP), DX
+	MOVQ flags+24(FP), CX
+	CALL ·__native_entry__+20576(SB) // _skip_array
+	MOVQ AX, ret+32(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__skip_number(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -72(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_skip_number:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	CALL ·__native_entry__+23920(SB) // _skip_number
+	MOVQ AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__skip_object(SB), NOSPLIT | NOFRAME, $0 - 40
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -128(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_skip_object:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ m+16(FP), DX
+	MOVQ flags+24(FP), CX
+	CALL ·__native_entry__+22496(SB) // _skip_object
+	MOVQ AX, ret+32(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__skip_one(SB), NOSPLIT | NOFRAME, $0 - 40
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -128(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_skip_one:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ m+16(FP), DX
+	MOVQ flags+24(FP), CX
+	CALL ·__native_entry__+24080(SB) // _skip_one
+	MOVQ AX, ret+32(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__skip_one_fast(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -208(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_skip_one_fast:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	CALL ·__native_entry__+24320(SB) // _skip_one_fast
+	MOVQ AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__u64toa(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -8(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_u64toa:
+	MOVQ out+0(FP), DI
+	MOVQ val+8(FP), SI
+	CALL ·__native_entry__+4384(SB) // _u64toa
+	MOVQ AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__unquote(SB), NOSPLIT | NOFRAME, $0 - 48
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -128(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_unquote:
+	MOVQ sp+0(FP), DI
+	MOVQ nb+8(FP), SI
+	MOVQ dp+16(FP), DX
+	MOVQ ep+24(FP), CX
+	MOVQ flags+32(FP), R8
+	CALL ·__native_entry__+7488(SB) // _unquote
+	MOVQ AX, ret+40(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__validate_one(SB), NOSPLIT | NOFRAME, $0 - 32
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -128(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_validate_one:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ m+16(FP), DX
+	CALL ·__native_entry__+24144(SB) // _validate_one
+	MOVQ AX, ret+24(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__validate_utf8(SB), NOSPLIT | NOFRAME, $0 - 32
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -48(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_validate_utf8:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ m+16(FP), DX
+	CALL ·__native_entry__+28464(SB) // _validate_utf8
+	MOVQ AX, ret+24(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__validate_utf8_fast(SB), NOSPLIT | NOFRAME, $0 - 16
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -24(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_validate_utf8_fast:
+	MOVQ s+0(FP), DI
+	CALL ·__native_entry__+29136(SB) // _validate_utf8_fast
+	MOVQ AX, ret+8(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__value(SB), NOSPLIT | NOFRAME, $0 - 48
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -368(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_value:
+	MOVQ s+0(FP), DI
+	MOVQ n+8(FP), SI
+	MOVQ p+16(FP), DX
+	MOVQ v+24(FP), CX
+	MOVQ flags+32(FP), R8
+	CALL ·__native_entry__+14672(SB) // _value
+	MOVQ AX, ret+40(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__vnumber(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -280(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_vnumber:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ v+16(FP), DX
+	LEAQ ·__native_entry__+18320(SB), AX // _vnumber
+	JMP  AX
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__vsigned(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -16(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_vsigned:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ v+16(FP), DX
+	LEAQ ·__native_entry__+19856(SB), AX // _vsigned
+	JMP  AX
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__vstring(SB), NOSPLIT | NOFRAME, $0 - 32
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -128(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_vstring:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ v+16(FP), DX
+	MOVQ flags+24(FP), CX
+	LEAQ ·__native_entry__+16864(SB), AX // _vstring
+	JMP  AX
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__vunsigned(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -24(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_vunsigned:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ v+16(FP), DX
+	LEAQ ·__native_entry__+20208(SB), AX // _vunsigned
+	JMP  AX
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx/native_export_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/avx/native_export_amd64.go
new file mode 100644
index 000000000..1ca7f5753
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/avx/native_export_amd64.go
@@ -0,0 +1,49 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx
+
+var (
+    S_f64toa = _subr__f64toa
+    S_f32toa = _subr__f32toa
+    S_i64toa = _subr__i64toa
+    S_u64toa = _subr__u64toa
+    S_lspace = _subr__lspace
+)
+
+var (
+    S_quote   = _subr__quote
+    S_unquote = _subr__unquote
+)
+
+var (
+    S_value     = _subr__value
+    S_vstring   = _subr__vstring
+    S_vnumber   = _subr__vnumber
+    S_vsigned   = _subr__vsigned
+    S_vunsigned = _subr__vunsigned
+)
+
+var (
+    S_skip_one    = _subr__skip_one
+    S_skip_one_fast = _subr__skip_one_fast
+    S_skip_array  = _subr__skip_array
+    S_skip_object = _subr__skip_object
+    S_skip_number = _subr__skip_number
+    S_get_by_path = _subr__get_by_path
+)
diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx/native_subr_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/avx/native_subr_amd64.go
new file mode 100644
index 000000000..34eaeb97c
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/avx/native_subr_amd64.go
@@ -0,0 +1,109 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx
+
+//go:nosplit
+//go:noescape
+//goland:noinspection ALL
+func __native_entry__() uintptr
+
+var (
+    _subr__f32toa             = __native_entry__() + 29744
+    _subr__f64toa             = __native_entry__() + 496
+    _subr__get_by_path        = __native_entry__() + 27424
+    _subr__html_escape        = __native_entry__() + 9968
+    _subr__i64toa             = __native_entry__() + 4112
+    _subr__lspace             = __native_entry__() + 80
+    _subr__quote              = __native_entry__() + 5792
+    _subr__skip_array         = __native_entry__() + 20576
+    _subr__skip_number        = __native_entry__() + 23920
+    _subr__skip_object        = __native_entry__() + 22496
+    _subr__skip_one           = __native_entry__() + 24080
+    _subr__skip_one_fast      = __native_entry__() + 24320
+    _subr__u64toa             = __native_entry__() + 4384
+    _subr__unquote            = __native_entry__() + 7488
+    _subr__validate_one       = __native_entry__() + 24144
+    _subr__validate_utf8      = __native_entry__() + 28464
+    _subr__validate_utf8_fast = __native_entry__() + 29136
+    _subr__value              = __native_entry__() + 14672
+    _subr__vnumber            = __native_entry__() + 18320
+    _subr__vsigned            = __native_entry__() + 19856
+    _subr__vstring            = __native_entry__() + 16864
+    _subr__vunsigned          = __native_entry__() + 20208
+)
+
+const (
+    _stack__f32toa = 56
+    _stack__f64toa = 80
+    _stack__get_by_path = 312
+    _stack__html_escape = 64
+    _stack__i64toa = 16
+    _stack__lspace = 8
+    _stack__quote = 80
+    _stack__skip_array = 128
+    _stack__skip_number = 72
+    _stack__skip_object = 128
+    _stack__skip_one = 128
+    _stack__skip_one_fast = 208
+    _stack__u64toa = 8
+    _stack__unquote = 128
+    _stack__validate_one = 128
+    _stack__validate_utf8 = 48
+    _stack__validate_utf8_fast = 24
+    _stack__value = 368
+    _stack__vnumber = 280
+    _stack__vsigned = 16
+    _stack__vstring = 128
+    _stack__vunsigned = 24
+)
+
+var (
+    _ = _subr__f32toa
+    _ = _subr__f64toa
+    _ = _subr__get_by_path
+    _ = _subr__html_escape
+    _ = _subr__i64toa
+    _ = _subr__lspace
+    _ = _subr__quote
+    _ = _subr__skip_array
+    _ = _subr__skip_number
+    _ = _subr__skip_object
+    _ = _subr__skip_one
+    _ = _subr__skip_one_fast
+    _ = _subr__u64toa
+    _ = _subr__unquote
+    _ = _subr__validate_one
+    _ = _subr__validate_utf8
+    _ = _subr__validate_utf8_fast
+    _ = _subr__value
+    _ = _subr__vnumber
+    _ = _subr__vsigned
+    _ = _subr__vstring
+    _ = _subr__vunsigned
+)
+
+const (
+    _ = _stack__f32toa
+    _ = _stack__f64toa
+    _ = _stack__get_by_path
+    _ = _stack__html_escape
+    _ = _stack__i64toa
+    _ = _stack__lspace
+    _ = _stack__quote
+    _ = _stack__skip_array
+    _ = _stack__skip_number
+    _ = _stack__skip_object
+    _ = _stack__skip_one
+    _ = _stack__skip_one_fast
+    _ = _stack__u64toa
+    _ = _stack__unquote
+    _ = _stack__validate_one
+    _ = _stack__validate_utf8
+    _ = _stack__validate_utf8_fast
+    _ = _stack__value
+    _ = _stack__vnumber
+    _ = _stack__vsigned
+    _ = _stack__vstring
+    _ = _stack__vunsigned
+)
diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.go
new file mode 100644
index 000000000..bf7c68683
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.go
@@ -0,0 +1,135 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx2
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native/types`
+)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __i64toa(out *byte, val int64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __u64toa(out *byte, val uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __f64toa(out *byte, val float64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __f32toa(out *byte, val float32) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __lspace(sp unsafe.Pointer, nb int, off int) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __vstring(s *string, p *int, v *types.JsonState, flags uint64)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __vnumber(s *string, p *int, v *types.JsonState)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __vsigned(s *string, p *int, v *types.JsonState)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __vunsigned(s *string, p *int, v *types.JsonState)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_one_fast(s *string, p *int) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_number(s *string, p *int) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __validate_one(s *string, p *int, m *types.StateMachine) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __get_by_path(s *string, p *int, path *[]interface{}) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __validate_utf8(s *string, p *int, m *types.StateMachine) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __validate_utf8_fast(s *string)  (ret int)
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.s b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.s
new file mode 100644
index 000000000..198a06e92
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_amd64.s
@@ -0,0 +1,16629 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+#include "go_asm.h"
+#include "funcdata.h"
+#include "textflag.h"
+
+TEXT ·__native_entry__(SB), NOSPLIT, $0
+	NO_LOCAL_POINTERS
+	LONG $0xf9058d48; WORD $0xffff; BYTE $0xff                                   // leaq         $-7(%rip), %rax
+	LONG $0x24448948; BYTE $0x08                                                 // movq         %rax, $8(%rsp)
+	BYTE $0xc3                                                                   // retq
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000; WORD $0x0000; BYTE $0x00 // .p2align 5, 0x00
+
+LCPI0_0:
+	QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, '                '
+	QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, '                '
+
+LCPI0_1:
+	QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'
+	QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'
+
+LCPI0_2:
+	QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n'
+	QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n'
+
+LCPI0_3:
+	QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r'
+	QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r'
+
+	// .p2align 4, 0x00
+LCPI0_4:
+	QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, '                '
+
+LCPI0_5:
+	QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'
+
+LCPI0_6:
+	QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n'
+
+LCPI0_7:
+	QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r'
+
+	// .p2align 4, 0x90
+_lspace:
+	BYTE $0x55                                         // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                           // movq         %rsp, %rbp
+	WORD $0x8948; BYTE $0xd0                           // movq         %rdx, %rax
+	LONG $0x17148d4c                                   // leaq         (%rdi,%rdx), %r10
+	WORD $0x8948; BYTE $0xf2                           // movq         %rsi, %rdx
+	WORD $0x2948; BYTE $0xc2                           // subq         %rax, %rdx
+	LONG $0x0066840f; WORD $0x0000                     // je           LBB0_7, $102(%rip)
+	WORD $0x8944; BYTE $0xd1                           // movl         %r10d, %ecx
+	WORD $0xe183; BYTE $0x1f                           // andl         $31, %ecx
+	LONG $0x005a840f; WORD $0x0000                     // je           LBB0_7, $90(%rip)
+	LONG $0x014f8d4c                                   // leaq         $1(%rdi), %r9
+	LONG $0xff4e8d48                                   // leaq         $-1(%rsi), %rcx
+	QUAD $0x000100002600b849; WORD $0x0000             // movabsq      $4294977024, %r8
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB0_3:
+	LONG $0x0714be0f               // movsbl       (%rdi,%rax), %edx
+	WORD $0xfa83; BYTE $0x20       // cmpl         $32, %edx
+	LONG $0x016e870f; WORD $0x0000 // ja           LBB0_27, $366(%rip)
+	LONG $0xd0a30f49               // btq          %rdx, %r8
+	LONG $0x0164830f; WORD $0x0000 // jae          LBB0_27, $356(%rip)
+	LONG $0x01508d48               // leaq         $1(%rax), %rdx
+	WORD $0x3948; BYTE $0xc1       // cmpq         %rax, %rcx
+	LONG $0x000f840f; WORD $0x0000 // je           LBB0_6, $15(%rip)
+	WORD $0x0144; BYTE $0xc8       // addl         %r9d, %eax
+	WORD $0xe083; BYTE $0x1f       // andl         $31, %eax
+	WORD $0x8948; BYTE $0xd0       // movq         %rdx, %rax
+	LONG $0xffcd850f; WORD $0xffff // jne          LBB0_3, $-51(%rip)
+
+LBB0_6:
+	LONG $0x17148d4c         // leaq         (%rdi,%rdx), %r10
+	WORD $0x2948; BYTE $0xd6 // subq         %rdx, %rsi
+	WORD $0x8948; BYTE $0xf2 // movq         %rsi, %rdx
+
+LBB0_7:
+	LONG $0x20fa8348               // cmpq         $32, %rdx
+	LONG $0x006d820f; WORD $0x0000 // jb           LBB0_13, $109(%rip)
+	WORD $0x8948; BYTE $0xfe       // movq         %rdi, %rsi
+	WORD $0x294c; BYTE $0xd6       // subq         %r10, %rsi
+	QUAD $0xfffffeab056ffdc5       // vmovdqa      $-341(%rip), %ymm0  /* LCPI0_0(%rip) */
+	QUAD $0xfffffec30d6ffdc5       // vmovdqa      $-317(%rip), %ymm1  /* LCPI0_1(%rip) */
+	QUAD $0xfffffedb156ffdc5       // vmovdqa      $-293(%rip), %ymm2  /* LCPI0_2(%rip) */
+	QUAD $0xfffffef31d6ffdc5       // vmovdqa      $-269(%rip), %ymm3  /* LCPI0_3(%rip) */
+	WORD $0x9090; BYTE $0x90       // .p2align 4, 0x90
+
+LBB0_9:
+	LONG $0x6f7dc1c4; BYTE $0x22   // vmovdqa      (%r10), %ymm4
+	LONG $0xe874ddc5               // vpcmpeqb     %ymm0, %ymm4, %ymm5
+	LONG $0xf174ddc5               // vpcmpeqb     %ymm1, %ymm4, %ymm6
+	LONG $0xeeebd5c5               // vpor         %ymm6, %ymm5, %ymm5
+	LONG $0xf274ddc5               // vpcmpeqb     %ymm2, %ymm4, %ymm6
+	LONG $0xe374ddc5               // vpcmpeqb     %ymm3, %ymm4, %ymm4
+	LONG $0xe6ebddc5               // vpor         %ymm6, %ymm4, %ymm4
+	LONG $0xe5ebddc5               // vpor         %ymm5, %ymm4, %ymm4
+	LONG $0xc4d7fdc5               // vpmovmskb    %ymm4, %eax
+	WORD $0xf883; BYTE $0xff       // cmpl         $-1, %eax
+	LONG $0x00df850f; WORD $0x0000 // jne          LBB0_10, $223(%rip)
+	LONG $0x20c28349               // addq         $32, %r10
+	LONG $0xe0c28348               // addq         $-32, %rdx
+	LONG $0xe0c68348               // addq         $-32, %rsi
+	LONG $0x1ffa8348               // cmpq         $31, %rdx
+	LONG $0xffbc870f; WORD $0xffff // ja           LBB0_9, $-68(%rip)
+
+LBB0_13:
+	WORD $0xf8c5; BYTE $0x77             // vzeroupper
+	LONG $0x10fa8348                     // cmpq         $16, %rdx
+	LONG $0x0074820f; WORD $0x0000       // jb           LBB0_18, $116(%rip)
+	WORD $0x8948; BYTE $0xfe             // movq         %rdi, %rsi
+	WORD $0x294c; BYTE $0xd6             // subq         %r10, %rsi
+	QUAD $0xfffffeb1056ff9c5             // vmovdqa      $-335(%rip), %xmm0  /* LCPI0_4(%rip) */
+	QUAD $0xfffffeb90d6ff9c5             // vmovdqa      $-327(%rip), %xmm1  /* LCPI0_5(%rip) */
+	QUAD $0xfffffec1156ff9c5             // vmovdqa      $-319(%rip), %xmm2  /* LCPI0_6(%rip) */
+	QUAD $0xfffffec91d6ff9c5             // vmovdqa      $-311(%rip), %xmm3  /* LCPI0_7(%rip) */
+	QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB0_15:
+	LONG $0x6f79c1c4; BYTE $0x22   // vmovdqa      (%r10), %xmm4
+	LONG $0xe874d9c5               // vpcmpeqb     %xmm0, %xmm4, %xmm5
+	LONG $0xf174d9c5               // vpcmpeqb     %xmm1, %xmm4, %xmm6
+	LONG $0xeeebd1c5               // vpor         %xmm6, %xmm5, %xmm5
+	LONG $0xf274d9c5               // vpcmpeqb     %xmm2, %xmm4, %xmm6
+	LONG $0xe374d9c5               // vpcmpeqb     %xmm3, %xmm4, %xmm4
+	LONG $0xe6ebd9c5               // vpor         %xmm6, %xmm4, %xmm4
+	LONG $0xe5ebd9c5               // vpor         %xmm5, %xmm4, %xmm4
+	LONG $0xc4d7f9c5               // vpmovmskb    %xmm4, %eax
+	LONG $0xfff88366               // cmpw         $-1, %ax
+	LONG $0x006b850f; WORD $0x0000 // jne          LBB0_16, $107(%rip)
+	LONG $0x10c28349               // addq         $16, %r10
+	LONG $0xf0c28348               // addq         $-16, %rdx
+	LONG $0xf0c68348               // addq         $-16, %rsi
+	LONG $0x0ffa8348               // cmpq         $15, %rdx
+	LONG $0xffbb870f; WORD $0xffff // ja           LBB0_15, $-69(%rip)
+
+LBB0_18:
+	WORD $0x8548; BYTE $0xd2               // testq        %rdx, %rdx
+	LONG $0x0037840f; WORD $0x0000         // je           LBB0_25, $55(%rip)
+	LONG $0x12048d4d                       // leaq         (%r10,%rdx), %r8
+	WORD $0xc031                           // xorl         %eax, %eax
+	QUAD $0x000100002600b949; WORD $0x0000 // movabsq      $4294977024, %r9
+
+LBB0_20:
+	LONG $0x34be0f41; BYTE $0x02   // movsbl       (%r10,%rax), %esi
+	WORD $0xfe83; BYTE $0x20       // cmpl         $32, %esi
+	LONG $0x0036870f; WORD $0x0000 // ja           LBB0_22, $54(%rip)
+	LONG $0xf1a30f49               // btq          %rsi, %r9
+	LONG $0x002c830f; WORD $0x0000 // jae          LBB0_22, $44(%rip)
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3948; BYTE $0xc2       // cmpq         %rax, %rdx
+	LONG $0xffdc850f; WORD $0xffff // jne          LBB0_20, $-36(%rip)
+	WORD $0x894d; BYTE $0xc2       // movq         %r8, %r10
+
+LBB0_25:
+	WORD $0x2949; BYTE $0xfa // subq         %rdi, %r10
+
+LBB0_26:
+	WORD $0x894c; BYTE $0xd0 // movq         %r10, %rax
+
+LBB0_27:
+	BYTE $0x5d // popq         %rbp
+	BYTE $0xc3 // retq
+
+LBB0_10:
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+
+LBB0_11:
+	WORD $0xd0f7             // notl         %eax
+	WORD $0xbc0f; BYTE $0xc0 // bsfl         %eax, %eax
+	WORD $0x2948; BYTE $0xf0 // subq         %rsi, %rax
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB0_16:
+	WORD $0xb70f; BYTE $0xc0     // movzwl       %ax, %eax
+	LONG $0xffffeee9; BYTE $0xff // jmp          LBB0_11, $-18(%rip)
+
+LBB0_22:
+	WORD $0x2949; BYTE $0xfa     // subq         %rdi, %r10
+	WORD $0x0149; BYTE $0xc2     // addq         %rax, %r10
+	LONG $0xffffdbe9; BYTE $0xff // jmp          LBB0_26, $-37(%rip)
+	WORD $0x0000; BYTE $0x00     // .p2align 5, 0x00
+
+LCPI1_0:
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+
+	// .p2align 4, 0x00
+LCPI1_1:
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+
+	// .p2align 4, 0x90
+_f64toa:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	BYTE $0x50                                 // pushq        %rax
+	LONG $0x7ef9e1c4; BYTE $0xc2               // vmovq        %xmm0, %rdx
+	WORD $0x8948; BYTE $0xd0                   // movq         %rdx, %rax
+	LONG $0x34e8c148                           // shrq         $52, %rax
+	LONG $0x0007ff25; BYTE $0x00               // andl         $2047, %eax
+	LONG $0x0007ff3d; BYTE $0x00               // cmpl         $2047, %eax
+	LONG $0x0c1e840f; WORD $0x0000             // je           LBB1_1, $3102(%rip)
+	WORD $0x8948; BYTE $0xfe                   // movq         %rdi, %rsi
+	WORD $0x07c6; BYTE $0x2d                   // movb         $45, (%rdi)
+	WORD $0x8949; BYTE $0xd5                   // movq         %rdx, %r13
+	LONG $0x3fedc149                           // shrq         $63, %r13
+	LONG $0x2f3c8d4e                           // leaq         (%rdi,%r13), %r15
+	QUAD $0x00000000550c8d48                   // leaq         (,%rdx,2), %rcx
+	WORD $0x8548; BYTE $0xc9                   // testq        %rcx, %rcx
+	LONG $0x01f5840f; WORD $0x0000             // je           LBB1_3, $501(%rip)
+	QUAD $0xffffffffffffbf48; WORD $0x000f     // movabsq      $4503599627370495, %rdi
+	WORD $0x2148; BYTE $0xfa                   // andq         %rdi, %rdx
+	WORD $0xc085                               // testl        %eax, %eax
+	LONG $0xd0758948                           // movq         %rsi, $-48(%rbp)
+	LONG $0x0bea840f; WORD $0x0000             // je           LBB1_5, $3050(%rip)
+	WORD $0xff48; BYTE $0xc7                   // incq         %rdi
+	WORD $0x0948; BYTE $0xd7                   // orq          %rdx, %rdi
+	LONG $0xfbcdb08d; WORD $0xffff             // leal         $-1075(%rax), %esi
+	LONG $0xfc01888d; WORD $0xffff             // leal         $-1023(%rax), %ecx
+	WORD $0xf983; BYTE $0x34                   // cmpl         $52, %ecx
+	LONG $0x001d870f; WORD $0x0000             // ja           LBB1_6, $29(%rip)
+	LONG $0x000433b9; BYTE $0x00               // movl         $1075, %ecx
+	WORD $0xc129                               // subl         %eax, %ecx
+	LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rbx
+	WORD $0xd348; BYTE $0xe3                   // shlq         %cl, %rbx
+	WORD $0xf748; BYTE $0xd3                   // notq         %rbx
+	WORD $0x8548; BYTE $0xdf                   // testq        %rbx, %rdi
+	LONG $0x0421840f; WORD $0x0000             // je           LBB1_11, $1057(%rip)
+
+LBB1_6:
+	WORD $0x8548; BYTE $0xd2                   // testq        %rdx, %rdx
+	WORD $0x940f; BYTE $0xc1                   // sete         %cl
+	WORD $0xf883; BYTE $0x02                   // cmpl         $2, %eax
+	WORD $0x930f; BYTE $0xc0                   // setae        %al
+	WORD $0xc820                               // andb         %cl, %al
+	QUAD $0x00000000bd0c8d4c                   // leaq         (,%rdi,4), %r9
+	WORD $0xb60f; BYTE $0xc0                   // movzbl       %al, %eax
+	LONG $0xb81c8d48                           // leaq         (%rax,%rdi,4), %rbx
+	LONG $0xfec38348                           // addq         $-2, %rbx
+	LONG $0x4413ce69; WORD $0x0013             // imull        $1262611, %esi, %ecx
+	LONG $0x01918d44; WORD $0xf801; BYTE $0xff // leal         $-524031(%rcx), %r10d
+	WORD $0xc084                               // testb        %al, %al
+	LONG $0xd1440f44                           // cmovel       %ecx, %r10d
+	QUAD $0x00000002bd048d4c                   // leaq         $2(,%rdi,4), %r8
+	LONG $0x16fac141                           // sarl         $22, %r10d
+	LONG $0xb1ca6941; WORD $0xe56c; BYTE $0xff // imull        $-1741647, %r10d, %ecx
+	WORD $0xe9c1; BYTE $0x13                   // shrl         $19, %ecx
+	WORD $0xf101                               // addl         %esi, %ecx
+	LONG $0x000124b8; BYTE $0x00               // movl         $292, %eax
+	WORD $0x2944; BYTE $0xd0                   // subl         %r10d, %eax
+	LONG $0x04e0c148                           // shlq         $4, %rax
+	LONG $0x44158d48; WORD $0x00cc; BYTE $0x00 // leaq         $52292(%rip), %rdx  /* _pow10_ceil_sig.g(%rip) */
+	LONG $0x101c8b4c                           // movq         (%rax,%rdx), %r11
+	LONG $0x10748b4c; BYTE $0x08               // movq         $8(%rax,%rdx), %r14
+	WORD $0xc1fe                               // incb         %cl
+	WORD $0xd348; BYTE $0xe3                   // shlq         %cl, %rbx
+	WORD $0x8948; BYTE $0xd8                   // movq         %rbx, %rax
+	WORD $0xf749; BYTE $0xe6                   // mulq         %r14
+	WORD $0x8948; BYTE $0xd6                   // movq         %rdx, %rsi
+	WORD $0x8948; BYTE $0xd8                   // movq         %rbx, %rax
+	WORD $0xf749; BYTE $0xe3                   // mulq         %r11
+	WORD $0x0148; BYTE $0xf0                   // addq         %rsi, %rax
+	LONG $0x00d28348                           // adcq         $0, %rdx
+	WORD $0xf631                               // xorl         %esi, %esi
+	LONG $0xfffea948; WORD $0xffff             // testq        $-2, %rax
+	LONG $0xc6950f40                           // setne        %sil
+	WORD $0x0948; BYTE $0xd6                   // orq          %rdx, %rsi
+	WORD $0xd349; BYTE $0xe1                   // shlq         %cl, %r9
+	WORD $0x894c; BYTE $0xc8                   // movq         %r9, %rax
+	WORD $0xf749; BYTE $0xe6                   // mulq         %r14
+	WORD $0x8948; BYTE $0xd3                   // movq         %rdx, %rbx
+	WORD $0x894c; BYTE $0xc8                   // movq         %r9, %rax
+	WORD $0xf749; BYTE $0xe3                   // mulq         %r11
+	WORD $0x8949; BYTE $0xd1                   // movq         %rdx, %r9
+	WORD $0x0148; BYTE $0xd8                   // addq         %rbx, %rax
+	LONG $0x00d18349                           // adcq         $0, %r9
+	WORD $0xdb31                               // xorl         %ebx, %ebx
+	LONG $0xfffea948; WORD $0xffff             // testq        $-2, %rax
+	WORD $0x950f; BYTE $0xc3                   // setne        %bl
+	WORD $0x094c; BYTE $0xcb                   // orq          %r9, %rbx
+	WORD $0xd349; BYTE $0xe0                   // shlq         %cl, %r8
+	WORD $0x894c; BYTE $0xc0                   // movq         %r8, %rax
+	WORD $0xf749; BYTE $0xe6                   // mulq         %r14
+	WORD $0x8948; BYTE $0xd1                   // movq         %rdx, %rcx
+	WORD $0x894c; BYTE $0xc0                   // movq         %r8, %rax
+	WORD $0xf749; BYTE $0xe3                   // mulq         %r11
+	WORD $0x0148; BYTE $0xc8                   // addq         %rcx, %rax
+	LONG $0x00d28348                           // adcq         $0, %rdx
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0xfffea948; WORD $0xffff             // testq        $-2, %rax
+	WORD $0x950f; BYTE $0xc1                   // setne        %cl
+	WORD $0x0948; BYTE $0xd1                   // orq          %rdx, %rcx
+	WORD $0xe783; BYTE $0x01                   // andl         $1, %edi
+	WORD $0x0148; BYTE $0xfe                   // addq         %rdi, %rsi
+	WORD $0x2948; BYTE $0xf9                   // subq         %rdi, %rcx
+	LONG $0x28fb8348                           // cmpq         $40, %rbx
+	LONG $0x0043820f; WORD $0x0000             // jb           LBB1_28, $67(%rip)
+	QUAD $0xcccccccccccdba48; WORD $0xcccc     // movabsq      $-3689348814741910323, %rdx
+	WORD $0x894c; BYTE $0xc8                   // movq         %r9, %rax
+	WORD $0xf748; BYTE $0xe2                   // mulq         %rdx
+	WORD $0x8948; BYTE $0xd7                   // movq         %rdx, %rdi
+	LONG $0x05efc148                           // shrq         $5, %rdi
+	QUAD $0x00000000fd048d48                   // leaq         (,%rdi,8), %rax
+	LONG $0x80148d48                           // leaq         (%rax,%rax,4), %rdx
+	WORD $0x3948; BYTE $0xd6                   // cmpq         %rdx, %rsi
+	LONG $0xc0970f41                           // seta         %r8b
+	LONG $0x80148d48                           // leaq         (%rax,%rax,4), %rdx
+	LONG $0x28c28348                           // addq         $40, %rdx
+	WORD $0xc031                               // xorl         %eax, %eax
+	WORD $0x3948; BYTE $0xca                   // cmpq         %rcx, %rdx
+	WORD $0x960f; BYTE $0xc2                   // setbe        %dl
+	WORD $0x3841; BYTE $0xd0                   // cmpb         %dl, %r8b
+	LONG $0x0134840f; WORD $0x0000             // je           LBB1_8, $308(%rip)
+
+LBB1_28:
+	WORD $0x894d; BYTE $0xc8       // movq         %r9, %r8
+	LONG $0x02e8c149               // shrq         $2, %r8
+	WORD $0x894c; BYTE $0xca       // movq         %r9, %rdx
+	LONG $0xfce28348               // andq         $-4, %rdx
+	WORD $0x3948; BYTE $0xd6       // cmpq         %rdx, %rsi
+	LONG $0xc7970f40               // seta         %dil
+	LONG $0x04728d48               // leaq         $4(%rdx), %rsi
+	WORD $0x3948; BYTE $0xce       // cmpq         %rcx, %rsi
+	WORD $0x960f; BYTE $0xc0       // setbe        %al
+	WORD $0x3040; BYTE $0xf8       // xorb         %dil, %al
+	LONG $0x0055840f; WORD $0x0000 // je           LBB1_29, $85(%rip)
+	LONG $0x02ca8348               // orq          $2, %rdx
+	LONG $0x000001bf; BYTE $0x00   // movl         $1, %edi
+	WORD $0x3948; BYTE $0xd3       // cmpq         %rdx, %rbx
+	LONG $0x000e870f; WORD $0x0000 // ja           LBB1_32, $14(%rip)
+	WORD $0x940f; BYTE $0xc0       // sete         %al
+	LONG $0x02e9c041               // shrb         $2, %r9b
+	WORD $0x2041; BYTE $0xc1       // andb         %al, %r9b
+	LONG $0xf9b60f41               // movzbl       %r9b, %edi
+
+LBB1_32:
+	WORD $0x014c; BYTE $0xc7               // addq         %r8, %rdi
+	QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq      $8589934464, %r12
+	QUAD $0x540be47f24848d49               // leaq         $1410065535(%r12), %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x003c870f; WORD $0x0000         // ja           LBB1_34, $60(%rip)
+	LONG $0x0000ece9; BYTE $0x00           // jmp          LBB1_40, $236(%rip)
+
+LBB1_3:
+	LONG $0x3007c641             // movb         $48, (%r15)
+	WORD $0x2941; BYTE $0xf7     // subl         %esi, %r15d
+	WORD $0xff41; BYTE $0xc7     // incl         %r15d
+	WORD $0x8944; BYTE $0xfb     // movl         %r15d, %ebx
+	LONG $0x0009e1e9; BYTE $0x00 // jmp          LBB1_123, $2529(%rip)
+
+LBB1_29:
+	WORD $0x3948; BYTE $0xf1               // cmpq         %rsi, %rcx
+	LONG $0xffd88349                       // sbbq         $-1, %r8
+	WORD $0x894c; BYTE $0xc7               // movq         %r8, %rdi
+	QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq      $8589934464, %r12
+	QUAD $0x540be47f24848d49               // leaq         $1410065535(%r12), %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x00b5860f; WORD $0x0000         // jbe          LBB1_40, $181(%rip)
+
+LBB1_34:
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0be8c148                       // shrq         $11, %rax
+	LONG $0x00000bba; BYTE $0x00           // movl         $11, %edx
+	LONG $0x0edd3d48; WORD $0x02e9         // cmpq         $48828125, %rax
+	LONG $0x0136820f; WORD $0x0000         // jb           LBB1_49, $310(%rip)
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0ce8c148                       // shrq         $12, %rax
+	LONG $0x00000cba; BYTE $0x00           // movl         $12, %edx
+	LONG $0x4a513d48; WORD $0x0e8d         // cmpq         $244140625, %rax
+	LONG $0x011e820f; WORD $0x0000         // jb           LBB1_49, $286(%rip)
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0de8c148                       // shrq         $13, %rax
+	LONG $0x00000dba; BYTE $0x00           // movl         $13, %edx
+	LONG $0x73953d48; WORD $0x48c2         // cmpq         $1220703125, %rax
+	LONG $0x0106820f; WORD $0x0000         // jb           LBB1_49, $262(%rip)
+	LONG $0x00000eba; BYTE $0x00           // movl         $14, %edx
+	QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq      $100000000000000, %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x00ee820f; WORD $0x0000         // jb           LBB1_49, $238(%rip)
+	LONG $0x00000fba; BYTE $0x00           // movl         $15, %edx
+	QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq      $1000000000000000, %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x00d6820f; WORD $0x0000         // jb           LBB1_49, $214(%rip)
+	QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq      $10000000000000000, %rax
+	WORD $0xd231                           // xorl         %edx, %edx
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	WORD $0x920f; BYTE $0xc2               // setb         %dl
+	WORD $0xf283; BYTE $0x11               // xorl         $17, %edx
+	LONG $0x0000bce9; BYTE $0x00           // jmp          LBB1_49, $188(%rip)
+
+LBB1_8:
+	WORD $0xd088                           // movb         %dl, %al
+	WORD $0x0148; BYTE $0xc7               // addq         %rax, %rdi
+	WORD $0xff41; BYTE $0xc2               // incl         %r10d
+	QUAD $0x0001ffffff80bc49; WORD $0x0000 // movabsq      $8589934464, %r12
+	QUAD $0x540be47f24848d49               // leaq         $1410065535(%r12), %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0xff4b870f; WORD $0xffff         // ja           LBB1_34, $-181(%rip)
+
+LBB1_40:
+	LONG $0x000001ba; BYTE $0x00               // movl         $1, %edx
+	LONG $0x0aff8348                           // cmpq         $10, %rdi
+	LONG $0x008a820f; WORD $0x0000             // jb           LBB1_49, $138(%rip)
+	LONG $0x000002ba; BYTE $0x00               // movl         $2, %edx
+	LONG $0x64ff8348                           // cmpq         $100, %rdi
+	LONG $0x007b820f; WORD $0x0000             // jb           LBB1_49, $123(%rip)
+	LONG $0x000003ba; BYTE $0x00               // movl         $3, %edx
+	LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq         $1000, %rdi
+	LONG $0x0069820f; WORD $0x0000             // jb           LBB1_49, $105(%rip)
+	LONG $0x000004ba; BYTE $0x00               // movl         $4, %edx
+	LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq         $10000, %rdi
+	LONG $0x0057820f; WORD $0x0000             // jb           LBB1_49, $87(%rip)
+	LONG $0x000005ba; BYTE $0x00               // movl         $5, %edx
+	LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq         $100000, %rdi
+	LONG $0x0045820f; WORD $0x0000             // jb           LBB1_49, $69(%rip)
+	LONG $0x000006ba; BYTE $0x00               // movl         $6, %edx
+	LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq         $1000000, %rdi
+	LONG $0x0033820f; WORD $0x0000             // jb           LBB1_49, $51(%rip)
+	LONG $0x000007ba; BYTE $0x00               // movl         $7, %edx
+	LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq         $10000000, %rdi
+	LONG $0x0021820f; WORD $0x0000             // jb           LBB1_49, $33(%rip)
+	LONG $0x000008ba; BYTE $0x00               // movl         $8, %edx
+	LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq         $100000000, %rdi
+	LONG $0x000f820f; WORD $0x0000             // jb           LBB1_49, $15(%rip)
+	LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq         $1000000000, %rdi
+	LONG $0x00000aba; BYTE $0x00               // movl         $10, %edx
+	WORD $0xda83; BYTE $0x00                   // sbbl         $0, %edx
+
+LBB1_49:
+	LONG $0x12348d46                                       // leal         (%rdx,%r10), %r14d
+	LONG $0x12048d42                                       // leal         (%rdx,%r10), %eax
+	WORD $0xc083; BYTE $0xea                               // addl         $-22, %eax
+	WORD $0xf883; BYTE $0xe4                               // cmpl         $-28, %eax
+	LONG $0x00a4870f; WORD $0x0000                         // ja           LBB1_62, $164(%rip)
+	LONG $0x01678d4d                                       // leaq         $1(%r15), %r12
+	WORD $0x894c; BYTE $0xe6                               // movq         %r12, %rsi
+	LONG $0x0090eae8; BYTE $0x00                           // callq        _format_significand, $37098(%rip)
+	WORD $0x8948; BYTE $0xc3                               // movq         %rax, %rbx
+	LONG $0xd0558b4c                                       // movq         $-48(%rbp), %r10
+	WORD $0x294c; BYTE $0xd0                               // subq         %r10, %rax
+	WORD $0x294c; BYTE $0xe8                               // subq         %r13, %rax
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB1_51:
+	WORD $0xff48; BYTE $0xc8       // decq         %rax
+	LONG $0x30ff7b80               // cmpb         $48, $-1(%rbx)
+	LONG $0xff5b8d48               // leaq         $-1(%rbx), %rbx
+	LONG $0xffef840f; WORD $0xffff // je           LBB1_51, $-17(%rip)
+	LONG $0x4fb60f41; BYTE $0x01   // movzbl       $1(%r15), %ecx
+	WORD $0x8841; BYTE $0x0f       // movb         %cl, (%r15)
+	LONG $0x02f88348               // cmpq         $2, %rax
+	LONG $0x00088c0f; WORD $0x0000 // jl           LBB1_54, $8(%rip)
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	LONG $0x2404c641; BYTE $0x2e   // movb         $46, (%r12)
+
+LBB1_54:
+	WORD $0x03c6; BYTE $0x65       // movb         $101, (%rbx)
+	WORD $0x8545; BYTE $0xf6       // testl        %r14d, %r14d
+	LONG $0x011d8e0f; WORD $0x0000 // jle          LBB1_55, $285(%rip)
+	WORD $0xff41; BYTE $0xce       // decl         %r14d
+	LONG $0x2b0143c6               // movb         $43, $1(%rbx)
+	WORD $0x8944; BYTE $0xf0       // movl         %r14d, %eax
+	WORD $0xf883; BYTE $0x64       // cmpl         $100, %eax
+	LONG $0x011f820f; WORD $0x0000 // jb           LBB1_59, $287(%rip)
+
+LBB1_58:
+	WORD $0xc189                               // movl         %eax, %ecx
+	LONG $0xcccccdba; BYTE $0xcc               // movl         $3435973837, %edx
+	LONG $0xd1af0f48                           // imulq        %rcx, %rdx
+	LONG $0x23eac148                           // shrq         $35, %rdx
+	WORD $0x0c8d; BYTE $0x12                   // leal         (%rdx,%rdx), %ecx
+	WORD $0x0c8d; BYTE $0x89                   // leal         (%rcx,%rcx,4), %ecx
+	WORD $0xc829                               // subl         %ecx, %eax
+	LONG $0x080d8d48; WORD $0x00c8; BYTE $0x00 // leaq         $51208(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x510cb70f                           // movzwl       (%rcx,%rdx,2), %ecx
+	LONG $0x024b8966                           // movw         %cx, $2(%rbx)
+	WORD $0x300c                               // orb          $48, %al
+	WORD $0x4388; BYTE $0x04                   // movb         %al, $4(%rbx)
+	LONG $0x05c38348                           // addq         $5, %rbx
+	LONG $0x0007b3e9; BYTE $0x00               // jmp          LBB1_122, $1971(%rip)
+
+LBB1_62:
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0x0105880f; WORD $0x0000 // js           LBB1_63, $261(%rip)
+	WORD $0x8945; BYTE $0xf6       // movl         %r14d, %r14d
+	LONG $0x371c8d4b               // leaq         (%r15,%r14), %rbx
+	WORD $0x894c; BYTE $0xfe       // movq         %r15, %rsi
+	LONG $0x0007dae8; BYTE $0x00   // callq        _format_integer, $2010(%rip)
+	WORD $0x3948; BYTE $0xd8       // cmpq         %rbx, %rax
+	LONG $0x0154830f; WORD $0x0000 // jae          LBB1_103, $340(%rip)
+	LONG $0xd0558b4c               // movq         $-48(%rbp), %r10
+	WORD $0x014d; BYTE $0xd5       // addq         %r10, %r13
+	WORD $0x014d; BYTE $0xf5       // addq         %r14, %r13
+	WORD $0x2949; BYTE $0xc5       // subq         %rax, %r13
+	LONG $0x10fd8349               // cmpq         $16, %r13
+	LONG $0x01f1830f; WORD $0x0000 // jae          LBB1_105, $497(%rip)
+
+LBB1_120:
+	WORD $0x8948; BYTE $0xc2     // movq         %rax, %rdx
+	LONG $0x000372e9; BYTE $0x00 // jmp          LBB1_121, $882(%rip)
+
+LBB1_11:
+	WORD $0xd348; BYTE $0xef               // shrq         %cl, %rdi
+	QUAD $0x0001ffffff80b848; WORD $0x0000 // movabsq      $8589934464, %rax
+	LONG $0xe47f0548; WORD $0x540b         // addq         $1410065535, %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x0130860f; WORD $0x0000         // jbe          LBB1_17, $304(%rip)
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0be8c148                       // shrq         $11, %rax
+	LONG $0x00000bba; BYTE $0x00           // movl         $11, %edx
+	LONG $0x0edd3d48; WORD $0x02e9         // cmpq         $48828125, %rax
+	LONG $0x01a2820f; WORD $0x0000         // jb           LBB1_27, $418(%rip)
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0ce8c148                       // shrq         $12, %rax
+	LONG $0x00000cba; BYTE $0x00           // movl         $12, %edx
+	LONG $0x4a513d48; WORD $0x0e8d         // cmpq         $244140625, %rax
+	LONG $0x018a820f; WORD $0x0000         // jb           LBB1_27, $394(%rip)
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0de8c148                       // shrq         $13, %rax
+	LONG $0x00000dba; BYTE $0x00           // movl         $13, %edx
+	LONG $0x73953d48; WORD $0x48c2         // cmpq         $1220703125, %rax
+	LONG $0x0172820f; WORD $0x0000         // jb           LBB1_27, $370(%rip)
+	LONG $0x00000eba; BYTE $0x00           // movl         $14, %edx
+	QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq      $100000000000000, %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x015a820f; WORD $0x0000         // jb           LBB1_27, $346(%rip)
+	QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq      $1000000000000000, %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x000010ba; BYTE $0x00           // movl         $16, %edx
+
+LBB1_26:
+	WORD $0xda83; BYTE $0x00     // sbbl         $0, %edx
+	LONG $0x000140e9; BYTE $0x00 // jmp          LBB1_27, $320(%rip)
+
+LBB1_55:
+	LONG $0x2d0143c6               // movb         $45, $1(%rbx)
+	LONG $0x000001b8; BYTE $0x00   // movl         $1, %eax
+	WORD $0x2944; BYTE $0xf0       // subl         %r14d, %eax
+	WORD $0xf883; BYTE $0x64       // cmpl         $100, %eax
+	LONG $0xfee1830f; WORD $0xffff // jae          LBB1_58, $-287(%rip)
+
+LBB1_59:
+	WORD $0xf883; BYTE $0x0a                   // cmpl         $10, %eax
+	LONG $0x008a820f; WORD $0x0000             // jb           LBB1_61, $138(%rip)
+	WORD $0xc089                               // movl         %eax, %eax
+	LONG $0xf50d8d48; WORD $0x00c6; BYTE $0x00 // leaq         $50933(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	LONG $0x02438966                           // movw         %ax, $2(%rbx)
+	LONG $0x04c38348                           // addq         $4, %rbx
+	LONG $0x0006a5e9; BYTE $0x00               // jmp          LBB1_122, $1701(%rip)
+
+LBB1_63:
+	WORD $0x8545; BYTE $0xf6                   // testl        %r14d, %r14d
+	LONG $0x03ca8f0f; WORD $0x0000             // jg           LBB1_76, $970(%rip)
+	LONG $0x07c74166; WORD $0x2e30             // movw         $11824, (%r15)
+	LONG $0x02c78349                           // addq         $2, %r15
+	WORD $0x8545; BYTE $0xf6                   // testl        %r14d, %r14d
+	LONG $0x03b7890f; WORD $0x0000             // jns          LBB1_76, $951(%rip)
+	WORD $0x8941; BYTE $0xd0                   // movl         %edx, %r8d
+	WORD $0xf741; BYTE $0xd0                   // notl         %r8d
+	WORD $0x2945; BYTE $0xd0                   // subl         %r10d, %r8d
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0x7ff88341                           // cmpl         $127, %r8d
+	LONG $0x038e820f; WORD $0x0000             // jb           LBB1_74, $910(%rip)
+	WORD $0xff49; BYTE $0xc0                   // incq         %r8
+	WORD $0x894c; BYTE $0xc0                   // movq         %r8, %rax
+	WORD $0x214c; BYTE $0xe0                   // andq         %r12, %rax
+	LONG $0x80488d48                           // leaq         $-128(%rax), %rcx
+	WORD $0x8948; BYTE $0xce                   // movq         %rcx, %rsi
+	LONG $0x07eec148                           // shrq         $7, %rsi
+	WORD $0xff48; BYTE $0xc6                   // incq         %rsi
+	WORD $0x8941; BYTE $0xf1                   // movl         %esi, %r9d
+	LONG $0x03e18341                           // andl         $3, %r9d
+	LONG $0x80f98148; WORD $0x0001; BYTE $0x00 // cmpq         $384, %rcx
+	LONG $0x0264830f; WORD $0x0000             // jae          LBB1_68, $612(%rip)
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0xd0558b4c                           // movq         $-48(%rbp), %r10
+	LONG $0x000307e9; BYTE $0x00               // jmp          LBB1_70, $775(%rip)
+
+LBB1_103:
+	LONG $0xd0558b4c             // movq         $-48(%rbp), %r10
+	LONG $0x000635e9; BYTE $0x00 // jmp          LBB1_122, $1589(%rip)
+
+LBB1_61:
+	WORD $0x3004                 // addb         $48, %al
+	WORD $0x4388; BYTE $0x02     // movb         %al, $2(%rbx)
+	LONG $0x03c38348             // addq         $3, %rbx
+	LONG $0x000627e9; BYTE $0x00 // jmp          LBB1_122, $1575(%rip)
+
+LBB1_17:
+	LONG $0x000001ba; BYTE $0x00               // movl         $1, %edx
+	LONG $0x0aff8348                           // cmpq         $10, %rdi
+	LONG $0x007b820f; WORD $0x0000             // jb           LBB1_27, $123(%rip)
+	LONG $0x000002ba; BYTE $0x00               // movl         $2, %edx
+	LONG $0x64ff8348                           // cmpq         $100, %rdi
+	LONG $0x006c820f; WORD $0x0000             // jb           LBB1_27, $108(%rip)
+	LONG $0x000003ba; BYTE $0x00               // movl         $3, %edx
+	LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq         $1000, %rdi
+	LONG $0x005a820f; WORD $0x0000             // jb           LBB1_27, $90(%rip)
+	LONG $0x000004ba; BYTE $0x00               // movl         $4, %edx
+	LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq         $10000, %rdi
+	LONG $0x0048820f; WORD $0x0000             // jb           LBB1_27, $72(%rip)
+	LONG $0x000005ba; BYTE $0x00               // movl         $5, %edx
+	LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq         $100000, %rdi
+	LONG $0x0036820f; WORD $0x0000             // jb           LBB1_27, $54(%rip)
+	LONG $0x000006ba; BYTE $0x00               // movl         $6, %edx
+	LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq         $1000000, %rdi
+	LONG $0x0024820f; WORD $0x0000             // jb           LBB1_27, $36(%rip)
+	LONG $0x000007ba; BYTE $0x00               // movl         $7, %edx
+	LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq         $10000000, %rdi
+	LONG $0x0012820f; WORD $0x0000             // jb           LBB1_27, $18(%rip)
+	LONG $0x000008ba; BYTE $0x00               // movl         $8, %edx
+	LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq         $100000000, %rdi
+	LONG $0x05c8830f; WORD $0x0000             // jae          LBB1_25, $1480(%rip)
+
+LBB1_27:
+	WORD $0x894c; BYTE $0xfe     // movq         %r15, %rsi
+	LONG $0x0005d4e8; BYTE $0x00 // callq        _format_integer, $1492(%rip)
+	WORD $0x8948; BYTE $0xc3     // movq         %rax, %rbx
+	WORD $0x5d2b; BYTE $0xd0     // subl         $-48(%rbp), %ebx
+	LONG $0x00058de9; BYTE $0x00 // jmp          LBB1_123, $1421(%rip)
+
+LBB1_105:
+	LONG $0x80fd8149; WORD $0x0000; BYTE $0x00 // cmpq         $128, %r13
+	LONG $0x0007830f; WORD $0x0000             // jae          LBB1_110, $7(%rip)
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0x00013ce9; BYTE $0x00               // jmp          LBB1_107, $316(%rip)
+
+LBB1_110:
+	WORD $0x894c; BYTE $0xe9                   // movq         %r13, %rcx
+	LONG $0x80e18348                           // andq         $-128, %rcx
+	LONG $0x80798d48                           // leaq         $-128(%rcx), %rdi
+	WORD $0x8948; BYTE $0xfe                   // movq         %rdi, %rsi
+	LONG $0x07eec148                           // shrq         $7, %rsi
+	WORD $0xff48; BYTE $0xc6                   // incq         %rsi
+	WORD $0xf289                               // movl         %esi, %edx
+	WORD $0xe283; BYTE $0x03                   // andl         $3, %edx
+	LONG $0x80ff8148; WORD $0x0001; BYTE $0x00 // cmpq         $384, %rdi
+	LONG $0x0007830f; WORD $0x0000             // jae          LBB1_112, $7(%rip)
+	WORD $0xff31                               // xorl         %edi, %edi
+	LONG $0x0000abe9; BYTE $0x00               // jmp          LBB1_114, $171(%rip)
+
+LBB1_112:
+	LONG $0xfce68348                     // andq         $-4, %rsi
+	WORD $0xff31                         // xorl         %edi, %edi
+	QUAD $0xfffff8d9056ffdc5             // vmovdqa      $-1831(%rip), %ymm0  /* LCPI1_0(%rip) */
+	QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB1_113:
+	LONG $0x047ffec5; BYTE $0x38               // vmovdqu      %ymm0, (%rax,%rdi)
+	LONG $0x447ffec5; WORD $0x2038             // vmovdqu      %ymm0, $32(%rax,%rdi)
+	LONG $0x447ffec5; WORD $0x4038             // vmovdqu      %ymm0, $64(%rax,%rdi)
+	LONG $0x447ffec5; WORD $0x6038             // vmovdqu      %ymm0, $96(%rax,%rdi)
+	QUAD $0x00008038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $128(%rax,%rdi)
+	QUAD $0x0000a038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $160(%rax,%rdi)
+	QUAD $0x0000c038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $192(%rax,%rdi)
+	QUAD $0x0000e038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $224(%rax,%rdi)
+	QUAD $0x00010038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $256(%rax,%rdi)
+	QUAD $0x00012038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $288(%rax,%rdi)
+	QUAD $0x00014038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $320(%rax,%rdi)
+	QUAD $0x00016038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $352(%rax,%rdi)
+	QUAD $0x00018038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $384(%rax,%rdi)
+	QUAD $0x0001a038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $416(%rax,%rdi)
+	QUAD $0x0001c038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $448(%rax,%rdi)
+	QUAD $0x0001e038847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $480(%rax,%rdi)
+	LONG $0x00c78148; WORD $0x0002; BYTE $0x00 // addq         $512, %rdi
+	LONG $0xfcc68348                           // addq         $-4, %rsi
+	LONG $0xff6c850f; WORD $0xffff             // jne          LBB1_113, $-148(%rip)
+
+LBB1_114:
+	WORD $0x8548; BYTE $0xd2                               // testq        %rdx, %rdx
+	LONG $0x0047840f; WORD $0x0000                         // je           LBB1_117, $71(%rip)
+	LONG $0x07348d48                                       // leaq         (%rdi,%rax), %rsi
+	LONG $0x60c68348                                       // addq         $96, %rsi
+	LONG $0x07e2c148                                       // shlq         $7, %rdx
+	WORD $0xff31                                           // xorl         %edi, %edi
+	QUAD $0xfffff81d056ffdc5                               // vmovdqa      $-2019(%rip), %ymm0  /* LCPI1_0(%rip) */
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB1_116:
+	LONG $0x447ffec5; WORD $0xa03e // vmovdqu      %ymm0, $-96(%rsi,%rdi)
+	LONG $0x447ffec5; WORD $0xc03e // vmovdqu      %ymm0, $-64(%rsi,%rdi)
+	LONG $0x447ffec5; WORD $0xe03e // vmovdqu      %ymm0, $-32(%rsi,%rdi)
+	LONG $0x047ffec5; BYTE $0x3e   // vmovdqu      %ymm0, (%rsi,%rdi)
+	LONG $0x80ef8348               // subq         $-128, %rdi
+	WORD $0x3948; BYTE $0xfa       // cmpq         %rdi, %rdx
+	LONG $0xffdc850f; WORD $0xffff // jne          LBB1_116, $-36(%rip)
+
+LBB1_117:
+	WORD $0x3949; BYTE $0xcd       // cmpq         %rcx, %r13
+	LONG $0x0444840f; WORD $0x0000 // je           LBB1_122, $1092(%rip)
+	LONG $0x70c5f641               // testb        $112, %r13b
+	LONG $0x004d840f; WORD $0x0000 // je           LBB1_119, $77(%rip)
+
+LBB1_107:
+	WORD $0x894c; BYTE $0xee // movq         %r13, %rsi
+	LONG $0xf0e68348         // andq         $-16, %rsi
+	WORD $0x8948; BYTE $0xc2 // movq         %rax, %rdx
+	WORD $0x0148; BYTE $0xf2 // addq         %rsi, %rdx
+	QUAD $0xfffff7e4056ff9c5 // vmovdqa      $-2076(%rip), %xmm0  /* LCPI1_1(%rip) */
+	LONG $0x90909090         // .p2align 4, 0x90
+
+LBB1_108:
+	LONG $0x047ffac5; BYTE $0x08   // vmovdqu      %xmm0, (%rax,%rcx)
+	LONG $0x10c18348               // addq         $16, %rcx
+	WORD $0x3948; BYTE $0xce       // cmpq         %rcx, %rsi
+	LONG $0xffee850f; WORD $0xffff // jne          LBB1_108, $-18(%rip)
+	WORD $0x3949; BYTE $0xf5       // cmpq         %rsi, %r13
+	LONG $0x0406840f; WORD $0x0000 // je           LBB1_122, $1030(%rip)
+	LONG $0x90909090; BYTE $0x90   // .p2align 4, 0x90
+
+LBB1_121:
+	WORD $0x02c6; BYTE $0x30       // movb         $48, (%rdx)
+	WORD $0xff48; BYTE $0xc2       // incq         %rdx
+	WORD $0x3948; BYTE $0xda       // cmpq         %rbx, %rdx
+	LONG $0xfff1820f; WORD $0xffff // jb           LBB1_121, $-15(%rip)
+	LONG $0x0003ede9; BYTE $0x00   // jmp          LBB1_122, $1005(%rip)
+
+LBB1_119:
+	WORD $0x0148; BYTE $0xc8     // addq         %rcx, %rax
+	LONG $0xfffc6ae9; BYTE $0xff // jmp          LBB1_120, $-918(%rip)
+
+LBB1_68:
+	LONG $0xfce68348                           // andq         $-4, %rsi
+	LONG $0xd0558b4c                           // movq         $-48(%rbp), %r10
+	LONG $0x2a1c8d4b                           // leaq         (%r10,%r13), %rbx
+	LONG $0xe2c38148; WORD $0x0001; BYTE $0x00 // addq         $482, %rbx
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	QUAD $0xfffff767056ffdc5                   // vmovdqa      $-2201(%rip), %ymm0  /* LCPI1_0(%rip) */
+
+LBB1_69:
+	QUAD $0xfffe200b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-480(%rbx,%rcx)
+	QUAD $0xfffe400b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-448(%rbx,%rcx)
+	QUAD $0xfffe600b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-416(%rbx,%rcx)
+	QUAD $0xfffe800b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-384(%rbx,%rcx)
+	QUAD $0xfffea00b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-352(%rbx,%rcx)
+	QUAD $0xfffec00b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-320(%rbx,%rcx)
+	QUAD $0xfffee00b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-288(%rbx,%rcx)
+	QUAD $0xffff000b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-256(%rbx,%rcx)
+	QUAD $0xffff200b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-224(%rbx,%rcx)
+	QUAD $0xffff400b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-192(%rbx,%rcx)
+	QUAD $0xffff600b847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-160(%rbx,%rcx)
+	LONG $0x447ffec5; WORD $0x800b             // vmovdqu      %ymm0, $-128(%rbx,%rcx)
+	LONG $0x447ffec5; WORD $0xa00b             // vmovdqu      %ymm0, $-96(%rbx,%rcx)
+	LONG $0x447ffec5; WORD $0xc00b             // vmovdqu      %ymm0, $-64(%rbx,%rcx)
+	LONG $0x447ffec5; WORD $0xe00b             // vmovdqu      %ymm0, $-32(%rbx,%rcx)
+	LONG $0x047ffec5; BYTE $0x0b               // vmovdqu      %ymm0, (%rbx,%rcx)
+	LONG $0x00c18148; WORD $0x0002; BYTE $0x00 // addq         $512, %rcx
+	LONG $0xfcc68348                           // addq         $-4, %rsi
+	LONG $0xff6f850f; WORD $0xffff             // jne          LBB1_69, $-145(%rip)
+
+LBB1_70:
+	WORD $0x854d; BYTE $0xc9       // testq        %r9, %r9
+	LONG $0x003c840f; WORD $0x0000 // je           LBB1_73, $60(%rip)
+	WORD $0x014c; BYTE $0xe9       // addq         %r13, %rcx
+	WORD $0x014c; BYTE $0xd1       // addq         %r10, %rcx
+	LONG $0x62c18348               // addq         $98, %rcx
+	LONG $0x07e1c149               // shlq         $7, %r9
+	WORD $0xf631                   // xorl         %esi, %esi
+	QUAD $0xfffff6b5056ffdc5       // vmovdqa      $-2379(%rip), %ymm0  /* LCPI1_0(%rip) */
+
+LBB1_72:
+	LONG $0x447ffec5; WORD $0xa031 // vmovdqu      %ymm0, $-96(%rcx,%rsi)
+	LONG $0x447ffec5; WORD $0xc031 // vmovdqu      %ymm0, $-64(%rcx,%rsi)
+	LONG $0x447ffec5; WORD $0xe031 // vmovdqu      %ymm0, $-32(%rcx,%rsi)
+	LONG $0x047ffec5; BYTE $0x31   // vmovdqu      %ymm0, (%rcx,%rsi)
+	LONG $0x80ee8348               // subq         $-128, %rsi
+	WORD $0x3949; BYTE $0xf1       // cmpq         %rsi, %r9
+	LONG $0xffdc850f; WORD $0xffff // jne          LBB1_72, $-36(%rip)
+
+LBB1_73:
+	WORD $0x0149; BYTE $0xc7       // addq         %rax, %r15
+	WORD $0x3949; BYTE $0xc0       // cmpq         %rax, %r8
+	LONG $0x0014840f; WORD $0x0000 // je           LBB1_76, $20(%rip)
+
+LBB1_74:
+	WORD $0x0144; BYTE $0xf0 // addl         %r14d, %eax
+	WORD $0xd8f7             // negl         %eax
+
+	// .p2align 4, 0x90
+LBB1_75:
+	LONG $0x3007c641               // movb         $48, (%r15)
+	WORD $0xff49; BYTE $0xc7       // incq         %r15
+	WORD $0xc8ff                   // decl         %eax
+	LONG $0xfff1850f; WORD $0xffff // jne          LBB1_75, $-15(%rip)
+
+LBB1_76:
+	WORD $0x894c; BYTE $0xfe                               // movq         %r15, %rsi
+	WORD $0xf8c5; BYTE $0x77                               // vzeroupper
+	LONG $0x008b66e8; BYTE $0x00                           // callq        _format_significand, $35686(%rip)
+	WORD $0xc389                                           // movl         %eax, %ebx
+	WORD $0x2844; BYTE $0xfb                               // subb         %r15b, %bl
+	WORD $0x2844; BYTE $0xf3                               // subb         %r14b, %bl
+	LONG $0x3e2c8d47                                       // leal         (%r14,%r15), %r13d
+	WORD $0x2941; BYTE $0xc5                               // subl         %eax, %r13d
+	LONG $0xff458d45                                       // leal         $-1(%r13), %r8d
+	LONG $0xfe7d8d41                                       // leal         $-2(%r13), %edi
+	WORD $0xc931                                           // xorl         %ecx, %ecx
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB1_77:
+	WORD $0xda89                   // movl         %ebx, %edx
+	WORD $0x5a8d; BYTE $0x03       // leal         $3(%rdx), %ebx
+	WORD $0xc7ff                   // incl         %edi
+	LONG $0xff087c80; BYTE $0x30   // cmpb         $48, $-1(%rax,%rcx)
+	LONG $0xff498d48               // leaq         $-1(%rcx), %rcx
+	LONG $0xffea840f; WORD $0xffff // je           LBB1_77, $-22(%rip)
+	LONG $0x081c8d48               // leaq         (%rax,%rcx), %rbx
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	WORD $0x8545; BYTE $0xf6       // testl        %r14d, %r14d
+	LONG $0xd0558b4c               // movq         $-48(%rbp), %r10
+	LONG $0x02778e0f; WORD $0x0000 // jle          LBB1_122, $631(%rip)
+	WORD $0xc689                   // movl         %eax, %esi
+	WORD $0x2944; BYTE $0xfe       // subl         %r15d, %esi
+	WORD $0xce01                   // addl         %ecx, %esi
+	WORD $0xc6ff                   // incl         %esi
+	WORD $0x3941; BYTE $0xf6       // cmpl         %esi, %r14d
+	LONG $0x00308d0f; WORD $0x0000 // jge          LBB1_80, $48(%rip)
+	WORD $0x8941; BYTE $0xc1       // movl         %eax, %r9d
+	WORD $0x2945; BYTE $0xf1       // subl         %r14d, %r9d
+	WORD $0x2945; BYTE $0xf9       // subl         %r15d, %r9d
+	WORD $0xff41; BYTE $0xc1       // incl         %r9d
+	LONG $0x093c8d49               // leaq         (%r9,%rcx), %rdi
+	WORD $0xff85                   // testl        %edi, %edi
+	LONG $0x00e48e0f; WORD $0x0000 // jle          LBB1_99, $228(%rip)
+	WORD $0x8941; BYTE $0xf8       // movl         %edi, %r8d
+	LONG $0xff588d49               // leaq         $-1(%r8), %rbx
+	LONG $0x03fb8348               // cmpq         $3, %rbx
+	LONG $0x006c830f; WORD $0x0000 // jae          LBB1_100, $108(%rip)
+	WORD $0xdb31                   // xorl         %ebx, %ebx
+	LONG $0x000090e9; BYTE $0x00   // jmp          LBB1_96, $144(%rip)
+
+LBB1_80:
+	WORD $0x8945; BYTE $0xc3                   // movl         %r8d, %r11d
+	WORD $0x2949; BYTE $0xcb                   // subq         %rcx, %r11
+	WORD $0x8545; BYTE $0xdb                   // testl        %r11d, %r11d
+	LONG $0x02268e0f; WORD $0x0000             // jle          LBB1_122, $550(%rip)
+	WORD $0x0145; BYTE $0xfe                   // addl         %r15d, %r14d
+	WORD $0x2941; BYTE $0xc6                   // subl         %eax, %r14d
+	LONG $0xfec68341                           // addl         $-2, %r14d
+	WORD $0x2949; BYTE $0xce                   // subq         %rcx, %r14
+	WORD $0xd231                               // xorl         %edx, %edx
+	LONG $0x7ffe8341                           // cmpl         $127, %r14d
+	LONG $0x01fc820f; WORD $0x0000             // jb           LBB1_91, $508(%rip)
+	LONG $0xfec58341                           // addl         $-2, %r13d
+	WORD $0x2949; BYTE $0xcd                   // subq         %rcx, %r13
+	WORD $0x8945; BYTE $0xf0                   // movl         %r14d, %r8d
+	WORD $0xff49; BYTE $0xc0                   // incq         %r8
+	WORD $0x214d; BYTE $0xc4                   // andq         %r8, %r12
+	WORD $0x8941; BYTE $0xf9                   // movl         %edi, %r9d
+	WORD $0xff49; BYTE $0xc1                   // incq         %r9
+	LONG $0x80e18349                           // andq         $-128, %r9
+	LONG $0x24548d49; BYTE $0x80               // leaq         $-128(%r12), %rdx
+	WORD $0x8949; BYTE $0xd2                   // movq         %rdx, %r10
+	LONG $0x07eac149                           // shrq         $7, %r10
+	WORD $0xff49; BYTE $0xc2                   // incq         %r10
+	LONG $0x80fa8148; WORD $0x0001; BYTE $0x00 // cmpq         $384, %rdx
+	LONG $0x0083830f; WORD $0x0000             // jae          LBB1_84, $131(%rip)
+	WORD $0xff31                               // xorl         %edi, %edi
+	LONG $0x000138e9; BYTE $0x00               // jmp          LBB1_86, $312(%rip)
+
+LBB1_100:
+	WORD $0x0149; BYTE $0xc9 // addq         %rcx, %r9
+	LONG $0xfce18341         // andl         $-4, %r9d
+	WORD $0xf749; BYTE $0xd9 // negq         %r9
+	WORD $0xdb31             // xorl         %ebx, %ebx
+	WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB1_101:
+	LONG $0x183c8d48               // leaq         (%rax,%rbx), %rdi
+	LONG $0xfd39748b               // movl         $-3(%rcx,%rdi), %esi
+	LONG $0xfe397489               // movl         %esi, $-2(%rcx,%rdi)
+	LONG $0xfcc38348               // addq         $-4, %rbx
+	WORD $0x3949; BYTE $0xd9       // cmpq         %rbx, %r9
+	LONG $0xffe7850f; WORD $0xffff // jne          LBB1_101, $-25(%rip)
+	WORD $0xf748; BYTE $0xdb       // negq         %rbx
+
+LBB1_96:
+	LONG $0x03c0f641                           // testb        $3, %r8b
+	LONG $0x0032840f; WORD $0x0000             // je           LBB1_99, $50(%rip)
+	LONG $0xc2b60f44                           // movzbl       %dl, %r8d
+	LONG $0x03e08341                           // andl         $3, %r8d
+	WORD $0xf749; BYTE $0xd8                   // negq         %r8
+	WORD $0x8948; BYTE $0xc6                   // movq         %rax, %rsi
+	WORD $0x2948; BYTE $0xde                   // subq         %rbx, %rsi
+	WORD $0xff31                               // xorl         %edi, %edi
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB1_98:
+	LONG $0x3e1c8d48               // leaq         (%rsi,%rdi), %rbx
+	LONG $0x1914b60f               // movzbl       (%rcx,%rbx), %edx
+	LONG $0x01195488               // movb         %dl, $1(%rcx,%rbx)
+	WORD $0xff48; BYTE $0xcf       // decq         %rdi
+	WORD $0x3949; BYTE $0xf8       // cmpq         %rdi, %r8
+	LONG $0xffe8850f; WORD $0xffff // jne          LBB1_98, $-24(%rip)
+
+LBB1_99:
+	WORD $0x8944; BYTE $0xf2     // movl         %r14d, %edx
+	LONG $0x1704c641; BYTE $0x2e // movb         $46, (%r15,%rdx)
+	LONG $0x081c8d48             // leaq         (%rax,%rcx), %rbx
+	LONG $0x02c38348             // addq         $2, %rbx
+	LONG $0x000154e9; BYTE $0x00 // jmp          LBB1_122, $340(%rip)
+
+LBB1_84:
+	WORD $0x8944; BYTE $0xeb // movl         %r13d, %ebx
+	WORD $0xff48; BYTE $0xc3 // incq         %rbx
+	LONG $0x80e38348         // andq         $-128, %rbx
+	LONG $0x80c38348         // addq         $-128, %rbx
+	LONG $0x07ebc148         // shrq         $7, %rbx
+	WORD $0xff48; BYTE $0xc3 // incq         %rbx
+	LONG $0xfce38348         // andq         $-4, %rbx
+	WORD $0xff31             // xorl         %edi, %edi
+	QUAD $0xfffff4d0056ffdc5 // vmovdqa      $-2864(%rip), %ymm0  /* LCPI1_0(%rip) */
+
+LBB1_85:
+	LONG $0x38148d48                           // leaq         (%rax,%rdi), %rdx
+	LONG $0x447ffec5; WORD $0x0111             // vmovdqu      %ymm0, $1(%rcx,%rdx)
+	LONG $0x447ffec5; WORD $0x2111             // vmovdqu      %ymm0, $33(%rcx,%rdx)
+	LONG $0x447ffec5; WORD $0x4111             // vmovdqu      %ymm0, $65(%rcx,%rdx)
+	LONG $0x447ffec5; WORD $0x6111             // vmovdqu      %ymm0, $97(%rcx,%rdx)
+	QUAD $0x00008111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $129(%rcx,%rdx)
+	QUAD $0x0000a111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $161(%rcx,%rdx)
+	QUAD $0x0000c111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $193(%rcx,%rdx)
+	QUAD $0x0000e111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $225(%rcx,%rdx)
+	QUAD $0x00010111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $257(%rcx,%rdx)
+	QUAD $0x00012111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $289(%rcx,%rdx)
+	QUAD $0x00014111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $321(%rcx,%rdx)
+	QUAD $0x00016111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $353(%rcx,%rdx)
+	QUAD $0x00018111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $385(%rcx,%rdx)
+	QUAD $0x0001a111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $417(%rcx,%rdx)
+	QUAD $0x0001c111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $449(%rcx,%rdx)
+	QUAD $0x0001e111847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $481(%rcx,%rdx)
+	LONG $0x00c78148; WORD $0x0002; BYTE $0x00 // addq         $512, %rdi
+	LONG $0xfcc38348                           // addq         $-4, %rbx
+	LONG $0xff67850f; WORD $0xffff             // jne          LBB1_85, $-153(%rip)
+
+LBB1_86:
+	WORD $0x0149; BYTE $0xc1                   // addq         %rax, %r9
+	LONG $0x03c2f641                           // testb        $3, %r10b
+	LONG $0x0059840f; WORD $0x0000             // je           LBB1_89, $89(%rip)
+	WORD $0xff41; BYTE $0xc5                   // incl         %r13d
+	LONG $0x80e58141; WORD $0x0001; BYTE $0x00 // andl         $384, %r13d
+	LONG $0x80c58341                           // addl         $-128, %r13d
+	LONG $0x07edc141                           // shrl         $7, %r13d
+	WORD $0xfe41; BYTE $0xc5                   // incb         %r13b
+	LONG $0xd5b60f41                           // movzbl       %r13b, %edx
+	WORD $0xe283; BYTE $0x03                   // andl         $3, %edx
+	LONG $0x07e2c148                           // shlq         $7, %rdx
+	WORD $0x0148; BYTE $0xf8                   // addq         %rdi, %rax
+	LONG $0x61c08348                           // addq         $97, %rax
+	WORD $0xf631                               // xorl         %esi, %esi
+	QUAD $0xfffff3f9056ffdc5                   // vmovdqa      $-3079(%rip), %ymm0  /* LCPI1_0(%rip) */
+
+LBB1_88:
+	LONG $0x303c8d48               // leaq         (%rax,%rsi), %rdi
+	LONG $0x447ffec5; WORD $0xa039 // vmovdqu      %ymm0, $-96(%rcx,%rdi)
+	LONG $0x447ffec5; WORD $0xc039 // vmovdqu      %ymm0, $-64(%rcx,%rdi)
+	LONG $0x447ffec5; WORD $0xe039 // vmovdqu      %ymm0, $-32(%rcx,%rdi)
+	LONG $0x047ffec5; BYTE $0x39   // vmovdqu      %ymm0, (%rcx,%rdi)
+	LONG $0x80ee8348               // subq         $-128, %rsi
+	WORD $0x3948; BYTE $0xf2       // cmpq         %rsi, %rdx
+	LONG $0xffd8850f; WORD $0xffff // jne          LBB1_88, $-40(%rip)
+
+LBB1_89:
+	LONG $0x091c8d4a                       // leaq         (%rcx,%r9), %rbx
+	WORD $0xff48; BYTE $0xc3               // incq         %rbx
+	WORD $0x394d; BYTE $0xe0               // cmpq         %r12, %r8
+	LONG $0xd0558b4c                       // movq         $-48(%rbp), %r10
+	LONG $0x001e840f; WORD $0x0000         // je           LBB1_122, $30(%rip)
+	WORD $0x8944; BYTE $0xe2               // movl         %r12d, %edx
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB1_91:
+	WORD $0x03c6; BYTE $0x30       // movb         $48, (%rbx)
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	WORD $0xc2ff                   // incl         %edx
+	WORD $0x3944; BYTE $0xda       // cmpl         %r11d, %edx
+	LONG $0xffef8c0f; WORD $0xffff // jl           LBB1_91, $-17(%rip)
+
+LBB1_122:
+	WORD $0x2944; BYTE $0xd3 // subl         %r10d, %ebx
+
+LBB1_123:
+	WORD $0xd889             // movl         %ebx, %eax
+	LONG $0x08c48348         // addq         $8, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	BYTE $0xc3               // retq
+
+LBB1_1:
+	WORD $0xdb31                 // xorl         %ebx, %ebx
+	LONG $0xffffe5e9; BYTE $0xff // jmp          LBB1_123, $-27(%rip)
+
+LBB1_5:
+	LONG $0xfffbcebe; BYTE $0xff // movl         $-1074, %esi
+	WORD $0x8948; BYTE $0xd7     // movq         %rdx, %rdi
+	LONG $0xfff441e9; BYTE $0xff // jmp          LBB1_6, $-3007(%rip)
+
+LBB1_25:
+	LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq         $1000000000, %rdi
+	LONG $0x00000aba; BYTE $0x00               // movl         $10, %edx
+	LONG $0xfff8dfe9; BYTE $0xff               // jmp          LBB1_26, $-1825(%rip)
+	WORD $0x9090; BYTE $0x90                   // .p2align 4, 0x90
+
+_format_integer:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	BYTE $0x53                     // pushq        %rbx
+	WORD $0x8941; BYTE $0xd0       // movl         %edx, %r8d
+	WORD $0x0149; BYTE $0xf0       // addq         %rsi, %r8
+	WORD $0x8948; BYTE $0xf8       // movq         %rdi, %rax
+	LONG $0x20e8c148               // shrq         $32, %rax
+	LONG $0x0016850f; WORD $0x0000 // jne          LBB2_2, $22(%rip)
+	WORD $0x894d; BYTE $0xc3       // movq         %r8, %r11
+	LONG $0x2710ff81; WORD $0x0000 // cmpl         $10000, %edi
+	LONG $0x00c3830f; WORD $0x0000 // jae          LBB2_5, $195(%rip)
+
+LBB2_4:
+	WORD $0xfa89                 // movl         %edi, %edx
+	LONG $0x00011ae9; BYTE $0x00 // jmp          LBB2_7, $282(%rip)
+
+LBB2_2:
+	QUAD $0x77118461cefdb948; WORD $0xabcc     // movabsq      $-6067343680855748867, %rcx
+	WORD $0x8948; BYTE $0xf8                   // movq         %rdi, %rax
+	WORD $0xf748; BYTE $0xe1                   // mulq         %rcx
+	LONG $0x1aeac148                           // shrq         $26, %rdx
+	LONG $0x1f00ca69; WORD $0xfa0a             // imull        $-100000000, %edx, %ecx
+	WORD $0xf901                               // addl         %edi, %ecx
+	LONG $0x1759b941; WORD $0xd1b7             // movl         $3518437209, %r9d
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	LONG $0xc1af0f49                           // imulq        %r9, %rax
+	LONG $0x2de8c148                           // shrq         $45, %rax
+	LONG $0x2710f869; WORD $0x0000             // imull        $10000, %eax, %edi
+	WORD $0xf929                               // subl         %edi, %ecx
+	WORD $0x8948; BYTE $0xc7                   // movq         %rax, %rdi
+	LONG $0xf9af0f49                           // imulq        %r9, %rdi
+	LONG $0x2defc148                           // shrq         $45, %rdi
+	LONG $0x2710ff69; WORD $0x0000             // imull        $10000, %edi, %edi
+	WORD $0xf829                               // subl         %edi, %eax
+	WORD $0xb70f; BYTE $0xf9                   // movzwl       %cx, %edi
+	WORD $0xefc1; BYTE $0x02                   // shrl         $2, %edi
+	LONG $0x7bcf6944; WORD $0x0014; BYTE $0x00 // imull        $5243, %edi, %r9d
+	LONG $0x11e9c141                           // shrl         $17, %r9d
+	LONG $0x64f96b41                           // imull        $100, %r9d, %edi
+	WORD $0xf929                               // subl         %edi, %ecx
+	LONG $0xd1b70f44                           // movzwl       %cx, %r10d
+	WORD $0xb70f; BYTE $0xf8                   // movzwl       %ax, %edi
+	WORD $0xefc1; BYTE $0x02                   // shrl         $2, %edi
+	LONG $0x147bff69; WORD $0x0000             // imull        $5243, %edi, %edi
+	WORD $0xefc1; BYTE $0x11                   // shrl         $17, %edi
+	WORD $0xcf6b; BYTE $0x64                   // imull        $100, %edi, %ecx
+	WORD $0xc829                               // subl         %ecx, %eax
+	LONG $0xd8b70f44                           // movzwl       %ax, %r11d
+	LONG $0x500d8d48; WORD $0x00bf; BYTE $0x00 // leaq         $48976(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x04b70f42; BYTE $0x51               // movzwl       (%rcx,%r10,2), %eax
+	LONG $0x40894166; BYTE $0xfe               // movw         %ax, $-2(%r8)
+	LONG $0x04b70f42; BYTE $0x49               // movzwl       (%rcx,%r9,2), %eax
+	LONG $0x40894166; BYTE $0xfc               // movw         %ax, $-4(%r8)
+	LONG $0x04b70f42; BYTE $0x59               // movzwl       (%rcx,%r11,2), %eax
+	LONG $0x40894166; BYTE $0xfa               // movw         %ax, $-6(%r8)
+	LONG $0xf8588d4d                           // leaq         $-8(%r8), %r11
+	LONG $0x790cb70f                           // movzwl       (%rcx,%rdi,2), %ecx
+	LONG $0x48894166; BYTE $0xf8               // movw         %cx, $-8(%r8)
+	WORD $0x8948; BYTE $0xd7                   // movq         %rdx, %rdi
+	LONG $0x2710ff81; WORD $0x0000             // cmpl         $10000, %edi
+	LONG $0xff3d820f; WORD $0xffff             // jb           LBB2_4, $-195(%rip)
+
+LBB2_5:
+	LONG $0x1759b941; WORD $0xd1b7             // movl         $3518437209, %r9d
+	LONG $0x09158d4c; WORD $0x00bf; BYTE $0x00 // leaq         $48905(%rip), %r10  /* _Digits(%rip) */
+	QUAD $0x9090909090909090; BYTE $0x90       // .p2align 4, 0x90
+
+LBB2_6:
+	WORD $0xfa89                               // movl         %edi, %edx
+	LONG $0xd1af0f49                           // imulq        %r9, %rdx
+	LONG $0x2deac148                           // shrq         $45, %rdx
+	LONG $0xd8f0ca69; WORD $0xffff             // imull        $-10000, %edx, %ecx
+	WORD $0xf901                               // addl         %edi, %ecx
+	LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rcx, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xd86b; BYTE $0x64                   // imull        $100, %eax, %ebx
+	WORD $0xd929                               // subl         %ebx, %ecx
+	LONG $0x0cb70f41; BYTE $0x4a               // movzwl       (%r10,%rcx,2), %ecx
+	LONG $0x4b894166; BYTE $0xfe               // movw         %cx, $-2(%r11)
+	LONG $0x04b70f41; BYTE $0x42               // movzwl       (%r10,%rax,2), %eax
+	LONG $0x43894166; BYTE $0xfc               // movw         %ax, $-4(%r11)
+	LONG $0xfcc38349                           // addq         $-4, %r11
+	LONG $0xe0ffff81; WORD $0x05f5             // cmpl         $99999999, %edi
+	WORD $0xd789                               // movl         %edx, %edi
+	LONG $0xffb8870f; WORD $0xffff             // ja           LBB2_6, $-72(%rip)
+
+LBB2_7:
+	WORD $0xfa83; BYTE $0x64                   // cmpl         $100, %edx
+	LONG $0x002d820f; WORD $0x0000             // jb           LBB2_9, $45(%rip)
+	WORD $0xb70f; BYTE $0xc2                   // movzwl       %dx, %eax
+	WORD $0xe8c1; BYTE $0x02                   // shrl         $2, %eax
+	LONG $0x147bc069; WORD $0x0000             // imull        $5243, %eax, %eax
+	WORD $0xe8c1; BYTE $0x11                   // shrl         $17, %eax
+	WORD $0xc86b; BYTE $0x64                   // imull        $100, %eax, %ecx
+	WORD $0xca29                               // subl         %ecx, %edx
+	WORD $0xb70f; BYTE $0xca                   // movzwl       %dx, %ecx
+	LONG $0x91158d48; WORD $0x00be; BYTE $0x00 // leaq         $48785(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x4a0cb70f                           // movzwl       (%rdx,%rcx,2), %ecx
+	LONG $0x4b894166; BYTE $0xfe               // movw         %cx, $-2(%r11)
+	LONG $0xfec38349                           // addq         $-2, %r11
+	WORD $0xc289                               // movl         %eax, %edx
+
+LBB2_9:
+	WORD $0xfa83; BYTE $0x0a                   // cmpl         $10, %edx
+	LONG $0x0018820f; WORD $0x0000             // jb           LBB2_11, $24(%rip)
+	WORD $0xd089                               // movl         %edx, %eax
+	LONG $0x700d8d48; WORD $0x00be; BYTE $0x00 // leaq         $48752(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	LONG $0x43894166; BYTE $0xfe               // movw         %ax, $-2(%r11)
+	WORD $0x894c; BYTE $0xc0                   // movq         %r8, %rax
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB2_11:
+	WORD $0xc280; BYTE $0x30       // addb         $48, %dl
+	WORD $0x1688                   // movb         %dl, (%rsi)
+	WORD $0x894c; BYTE $0xc0       // movq         %r8, %rax
+	BYTE $0x5b                     // popq         %rbx
+	BYTE $0x5d                     // popq         %rbp
+	BYTE $0xc3                     // retq
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+_i64toa:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x8548; BYTE $0xf6                   // testq        %rsi, %rsi
+	LONG $0x00b1880f; WORD $0x0000             // js           LBB3_12, $177(%rip)
+	LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq         $9999, %rsi
+	LONG $0x00b6870f; WORD $0x0000             // ja           LBB3_9, $182(%rip)
+	WORD $0xb70f; BYTE $0xc6                   // movzwl       %si, %eax
+	WORD $0xe8c1; BYTE $0x02                   // shrl         $2, %eax
+	LONG $0x147bc069; WORD $0x0000             // imull        $5243, %eax, %eax
+	WORD $0xe8c1; BYTE $0x11                   // shrl         $17, %eax
+	LONG $0x00148d48                           // leaq         (%rax,%rax), %rdx
+	WORD $0xc06b; BYTE $0x64                   // imull        $100, %eax, %eax
+	WORD $0xf189                               // movl         %esi, %ecx
+	WORD $0xc129                               // subl         %eax, %ecx
+	WORD $0xb70f; BYTE $0xc9                   // movzwl       %cx, %ecx
+	WORD $0x0148; BYTE $0xc9                   // addq         %rcx, %rcx
+	LONG $0x03e8fe81; WORD $0x0000             // cmpl         $1000, %esi
+	LONG $0x0017820f; WORD $0x0000             // jb           LBB3_4, $23(%rip)
+	LONG $0x03058d48; WORD $0x00be; BYTE $0x00 // leaq         $48643(%rip), %rax  /* _Digits(%rip) */
+	LONG $0x0204b60f                           // movzbl       (%rdx,%rax), %eax
+	WORD $0x0788                               // movb         %al, (%rdi)
+	LONG $0x000001b8; BYTE $0x00               // movl         $1, %eax
+	LONG $0x00000be9; BYTE $0x00               // jmp          LBB3_5, $11(%rip)
+
+LBB3_4:
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xfe83; BYTE $0x64       // cmpl         $100, %esi
+	LONG $0x0046820f; WORD $0x0000 // jb           LBB3_6, $70(%rip)
+
+LBB3_5:
+	WORD $0xb70f; BYTE $0xd2                   // movzwl       %dx, %edx
+	LONG $0x01ca8348                           // orq          $1, %rdx
+	LONG $0xda358d48; WORD $0x00bd; BYTE $0x00 // leaq         $48602(%rip), %rsi  /* _Digits(%rip) */
+	LONG $0x3214b60f                           // movzbl       (%rdx,%rsi), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB3_7:
+	LONG $0xc8158d48; WORD $0x00bd; BYTE $0x00 // leaq         $48584(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x1114b60f                           // movzbl       (%rcx,%rdx), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB3_8:
+	WORD $0xb70f; BYTE $0xc9                   // movzwl       %cx, %ecx
+	LONG $0x01c98348                           // orq          $1, %rcx
+	LONG $0xaf158d48; WORD $0x00bd; BYTE $0x00 // leaq         $48559(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x110cb60f                           // movzbl       (%rcx,%rdx), %ecx
+	WORD $0xc289                               // movl         %eax, %edx
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x0c88; BYTE $0x17                   // movb         %cl, (%rdi,%rdx)
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB3_6:
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xfe83; BYTE $0x0a       // cmpl         $10, %esi
+	LONG $0xffc8830f; WORD $0xffff // jae          LBB3_7, $-56(%rip)
+	LONG $0xffffd5e9; BYTE $0xff   // jmp          LBB3_8, $-43(%rip)
+
+LBB3_12:
+	WORD $0x07c6; BYTE $0x2d     // movb         $45, (%rdi)
+	WORD $0xff48; BYTE $0xc7     // incq         %rdi
+	WORD $0xf748; BYTE $0xde     // negq         %rsi
+	LONG $0x000044e8; BYTE $0x00 // callq        _u64toa, $68(%rip)
+	WORD $0xc0ff                 // incl         %eax
+	BYTE $0x5d                   // popq         %rbp
+	BYTE $0xc3                   // retq
+
+LBB3_9:
+	LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq         $99999999, %rsi
+	LONG $0x0006870f; WORD $0x0000             // ja           LBB3_10, $6(%rip)
+	BYTE $0x5d                                 // popq         %rbp
+	LONG $0x00011de9; BYTE $0x00               // jmp          _u32toa_medium, $285(%rip)
+
+LBB3_10:
+	QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq      $9999999999999999, %rax
+	WORD $0x3948; BYTE $0xc6               // cmpq         %rax, %rsi
+	LONG $0x0006870f; WORD $0x0000         // ja           LBB3_11, $6(%rip)
+	BYTE $0x5d                             // popq         %rbp
+	LONG $0x000244e9; BYTE $0x00           // jmp          _u64toa_large_sse2, $580(%rip)
+
+LBB3_11:
+	BYTE $0x5d                                               // popq         %rbp
+	LONG $0x00038ee9; BYTE $0x00                             // jmp          _u64toa_xlarge_sse2, $910(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+_u64toa:
+	LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq         $9999, %rsi
+	LONG $0x00a8870f; WORD $0x0000             // ja           LBB4_8, $168(%rip)
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0xb70f; BYTE $0xc6                   // movzwl       %si, %eax
+	WORD $0xe8c1; BYTE $0x02                   // shrl         $2, %eax
+	LONG $0x147bc069; WORD $0x0000             // imull        $5243, %eax, %eax
+	WORD $0xe8c1; BYTE $0x11                   // shrl         $17, %eax
+	LONG $0x00148d48                           // leaq         (%rax,%rax), %rdx
+	WORD $0xc06b; BYTE $0x64                   // imull        $100, %eax, %eax
+	WORD $0xf189                               // movl         %esi, %ecx
+	WORD $0xc129                               // subl         %eax, %ecx
+	WORD $0xb70f; BYTE $0xc9                   // movzwl       %cx, %ecx
+	WORD $0x0148; BYTE $0xc9                   // addq         %rcx, %rcx
+	LONG $0x03e8fe81; WORD $0x0000             // cmpl         $1000, %esi
+	LONG $0x0017820f; WORD $0x0000             // jb           LBB4_3, $23(%rip)
+	LONG $0xfc058d48; WORD $0x00bc; BYTE $0x00 // leaq         $48380(%rip), %rax  /* _Digits(%rip) */
+	LONG $0x0204b60f                           // movzbl       (%rdx,%rax), %eax
+	WORD $0x0788                               // movb         %al, (%rdi)
+	LONG $0x000001b8; BYTE $0x00               // movl         $1, %eax
+	LONG $0x00000be9; BYTE $0x00               // jmp          LBB4_4, $11(%rip)
+
+LBB4_3:
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xfe83; BYTE $0x64       // cmpl         $100, %esi
+	LONG $0x0046820f; WORD $0x0000 // jb           LBB4_5, $70(%rip)
+
+LBB4_4:
+	WORD $0xb70f; BYTE $0xd2                   // movzwl       %dx, %edx
+	LONG $0x01ca8348                           // orq          $1, %rdx
+	LONG $0xd3358d48; WORD $0x00bc; BYTE $0x00 // leaq         $48339(%rip), %rsi  /* _Digits(%rip) */
+	LONG $0x3214b60f                           // movzbl       (%rdx,%rsi), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB4_6:
+	LONG $0xc1158d48; WORD $0x00bc; BYTE $0x00 // leaq         $48321(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x1114b60f                           // movzbl       (%rcx,%rdx), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB4_7:
+	WORD $0xb70f; BYTE $0xc9                   // movzwl       %cx, %ecx
+	LONG $0x01c98348                           // orq          $1, %rcx
+	LONG $0xa8158d48; WORD $0x00bc; BYTE $0x00 // leaq         $48296(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x110cb60f                           // movzbl       (%rcx,%rdx), %ecx
+	WORD $0xc289                               // movl         %eax, %edx
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x0c88; BYTE $0x17                   // movb         %cl, (%rdi,%rdx)
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB4_5:
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xfe83; BYTE $0x0a       // cmpl         $10, %esi
+	LONG $0xffc8830f; WORD $0xffff // jae          LBB4_6, $-56(%rip)
+	LONG $0xffffd5e9; BYTE $0xff   // jmp          LBB4_7, $-43(%rip)
+
+LBB4_8:
+	LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq         $99999999, %rsi
+	LONG $0x0005870f; WORD $0x0000             // ja           LBB4_9, $5(%rip)
+	LONG $0x000029e9; BYTE $0x00               // jmp          _u32toa_medium, $41(%rip)
+
+LBB4_9:
+	QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq      $9999999999999999, %rax
+	WORD $0x3948; BYTE $0xc6               // cmpq         %rax, %rsi
+	LONG $0x0005870f; WORD $0x0000         // ja           LBB4_10, $5(%rip)
+	LONG $0x000151e9; BYTE $0x00           // jmp          _u64toa_large_sse2, $337(%rip)
+
+LBB4_10:
+	LONG $0x00029ce9; BYTE $0x00               // jmp          _u64toa_xlarge_sse2, $668(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+_u32toa_medium:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0xf089                               // movl         %esi, %eax
+	LONG $0xb71759b9; BYTE $0xd1               // movl         $3518437209, %ecx
+	LONG $0xc8af0f48                           // imulq        %rax, %rcx
+	LONG $0x2de9c148                           // shrq         $45, %rcx
+	LONG $0x2710d169; WORD $0x0000             // imull        $10000, %ecx, %edx
+	WORD $0x8941; BYTE $0xf0                   // movl         %esi, %r8d
+	WORD $0x2941; BYTE $0xd0                   // subl         %edx, %r8d
+	LONG $0x83d06948; WORD $0x1bde; BYTE $0x43 // imulq        $1125899907, %rax, %rdx
+	LONG $0x31eac148                           // shrq         $49, %rdx
+	WORD $0xe283; BYTE $0xfe                   // andl         $-2, %edx
+	LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rcx, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xc06b; BYTE $0x64                   // imull        $100, %eax, %eax
+	WORD $0xc129                               // subl         %eax, %ecx
+	WORD $0x0148; BYTE $0xc9                   // addq         %rcx, %rcx
+	LONG $0x9680fe81; WORD $0x0098             // cmpl         $10000000, %esi
+	LONG $0x0017820f; WORD $0x0000             // jb           LBB5_2, $23(%rip)
+	LONG $0xfd058d48; WORD $0x00bb; BYTE $0x00 // leaq         $48125(%rip), %rax  /* _Digits(%rip) */
+	LONG $0x0204b60f                           // movzbl       (%rdx,%rax), %eax
+	WORD $0x0788                               // movb         %al, (%rdi)
+	LONG $0x000001b8; BYTE $0x00               // movl         $1, %eax
+	LONG $0x00000ee9; BYTE $0x00               // jmp          LBB5_3, $14(%rip)
+
+LBB5_2:
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x4240fe81; WORD $0x000f // cmpl         $1000000, %esi
+	LONG $0x0074820f; WORD $0x0000 // jb           LBB5_4, $116(%rip)
+
+LBB5_3:
+	WORD $0xd289                               // movl         %edx, %edx
+	LONG $0x01ca8348                           // orq          $1, %rdx
+	LONG $0xd2358d48; WORD $0x00bb; BYTE $0x00 // leaq         $48082(%rip), %rsi  /* _Digits(%rip) */
+	LONG $0x3214b60f                           // movzbl       (%rdx,%rsi), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB5_5:
+	LONG $0xc0158d48; WORD $0x00bb; BYTE $0x00 // leaq         $48064(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x1114b60f                           // movzbl       (%rcx,%rdx), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB5_6:
+	LONG $0xd0b70f41                           // movzwl       %r8w, %edx
+	WORD $0xeac1; BYTE $0x02                   // shrl         $2, %edx
+	LONG $0x147bd269; WORD $0x0000             // imull        $5243, %edx, %edx
+	WORD $0xeac1; BYTE $0x11                   // shrl         $17, %edx
+	WORD $0xf26b; BYTE $0x64                   // imull        $100, %edx, %esi
+	WORD $0x2941; BYTE $0xf0                   // subl         %esi, %r8d
+	LONG $0xc0b70f45                           // movzwl       %r8w, %r8d
+	WORD $0xc989                               // movl         %ecx, %ecx
+	LONG $0x01c98348                           // orq          $1, %rcx
+	LONG $0x8e0d8d4c; WORD $0x00bb; BYTE $0x00 // leaq         $48014(%rip), %r9  /* _Digits(%rip) */
+	LONG $0x0cb60f42; BYTE $0x09               // movzbl       (%rcx,%r9), %ecx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0x0c88; BYTE $0x37                   // movb         %cl, (%rdi,%rsi)
+	LONG $0x0cb70f41; BYTE $0x51               // movzwl       (%r9,%rdx,2), %ecx
+	LONG $0x374c8966; BYTE $0x01               // movw         %cx, $1(%rdi,%rsi)
+	LONG $0x0cb70f43; BYTE $0x41               // movzwl       (%r9,%r8,2), %ecx
+	LONG $0x374c8966; BYTE $0x03               // movw         %cx, $3(%rdi,%rsi)
+	WORD $0xc083; BYTE $0x05                   // addl         $5, %eax
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB5_4:
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x86a0fe81; WORD $0x0001 // cmpl         $100000, %esi
+	LONG $0xff96830f; WORD $0xffff // jae          LBB5_5, $-106(%rip)
+	LONG $0xffffa3e9; BYTE $0xff   // jmp          LBB5_6, $-93(%rip)
+	QUAD $0x0000000000000000       // .p2align 4, 0x00
+
+LCPI6_0:
+	QUAD $0x00000000d1b71759 // .quad 3518437209
+	QUAD $0x00000000d1b71759 // .quad 3518437209
+
+LCPI6_3:
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+
+LCPI6_4:
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+
+	// .p2align 3, 0x00
+LCPI6_1:
+	QUAD $0x80003334147b20c5 // .quad -9223315738079846203
+
+LCPI6_2:
+	QUAD $0x8000200008000080 // .quad -9223336852348469120
+
+	// .p2align 4, 0x90
+_u64toa_large_sse2:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	QUAD $0x77118461cefdb948; WORD $0xabcc     // movabsq      $-6067343680855748867, %rcx
+	WORD $0x8948; BYTE $0xf0                   // movq         %rsi, %rax
+	WORD $0xf748; BYTE $0xe1                   // mulq         %rcx
+	LONG $0x1aeac148                           // shrq         $26, %rdx
+	LONG $0xe100c269; WORD $0x05f5             // imull        $100000000, %edx, %eax
+	WORD $0xc629                               // subl         %eax, %esi
+	LONG $0xc26ef9c5                           // vmovd        %edx, %xmm0
+	QUAD $0xffffff940d6ff9c5                   // vmovdqa      $-108(%rip), %xmm1  /* LCPI6_0(%rip) */
+	LONG $0xd1f4f9c5                           // vpmuludq     %xmm1, %xmm0, %xmm2
+	LONG $0xd273e9c5; BYTE $0x2d               // vpsrlq       $45, %xmm2, %xmm2
+	LONG $0x002710b8; BYTE $0x00               // movl         $10000, %eax
+	LONG $0x6ef9e1c4; BYTE $0xd8               // vmovq        %rax, %xmm3
+	LONG $0xe3f4e9c5                           // vpmuludq     %xmm3, %xmm2, %xmm4
+	LONG $0xc4faf9c5                           // vpsubd       %xmm4, %xmm0, %xmm0
+	LONG $0xc061e9c5                           // vpunpcklwd   %xmm0, %xmm2, %xmm0
+	LONG $0xf073f9c5; BYTE $0x02               // vpsllq       $2, %xmm0, %xmm0
+	LONG $0xc070fbc5; BYTE $0x50               // vpshuflw     $80, %xmm0, %xmm0
+	LONG $0xc070f9c5; BYTE $0x50               // vpshufd      $80, %xmm0, %xmm0
+	QUAD $0xffff8d155979e2c4; BYTE $0xff       // vpbroadcastq $-115(%rip), %xmm2  /* LCPI6_1(%rip) */
+	LONG $0xc2e4f9c5                           // vpmulhuw     %xmm2, %xmm0, %xmm0
+	QUAD $0xffff88255979e2c4; BYTE $0xff       // vpbroadcastq $-120(%rip), %xmm4  /* LCPI6_2(%rip) */
+	LONG $0xc4e4f9c5                           // vpmulhuw     %xmm4, %xmm0, %xmm0
+	QUAD $0xffffff542d6ff9c5                   // vmovdqa      $-172(%rip), %xmm5  /* LCPI6_3(%rip) */
+	LONG $0xf5d5f9c5                           // vpmullw      %xmm5, %xmm0, %xmm6
+	LONG $0xf673c9c5; BYTE $0x10               // vpsllq       $16, %xmm6, %xmm6
+	LONG $0xc6f9f9c5                           // vpsubw       %xmm6, %xmm0, %xmm0
+	LONG $0xf66ef9c5                           // vmovd        %esi, %xmm6
+	LONG $0xc9f4c9c5                           // vpmuludq     %xmm1, %xmm6, %xmm1
+	LONG $0xd173f1c5; BYTE $0x2d               // vpsrlq       $45, %xmm1, %xmm1
+	LONG $0xdbf4f1c5                           // vpmuludq     %xmm3, %xmm1, %xmm3
+	LONG $0xdbfac9c5                           // vpsubd       %xmm3, %xmm6, %xmm3
+	LONG $0xcb61f1c5                           // vpunpcklwd   %xmm3, %xmm1, %xmm1
+	LONG $0xf173f1c5; BYTE $0x02               // vpsllq       $2, %xmm1, %xmm1
+	LONG $0xc970fbc5; BYTE $0x50               // vpshuflw     $80, %xmm1, %xmm1
+	LONG $0xc970f9c5; BYTE $0x50               // vpshufd      $80, %xmm1, %xmm1
+	LONG $0xcae4f1c5                           // vpmulhuw     %xmm2, %xmm1, %xmm1
+	LONG $0xcce4f1c5                           // vpmulhuw     %xmm4, %xmm1, %xmm1
+	LONG $0xd5d5f1c5                           // vpmullw      %xmm5, %xmm1, %xmm2
+	LONG $0xf273e9c5; BYTE $0x10               // vpsllq       $16, %xmm2, %xmm2
+	LONG $0xcaf9f1c5                           // vpsubw       %xmm2, %xmm1, %xmm1
+	LONG $0xc167f9c5                           // vpackuswb    %xmm1, %xmm0, %xmm0
+	QUAD $0xffffff0e0dfcf9c5                   // vpaddb       $-242(%rip), %xmm0, %xmm1  /* LCPI6_4(%rip) */
+	LONG $0xd2efe9c5                           // vpxor        %xmm2, %xmm2, %xmm2
+	LONG $0xc274f9c5                           // vpcmpeqb     %xmm2, %xmm0, %xmm0
+	LONG $0xc0d7f9c5                           // vpmovmskb    %xmm0, %eax
+	WORD $0xd0f7                               // notl         %eax
+	LONG $0x0080000d; BYTE $0x00               // orl          $32768, %eax
+	WORD $0xbc0f; BYTE $0xc8                   // bsfl         %eax, %ecx
+	LONG $0x000010b8; BYTE $0x00               // movl         $16, %eax
+	WORD $0xc829                               // subl         %ecx, %eax
+	LONG $0x04e1c148                           // shlq         $4, %rcx
+	LONG $0x76158d48; WORD $0x00e1; BYTE $0x00 // leaq         $57718(%rip), %rdx  /* _VecShiftShuffles(%rip) */
+	LONG $0x0071e2c4; WORD $0x1104             // vpshufb      (%rcx,%rdx), %xmm1, %xmm0
+	LONG $0x077ffac5                           // vmovdqu      %xmm0, (%rdi)
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+	QUAD $0x0000000000000000; WORD $0x0000     // .p2align 4, 0x00
+
+LCPI7_0:
+	QUAD $0x00000000d1b71759 // .quad 3518437209
+	QUAD $0x00000000d1b71759 // .quad 3518437209
+
+LCPI7_3:
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+
+LCPI7_4:
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+
+	// .p2align 3, 0x00
+LCPI7_1:
+	QUAD $0x80003334147b20c5 // .quad -9223315738079846203
+
+LCPI7_2:
+	QUAD $0x8000200008000080 // .quad -9223336852348469120
+
+	// .p2align 4, 0x90
+_u64toa_xlarge_sse2:
+	BYTE $0x55                             // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5               // movq         %rsp, %rbp
+	QUAD $0x652fb1137857b948; WORD $0x39a5 // movabsq      $4153837486827862103, %rcx
+	WORD $0x8948; BYTE $0xf0               // movq         %rsi, %rax
+	WORD $0xf748; BYTE $0xe1               // mulq         %rcx
+	LONG $0x33eac148                       // shrq         $51, %rdx
+	QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq      $10000000000000000, %rax
+	LONG $0xc2af0f48                       // imulq        %rdx, %rax
+	WORD $0x2948; BYTE $0xc6               // subq         %rax, %rsi
+	WORD $0xfa83; BYTE $0x09               // cmpl         $9, %edx
+	LONG $0x000f870f; WORD $0x0000         // ja           LBB7_2, $15(%rip)
+	WORD $0xc280; BYTE $0x30               // addb         $48, %dl
+	WORD $0x1788                           // movb         %dl, (%rdi)
+	LONG $0x000001b9; BYTE $0x00           // movl         $1, %ecx
+	LONG $0x0000a7e9; BYTE $0x00           // jmp          LBB7_7, $167(%rip)
+
+LBB7_2:
+	WORD $0xfa83; BYTE $0x63                   // cmpl         $99, %edx
+	LONG $0x001a870f; WORD $0x0000             // ja           LBB7_4, $26(%rip)
+	WORD $0xd089                               // movl         %edx, %eax
+	LONG $0x6d0d8d48; WORD $0x00b9; BYTE $0x00 // leaq         $47469(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	WORD $0x8966; BYTE $0x07                   // movw         %ax, (%rdi)
+	LONG $0x000002b9; BYTE $0x00               // movl         $2, %ecx
+	LONG $0x000084e9; BYTE $0x00               // jmp          LBB7_7, $132(%rip)
+
+LBB7_4:
+	WORD $0xd089                               // movl         %edx, %eax
+	WORD $0xe8c1; BYTE $0x02                   // shrl         $2, %eax
+	LONG $0x147bc069; WORD $0x0000             // imull        $5243, %eax, %eax
+	WORD $0xe8c1; BYTE $0x11                   // shrl         $17, %eax
+	LONG $0x03e7fa81; WORD $0x0000             // cmpl         $999, %edx
+	LONG $0x0037870f; WORD $0x0000             // ja           LBB7_6, $55(%rip)
+	WORD $0xc083; BYTE $0x30                   // addl         $48, %eax
+	WORD $0x0788                               // movb         %al, (%rdi)
+	WORD $0xb70f; BYTE $0xc2                   // movzwl       %dx, %eax
+	WORD $0xc189                               // movl         %eax, %ecx
+	WORD $0xe9c1; BYTE $0x02                   // shrl         $2, %ecx
+	LONG $0x147bc969; WORD $0x0000             // imull        $5243, %ecx, %ecx
+	WORD $0xe9c1; BYTE $0x11                   // shrl         $17, %ecx
+	WORD $0xc96b; BYTE $0x64                   // imull        $100, %ecx, %ecx
+	WORD $0xc829                               // subl         %ecx, %eax
+	WORD $0xb70f; BYTE $0xc0                   // movzwl       %ax, %eax
+	LONG $0x1d0d8d48; WORD $0x00b9; BYTE $0x00 // leaq         $47389(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	LONG $0x01478966                           // movw         %ax, $1(%rdi)
+	LONG $0x000003b9; BYTE $0x00               // movl         $3, %ecx
+	LONG $0x000033e9; BYTE $0x00               // jmp          LBB7_7, $51(%rip)
+
+LBB7_6:
+	WORD $0xc86b; BYTE $0x64                   // imull        $100, %eax, %ecx
+	WORD $0xca29                               // subl         %ecx, %edx
+	WORD $0xb70f; BYTE $0xc0                   // movzwl       %ax, %eax
+	LONG $0xfc0d8d48; WORD $0x00b8; BYTE $0x00 // leaq         $47356(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	WORD $0x8966; BYTE $0x07                   // movw         %ax, (%rdi)
+	WORD $0xb70f; BYTE $0xc2                   // movzwl       %dx, %eax
+	LONG $0x4114b60f                           // movzbl       (%rcx,%rax,2), %edx
+	WORD $0x0148; BYTE $0xc0                   // addq         %rax, %rax
+	WORD $0x5788; BYTE $0x02                   // movb         %dl, $2(%rdi)
+	WORD $0xb70f; BYTE $0xc0                   // movzwl       %ax, %eax
+	LONG $0x0844b60f; BYTE $0x01               // movzbl       $1(%rax,%rcx), %eax
+	WORD $0x4788; BYTE $0x03                   // movb         %al, $3(%rdi)
+	LONG $0x000004b9; BYTE $0x00               // movl         $4, %ecx
+
+LBB7_7:
+	QUAD $0x77118461cefdba48; WORD $0xabcc                                                         // movabsq      $-6067343680855748867, %rdx
+	WORD $0x8948; BYTE $0xf0                                                                       // movq         %rsi, %rax
+	WORD $0xf748; BYTE $0xe2                                                                       // mulq         %rdx
+	LONG $0x1aeac148                                                                               // shrq         $26, %rdx
+	LONG $0xc26ef9c5                                                                               // vmovd        %edx, %xmm0
+	QUAD $0xfffffeb80d6ff9c5                                                                       // vmovdqa      $-328(%rip), %xmm1  /* LCPI7_0(%rip) */
+	LONG $0xd1f4f9c5                                                                               // vpmuludq     %xmm1, %xmm0, %xmm2
+	LONG $0xd273e9c5; BYTE $0x2d                                                                   // vpsrlq       $45, %xmm2, %xmm2
+	LONG $0x002710b8; BYTE $0x00                                                                   // movl         $10000, %eax
+	LONG $0x6ef9e1c4; BYTE $0xd8                                                                   // vmovq        %rax, %xmm3
+	LONG $0xe3f4e9c5                                                                               // vpmuludq     %xmm3, %xmm2, %xmm4
+	LONG $0xc4faf9c5                                                                               // vpsubd       %xmm4, %xmm0, %xmm0
+	LONG $0xc061e9c5                                                                               // vpunpcklwd   %xmm0, %xmm2, %xmm0
+	LONG $0xf073f9c5; BYTE $0x02                                                                   // vpsllq       $2, %xmm0, %xmm0
+	LONG $0xc070fbc5; BYTE $0x50                                                                   // vpshuflw     $80, %xmm0, %xmm0
+	QUAD $0xfffeb6155979e2c4; BYTE $0xff                                                           // vpbroadcastq $-330(%rip), %xmm2  /* LCPI7_1(%rip) */
+	LONG $0xc070f9c5; BYTE $0x50                                                                   // vpshufd      $80, %xmm0, %xmm0
+	LONG $0xc2e4f9c5                                                                               // vpmulhuw     %xmm2, %xmm0, %xmm0
+	QUAD $0xfffeac255979e2c4; BYTE $0xff                                                           // vpbroadcastq $-340(%rip), %xmm4  /* LCPI7_2(%rip) */
+	LONG $0xc4e4f9c5                                                                               // vpmulhuw     %xmm4, %xmm0, %xmm0
+	QUAD $0xfffffe782d6ff9c5                                                                       // vmovdqa      $-392(%rip), %xmm5  /* LCPI7_3(%rip) */
+	LONG $0xf5d5f9c5                                                                               // vpmullw      %xmm5, %xmm0, %xmm6
+	LONG $0xf673c9c5; BYTE $0x10                                                                   // vpsllq       $16, %xmm6, %xmm6
+	LONG $0xc6f9f9c5                                                                               // vpsubw       %xmm6, %xmm0, %xmm0
+	LONG $0xe100c269; WORD $0x05f5                                                                 // imull        $100000000, %edx, %eax
+	WORD $0xc629                                                                                   // subl         %eax, %esi
+	LONG $0xf66ef9c5                                                                               // vmovd        %esi, %xmm6
+	LONG $0xc9f4c9c5                                                                               // vpmuludq     %xmm1, %xmm6, %xmm1
+	LONG $0xd173f1c5; BYTE $0x2d                                                                   // vpsrlq       $45, %xmm1, %xmm1
+	LONG $0xdbf4f1c5                                                                               // vpmuludq     %xmm3, %xmm1, %xmm3
+	LONG $0xdbfac9c5                                                                               // vpsubd       %xmm3, %xmm6, %xmm3
+	LONG $0xcb61f1c5                                                                               // vpunpcklwd   %xmm3, %xmm1, %xmm1
+	LONG $0xf173f1c5; BYTE $0x02                                                                   // vpsllq       $2, %xmm1, %xmm1
+	LONG $0xc970fbc5; BYTE $0x50                                                                   // vpshuflw     $80, %xmm1, %xmm1
+	LONG $0xc970f9c5; BYTE $0x50                                                                   // vpshufd      $80, %xmm1, %xmm1
+	LONG $0xcae4f1c5                                                                               // vpmulhuw     %xmm2, %xmm1, %xmm1
+	LONG $0xcce4f1c5                                                                               // vpmulhuw     %xmm4, %xmm1, %xmm1
+	LONG $0xd5d5f1c5                                                                               // vpmullw      %xmm5, %xmm1, %xmm2
+	LONG $0xf273e9c5; BYTE $0x10                                                                   // vpsllq       $16, %xmm2, %xmm2
+	LONG $0xcaf9f1c5                                                                               // vpsubw       %xmm2, %xmm1, %xmm1
+	LONG $0xc167f9c5                                                                               // vpackuswb    %xmm1, %xmm0, %xmm0
+	QUAD $0xfffffe2a05fcf9c5                                                                       // vpaddb       $-470(%rip), %xmm0, %xmm0  /* LCPI7_4(%rip) */
+	WORD $0xc889                                                                                   // movl         %ecx, %eax
+	LONG $0x047ffac5; BYTE $0x07                                                                   // vmovdqu      %xmm0, (%rdi,%rax)
+	WORD $0xc983; BYTE $0x10                                                                       // orl          $16, %ecx
+	WORD $0xc889                                                                                   // movl         %ecx, %eax
+	BYTE $0x5d                                                                                     // popq         %rbp
+	BYTE $0xc3                                                                                     // retq
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000; QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 5, 0x00
+
+LCPI8_0:
+	QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
+	QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
+
+LCPI8_1:
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+
+LCPI8_2:
+	QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f'
+	QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f'
+
+	// .p2align 4, 0x00
+LCPI8_3:
+	QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
+
+LCPI8_4:
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+
+LCPI8_5:
+	QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f'
+
+	// .p2align 4, 0x90
+_quote:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x18ec8348                           // subq         $24, %rsp
+	WORD $0x8949; BYTE $0xcf                   // movq         %rcx, %r15
+	WORD $0x8949; BYTE $0xf6                   // movq         %rsi, %r14
+	WORD $0x8b4c; BYTE $0x11                   // movq         (%rcx), %r10
+	LONG $0x01c0f641                           // testb        $1, %r8b
+	LONG $0x1b058d48; WORD $0x00df; BYTE $0x00 // leaq         $57115(%rip), %rax  /* __SingleQuoteTab(%rip) */
+	LONG $0x14058d4c; WORD $0x00ef; BYTE $0x00 // leaq         $61204(%rip), %r8  /* __DoubleQuoteTab(%rip) */
+	LONG $0xc0440f4c                           // cmoveq       %rax, %r8
+	QUAD $0x00000000f5048d48                   // leaq         (,%rsi,8), %rax
+	WORD $0x3949; BYTE $0xc2                   // cmpq         %rax, %r10
+	LONG $0x07128d0f; WORD $0x0000             // jge          LBB8_93, $1810(%rip)
+	WORD $0x8949; BYTE $0xd1                   // movq         %rdx, %r9
+	WORD $0x8949; BYTE $0xfb                   // movq         %rdi, %r11
+	WORD $0x854d; BYTE $0xf6                   // testq        %r14, %r14
+	LONG $0x09ef840f; WORD $0x0000             // je           LBB8_122, $2543(%rip)
+	QUAD $0xffffff181d6ffdc5                   // vmovdqa      $-232(%rip), %ymm3  /* LCPI8_0(%rip) */
+	QUAD $0xffffff30256ffdc5                   // vmovdqa      $-208(%rip), %ymm4  /* LCPI8_1(%rip) */
+	QUAD $0xffffff482d6ffdc5                   // vmovdqa      $-184(%rip), %ymm5  /* LCPI8_2(%rip) */
+	WORD $0x8948; BYTE $0xf9                   // movq         %rdi, %rcx
+	LONG $0xc0558948                           // movq         %rdx, $-64(%rbp)
+	WORD $0x8949; BYTE $0xd1                   // movq         %rdx, %r9
+
+LBB8_3:
+	WORD $0x8949; BYTE $0xcd                           // movq         %rcx, %r13
+	LONG $0x20fe8349                                   // cmpq         $32, %r14
+	WORD $0x9d0f; BYTE $0xc1                           // setge        %cl
+	LONG $0x20fa8349                                   // cmpq         $32, %r10
+	WORD $0x894c; BYTE $0xe8                           // movq         %r13, %rax
+	WORD $0x894c; BYTE $0xd3                           // movq         %r10, %rbx
+	WORD $0x894d; BYTE $0xcc                           // movq         %r9, %r12
+	WORD $0x894d; BYTE $0xf3                           // movq         %r14, %r11
+	LONG $0x007e8c0f; WORD $0x0000                     // jl           LBB8_10, $126(%rip)
+	LONG $0x20fe8349                                   // cmpq         $32, %r14
+	LONG $0x00748c0f; WORD $0x0000                     // jl           LBB8_10, $116(%rip)
+	WORD $0x3145; BYTE $0xe4                           // xorl         %r12d, %r12d
+	WORD $0x894c; BYTE $0xf6                           // movq         %r14, %rsi
+	WORD $0x894c; BYTE $0xd2                           // movq         %r10, %rdx
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB8_6:
+	LONG $0x6f7ea1c4; WORD $0x2004 // vmovdqu      (%rax,%r12), %ymm0
+	LONG $0xcb74fdc5               // vpcmpeqb     %ymm3, %ymm0, %ymm1
+	LONG $0xd474fdc5               // vpcmpeqb     %ymm4, %ymm0, %ymm2
+	LONG $0xc9ebedc5               // vpor         %ymm1, %ymm2, %ymm1
+	LONG $0x7f7e81c4; WORD $0x2104 // vmovdqu      %ymm0, (%r9,%r12)
+	LONG $0xd5dafdc5               // vpminub      %ymm5, %ymm0, %ymm2
+	LONG $0xc274fdc5               // vpcmpeqb     %ymm2, %ymm0, %ymm0
+	LONG $0xc0ebf5c5               // vpor         %ymm0, %ymm1, %ymm0
+	LONG $0xc8d7fdc5               // vpmovmskb    %ymm0, %ecx
+	WORD $0xc985                   // testl        %ecx, %ecx
+	LONG $0x01d8850f; WORD $0x0000 // jne          LBB8_20, $472(%rip)
+	LONG $0xe05e8d4c               // leaq         $-32(%rsi), %r11
+	LONG $0xe05a8d48               // leaq         $-32(%rdx), %rbx
+	LONG $0x20c48349               // addq         $32, %r12
+	LONG $0x40fe8348               // cmpq         $64, %rsi
+	WORD $0x9d0f; BYTE $0xc1       // setge        %cl
+	LONG $0x00108c0f; WORD $0x0000 // jl           LBB8_9, $16(%rip)
+	WORD $0x894c; BYTE $0xde       // movq         %r11, %rsi
+	LONG $0x3ffa8348               // cmpq         $63, %rdx
+	WORD $0x8948; BYTE $0xda       // movq         %rbx, %rdx
+	LONG $0xffa78f0f; WORD $0xffff // jg           LBB8_6, $-89(%rip)
+
+LBB8_9:
+	LONG $0x202c8d4e         // leaq         (%rax,%r12), %r13
+	WORD $0x014d; BYTE $0xcc // addq         %r9, %r12
+
+LBB8_10:
+	WORD $0xc984                           // testb        %cl, %cl
+	LONG $0x007b840f; WORD $0x0000         // je           LBB8_14, $123(%rip)
+	WORD $0x894c; BYTE $0xf6               // movq         %r14, %rsi
+	LONG $0x6f7ec1c4; WORD $0x0045         // vmovdqu      (%r13), %ymm0
+	LONG $0xcb74fdc5                       // vpcmpeqb     %ymm3, %ymm0, %ymm1
+	LONG $0xd474fdc5                       // vpcmpeqb     %ymm4, %ymm0, %ymm2
+	LONG $0xc9ebedc5                       // vpor         %ymm1, %ymm2, %ymm1
+	LONG $0xd5dafdc5                       // vpminub      %ymm5, %ymm0, %ymm2
+	LONG $0xc274fdc5                       // vpcmpeqb     %ymm2, %ymm0, %ymm0
+	LONG $0xc0ebf5c5                       // vpor         %ymm0, %ymm1, %ymm0
+	LONG $0xc8d7fdc5                       // vpmovmskb    %ymm0, %ecx
+	QUAD $0x000100000000ba48; WORD $0x0000 // movabsq      $4294967296, %rdx
+	WORD $0x0948; BYTE $0xd1               // orq          %rdx, %rcx
+	LONG $0xf1bc0f4c                       // bsfq         %rcx, %r14
+	LONG $0x00558b49                       // movq         (%r13), %rdx
+	LONG $0x084d8b49                       // movq         $8(%r13), %rcx
+	WORD $0x3949; BYTE $0xde               // cmpq         %rbx, %r14
+	LONG $0x01688e0f; WORD $0x0000         // jle          LBB8_21, $360(%rip)
+	LONG $0x10fb8348                       // cmpq         $16, %rbx
+	WORD $0x8949; BYTE $0xc3               // movq         %rax, %r11
+	LONG $0x01a7820f; WORD $0x0000         // jb           LBB8_24, $423(%rip)
+	LONG $0x24148949                       // movq         %rdx, (%r12)
+	LONG $0x244c8949; BYTE $0x08           // movq         %rcx, $8(%r12)
+	LONG $0x104d8d49                       // leaq         $16(%r13), %rcx
+	LONG $0x10c48349                       // addq         $16, %r12
+	LONG $0xf0538d48                       // leaq         $-16(%rbx), %rdx
+	WORD $0x8949; BYTE $0xf6               // movq         %rsi, %r14
+	LONG $0x08fa8348                       // cmpq         $8, %rdx
+	LONG $0x0198830f; WORD $0x0000         // jae          LBB8_25, $408(%rip)
+	LONG $0x0001a6e9; BYTE $0x00           // jmp          LBB8_26, $422(%rip)
+
+LBB8_14:
+	WORD $0xf8c5; BYTE $0x77       // vzeroupper
+	LONG $0x10fb8349               // cmpq         $16, %r11
+	WORD $0x9d0f; BYTE $0xc2       // setge        %dl
+	LONG $0xc87d894c               // movq         %r15, $-56(%rbp)
+	LONG $0xd075894c               // movq         %r14, $-48(%rbp)
+	LONG $0x02018c0f; WORD $0x0000 // jl           LBB8_31, $513(%rip)
+	LONG $0x10fb8348               // cmpq         $16, %rbx
+	QUAD $0xfffffe19356ff9c5       // vmovdqa      $-487(%rip), %xmm6  /* LCPI8_3(%rip) */
+	QUAD $0xfffffe213d6ff9c5       // vmovdqa      $-479(%rip), %xmm7  /* LCPI8_4(%rip) */
+	QUAD $0xfffffe29056f79c5       // vmovdqa      $-471(%rip), %xmm8  /* LCPI8_5(%rip) */
+	LONG $0x02228c0f; WORD $0x0000 // jl           LBB8_36, $546(%rip)
+	WORD $0x8948; BYTE $0xc1       // movq         %rax, %rcx
+	WORD $0x294c; BYTE $0xe9       // subq         %r13, %rcx
+	QUAD $0xfffffd951d6ffdc5       // vmovdqa      $-619(%rip), %ymm3  /* LCPI8_0(%rip) */
+	QUAD $0xfffffdad256ffdc5       // vmovdqa      $-595(%rip), %ymm4  /* LCPI8_1(%rip) */
+	QUAD $0xfffffdc52d6ffdc5       // vmovdqa      $-571(%rip), %ymm5  /* LCPI8_2(%rip) */
+	LONG $0x90909090; BYTE $0x90   // .p2align 4, 0x90
+
+LBB8_17:
+	LONG $0x6f7ac1c4; WORD $0x0045 // vmovdqu      (%r13), %xmm0
+	LONG $0xce74f9c5               // vpcmpeqb     %xmm6, %xmm0, %xmm1
+	LONG $0xd774f9c5               // vpcmpeqb     %xmm7, %xmm0, %xmm2
+	LONG $0xc9ebe9c5               // vpor         %xmm1, %xmm2, %xmm1
+	LONG $0x7f7ac1c4; WORD $0x2404 // vmovdqu      %xmm0, (%r12)
+	LONG $0xd0dab9c5               // vpminub      %xmm0, %xmm8, %xmm2
+	LONG $0xc274f9c5               // vpcmpeqb     %xmm2, %xmm0, %xmm0
+	LONG $0xc0ebf1c5               // vpor         %xmm0, %xmm1, %xmm0
+	LONG $0xd0d7f9c5               // vpmovmskb    %xmm0, %edx
+	WORD $0xd285                   // testl        %edx, %edx
+	LONG $0x00d8850f; WORD $0x0000 // jne          LBB8_23, $216(%rip)
+	LONG $0x10c58349               // addq         $16, %r13
+	LONG $0x10c48349               // addq         $16, %r12
+	LONG $0xf07b8d4d               // leaq         $-16(%r11), %r15
+	LONG $0xf0738d4c               // leaq         $-16(%rbx), %r14
+	LONG $0x20fb8349               // cmpq         $32, %r11
+	WORD $0x9d0f; BYTE $0xc2       // setge        %dl
+	LONG $0x00148c0f; WORD $0x0000 // jl           LBB8_32, $20(%rip)
+	LONG $0xf0c18348               // addq         $-16, %rcx
+	WORD $0x894d; BYTE $0xfb       // movq         %r15, %r11
+	LONG $0x1ffb8348               // cmpq         $31, %rbx
+	WORD $0x894c; BYTE $0xf3       // movq         %r14, %rbx
+	LONG $0xff9f8f0f; WORD $0xffff // jg           LBB8_17, $-97(%rip)
+
+LBB8_32:
+	WORD $0xd284                   // testb        %dl, %dl
+	LONG $0x01bc840f; WORD $0x0000 // je           LBB8_37, $444(%rip)
+
+LBB8_33:
+	LONG $0x6f7ac1c4; WORD $0x0045 // vmovdqu      (%r13), %xmm0
+	LONG $0xce74f9c5               // vpcmpeqb     %xmm6, %xmm0, %xmm1
+	LONG $0xd774f9c5               // vpcmpeqb     %xmm7, %xmm0, %xmm2
+	LONG $0xc9ebe9c5               // vpor         %xmm1, %xmm2, %xmm1
+	LONG $0xd0dab9c5               // vpminub      %xmm0, %xmm8, %xmm2
+	LONG $0xd274f9c5               // vpcmpeqb     %xmm2, %xmm0, %xmm2
+	LONG $0xcaebf1c5               // vpor         %xmm2, %xmm1, %xmm1
+	LONG $0xc9d7f9c5               // vpmovmskb    %xmm1, %ecx
+	LONG $0x0000c981; WORD $0x0001 // orl          $65536, %ecx
+	WORD $0xbc0f; BYTE $0xd9       // bsfl         %ecx, %ebx
+	LONG $0x7ef9e1c4; BYTE $0xc1   // vmovq        %xmm0, %rcx
+	WORD $0x3949; BYTE $0xde       // cmpq         %rbx, %r14
+	WORD $0x8949; BYTE $0xc3       // movq         %rax, %r11
+	LONG $0x029e8d0f; WORD $0x0000 // jge          LBB8_57, $670(%rip)
+	LONG $0x08fe8349               // cmpq         $8, %r14
+	LONG $0xc87d8b4c               // movq         $-56(%rbp), %r15
+	LONG $0x02cd820f; WORD $0x0000 // jb           LBB8_62, $717(%rip)
+	LONG $0x240c8949               // movq         %rcx, (%r12)
+	LONG $0x084d8d49               // leaq         $8(%r13), %rcx
+	LONG $0x08c48349               // addq         $8, %r12
+	LONG $0xf8568d49               // leaq         $-8(%r14), %rdx
+	LONG $0x0002bee9; BYTE $0x00   // jmp          LBB8_63, $702(%rip)
+
+LBB8_20:
+	WORD $0x8949; BYTE $0xc3     // movq         %rax, %r11
+	LONG $0xe9bc0f44             // bsfl         %ecx, %r13d
+	WORD $0x014d; BYTE $0xe5     // addq         %r12, %r13
+	LONG $0x000379e9; BYTE $0x00 // jmp          LBB8_75, $889(%rip)
+
+LBB8_21:
+	LONG $0x10fe8341               // cmpl         $16, %r14d
+	WORD $0x8949; BYTE $0xc3       // movq         %rax, %r11
+	LONG $0x01cc820f; WORD $0x0000 // jb           LBB8_46, $460(%rip)
+	LONG $0x24148949               // movq         %rdx, (%r12)
+	LONG $0x244c8949; BYTE $0x08   // movq         %rcx, $8(%r12)
+	LONG $0x105d8d49               // leaq         $16(%r13), %rbx
+	LONG $0x10c48349               // addq         $16, %r12
+	LONG $0xf04e8d49               // leaq         $-16(%r14), %rcx
+	LONG $0x08f98348               // cmpq         $8, %rcx
+	LONG $0x01bd830f; WORD $0x0000 // jae          LBB8_47, $445(%rip)
+	LONG $0x0001cbe9; BYTE $0x00   // jmp          LBB8_48, $459(%rip)
+
+LBB8_23:
+	LONG $0xd2bc0f66             // bsfw         %dx, %dx
+	LONG $0xeab70f44             // movzwl       %dx, %r13d
+	WORD $0x2949; BYTE $0xcd     // subq         %rcx, %r13
+	LONG $0xc87d8b4c             // movq         $-56(%rbp), %r15
+	LONG $0xd0758b4c             // movq         $-48(%rbp), %r14
+	WORD $0x8949; BYTE $0xc3     // movq         %rax, %r11
+	LONG $0x00032de9; BYTE $0x00 // jmp          LBB8_75, $813(%rip)
+
+LBB8_24:
+	WORD $0x894c; BYTE $0xe9       // movq         %r13, %rcx
+	WORD $0x8948; BYTE $0xda       // movq         %rbx, %rdx
+	WORD $0x8949; BYTE $0xf6       // movq         %rsi, %r14
+	LONG $0x08fa8348               // cmpq         $8, %rdx
+	LONG $0x0013820f; WORD $0x0000 // jb           LBB8_26, $19(%rip)
+
+LBB8_25:
+	WORD $0x8b48; BYTE $0x31 // movq         (%rcx), %rsi
+	LONG $0x24348949         // movq         %rsi, (%r12)
+	LONG $0x08c18348         // addq         $8, %rcx
+	LONG $0x08c48349         // addq         $8, %r12
+	LONG $0xf8c28348         // addq         $-8, %rdx
+
+LBB8_26:
+	LONG $0x04fa8348               // cmpq         $4, %rdx
+	LONG $0x003d8c0f; WORD $0x0000 // jl           LBB8_27, $61(%rip)
+	WORD $0x318b                   // movl         (%rcx), %esi
+	LONG $0x24348941               // movl         %esi, (%r12)
+	LONG $0x04c18348               // addq         $4, %rcx
+	LONG $0x04c48349               // addq         $4, %r12
+	LONG $0xfcc28348               // addq         $-4, %rdx
+	LONG $0x02fa8348               // cmpq         $2, %rdx
+	LONG $0x002b830f; WORD $0x0000 // jae          LBB8_54, $43(%rip)
+
+LBB8_28:
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0x0007840f; WORD $0x0000 // je           LBB8_30, $7(%rip)
+
+LBB8_29:
+	WORD $0xb60f; BYTE $0x09 // movzbl       (%rcx), %ecx
+	LONG $0x240c8841         // movb         %cl, (%r12)
+
+LBB8_30:
+	WORD $0x014c; BYTE $0xeb     // addq         %r13, %rbx
+	WORD $0xf748; BYTE $0xd3     // notq         %rbx
+	WORD $0x014c; BYTE $0xdb     // addq         %r11, %rbx
+	WORD $0x8949; BYTE $0xdd     // movq         %rbx, %r13
+	LONG $0x0002c0e9; BYTE $0x00 // jmp          LBB8_75, $704(%rip)
+
+LBB8_27:
+	LONG $0x02fa8348               // cmpq         $2, %rdx
+	LONG $0xffd5820f; WORD $0xffff // jb           LBB8_28, $-43(%rip)
+
+LBB8_54:
+	WORD $0xb70f; BYTE $0x31       // movzwl       (%rcx), %esi
+	LONG $0x34894166; BYTE $0x24   // movw         %si, (%r12)
+	LONG $0x02c18348               // addq         $2, %rcx
+	LONG $0x02c48349               // addq         $2, %r12
+	LONG $0xfec28348               // addq         $-2, %rdx
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0xffc1850f; WORD $0xffff // jne          LBB8_29, $-63(%rip)
+	LONG $0xffffc3e9; BYTE $0xff   // jmp          LBB8_30, $-61(%rip)
+
+LBB8_31:
+	WORD $0x8949; BYTE $0xde       // movq         %rbx, %r14
+	WORD $0x894d; BYTE $0xdf       // movq         %r11, %r15
+	QUAD $0xfffffbb61d6ffdc5       // vmovdqa      $-1098(%rip), %ymm3  /* LCPI8_0(%rip) */
+	QUAD $0xfffffbce256ffdc5       // vmovdqa      $-1074(%rip), %ymm4  /* LCPI8_1(%rip) */
+	QUAD $0xfffffbe62d6ffdc5       // vmovdqa      $-1050(%rip), %ymm5  /* LCPI8_2(%rip) */
+	QUAD $0xfffffbfe356ff9c5       // vmovdqa      $-1026(%rip), %xmm6  /* LCPI8_3(%rip) */
+	QUAD $0xfffffc063d6ff9c5       // vmovdqa      $-1018(%rip), %xmm7  /* LCPI8_4(%rip) */
+	QUAD $0xfffffc0e056f79c5       // vmovdqa      $-1010(%rip), %xmm8  /* LCPI8_5(%rip) */
+	WORD $0xd284                   // testb        %dl, %dl
+	LONG $0x002b840f; WORD $0x0000 // je           LBB8_37, $43(%rip)
+	LONG $0xfffe6ae9; BYTE $0xff   // jmp          LBB8_33, $-406(%rip)
+
+LBB8_36:
+	WORD $0x8949; BYTE $0xde       // movq         %rbx, %r14
+	WORD $0x894d; BYTE $0xdf       // movq         %r11, %r15
+	QUAD $0xfffffb731d6ffdc5       // vmovdqa      $-1165(%rip), %ymm3  /* LCPI8_0(%rip) */
+	QUAD $0xfffffb8b256ffdc5       // vmovdqa      $-1141(%rip), %ymm4  /* LCPI8_1(%rip) */
+	QUAD $0xfffffba32d6ffdc5       // vmovdqa      $-1117(%rip), %ymm5  /* LCPI8_2(%rip) */
+	WORD $0xd284                   // testb        %dl, %dl
+	LONG $0xfe44850f; WORD $0xffff // jne          LBB8_33, $-444(%rip)
+
+LBB8_37:
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	WORD $0x8949; BYTE $0xc3       // movq         %rax, %r11
+	LONG $0x005d8e0f; WORD $0x0000 // jle          LBB8_44, $93(%rip)
+	WORD $0x854d; BYTE $0xf6       // testq        %r14, %r14
+	LONG $0x00548e0f; WORD $0x0000 // jle          LBB8_44, $84(%rip)
+	WORD $0xd231                   // xorl         %edx, %edx
+	WORD $0xc931                   // xorl         %ecx, %ecx
+	WORD $0x9090                   // .p2align 4, 0x90
+
+LBB8_40:
+	LONG $0x5cb60f41; WORD $0x0015             // movzbl       (%r13,%rdx), %ebx
+	WORD $0x8948; BYTE $0xde                   // movq         %rbx, %rsi
+	LONG $0x04e6c148                           // shlq         $4, %rsi
+	LONG $0xfc058d48; WORD $0x00da; BYTE $0x00 // leaq         $56060(%rip), %rax  /* __SingleQuoteTab(%rip) */
+	LONG $0x063c8348; BYTE $0x00               // cmpq         $0, (%rsi,%rax)
+	LONG $0x0112850f; WORD $0x0000             // jne          LBB8_61, $274(%rip)
+	LONG $0x0f048d49                           // leaq         (%r15,%rcx), %rax
+	LONG $0x141c8841                           // movb         %bl, (%r12,%rdx)
+	LONG $0xff718d48                           // leaq         $-1(%rcx), %rsi
+	LONG $0x02f88348                           // cmpq         $2, %rax
+	LONG $0x00138c0f; WORD $0x0000             // jl           LBB8_43, $19(%rip)
+	WORD $0x014c; BYTE $0xf1                   // addq         %r14, %rcx
+	WORD $0xff48; BYTE $0xc2                   // incq         %rdx
+	LONG $0x01f98348                           // cmpq         $1, %rcx
+	WORD $0x8948; BYTE $0xf1                   // movq         %rsi, %rcx
+	LONG $0xffb88f0f; WORD $0xffff             // jg           LBB8_40, $-72(%rip)
+
+LBB8_43:
+	WORD $0x2949; BYTE $0xf5 // subq         %rsi, %r13
+	WORD $0x0149; BYTE $0xf7 // addq         %rsi, %r15
+
+LBB8_44:
+	WORD $0x854d; BYTE $0xff               // testq        %r15, %r15
+	LONG $0xd0758b4c                       // movq         $-48(%rbp), %r14
+	QUAD $0x000300000001bc49; WORD $0x0000 // movabsq      $12884901889, %r12
+	LONG $0x00c0840f; WORD $0x0000         // je           LBB8_59, $192(%rip)
+	WORD $0xf749; BYTE $0xd5               // notq         %r13
+	WORD $0x014d; BYTE $0xdd               // addq         %r11, %r13
+	LONG $0x0000b8e9; BYTE $0x00           // jmp          LBB8_60, $184(%rip)
+
+LBB8_46:
+	WORD $0x894c; BYTE $0xeb       // movq         %r13, %rbx
+	WORD $0x894c; BYTE $0xf1       // movq         %r14, %rcx
+	LONG $0x08f98348               // cmpq         $8, %rcx
+	LONG $0x0013820f; WORD $0x0000 // jb           LBB8_48, $19(%rip)
+
+LBB8_47:
+	WORD $0x8b48; BYTE $0x13 // movq         (%rbx), %rdx
+	LONG $0x24148949         // movq         %rdx, (%r12)
+	LONG $0x08c38348         // addq         $8, %rbx
+	LONG $0x08c48349         // addq         $8, %r12
+	LONG $0xf8c18348         // addq         $-8, %rcx
+
+LBB8_48:
+	LONG $0x04f98348               // cmpq         $4, %rcx
+	LONG $0x003a820f; WORD $0x0000 // jb           LBB8_49, $58(%rip)
+	WORD $0x138b                   // movl         (%rbx), %edx
+	LONG $0x24148941               // movl         %edx, (%r12)
+	LONG $0x04c38348               // addq         $4, %rbx
+	LONG $0x04c48349               // addq         $4, %r12
+	LONG $0xfcc18348               // addq         $-4, %rcx
+	LONG $0x02f98348               // cmpq         $2, %rcx
+	LONG $0x0028830f; WORD $0x0000 // jae          LBB8_56, $40(%rip)
+
+LBB8_50:
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x0007840f; WORD $0x0000 // je           LBB8_52, $7(%rip)
+
+LBB8_51:
+	WORD $0xb60f; BYTE $0x0b // movzbl       (%rbx), %ecx
+	LONG $0x240c8841         // movb         %cl, (%r12)
+
+LBB8_52:
+	WORD $0x294d; BYTE $0xdd     // subq         %r11, %r13
+	WORD $0x014d; BYTE $0xf5     // addq         %r14, %r13
+	WORD $0x8949; BYTE $0xf6     // movq         %rsi, %r14
+	LONG $0x000139e9; BYTE $0x00 // jmp          LBB8_75, $313(%rip)
+
+LBB8_49:
+	LONG $0x02f98348               // cmpq         $2, %rcx
+	LONG $0xffd8820f; WORD $0xffff // jb           LBB8_50, $-40(%rip)
+
+LBB8_56:
+	WORD $0xb70f; BYTE $0x13       // movzwl       (%rbx), %edx
+	LONG $0x14894166; BYTE $0x24   // movw         %dx, (%r12)
+	LONG $0x02c38348               // addq         $2, %rbx
+	LONG $0x02c48349               // addq         $2, %r12
+	LONG $0xfec18348               // addq         $-2, %rcx
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0xffc4850f; WORD $0xffff // jne          LBB8_51, $-60(%rip)
+	LONG $0xffffc6e9; BYTE $0xff   // jmp          LBB8_52, $-58(%rip)
+
+LBB8_57:
+	WORD $0xfb83; BYTE $0x08       // cmpl         $8, %ebx
+	LONG $0xc87d8b4c               // movq         $-56(%rbp), %r15
+	LONG $0x00ad820f; WORD $0x0000 // jb           LBB8_69, $173(%rip)
+	LONG $0x240c8949               // movq         %rcx, (%r12)
+	LONG $0x08558d49               // leaq         $8(%r13), %rdx
+	LONG $0x08c48349               // addq         $8, %r12
+	LONG $0xf84b8d48               // leaq         $-8(%rbx), %rcx
+	LONG $0x00009ee9; BYTE $0x00   // jmp          LBB8_70, $158(%rip)
+
+LBB8_59:
+	WORD $0x294d; BYTE $0xdd // subq         %r11, %r13
+
+LBB8_60:
+	LONG $0xc87d8b4c             // movq         $-56(%rbp), %r15
+	LONG $0x0000e9e9; BYTE $0x00 // jmp          LBB8_76, $233(%rip)
+
+LBB8_61:
+	WORD $0x294d; BYTE $0xdd     // subq         %r11, %r13
+	WORD $0x2949; BYTE $0xcd     // subq         %rcx, %r13
+	LONG $0xc87d8b4c             // movq         $-56(%rbp), %r15
+	LONG $0x000048e9; BYTE $0x00 // jmp          LBB8_68, $72(%rip)
+
+LBB8_62:
+	WORD $0x894c; BYTE $0xe9 // movq         %r13, %rcx
+	WORD $0x894c; BYTE $0xf2 // movq         %r14, %rdx
+
+LBB8_63:
+	LONG $0x04fa8348               // cmpq         $4, %rdx
+	LONG $0x00418c0f; WORD $0x0000 // jl           LBB8_64, $65(%rip)
+	WORD $0x318b                   // movl         (%rcx), %esi
+	LONG $0x24348941               // movl         %esi, (%r12)
+	LONG $0x04c18348               // addq         $4, %rcx
+	LONG $0x04c48349               // addq         $4, %r12
+	LONG $0xfcc28348               // addq         $-4, %rdx
+	LONG $0x02fa8348               // cmpq         $2, %rdx
+	LONG $0x002f830f; WORD $0x0000 // jae          LBB8_90, $47(%rip)
+
+LBB8_65:
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0x0007840f; WORD $0x0000 // je           LBB8_67, $7(%rip)
+
+LBB8_66:
+	WORD $0xb60f; BYTE $0x09 // movzbl       (%rcx), %ecx
+	LONG $0x240c8841         // movb         %cl, (%r12)
+
+LBB8_67:
+	WORD $0x014d; BYTE $0xee // addq         %r13, %r14
+	WORD $0xf749; BYTE $0xd6 // notq         %r14
+	WORD $0x014d; BYTE $0xde // addq         %r11, %r14
+	WORD $0x894d; BYTE $0xf5 // movq         %r14, %r13
+
+LBB8_68:
+	LONG $0xd0758b4c             // movq         $-48(%rbp), %r14
+	LONG $0x00007fe9; BYTE $0x00 // jmp          LBB8_75, $127(%rip)
+
+LBB8_64:
+	LONG $0x02fa8348               // cmpq         $2, %rdx
+	LONG $0xffd1820f; WORD $0xffff // jb           LBB8_65, $-47(%rip)
+
+LBB8_90:
+	WORD $0xb70f; BYTE $0x31       // movzwl       (%rcx), %esi
+	LONG $0x34894166; BYTE $0x24   // movw         %si, (%r12)
+	LONG $0x02c18348               // addq         $2, %rcx
+	LONG $0x02c48349               // addq         $2, %r12
+	LONG $0xfec28348               // addq         $-2, %rdx
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0xffbd850f; WORD $0xffff // jne          LBB8_66, $-67(%rip)
+	LONG $0xffffbfe9; BYTE $0xff   // jmp          LBB8_67, $-65(%rip)
+
+LBB8_69:
+	WORD $0x894c; BYTE $0xea // movq         %r13, %rdx
+	WORD $0x8948; BYTE $0xd9 // movq         %rbx, %rcx
+
+LBB8_70:
+	LONG $0xd0758b4c               // movq         $-48(%rbp), %r14
+	LONG $0x04f98348               // cmpq         $4, %rcx
+	LONG $0x0126820f; WORD $0x0000 // jb           LBB8_71, $294(%rip)
+	WORD $0x328b                   // movl         (%rdx), %esi
+	LONG $0x24348941               // movl         %esi, (%r12)
+	LONG $0x04c28348               // addq         $4, %rdx
+	LONG $0x04c48349               // addq         $4, %r12
+	LONG $0xfcc18348               // addq         $-4, %rcx
+	LONG $0x02f98348               // cmpq         $2, %rcx
+	LONG $0x0114830f; WORD $0x0000 // jae          LBB8_92, $276(%rip)
+
+LBB8_72:
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x0007840f; WORD $0x0000 // je           LBB8_74, $7(%rip)
+
+LBB8_73:
+	WORD $0xb60f; BYTE $0x0a // movzbl       (%rdx), %ecx
+	LONG $0x240c8841         // movb         %cl, (%r12)
+
+LBB8_74:
+	WORD $0x294d; BYTE $0xdd                               // subq         %r11, %r13
+	WORD $0x0149; BYTE $0xdd                               // addq         %rbx, %r13
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB8_75:
+	QUAD $0x000300000001bc49; WORD $0x0000 // movabsq      $12884901889, %r12
+
+LBB8_76:
+	WORD $0x854d; BYTE $0xed             // testq        %r13, %r13
+	LONG $0x0425880f; WORD $0x0000       // js           LBB8_125, $1061(%rip)
+	WORD $0x014d; BYTE $0xe9             // addq         %r13, %r9
+	WORD $0x394d; BYTE $0xee             // cmpq         %r13, %r14
+	LONG $0x03d9840f; WORD $0x0000       // je           LBB8_121, $985(%rip)
+	WORD $0x294d; BYTE $0xea             // subq         %r13, %r10
+	LONG $0x000018e9; BYTE $0x00         // jmp          LBB8_80, $24(%rip)
+	QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB8_79:
+	WORD $0x0149; BYTE $0xc9       // addq         %rcx, %r9
+	WORD $0xff49; BYTE $0xc5       // incq         %r13
+	WORD $0x394d; BYTE $0xee       // cmpq         %r13, %r14
+	LONG $0x03b9840f; WORD $0x0000 // je           LBB8_121, $953(%rip)
+
+LBB8_80:
+	LONG $0x14b60f43; BYTE $0x2b                       // movzbl       (%r11,%r13), %edx
+	LONG $0x04e2c148                                   // shlq         $4, %rdx
+	LONG $0x10348b41                                   // movl         (%r8,%rdx), %esi
+	WORD $0x8548; BYTE $0xf6                           // testq        %rsi, %rsi
+	LONG $0x0080840f; WORD $0x0000                     // je           LBB8_88, $128(%rip)
+	WORD $0x6348; BYTE $0xce                           // movslq       %esi, %rcx
+	WORD $0x2949; BYTE $0xca                           // subq         %rcx, %r10
+	LONG $0x03af8c0f; WORD $0x0000                     // jl           LBB8_123, $943(%rip)
+	LONG $0x20e6c148                                   // shlq         $32, %rsi
+	WORD $0x014c; BYTE $0xc2                           // addq         %r8, %rdx
+	LONG $0x08c28348                                   // addq         $8, %rdx
+	WORD $0x394c; BYTE $0xe6                           // cmpq         %r12, %rsi
+	LONG $0x002b8c0f; WORD $0x0000                     // jl           LBB8_84, $43(%rip)
+	WORD $0x028b                                       // movl         (%rdx), %eax
+	WORD $0x8941; BYTE $0x01                           // movl         %eax, (%r9)
+	LONG $0x04c28348                                   // addq         $4, %rdx
+	LONG $0x04718d49                                   // leaq         $4(%r9), %rsi
+	LONG $0xfc598d48                                   // leaq         $-4(%rcx), %rbx
+	LONG $0x02fb8348                                   // cmpq         $2, %rbx
+	LONG $0x0020830f; WORD $0x0000                     // jae          LBB8_85, $32(%rip)
+	LONG $0x00002de9; BYTE $0x00                       // jmp          LBB8_86, $45(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB8_84:
+	WORD $0x894c; BYTE $0xce       // movq         %r9, %rsi
+	WORD $0x8948; BYTE $0xcb       // movq         %rcx, %rbx
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0x0012820f; WORD $0x0000 // jb           LBB8_86, $18(%rip)
+
+LBB8_85:
+	WORD $0xb70f; BYTE $0x02 // movzwl       (%rdx), %eax
+	WORD $0x8966; BYTE $0x06 // movw         %ax, (%rsi)
+	LONG $0x02c28348         // addq         $2, %rdx
+	LONG $0x02c68348         // addq         $2, %rsi
+	LONG $0xfec38348         // addq         $-2, %rbx
+
+LBB8_86:
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0xff65840f; WORD $0xffff // je           LBB8_79, $-155(%rip)
+	WORD $0xb60f; BYTE $0x02       // movzbl       (%rdx), %eax
+	WORD $0x0688                   // movb         %al, (%rsi)
+	LONG $0xffff5be9; BYTE $0xff   // jmp          LBB8_79, $-165(%rip)
+
+LBB8_88:
+	LONG $0x2b0c8d4b               // leaq         (%r11,%r13), %rcx
+	WORD $0x294d; BYTE $0xee       // subq         %r13, %r14
+	LONG $0xf950850f; WORD $0xffff // jne          LBB8_3, $-1712(%rip)
+	LONG $0x000311e9; BYTE $0x00   // jmp          LBB8_121, $785(%rip)
+
+LBB8_71:
+	LONG $0x02f98348               // cmpq         $2, %rcx
+	LONG $0xfeec820f; WORD $0xffff // jb           LBB8_72, $-276(%rip)
+
+LBB8_92:
+	WORD $0xb70f; BYTE $0x32       // movzwl       (%rdx), %esi
+	LONG $0x34894166; BYTE $0x24   // movw         %si, (%r12)
+	LONG $0x02c28348               // addq         $2, %rdx
+	LONG $0x02c48349               // addq         $2, %r12
+	LONG $0xfec18348               // addq         $-2, %rcx
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0xfed8850f; WORD $0xffff // jne          LBB8_73, $-296(%rip)
+	LONG $0xfffedae9; BYTE $0xff   // jmp          LBB8_74, $-294(%rip)
+
+LBB8_93:
+	LONG $0xe60d8d4c; WORD $0x00f7; BYTE $0x00 // leaq         $63462(%rip), %r9  /* __EscTab(%rip) */
+	QUAD $0xfffff80e1d6ffdc5                   // vmovdqa      $-2034(%rip), %ymm3  /* LCPI8_0(%rip) */
+	QUAD $0xfffff826056f7dc5                   // vmovdqa      $-2010(%rip), %ymm8  /* LCPI8_1(%rip) */
+	QUAD $0xfffff83e2d6ffdc5                   // vmovdqa      $-1986(%rip), %ymm5  /* LCPI8_2(%rip) */
+	WORD $0x8948; BYTE $0xd3                   // movq         %rdx, %rbx
+	WORD $0x894c; BYTE $0xf6                   // movq         %r14, %rsi
+
+LBB8_94:
+	LONG $0x10fe8348               // cmpq         $16, %rsi
+	LONG $0x01108c0f; WORD $0x0000 // jl           LBB8_102, $272(%rip)
+	LONG $0x20fe8348               // cmpq         $32, %rsi
+	LONG $0x0088820f; WORD $0x0000 // jb           LBB8_99, $136(%rip)
+	LONG $0x90909090               // .p2align 4, 0x90
+
+LBB8_96:
+	LONG $0x076ffec5               // vmovdqu      (%rdi), %ymm0
+	LONG $0xcb74fdc5               // vpcmpeqb     %ymm3, %ymm0, %ymm1
+	LONG $0xd074bdc5               // vpcmpeqb     %ymm0, %ymm8, %ymm2
+	LONG $0xc9ebedc5               // vpor         %ymm1, %ymm2, %ymm1
+	LONG $0x037ffec5               // vmovdqu      %ymm0, (%rbx)
+	LONG $0xd5dafdc5               // vpminub      %ymm5, %ymm0, %ymm2
+	LONG $0xc274fdc5               // vpcmpeqb     %ymm2, %ymm0, %ymm0
+	LONG $0xc0ebf5c5               // vpor         %ymm0, %ymm1, %ymm0
+	LONG $0xc0d7fdc5               // vpmovmskb    %ymm0, %eax
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x01ff850f; WORD $0x0000 // jne          LBB8_114, $511(%rip)
+	LONG $0x20c78348               // addq         $32, %rdi
+	LONG $0x20c38348               // addq         $32, %rbx
+	LONG $0xe0c68348               // addq         $-32, %rsi
+	LONG $0x1ffe8348               // cmpq         $31, %rsi
+	LONG $0xffbe870f; WORD $0xffff // ja           LBB8_96, $-66(%rip)
+	WORD $0xf8c5; BYTE $0x77       // vzeroupper
+	QUAD $0xfffff7d32d6ffdc5       // vmovdqa      $-2093(%rip), %ymm5  /* LCPI8_2(%rip) */
+	QUAD $0xfffff7ab056f7dc5       // vmovdqa      $-2133(%rip), %ymm8  /* LCPI8_1(%rip) */
+	QUAD $0xfffff7831d6ffdc5       // vmovdqa      $-2173(%rip), %ymm3  /* LCPI8_0(%rip) */
+	LONG $0x10fe8348               // cmpq         $16, %rsi
+	QUAD $0xfffff7d7356ff9c5       // vmovdqa      $-2089(%rip), %xmm6  /* LCPI8_3(%rip) */
+	QUAD $0xfffff7df3d6ff9c5       // vmovdqa      $-2081(%rip), %xmm7  /* LCPI8_4(%rip) */
+	QUAD $0xfffff7e7256ff9c5       // vmovdqa      $-2073(%rip), %xmm4  /* LCPI8_5(%rip) */
+	LONG $0x0041830f; WORD $0x0000 // jae          LBB8_100, $65(%rip)
+	LONG $0x00007ee9; BYTE $0x00   // jmp          LBB8_102, $126(%rip)
+
+LBB8_99:
+	WORD $0xf8c5; BYTE $0x77             // vzeroupper
+	QUAD $0xfffff7912d6ffdc5             // vmovdqa      $-2159(%rip), %ymm5  /* LCPI8_2(%rip) */
+	QUAD $0xfffff769056f7dc5             // vmovdqa      $-2199(%rip), %ymm8  /* LCPI8_1(%rip) */
+	QUAD $0xfffff7411d6ffdc5             // vmovdqa      $-2239(%rip), %ymm3  /* LCPI8_0(%rip) */
+	QUAD $0xfffff799356ff9c5             // vmovdqa      $-2151(%rip), %xmm6  /* LCPI8_3(%rip) */
+	QUAD $0xfffff7a13d6ff9c5             // vmovdqa      $-2143(%rip), %xmm7  /* LCPI8_4(%rip) */
+	QUAD $0xfffff7a9256ff9c5             // vmovdqa      $-2135(%rip), %xmm4  /* LCPI8_5(%rip) */
+	QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB8_100:
+	LONG $0x076ffac5               // vmovdqu      (%rdi), %xmm0
+	LONG $0xce74f9c5               // vpcmpeqb     %xmm6, %xmm0, %xmm1
+	LONG $0xd774f9c5               // vpcmpeqb     %xmm7, %xmm0, %xmm2
+	LONG $0xc9ebe9c5               // vpor         %xmm1, %xmm2, %xmm1
+	LONG $0x037ffac5               // vmovdqu      %xmm0, (%rbx)
+	LONG $0xd4daf9c5               // vpminub      %xmm4, %xmm0, %xmm2
+	LONG $0xc274f9c5               // vpcmpeqb     %xmm2, %xmm0, %xmm0
+	LONG $0xc0ebf1c5               // vpor         %xmm0, %xmm1, %xmm0
+	LONG $0xc0d7f9c5               // vpmovmskb    %xmm0, %eax
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x0130850f; WORD $0x0000 // jne          LBB8_112, $304(%rip)
+	LONG $0x10c78348               // addq         $16, %rdi
+	LONG $0x10c38348               // addq         $16, %rbx
+	LONG $0xf0c68348               // addq         $-16, %rsi
+	LONG $0x0ffe8348               // cmpq         $15, %rsi
+	LONG $0xffbe870f; WORD $0xffff // ja           LBB8_100, $-66(%rip)
+
+LBB8_102:
+	LONG $0x08fe8348               // cmpq         $8, %rsi
+	LONG $0x00818c0f; WORD $0x0000 // jl           LBB8_106, $129(%rip)
+	WORD $0xb60f; BYTE $0x07       // movzbl       (%rdi), %eax
+	LONG $0x014fb60f               // movzbl       $1(%rdi), %ecx
+	LONG $0x0cb60f42; BYTE $0x09   // movzbl       (%rcx,%r9), %ecx
+	WORD $0xc900                   // addb         %cl, %cl
+	LONG $0x080c0a42               // orb          (%rax,%r9), %cl
+	LONG $0x0247b60f               // movzbl       $2(%rdi), %eax
+	LONG $0x14b60f46; BYTE $0x08   // movzbl       (%rax,%r9), %r10d
+	LONG $0x02e2c041               // shlb         $2, %r10b
+	WORD $0x0841; BYTE $0xca       // orb          %cl, %r10b
+	LONG $0x0347b60f               // movzbl       $3(%rdi), %eax
+	LONG $0x04b60f42; BYTE $0x08   // movzbl       (%rax,%r9), %eax
+	WORD $0xe0c0; BYTE $0x03       // shlb         $3, %al
+	WORD $0x0844; BYTE $0xd0       // orb          %r10b, %al
+	WORD $0x8b48; BYTE $0x0f       // movq         (%rdi), %rcx
+	WORD $0x8948; BYTE $0x0b       // movq         %rcx, (%rbx)
+	LONG $0x00df850f; WORD $0x0000 // jne          LBB8_113, $223(%rip)
+	LONG $0x0447b60f               // movzbl       $4(%rdi), %eax
+	LONG $0x054fb60f               // movzbl       $5(%rdi), %ecx
+	LONG $0x0cb60f42; BYTE $0x09   // movzbl       (%rcx,%r9), %ecx
+	WORD $0xc900                   // addb         %cl, %cl
+	LONG $0x080c0a42               // orb          (%rax,%r9), %cl
+	LONG $0x0647b60f               // movzbl       $6(%rdi), %eax
+	LONG $0x14b60f46; BYTE $0x08   // movzbl       (%rax,%r9), %r10d
+	LONG $0x02e2c041               // shlb         $2, %r10b
+	WORD $0x0841; BYTE $0xca       // orb          %cl, %r10b
+	LONG $0x0747b60f               // movzbl       $7(%rdi), %eax
+	LONG $0x04b60f42; BYTE $0x08   // movzbl       (%rax,%r9), %eax
+	WORD $0xe0c0; BYTE $0x03       // shlb         $3, %al
+	WORD $0x0844; BYTE $0xd0       // orb          %r10b, %al
+	LONG $0x00fc850f; WORD $0x0000 // jne          LBB8_119, $252(%rip)
+	LONG $0x08c38348               // addq         $8, %rbx
+	LONG $0x08c78348               // addq         $8, %rdi
+	LONG $0xf8c68348               // addq         $-8, %rsi
+
+LBB8_106:
+	LONG $0x04fe8348               // cmpq         $4, %rsi
+	LONG $0x00478c0f; WORD $0x0000 // jl           LBB8_109, $71(%rip)
+	WORD $0xb60f; BYTE $0x07       // movzbl       (%rdi), %eax
+	LONG $0x014fb60f               // movzbl       $1(%rdi), %ecx
+	LONG $0x0cb60f42; BYTE $0x09   // movzbl       (%rcx,%r9), %ecx
+	WORD $0xc900                   // addb         %cl, %cl
+	LONG $0x080c0a42               // orb          (%rax,%r9), %cl
+	LONG $0x0247b60f               // movzbl       $2(%rdi), %eax
+	LONG $0x14b60f46; BYTE $0x08   // movzbl       (%rax,%r9), %r10d
+	LONG $0x02e2c041               // shlb         $2, %r10b
+	WORD $0x0841; BYTE $0xca       // orb          %cl, %r10b
+	LONG $0x0347b60f               // movzbl       $3(%rdi), %eax
+	LONG $0x04b60f42; BYTE $0x08   // movzbl       (%rax,%r9), %eax
+	WORD $0xe0c0; BYTE $0x03       // shlb         $3, %al
+	WORD $0x0844; BYTE $0xd0       // orb          %r10b, %al
+	WORD $0x0f8b                   // movl         (%rdi), %ecx
+	WORD $0x0b89                   // movl         %ecx, (%rbx)
+	LONG $0x0056850f; WORD $0x0000 // jne          LBB8_113, $86(%rip)
+	LONG $0x04c38348               // addq         $4, %rbx
+	LONG $0x04c78348               // addq         $4, %rdi
+	LONG $0xfcc68348               // addq         $-4, %rsi
+
+LBB8_109:
+	WORD $0x8548; BYTE $0xf6             // testq        %rsi, %rsi
+	LONG $0x00b68e0f; WORD $0x0000       // jle          LBB8_120, $182(%rip)
+	QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB8_110:
+	WORD $0xb60f; BYTE $0x07       // movzbl       (%rdi), %eax
+	LONG $0x083c8042; BYTE $0x00   // cmpb         $0, (%rax,%r9)
+	LONG $0x0039850f; WORD $0x0000 // jne          LBB8_116, $57(%rip)
+	WORD $0xff48; BYTE $0xc7       // incq         %rdi
+	WORD $0x0388                   // movb         %al, (%rbx)
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	LONG $0xff468d48               // leaq         $-1(%rsi), %rax
+	LONG $0x01fe8348               // cmpq         $1, %rsi
+	WORD $0x8948; BYTE $0xc6       // movq         %rax, %rsi
+	LONG $0xffd98f0f; WORD $0xffff // jg           LBB8_110, $-39(%rip)
+	LONG $0x000081e9; BYTE $0x00   // jmp          LBB8_120, $129(%rip)
+
+LBB8_112:
+	LONG $0xc0bc0f66             // bsfw         %ax, %ax
+	WORD $0xb70f; BYTE $0xc0     // movzwl       %ax, %eax
+	LONG $0x000006e9; BYTE $0x00 // jmp          LBB8_115, $6(%rip)
+
+LBB8_113:
+	WORD $0xb60f; BYTE $0xc0 // movzbl       %al, %eax
+
+LBB8_114:
+	WORD $0xbc0f; BYTE $0xc0 // bsfl         %eax, %eax
+
+LBB8_115:
+	WORD $0x0148; BYTE $0xc7 // addq         %rax, %rdi
+	WORD $0x2948; BYTE $0xc6 // subq         %rax, %rsi
+	WORD $0x0148; BYTE $0xc3 // addq         %rax, %rbx
+
+LBB8_116:
+	WORD $0xb60f; BYTE $0x07       // movzbl       (%rdi), %eax
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB8_117:
+	WORD $0x8948; BYTE $0xd9       // movq         %rbx, %rcx
+	WORD $0xb60f; BYTE $0xc0       // movzbl       %al, %eax
+	LONG $0x04e0c148               // shlq         $4, %rax
+	LONG $0x001c6349               // movslq       (%r8,%rax), %rbx
+	LONG $0x00448b49; BYTE $0x08   // movq         $8(%r8,%rax), %rax
+	WORD $0x8948; BYTE $0x01       // movq         %rax, (%rcx)
+	WORD $0x0148; BYTE $0xcb       // addq         %rcx, %rbx
+	LONG $0x02fe8348               // cmpq         $2, %rsi
+	LONG $0x003a8c0f; WORD $0x0000 // jl           LBB8_120, $58(%rip)
+	WORD $0xff48; BYTE $0xce       // decq         %rsi
+	LONG $0x0147b60f               // movzbl       $1(%rdi), %eax
+	WORD $0xff48; BYTE $0xc7       // incq         %rdi
+	LONG $0x083c8042; BYTE $0x00   // cmpb         $0, (%rax,%r9)
+	LONG $0xffc8850f; WORD $0xffff // jne          LBB8_117, $-56(%rip)
+	LONG $0xfffd6be9; BYTE $0xff   // jmp          LBB8_94, $-661(%rip)
+
+LBB8_119:
+	WORD $0xb60f; BYTE $0xc0     // movzbl       %al, %eax
+	WORD $0xbc0f; BYTE $0xc0     // bsfl         %eax, %eax
+	LONG $0x04488d48             // leaq         $4(%rax), %rcx
+	WORD $0x0148; BYTE $0xc7     // addq         %rax, %rdi
+	LONG $0x04c78348             // addq         $4, %rdi
+	WORD $0x2948; BYTE $0xce     // subq         %rcx, %rsi
+	WORD $0x0148; BYTE $0xc3     // addq         %rax, %rbx
+	LONG $0x04c38348             // addq         $4, %rbx
+	LONG $0xffff9ae9; BYTE $0xff // jmp          LBB8_116, $-102(%rip)
+
+LBB8_120:
+	WORD $0x2948; BYTE $0xd3     // subq         %rdx, %rbx
+	WORD $0x8949; BYTE $0x1f     // movq         %rbx, (%r15)
+	LONG $0x00002be9; BYTE $0x00 // jmp          LBB8_124, $43(%rip)
+
+LBB8_121:
+	WORD $0x014d; BYTE $0xeb // addq         %r13, %r11
+	LONG $0xc0558b48         // movq         $-64(%rbp), %rdx
+
+LBB8_122:
+	WORD $0x2949; BYTE $0xd1     // subq         %rdx, %r9
+	WORD $0x894d; BYTE $0x0f     // movq         %r9, (%r15)
+	WORD $0x2949; BYTE $0xfb     // subq         %rdi, %r11
+	WORD $0x894d; BYTE $0xde     // movq         %r11, %r14
+	LONG $0x000013e9; BYTE $0x00 // jmp          LBB8_124, $19(%rip)
+
+LBB8_123:
+	LONG $0xc04d2b4c         // subq         $-64(%rbp), %r9
+	WORD $0x894d; BYTE $0x0f // movq         %r9, (%r15)
+	WORD $0x294c; BYTE $0xdf // subq         %r11, %rdi
+	WORD $0xf749; BYTE $0xd5 // notq         %r13
+	WORD $0x0149; BYTE $0xfd // addq         %rdi, %r13
+	WORD $0x894d; BYTE $0xee // movq         %r13, %r14
+
+LBB8_124:
+	WORD $0x894c; BYTE $0xf0 // movq         %r14, %rax
+	LONG $0x18c48348         // addq         $24, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	BYTE $0xc3               // retq
+
+LBB8_125:
+	LONG $0xc0458b48                                                                           // movq         $-64(%rbp), %rax
+	WORD $0x014c; BYTE $0xe8                                                                   // addq         %r13, %rax
+	WORD $0xf748; BYTE $0xd0                                                                   // notq         %rax
+	WORD $0x014c; BYTE $0xc8                                                                   // addq         %r9, %rax
+	WORD $0x8949; BYTE $0x07                                                                   // movq         %rax, (%r15)
+	WORD $0x294c; BYTE $0xdf                                                                   // subq         %r11, %rdi
+	WORD $0x014c; BYTE $0xef                                                                   // addq         %r13, %rdi
+	WORD $0x8949; BYTE $0xfe                                                                   // movq         %rdi, %r14
+	LONG $0xffffcde9; BYTE $0xff                                                               // jmp          LBB8_124, $-51(%rip)
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000; QUAD $0x0000000000000000; WORD $0x0000 // .p2align 5, 0x00
+
+LCPI9_0:
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+
+	// .p2align 4, 0x00
+LCPI9_1:
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+
+LCPI9_2:
+	BYTE $0xf0 // .byte 240
+	BYTE $0x80 // .byte 128
+	BYTE $0x80 // .byte 128
+	BYTE $0x80 // .byte 128
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+
+	// .p2align 4, 0x90
+_unquote:
+	BYTE $0x55                                                           // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                                             // movq         %rsp, %rbp
+	WORD $0x5741                                                         // pushq        %r15
+	WORD $0x5641                                                         // pushq        %r14
+	WORD $0x5541                                                         // pushq        %r13
+	WORD $0x5441                                                         // pushq        %r12
+	BYTE $0x53                                                           // pushq        %rbx
+	LONG $0x48ec8348                                                     // subq         $72, %rsp
+	WORD $0x8548; BYTE $0xf6                                             // testq        %rsi, %rsi
+	LONG $0x070f840f; WORD $0x0000                                       // je           LBB9_1, $1807(%rip)
+	LONG $0xd04d8948                                                     // movq         %rcx, $-48(%rbp)
+	WORD $0x894c; BYTE $0xc0                                             // movq         %r8, %rax
+	LONG $0xa045894c                                                     // movq         %r8, $-96(%rbp)
+	WORD $0x894d; BYTE $0xc2                                             // movq         %r8, %r10
+	LONG $0x01e28341                                                     // andl         $1, %r10d
+	LONG $0x1d058d4c; WORD $0x00f5; BYTE $0x00                           // leaq         $62749(%rip), %r8  /* __UnquoteTab(%rip) */
+	QUAD $0xffffff850d6ffdc5                                             // vmovdqa      $-123(%rip), %ymm1  /* LCPI9_0(%rip) */
+	QUAD $0xffffff9d156ff9c5                                             // vmovdqa      $-99(%rip), %xmm2  /* LCPI9_1(%rip) */
+	WORD $0x8949; BYTE $0xff                                             // movq         %rdi, %r15
+	WORD $0x8949; BYTE $0xf5                                             // movq         %rsi, %r13
+	WORD $0x8949; BYTE $0xd6                                             // movq         %rdx, %r14
+	LONG $0x00021fe9; BYTE $0x00                                         // jmp          LBB9_3, $543(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB9_59:
+	LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl         $2047, %r12d
+	LONG $0x0573860f; WORD $0x0000             // jbe          LBB9_67, $1395(%rip)
+	QUAD $0xffff200024848d41                   // leal         $-57344(%r12), %eax
+	LONG $0xfff7ff3d; BYTE $0xff               // cmpl         $-2049, %eax
+	LONG $0x0520860f; WORD $0x0000             // jbe          LBB9_70, $1312(%rip)
+	WORD $0x854d; BYTE $0xd2                   // testq        %r10, %r10
+	LONG $0xc07d8948                           // movq         %rdi, $-64(%rbp)
+	LONG $0xb8758948                           // movq         %rsi, $-72(%rbp)
+	LONG $0x00dc850f; WORD $0x0000             // jne          LBB9_62, $220(%rip)
+	LONG $0xb055894c                           // movq         %r10, $-80(%rbp)
+	LONG $0xa8558948                           // movq         %rdx, $-88(%rbp)
+	LONG $0x06fd8349                           // cmpq         $6, %r13
+	LONG $0x00f58c0f; WORD $0x0000             // jl           LBB9_94, $245(%rip)
+
+LBB9_91:
+	LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl         $56319, %r12d
+	LONG $0x00e8870f; WORD $0x0000             // ja           LBB9_94, $232(%rip)
+	LONG $0x5c3f8041                           // cmpb         $92, (%r15)
+	LONG $0x00de850f; WORD $0x0000             // jne          LBB9_94, $222(%rip)
+	LONG $0x017f8041; BYTE $0x75               // cmpb         $117, $1(%r15)
+	LONG $0x00d3850f; WORD $0x0000             // jne          LBB9_94, $211(%rip)
+	LONG $0x025f8b41                           // movl         $2(%r15), %ebx
+	WORD $0xdf89                               // movl         %ebx, %edi
+	WORD $0xf8c5; BYTE $0x77                   // vzeroupper
+	LONG $0x0008ade8; BYTE $0x00               // callq        _unhex16_is, $2221(%rip)
+	WORD $0xc084                               // testb        %al, %al
+	LONG $0x0798840f; WORD $0x0000             // je           LBB9_100, $1944(%rip)
+	WORD $0xcb0f                               // bswapl       %ebx
+	WORD $0xd889                               // movl         %ebx, %eax
+	WORD $0xd0f7                               // notl         %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	LONG $0x01010125; BYTE $0x01               // andl         $16843009, %eax
+	WORD $0x048d; BYTE $0xc0                   // leal         (%rax,%rax,8), %eax
+	LONG $0x0f0fe381; WORD $0x0f0f             // andl         $252645135, %ebx
+	WORD $0xc301                               // addl         %eax, %ebx
+	WORD $0xd889                               // movl         %ebx, %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	WORD $0xd809                               // orl          %ebx, %eax
+	WORD $0xb60f; BYTE $0xc8                   // movzbl       %al, %ecx
+	WORD $0xe8c1; BYTE $0x08                   // shrl         $8, %eax
+	LONG $0x00ff0025; BYTE $0x00               // andl         $65280, %eax
+	WORD $0x1c8d; BYTE $0x08                   // leal         (%rax,%rcx), %ebx
+	LONG $0x06c78349                           // addq         $6, %r15
+	LONG $0xfac58349                           // addq         $-6, %r13
+	WORD $0xc801                               // addl         %ecx, %eax
+	LONG $0xff200005; BYTE $0xff               // addl         $-57344, %eax
+	LONG $0xfffbff3d; BYTE $0xff               // cmpl         $-1025, %eax
+	LONG $0xc07d8b48                           // movq         $-64(%rbp), %rdi
+	LONG $0xa8558b48                           // movq         $-88(%rbp), %rdx
+	LONG $0xb8758b48                           // movq         $-72(%rbp), %rsi
+	LONG $0x20058d4c; WORD $0x00f4; BYTE $0x00 // leaq         $62496(%rip), %r8  /* __UnquoteTab(%rip) */
+	QUAD $0xfffffe880d6ffdc5                   // vmovdqa      $-376(%rip), %ymm1  /* LCPI9_0(%rip) */
+	QUAD $0xfffffea0156ff9c5                   // vmovdqa      $-352(%rip), %xmm2  /* LCPI9_1(%rip) */
+	LONG $0x0070870f; WORD $0x0000             // ja           LBB9_110, $112(%rip)
+	LONG $0x06c74166; WORD $0xbfef             // movw         $-16401, (%r14)
+	LONG $0x0246c641; BYTE $0xbd               // movb         $-67, $2(%r14)
+	LONG $0x03c68349                           // addq         $3, %r14
+	WORD $0x8941; BYTE $0xdc                   // movl         %ebx, %r12d
+	LONG $0x0080fb81; WORD $0x0000             // cmpl         $128, %ebx
+	LONG $0xb0558b4c                           // movq         $-80(%rbp), %r10
+	LONG $0xfef8830f; WORD $0xffff             // jae          LBB9_59, $-264(%rip)
+	LONG $0x0003f8e9; BYTE $0x00               // jmp          LBB9_112, $1016(%rip)
+
+LBB9_62:
+	WORD $0x854d; BYTE $0xed       // testq        %r13, %r13
+	LONG $0x06d88e0f; WORD $0x0000 // jle          LBB9_63, $1752(%rip)
+	LONG $0x5c3f8041               // cmpb         $92, (%r15)
+	LONG $0x00c5850f; WORD $0x0000 // jne          LBB9_96, $197(%rip)
+	WORD $0xff49; BYTE $0xcd       // decq         %r13
+	WORD $0xff49; BYTE $0xc7       // incq         %r15
+	LONG $0xb055894c               // movq         %r10, $-80(%rbp)
+	LONG $0xa8558948               // movq         %rdx, $-88(%rbp)
+	LONG $0x06fd8349               // cmpq         $6, %r13
+	LONG $0xff0b8d0f; WORD $0xffff // jge          LBB9_91, $-245(%rip)
+
+LBB9_94:
+	LONG $0x02a045f6               // testb        $2, $-96(%rbp)
+	LONG $0x0565840f; WORD $0x0000 // je           LBB9_77, $1381(%rip)
+	LONG $0x06c74166; WORD $0xbfef // movw         $-16401, (%r14)
+	LONG $0x0246c641; BYTE $0xbd   // movb         $-67, $2(%r14)
+	LONG $0x03c68349               // addq         $3, %r14
+	LONG $0x00005ae9; BYTE $0x00   // jmp          LBB9_86, $90(%rip)
+
+LBB9_110:
+	WORD $0xd889 // movl         %ebx, %eax
+
+LBB9_85:
+	LONG $0x0ae4c141               // shll         $10, %r12d
+	WORD $0xc189                   // movl         %eax, %ecx
+	WORD $0x0144; BYTE $0xe1       // addl         %r12d, %ecx
+	WORD $0x0144; BYTE $0xe0       // addl         %r12d, %eax
+	LONG $0xa0240005; BYTE $0xfc   // addl         $-56613888, %eax
+	WORD $0xc289                   // movl         %eax, %edx
+	WORD $0xeac1; BYTE $0x12       // shrl         $18, %edx
+	WORD $0xc689                   // movl         %eax, %esi
+	WORD $0xeec1; BYTE $0x0c       // shrl         $12, %esi
+	LONG $0x3fe68040               // andb         $63, %sil
+	WORD $0xe8c1; BYTE $0x06       // shrl         $6, %eax
+	LONG $0xc26ef9c5               // vmovd        %edx, %xmm0
+	LONG $0xd6b60f40               // movzbl       %sil, %edx
+	LONG $0x2079e3c4; WORD $0x01c2 // vpinsrb      $1, %edx, %xmm0, %xmm0
+	WORD $0x3f24                   // andb         $63, %al
+	WORD $0xb60f; BYTE $0xc0       // movzbl       %al, %eax
+	LONG $0x2079e3c4; WORD $0x02c0 // vpinsrb      $2, %eax, %xmm0, %xmm0
+	WORD $0xe180; BYTE $0x3f       // andb         $63, %cl
+	WORD $0xb60f; BYTE $0xc1       // movzbl       %cl, %eax
+	LONG $0x2079e3c4; WORD $0x03c0 // vpinsrb      $3, %eax, %xmm0, %xmm0
+	QUAD $0xfffffde905ebf9c5       // vpor         $-535(%rip), %xmm0, %xmm0  /* LCPI9_2(%rip) */
+	LONG $0x7e79c1c4; BYTE $0x06   // vmovd        %xmm0, (%r14)
+	LONG $0x04c68349               // addq         $4, %r14
+
+LBB9_86:
+	LONG $0xc07d8b48                           // movq         $-64(%rbp), %rdi
+	LONG $0xa8558b48                           // movq         $-88(%rbp), %rdx
+	LONG $0xb0558b4c                           // movq         $-80(%rbp), %r10
+	LONG $0xb8758b48                           // movq         $-72(%rbp), %rsi
+	LONG $0x29058d4c; WORD $0x00f3; BYTE $0x00 // leaq         $62249(%rip), %r8  /* __UnquoteTab(%rip) */
+	QUAD $0xfffffd910d6ffdc5                   // vmovdqa      $-623(%rip), %ymm1  /* LCPI9_0(%rip) */
+	QUAD $0xfffffda9156ff9c5                   // vmovdqa      $-599(%rip), %xmm2  /* LCPI9_1(%rip) */
+	WORD $0x854d; BYTE $0xed                   // testq        %r13, %r13
+	LONG $0x0030850f; WORD $0x0000             // jne          LBB9_3, $48(%rip)
+	LONG $0x000622e9; BYTE $0x00               // jmp          LBB9_115, $1570(%rip)
+
+LBB9_96:
+	LONG $0x02a045f6               // testb        $2, $-96(%rbp)
+	LONG $0x0705840f; WORD $0x0000 // je           LBB9_97, $1797(%rip)
+	LONG $0x06c74166; WORD $0xbfef // movw         $-16401, (%r14)
+	LONG $0x0246c641; BYTE $0xbd   // movb         $-67, $2(%r14)
+	LONG $0x03c68349               // addq         $3, %r14
+	LONG $0xc07d8b48               // movq         $-64(%rbp), %rdi
+	LONG $0xb8758b48               // movq         $-72(%rbp), %rsi
+	WORD $0x854d; BYTE $0xed       // testq        %r13, %r13
+	LONG $0x05f8840f; WORD $0x0000 // je           LBB9_115, $1528(%rip)
+	BYTE $0x90                     // .p2align 4, 0x90
+
+LBB9_3:
+	LONG $0x5c3f8041                                         // cmpb         $92, (%r15)
+	LONG $0x0016850f; WORD $0x0000                           // jne          LBB9_5, $22(%rip)
+	WORD $0x3145; BYTE $0xc9                                 // xorl         %r9d, %r9d
+	LONG $0x00015ee9; BYTE $0x00                             // jmp          LBB9_23, $350(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB9_5:
+	WORD $0x894c; BYTE $0xeb       // movq         %r13, %rbx
+	WORD $0x894c; BYTE $0xf1       // movq         %r14, %rcx
+	WORD $0x894d; BYTE $0xf9       // movq         %r15, %r9
+	LONG $0x20fd8349               // cmpq         $32, %r13
+	LONG $0x00458c0f; WORD $0x0000 // jl           LBB9_11, $69(%rip)
+	WORD $0xc931                   // xorl         %ecx, %ecx
+	WORD $0x894c; BYTE $0xe8       // movq         %r13, %rax
+	QUAD $0x9090909090909090       // .p2align 4, 0x90
+
+LBB9_7:
+	LONG $0x6f7ec1c4; WORD $0x0f04 // vmovdqu      (%r15,%rcx), %ymm0
+	LONG $0x7f7ec1c4; WORD $0x0e04 // vmovdqu      %ymm0, (%r14,%rcx)
+	LONG $0xc174fdc5               // vpcmpeqb     %ymm1, %ymm0, %ymm0
+	LONG $0xd8d7fdc5               // vpmovmskb    %ymm0, %ebx
+	WORD $0xdb85                   // testl        %ebx, %ebx
+	LONG $0x00db850f; WORD $0x0000 // jne          LBB9_8, $219(%rip)
+	LONG $0xe0588d48               // leaq         $-32(%rax), %rbx
+	LONG $0x20c18348               // addq         $32, %rcx
+	LONG $0x3ff88348               // cmpq         $63, %rax
+	WORD $0x8948; BYTE $0xd8       // movq         %rbx, %rax
+	LONG $0xffcf8f0f; WORD $0xffff // jg           LBB9_7, $-49(%rip)
+	LONG $0x0f0c8d4d               // leaq         (%r15,%rcx), %r9
+	WORD $0x014c; BYTE $0xf1       // addq         %r14, %rcx
+
+LBB9_11:
+	WORD $0xf8c5; BYTE $0x77       // vzeroupper
+	LONG $0x10fb8348               // cmpq         $16, %rbx
+	LONG $0x00568c0f; WORD $0x0000 // jl           LBB9_12, $86(%rip)
+	WORD $0x894d; BYTE $0xfb       // movq         %r15, %r11
+	WORD $0x294d; BYTE $0xcb       // subq         %r9, %r11
+	QUAD $0xfffffcbd0d6ffdc5       // vmovdqa      $-835(%rip), %ymm1  /* LCPI9_0(%rip) */
+	QUAD $0xfffffcd5156ff9c5       // vmovdqa      $-811(%rip), %xmm2  /* LCPI9_1(%rip) */
+	LONG $0x90909090; BYTE $0x90   // .p2align 4, 0x90
+
+LBB9_18:
+	LONG $0x6f7ac1c4; BYTE $0x01   // vmovdqu      (%r9), %xmm0
+	LONG $0x017ffac5               // vmovdqu      %xmm0, (%rcx)
+	LONG $0xc274f9c5               // vpcmpeqb     %xmm2, %xmm0, %xmm0
+	LONG $0xc0d7f9c5               // vpmovmskb    %xmm0, %eax
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x0094850f; WORD $0x0000 // jne          LBB9_19, $148(%rip)
+	LONG $0x10c18349               // addq         $16, %r9
+	LONG $0x10c18348               // addq         $16, %rcx
+	LONG $0xf0638d4c               // leaq         $-16(%rbx), %r12
+	LONG $0xf0c38349               // addq         $-16, %r11
+	LONG $0x1ffb8348               // cmpq         $31, %rbx
+	WORD $0x894c; BYTE $0xe3       // movq         %r12, %rbx
+	LONG $0xffca870f; WORD $0xffff // ja           LBB9_18, $-54(%rip)
+	LONG $0x000013e9; BYTE $0x00   // jmp          LBB9_13, $19(%rip)
+
+LBB9_12:
+	WORD $0x8949; BYTE $0xdc // movq         %rbx, %r12
+	QUAD $0xfffffc6a0d6ffdc5 // vmovdqa      $-918(%rip), %ymm1  /* LCPI9_0(%rip) */
+	QUAD $0xfffffc82156ff9c5 // vmovdqa      $-894(%rip), %xmm2  /* LCPI9_1(%rip) */
+
+LBB9_13:
+	WORD $0x854d; BYTE $0xe4                   // testq        %r12, %r12
+	LONG $0x03c8840f; WORD $0x0000             // je           LBB9_116, $968(%rip)
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB9_15:
+	LONG $0x1cb60f41; BYTE $0x01   // movzbl       (%r9,%rax), %ebx
+	WORD $0xfb80; BYTE $0x5c       // cmpb         $92, %bl
+	LONG $0x0014840f; WORD $0x0000 // je           LBB9_21, $20(%rip)
+	WORD $0x1c88; BYTE $0x01       // movb         %bl, (%rcx,%rax)
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3949; BYTE $0xc4       // cmpq         %rax, %r12
+	LONG $0xffe3850f; WORD $0xffff // jne          LBB9_15, $-29(%rip)
+	LONG $0x00039de9; BYTE $0x00   // jmp          LBB9_116, $925(%rip)
+
+LBB9_21:
+	WORD $0x294d; BYTE $0xf9       // subq         %r15, %r9
+	WORD $0x0149; BYTE $0xc1       // addq         %rax, %r9
+	LONG $0xfff98349               // cmpq         $-1, %r9
+	LONG $0x003e850f; WORD $0x0000 // jne          LBB9_23, $62(%rip)
+	LONG $0x000388e9; BYTE $0x00   // jmp          LBB9_116, $904(%rip)
+
+LBB9_8:
+	LONG $0xcbbc0f44               // bsfl         %ebx, %r9d
+	WORD $0x0149; BYTE $0xc9       // addq         %rcx, %r9
+	LONG $0xfff98349               // cmpq         $-1, %r9
+	LONG $0x0028850f; WORD $0x0000 // jne          LBB9_23, $40(%rip)
+	LONG $0x000372e9; BYTE $0x00   // jmp          LBB9_116, $882(%rip)
+
+LBB9_19:
+	LONG $0xc0bc0f66                                         // bsfw         %ax, %ax
+	LONG $0xc8b70f44                                         // movzwl       %ax, %r9d
+	WORD $0x294d; BYTE $0xd9                                 // subq         %r11, %r9
+	LONG $0xfff98349                                         // cmpq         $-1, %r9
+	LONG $0x035d840f; WORD $0x0000                           // je           LBB9_116, $861(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB9_23:
+	LONG $0x02498d49               // leaq         $2(%r9), %rcx
+	WORD $0x2949; BYTE $0xcd       // subq         %rcx, %r13
+	LONG $0x0411880f; WORD $0x0000 // js           LBB9_24, $1041(%rip)
+	WORD $0x014d; BYTE $0xcf       // addq         %r9, %r15
+	LONG $0x02c78349               // addq         $2, %r15
+	WORD $0x854d; BYTE $0xd2       // testq        %r10, %r10
+	LONG $0x0112850f; WORD $0x0000 // jne          LBB9_26, $274(%rip)
+
+LBB9_37:
+	WORD $0x014d; BYTE $0xce       // addq         %r9, %r14
+	LONG $0x47b60f41; BYTE $0xff   // movzbl       $-1(%r15), %eax
+	LONG $0x04b60f42; BYTE $0x00   // movzbl       (%rax,%r8), %eax
+	LONG $0x0000ff3d; BYTE $0x00   // cmpl         $255, %eax
+	LONG $0x002b840f; WORD $0x0000 // je           LBB9_41, $43(%rip)
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x03f4840f; WORD $0x0000 // je           LBB9_39, $1012(%rip)
+	WORD $0x8841; BYTE $0x06       // movb         %al, (%r14)
+
+LBB9_113:
+	WORD $0xff49; BYTE $0xc6                                             // incq         %r14
+	WORD $0x854d; BYTE $0xed                                             // testq        %r13, %r13
+	LONG $0xfe44850f; WORD $0xffff                                       // jne          LBB9_3, $-444(%rip)
+	LONG $0x000436e9; BYTE $0x00                                         // jmp          LBB9_115, $1078(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB9_41:
+	LONG $0x03fd8349                           // cmpq         $3, %r13
+	LONG $0x03b4860f; WORD $0x0000             // jbe          LBB9_24, $948(%rip)
+	WORD $0x8b41; BYTE $0x1f                   // movl         (%r15), %ebx
+	WORD $0xd989                               // movl         %ebx, %ecx
+	WORD $0xd1f7                               // notl         %ecx
+	LONG $0xcfd0838d; WORD $0xcfcf             // leal         $-808464432(%rbx), %eax
+	LONG $0x8080e181; WORD $0x8080             // andl         $-2139062144, %ecx
+	WORD $0xc185                               // testl        %eax, %ecx
+	LONG $0x02e5850f; WORD $0x0000             // jne          LBB9_46, $741(%rip)
+	LONG $0x1919838d; WORD $0x1919             // leal         $421075225(%rbx), %eax
+	WORD $0xd809                               // orl          %ebx, %eax
+	LONG $0x808080a9; BYTE $0x80               // testl        $-2139062144, %eax
+	LONG $0x02d2850f; WORD $0x0000             // jne          LBB9_46, $722(%rip)
+	WORD $0xd889                               // movl         %ebx, %eax
+	LONG $0x7f7f7f25; BYTE $0x7f               // andl         $2139062143, %eax
+	LONG $0xc0c0bb41; WORD $0xc0c0             // movl         $-1061109568, %r11d
+	WORD $0x2941; BYTE $0xc3                   // subl         %eax, %r11d
+	LONG $0x46888d44; WORD $0x4646; BYTE $0x46 // leal         $1179010630(%rax), %r9d
+	WORD $0x2141; BYTE $0xcb                   // andl         %ecx, %r11d
+	WORD $0x8545; BYTE $0xcb                   // testl        %r9d, %r11d
+	LONG $0x02af850f; WORD $0x0000             // jne          LBB9_46, $687(%rip)
+	LONG $0xe0e0b941; WORD $0xe0e0             // movl         $-522133280, %r9d
+	WORD $0x2941; BYTE $0xc1                   // subl         %eax, %r9d
+	LONG $0x39393905; BYTE $0x39               // addl         $960051513, %eax
+	WORD $0x2144; BYTE $0xc9                   // andl         %r9d, %ecx
+	WORD $0xc185                               // testl        %eax, %ecx
+	LONG $0x0296850f; WORD $0x0000             // jne          LBB9_46, $662(%rip)
+	WORD $0xcb0f                               // bswapl       %ebx
+	WORD $0xd989                               // movl         %ebx, %ecx
+	WORD $0xd1f7                               // notl         %ecx
+	WORD $0xe9c1; BYTE $0x04                   // shrl         $4, %ecx
+	LONG $0x0101e181; WORD $0x0101             // andl         $16843009, %ecx
+	WORD $0x0c8d; BYTE $0xc9                   // leal         (%rcx,%rcx,8), %ecx
+	LONG $0x0f0fe381; WORD $0x0f0f             // andl         $252645135, %ebx
+	WORD $0xcb01                               // addl         %ecx, %ebx
+	WORD $0xd989                               // movl         %ebx, %ecx
+	WORD $0xe9c1; BYTE $0x04                   // shrl         $4, %ecx
+	WORD $0xd909                               // orl          %ebx, %ecx
+	WORD $0xb60f; BYTE $0xd9                   // movzbl       %cl, %ebx
+	WORD $0xe9c1; BYTE $0x08                   // shrl         $8, %ecx
+	LONG $0xff00e181; WORD $0x0000             // andl         $65280, %ecx
+	WORD $0xcb09                               // orl          %ecx, %ebx
+	LONG $0x044f8d4d                           // leaq         $4(%r15), %r9
+	LONG $0xfc4d8d49                           // leaq         $-4(%r13), %rcx
+	LONG $0x0080fb81; WORD $0x0000             // cmpl         $128, %ebx
+	LONG $0x0068820f; WORD $0x0000             // jb           LBB9_56, $104(%rip)
+	LONG $0x02a045f6                           // testb        $2, $-96(%rbp)
+	LONG $0x006c840f; WORD $0x0000             // je           LBB9_65, $108(%rip)
+	WORD $0x894d; BYTE $0xcf                   // movq         %r9, %r15
+	WORD $0x8941; BYTE $0xdc                   // movl         %ebx, %r12d
+	WORD $0x8949; BYTE $0xcd                   // movq         %rcx, %r13
+	LONG $0xfffb51e9; BYTE $0xff               // jmp          LBB9_59, $-1199(%rip)
+
+LBB9_26:
+	WORD $0x8545; BYTE $0xed       // testl        %r13d, %r13d
+	LONG $0x02e6840f; WORD $0x0000 // je           LBB9_24, $742(%rip)
+	LONG $0xff7f8041; BYTE $0x5c   // cmpb         $92, $-1(%r15)
+	LONG $0x0307850f; WORD $0x0000 // jne          LBB9_28, $775(%rip)
+	LONG $0x5c3f8041               // cmpb         $92, (%r15)
+	LONG $0x0027850f; WORD $0x0000 // jne          LBB9_36, $39(%rip)
+	LONG $0x01fd8341               // cmpl         $1, %r13d
+	LONG $0x02c78e0f; WORD $0x0000 // jle          LBB9_24, $711(%rip)
+	LONG $0x4fb60f41; BYTE $0x01   // movzbl       $1(%r15), %ecx
+	WORD $0xf983; BYTE $0x22       // cmpl         $34, %ecx
+	LONG $0x0009840f; WORD $0x0000 // je           LBB9_35, $9(%rip)
+	WORD $0xf983; BYTE $0x5c       // cmpl         $92, %ecx
+	LONG $0x02f5850f; WORD $0x0000 // jne          LBB9_34, $757(%rip)
+
+LBB9_35:
+	WORD $0xff49; BYTE $0xc7 // incq         %r15
+	WORD $0xff49; BYTE $0xcd // decq         %r13
+
+LBB9_36:
+	WORD $0xff49; BYTE $0xc7     // incq         %r15
+	WORD $0xff49; BYTE $0xcd     // decq         %r13
+	LONG $0xfffe9ee9; BYTE $0xff // jmp          LBB9_37, $-354(%rip)
+
+LBB9_56:
+	WORD $0x8949; BYTE $0xcd // movq         %rcx, %r13
+	WORD $0x894d; BYTE $0xcf // movq         %r9, %r15
+
+LBB9_112:
+	WORD $0x8841; BYTE $0x1e     // movb         %bl, (%r14)
+	LONG $0xfffeb3e9; BYTE $0xff // jmp          LBB9_113, $-333(%rip)
+
+LBB9_65:
+	LONG $0x0800fb81; WORD $0x0000                         // cmpl         $2048, %ebx
+	LONG $0x005e820f; WORD $0x0000                         // jb           LBB9_66, $94(%rip)
+	LONG $0x2000838d; WORD $0xffff                         // leal         $-57344(%rbx), %eax
+	LONG $0xfff8003d; BYTE $0xff                           // cmpl         $-2048, %eax
+	LONG $0x007f830f; WORD $0x0000                         // jae          LBB9_71, $127(%rip)
+	WORD $0x8949; BYTE $0xcd                               // movq         %rcx, %r13
+	WORD $0x8941; BYTE $0xdc                               // movl         %ebx, %r12d
+	WORD $0x894d; BYTE $0xcf                               // movq         %r9, %r15
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB9_70:
+	WORD $0x8944; BYTE $0xe0       // movl         %r12d, %eax
+	WORD $0xe8c1; BYTE $0x0c       // shrl         $12, %eax
+	WORD $0xe00c                   // orb          $-32, %al
+	WORD $0x8841; BYTE $0x06       // movb         %al, (%r14)
+	WORD $0x8944; BYTE $0xe0       // movl         %r12d, %eax
+	WORD $0xe8c1; BYTE $0x06       // shrl         $6, %eax
+	WORD $0x3f24                   // andb         $63, %al
+	WORD $0x800c                   // orb          $-128, %al
+	LONG $0x01468841               // movb         %al, $1(%r14)
+	LONG $0x3fe48041               // andb         $63, %r12b
+	LONG $0x80cc8041               // orb          $-128, %r12b
+	LONG $0x02668845               // movb         %r12b, $2(%r14)
+	LONG $0x03c68349               // addq         $3, %r14
+	WORD $0x854d; BYTE $0xed       // testq        %r13, %r13
+	LONG $0xfc9e850f; WORD $0xffff // jne          LBB9_3, $-866(%rip)
+	LONG $0x000290e9; BYTE $0x00   // jmp          LBB9_115, $656(%rip)
+
+LBB9_66:
+	WORD $0x8949; BYTE $0xcd // movq         %rcx, %r13
+	WORD $0x8941; BYTE $0xdc // movl         %ebx, %r12d
+	WORD $0x894d; BYTE $0xcf // movq         %r9, %r15
+
+LBB9_67:
+	WORD $0x8944; BYTE $0xe0       // movl         %r12d, %eax
+	WORD $0xe8c1; BYTE $0x06       // shrl         $6, %eax
+	WORD $0xc00c                   // orb          $-64, %al
+	WORD $0x8841; BYTE $0x06       // movb         %al, (%r14)
+	LONG $0x3fe48041               // andb         $63, %r12b
+	LONG $0x80cc8041               // orb          $-128, %r12b
+	LONG $0x01668845               // movb         %r12b, $1(%r14)
+	LONG $0x02c68349               // addq         $2, %r14
+	WORD $0x854d; BYTE $0xed       // testq        %r13, %r13
+	LONG $0xfc6c850f; WORD $0xffff // jne          LBB9_3, $-916(%rip)
+	LONG $0x00025ee9; BYTE $0x00   // jmp          LBB9_115, $606(%rip)
+
+LBB9_71:
+	WORD $0x8949; BYTE $0xdc       // movq         %rbx, %r12
+	LONG $0x984d8948               // movq         %rcx, $-104(%rbp)
+	LONG $0xc84d894c               // movq         %r9, $-56(%rbp)
+	LONG $0xb8758948               // movq         %rsi, $-72(%rbp)
+	LONG $0xa8558948               // movq         %rdx, $-88(%rbp)
+	LONG $0xc07d8948               // movq         %rdi, $-64(%rbp)
+	LONG $0xb055894c               // movq         %r10, $-80(%rbp)
+	WORD $0x854d; BYTE $0xd2       // testq        %r10, %r10
+	LONG $0x00a4850f; WORD $0x0000 // jne          LBB9_72, $164(%rip)
+	LONG $0x987d8348; BYTE $0x06   // cmpq         $6, $-104(%rbp)
+	LONG $0x00cb820f; WORD $0x0000 // jb           LBB9_76, $203(%rip)
+
+LBB9_78:
+	LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl         $56319, %r12d
+	LONG $0x00be870f; WORD $0x0000             // ja           LBB9_76, $190(%rip)
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	WORD $0x3880; BYTE $0x5c                   // cmpb         $92, (%rax)
+	LONG $0x00b1850f; WORD $0x0000             // jne          LBB9_76, $177(%rip)
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	LONG $0x75017880                           // cmpb         $117, $1(%rax)
+	LONG $0x00a3850f; WORD $0x0000             // jne          LBB9_76, $163(%rip)
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	WORD $0x588b; BYTE $0x02                   // movl         $2(%rax), %ebx
+	WORD $0xdf89                               // movl         %ebx, %edi
+	WORD $0xf8c5; BYTE $0x77                   // vzeroupper
+	LONG $0x00030fe8; BYTE $0x00               // callq        _unhex16_is, $783(%rip)
+	WORD $0xc084                               // testb        %al, %al
+	LONG $0x01f6840f; WORD $0x0000             // je           LBB9_82, $502(%rip)
+	WORD $0xcb0f                               // bswapl       %ebx
+	WORD $0xd889                               // movl         %ebx, %eax
+	WORD $0xd0f7                               // notl         %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	LONG $0x01010125; BYTE $0x01               // andl         $16843009, %eax
+	WORD $0x048d; BYTE $0xc0                   // leal         (%rax,%rax,8), %eax
+	LONG $0x0f0fe381; WORD $0x0f0f             // andl         $252645135, %ebx
+	WORD $0xc301                               // addl         %eax, %ebx
+	WORD $0xd889                               // movl         %ebx, %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	WORD $0xd809                               // orl          %ebx, %eax
+	WORD $0xb60f; BYTE $0xc8                   // movzbl       %al, %ecx
+	WORD $0xe8c1; BYTE $0x08                   // shrl         $8, %eax
+	LONG $0x00ff0025; BYTE $0x00               // andl         $65280, %eax
+	LONG $0xc8458348; BYTE $0x06               // addq         $6, $-56(%rbp)
+	WORD $0x148d; BYTE $0x08                   // leal         (%rax,%rcx), %edx
+	LONG $0x2000c281; WORD $0xffff             // addl         $-57344, %edx
+	LONG $0xfc00fa81; WORD $0xffff             // cmpl         $-1024, %edx
+	LONG $0x029a820f; WORD $0x0000             // jb           LBB9_98, $666(%rip)
+	WORD $0xc809                               // orl          %ecx, %eax
+	LONG $0x986d8b4c                           // movq         $-104(%rbp), %r13
+	LONG $0xfac58349                           // addq         $-6, %r13
+	LONG $0xc87d8b4c                           // movq         $-56(%rbp), %r15
+	LONG $0xfffae7e9; BYTE $0xff               // jmp          LBB9_85, $-1305(%rip)
+
+LBB9_72:
+	LONG $0x05fd8349               // cmpq         $5, %r13
+	LONG $0x0262820f; WORD $0x0000 // jb           LBB9_87, $610(%rip)
+	LONG $0xc8458b48               // movq         $-56(%rbp), %rax
+	WORD $0x3880; BYTE $0x5c       // cmpb         $92, (%rax)
+	LONG $0x0270850f; WORD $0x0000 // jne          LBB9_98, $624(%rip)
+	LONG $0xfbc58349               // addq         $-5, %r13
+	LONG $0x05c78349               // addq         $5, %r15
+	LONG $0x986d894c               // movq         %r13, $-104(%rbp)
+	LONG $0xc87d894c               // movq         %r15, $-56(%rbp)
+	LONG $0x987d8348; BYTE $0x06   // cmpq         $6, $-104(%rbp)
+	LONG $0xff35830f; WORD $0xffff // jae          LBB9_78, $-203(%rip)
+
+LBB9_76:
+	LONG $0xc87d8b4c // movq         $-56(%rbp), %r15
+
+LBB9_77:
+	LONG $0xb0458b48                           // movq         $-80(%rbp), %rax
+	LONG $0xc0450348                           // addq         $-64(%rbp), %rax
+	WORD $0x2949; BYTE $0xc7                   // subq         %rax, %r15
+	LONG $0xfcc78349                           // addq         $-4, %r15
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	WORD $0x894c; BYTE $0x38                   // movq         %r15, (%rax)
+	LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq         $-4, %r14
+	LONG $0x00000ce9; BYTE $0x00               // jmp          LBB9_117, $12(%rip)
+
+LBB9_1:
+	WORD $0x3145; BYTE $0xed // xorl         %r13d, %r13d
+	WORD $0x8949; BYTE $0xd6 // movq         %rdx, %r14
+
+LBB9_116:
+	WORD $0x014d; BYTE $0xee // addq         %r13, %r14
+	WORD $0x2949; BYTE $0xd6 // subq         %rdx, %r14
+
+LBB9_117:
+	WORD $0x894c; BYTE $0xf0 // movq         %r14, %rax
+	LONG $0x48c48348         // addq         $72, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	BYTE $0xc3               // retq
+
+LBB9_46:
+	WORD $0x894c; BYTE $0xf8                   // movq         %r15, %rax
+	WORD $0x2948; BYTE $0xf8                   // subq         %rdi, %rax
+	LONG $0xd0758b48                           // movq         $-48(%rbp), %rsi
+	WORD $0x8948; BYTE $0x06                   // movq         %rax, (%rsi)
+	LONG $0x0fb60f41                           // movzbl       (%r15), %ecx
+	WORD $0x518d; BYTE $0xc6                   // leal         $-58(%rcx), %edx
+	LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r14
+	WORD $0xfa80; BYTE $0xf5                   // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000             // ja           LBB9_48, $15(%rip)
+	WORD $0xe180; BYTE $0xdf                   // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9                   // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa                   // cmpb         $-6, %cl
+	LONG $0xffb8820f; WORD $0xffff             // jb           LBB9_117, $-72(%rip)
+
+LBB9_48:
+	LONG $0x01488d48               // leaq         $1(%rax), %rcx
+	WORD $0x8948; BYTE $0x0e       // movq         %rcx, (%rsi)
+	LONG $0x4fb60f41; BYTE $0x01   // movzbl       $1(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_50, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xff91820f; WORD $0xffff // jb           LBB9_117, $-111(%rip)
+
+LBB9_50:
+	LONG $0x02488d48               // leaq         $2(%rax), %rcx
+	WORD $0x8948; BYTE $0x0e       // movq         %rcx, (%rsi)
+	LONG $0x4fb60f41; BYTE $0x02   // movzbl       $2(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_52, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xff6a820f; WORD $0xffff // jb           LBB9_117, $-150(%rip)
+
+LBB9_52:
+	LONG $0x03488d48               // leaq         $3(%rax), %rcx
+	WORD $0x8948; BYTE $0x0e       // movq         %rcx, (%rsi)
+	LONG $0x4fb60f41; BYTE $0x03   // movzbl       $3(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_54, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xff43820f; WORD $0xffff // jb           LBB9_117, $-189(%rip)
+
+LBB9_54:
+	LONG $0x04c08348             // addq         $4, %rax
+	WORD $0x8948; BYTE $0x06     // movq         %rax, (%rsi)
+	LONG $0xffff37e9; BYTE $0xff // jmp          LBB9_117, $-201(%rip)
+
+LBB9_24:
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	WORD $0x8948; BYTE $0x30                   // movq         %rsi, (%rax)
+	LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r14
+	LONG $0xffff24e9; BYTE $0xff               // jmp          LBB9_117, $-220(%rip)
+
+LBB9_39:
+	WORD $0xf748; BYTE $0xd7                   // notq         %rdi
+	WORD $0x0149; BYTE $0xff                   // addq         %rdi, %r15
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	WORD $0x894c; BYTE $0x38                   // movq         %r15, (%rax)
+	LONG $0xfdc6c749; WORD $0xffff; BYTE $0xff // movq         $-3, %r14
+	LONG $0xffff0be9; BYTE $0xff               // jmp          LBB9_117, $-245(%rip)
+
+LBB9_28:
+	WORD $0xf748; BYTE $0xd7 // notq         %rdi
+	WORD $0x0149; BYTE $0xff // addq         %rdi, %r15
+
+LBB9_29:
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	WORD $0x894c; BYTE $0x38                   // movq         %r15, (%rax)
+	LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r14
+	LONG $0xfffef2e9; BYTE $0xff               // jmp          LBB9_117, $-270(%rip)
+
+LBB9_34:
+	WORD $0x2949; BYTE $0xff     // subq         %rdi, %r15
+	WORD $0xff49; BYTE $0xc7     // incq         %r15
+	LONG $0xffffe2e9; BYTE $0xff // jmp          LBB9_29, $-30(%rip)
+
+LBB9_63:
+	LONG $0x02a045f6               // testb        $2, $-96(%rbp)
+	LONG $0x00e5840f; WORD $0x0000 // je           LBB9_87, $229(%rip)
+	LONG $0x06c74166; WORD $0xbfef // movw         $-16401, (%r14)
+	LONG $0x0246c641; BYTE $0xbd   // movb         $-67, $2(%r14)
+	LONG $0x03c68349               // addq         $3, %r14
+
+LBB9_115:
+	WORD $0x3145; BYTE $0xed     // xorl         %r13d, %r13d
+	LONG $0xfffec0e9; BYTE $0xff // jmp          LBB9_116, $-320(%rip)
+
+LBB9_82:
+	LONG $0xc87d8b4c // movq         $-56(%rbp), %r15
+
+LBB9_100:
+	WORD $0x894c; BYTE $0xf8                   // movq         %r15, %rax
+	LONG $0xc0452b48                           // subq         $-64(%rbp), %rax
+	LONG $0x02c08348                           // addq         $2, %rax
+	LONG $0xd04d8b48                           // movq         $-48(%rbp), %rcx
+	WORD $0x8948; BYTE $0x01                   // movq         %rax, (%rcx)
+	LONG $0x4fb60f41; BYTE $0x02               // movzbl       $2(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6                   // leal         $-58(%rcx), %edx
+	LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r14
+	WORD $0xfa80; BYTE $0xf5                   // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000             // ja           LBB9_102, $15(%rip)
+	WORD $0xe180; BYTE $0xdf                   // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9                   // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa                   // cmpb         $-6, %cl
+	LONG $0xfe89820f; WORD $0xffff             // jb           LBB9_117, $-375(%rip)
+
+LBB9_102:
+	LONG $0x01488d48               // leaq         $1(%rax), %rcx
+	LONG $0xd0558b48               // movq         $-48(%rbp), %rdx
+	WORD $0x8948; BYTE $0x0a       // movq         %rcx, (%rdx)
+	LONG $0x4fb60f41; BYTE $0x03   // movzbl       $3(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_104, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xfe5e820f; WORD $0xffff // jb           LBB9_117, $-418(%rip)
+
+LBB9_104:
+	LONG $0x02488d48               // leaq         $2(%rax), %rcx
+	LONG $0xd0558b48               // movq         $-48(%rbp), %rdx
+	WORD $0x8948; BYTE $0x0a       // movq         %rcx, (%rdx)
+	LONG $0x4fb60f41; BYTE $0x04   // movzbl       $4(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_106, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xfe33820f; WORD $0xffff // jb           LBB9_117, $-461(%rip)
+
+LBB9_106:
+	LONG $0x03488d48               // leaq         $3(%rax), %rcx
+	LONG $0xd0558b48               // movq         $-48(%rbp), %rdx
+	WORD $0x8948; BYTE $0x0a       // movq         %rcx, (%rdx)
+	LONG $0x4fb60f41; BYTE $0x05   // movzbl       $5(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_108, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xfe08820f; WORD $0xffff // jb           LBB9_117, $-504(%rip)
+
+LBB9_108:
+	LONG $0x04c08348             // addq         $4, %rax
+	LONG $0xd04d8b48             // movq         $-48(%rbp), %rcx
+	WORD $0x8948; BYTE $0x01     // movq         %rax, (%rcx)
+	LONG $0xfffdf8e9; BYTE $0xff // jmp          LBB9_117, $-520(%rip)
+
+LBB9_87:
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	LONG $0xb84d8b48                           // movq         $-72(%rbp), %rcx
+	WORD $0x8948; BYTE $0x08                   // movq         %rcx, (%rax)
+	LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r14
+	LONG $0xfffde1e9; BYTE $0xff               // jmp          LBB9_117, $-543(%rip)
+
+LBB9_97:
+	LONG $0xc87d894c // movq         %r15, $-56(%rbp)
+
+LBB9_98:
+	LONG $0xc8658b4c                           // movq         $-56(%rbp), %r12
+	LONG $0xc0652b4c                           // subq         $-64(%rbp), %r12
+	LONG $0xfcc48349                           // addq         $-4, %r12
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	WORD $0x894c; BYTE $0x20                   // movq         %r12, (%rax)
+	LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq         $-4, %r14
+	LONG $0xfffdbee9; BYTE $0xff               // jmp          LBB9_117, $-578(%rip)
+	QUAD $0x9090909090909090; BYTE $0x90       // .p2align 4, 0x90
+
+_unhex16_is:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0xf889                   // movl         %edi, %eax
+	WORD $0xd0f7                   // notl         %eax
+	LONG $0xcfd08f8d; WORD $0xcfcf // leal         $-808464432(%rdi), %ecx
+	LONG $0x80808025; BYTE $0x80   // andl         $-2139062144, %eax
+	WORD $0xc885                   // testl        %ecx, %eax
+	LONG $0x0007840f; WORD $0x0000 // je           LBB10_2, $7(%rip)
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xb60f; BYTE $0xc0       // movzbl       %al, %eax
+	BYTE $0x5d                     // popq         %rbp
+	BYTE $0xc3                     // retq
+
+LBB10_2:
+	LONG $0x19198f8d; WORD $0x1919 // leal         $421075225(%rdi), %ecx
+	WORD $0xf909                   // orl          %edi, %ecx
+	LONG $0x8080c1f7; WORD $0x8080 // testl        $-2139062144, %ecx
+	LONG $0x0007840f; WORD $0x0000 // je           LBB10_4, $7(%rip)
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xb60f; BYTE $0xc0       // movzbl       %al, %eax
+	BYTE $0x5d                     // popq         %rbp
+	BYTE $0xc3                     // retq
+
+LBB10_4:
+	LONG $0x7f7fe781; WORD $0x7f7f // andl         $2139062143, %edi
+	LONG $0xc0c0c0b9; BYTE $0xc0   // movl         $-1061109568, %ecx
+	WORD $0xf929                   // subl         %edi, %ecx
+	LONG $0x4646978d; WORD $0x4646 // leal         $1179010630(%rdi), %edx
+	WORD $0xc121                   // andl         %eax, %ecx
+	WORD $0xd185                   // testl        %edx, %ecx
+	LONG $0x0007840f; WORD $0x0000 // je           LBB10_6, $7(%rip)
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xb60f; BYTE $0xc0       // movzbl       %al, %eax
+	BYTE $0x5d                     // popq         %rbp
+	BYTE $0xc3                     // retq
+
+LBB10_6:
+	LONG $0xe0e0e0b9; BYTE $0xe0   // movl         $-522133280, %ecx
+	WORD $0xf929                   // subl         %edi, %ecx
+	LONG $0x3939c781; WORD $0x3939 // addl         $960051513, %edi
+	WORD $0xc821                   // andl         %ecx, %eax
+	WORD $0xf885                   // testl        %edi, %eax
+	WORD $0x940f; BYTE $0xc0       // sete         %al
+	WORD $0xb60f; BYTE $0xc0       // movzbl       %al, %eax
+	BYTE $0x5d                     // popq         %rbp
+	BYTE $0xc3                     // retq
+	LONG $0x00000000; WORD $0x0000 // .p2align 5, 0x00
+
+LCPI11_0:
+	QUAD $0x2626262626262626; QUAD $0x2626262626262626 // .space 16, '&&&&&&&&&&&&&&&&'
+	QUAD $0x2626262626262626; QUAD $0x2626262626262626 // .space 16, '&&&&&&&&&&&&&&&&'
+
+LCPI11_1:
+	QUAD $0xe2e2e2e2e2e2e2e2; QUAD $0xe2e2e2e2e2e2e2e2 // .space 16, '\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2'
+	QUAD $0xe2e2e2e2e2e2e2e2; QUAD $0xe2e2e2e2e2e2e2e2 // .space 16, '\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2'
+
+LCPI11_2:
+	QUAD $0xfdfdfdfdfdfdfdfd; QUAD $0xfdfdfdfdfdfdfdfd // .space 16, '\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd'
+	QUAD $0xfdfdfdfdfdfdfdfd; QUAD $0xfdfdfdfdfdfdfdfd // .space 16, '\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd'
+
+LCPI11_3:
+	QUAD $0x3c3c3c3c3c3c3c3c; QUAD $0x3c3c3c3c3c3c3c3c // .space 16, '<<<<<<<<<<<<<<<<'
+	QUAD $0x3c3c3c3c3c3c3c3c; QUAD $0x3c3c3c3c3c3c3c3c // .space 16, '<<<<<<<<<<<<<<<<'
+
+	// .p2align 4, 0x00
+LCPI11_4:
+	QUAD $0x2626262626262626; QUAD $0x2626262626262626 // .space 16, '&&&&&&&&&&&&&&&&'
+
+LCPI11_5:
+	QUAD $0xe2e2e2e2e2e2e2e2; QUAD $0xe2e2e2e2e2e2e2e2 // .space 16, '\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2'
+
+LCPI11_6:
+	QUAD $0xfdfdfdfdfdfdfdfd; QUAD $0xfdfdfdfdfdfdfdfd // .space 16, '\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd'
+
+LCPI11_7:
+	QUAD $0x3c3c3c3c3c3c3c3c; QUAD $0x3c3c3c3c3c3c3c3c // .space 16, '<<<<<<<<<<<<<<<<'
+
+	// .p2align 4, 0x90
+_html_escape:
+	BYTE $0x55                                               // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                                 // movq         %rsp, %rbp
+	WORD $0x5741                                             // pushq        %r15
+	WORD $0x5641                                             // pushq        %r14
+	WORD $0x5541                                             // pushq        %r13
+	WORD $0x5441                                             // pushq        %r12
+	BYTE $0x53                                               // pushq        %rbx
+	LONG $0x18ec8348                                         // subq         $24, %rsp
+	LONG $0xc04d8948                                         // movq         %rcx, $-64(%rbp)
+	WORD $0x8949; BYTE $0xd7                                 // movq         %rdx, %r15
+	LONG $0xc8558948                                         // movq         %rdx, $-56(%rbp)
+	LONG $0xd07d8948                                         // movq         %rdi, $-48(%rbp)
+	WORD $0x8948; BYTE $0xf8                                 // movq         %rdi, %rax
+	WORD $0x8548; BYTE $0xf6                                 // testq        %rsi, %rsi
+	LONG $0x07e98e0f; WORD $0x0000                           // jle          LBB11_105, $2025(%rip)
+	LONG $0xc0458b48                                         // movq         $-64(%rbp), %rax
+	WORD $0x8b4c; BYTE $0x08                                 // movq         (%rax), %r9
+	QUAD $0xffffff051d6ffdc5                                 // vmovdqa      $-251(%rip), %ymm3  /* LCPI11_0(%rip) */
+	QUAD $0xffffff1d256ffdc5                                 // vmovdqa      $-227(%rip), %ymm4  /* LCPI11_1(%rip) */
+	QUAD $0xffffff352d6ffdc5                                 // vmovdqa      $-203(%rip), %ymm5  /* LCPI11_2(%rip) */
+	QUAD $0xffffff4d356ffdc5                                 // vmovdqa      $-179(%rip), %ymm6  /* LCPI11_3(%rip) */
+	LONG $0x362d8d4c; WORD $0x00eb; BYTE $0x00               // leaq         $60214(%rip), %r13  /* __HtmlQuoteTab(%rip) */
+	LONG $0xd05d8b4c                                         // movq         $-48(%rbp), %r11
+	LONG $0xc87d8b4c                                         // movq         $-56(%rbp), %r15
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB11_2:
+	WORD $0x854d; BYTE $0xc9                   // testq        %r9, %r9
+	LONG $0x07bb8e0f; WORD $0x0000             // jle          LBB11_3, $1979(%rip)
+	LONG $0x20fe8348                           // cmpq         $32, %rsi
+	WORD $0x930f; BYTE $0xc1                   // setae        %cl
+	WORD $0x894c; BYTE $0xc8                   // movq         %r9, %rax
+	WORD $0x894d; BYTE $0xf8                   // movq         %r15, %r8
+	WORD $0x8949; BYTE $0xf2                   // movq         %rsi, %r10
+	WORD $0x894d; BYTE $0xdc                   // movq         %r11, %r12
+	LONG $0x20f98349                           // cmpq         $32, %r9
+	LONG $0x007a820f; WORD $0x0000             // jb           LBB11_12, $122(%rip)
+	LONG $0x20fe8348                           // cmpq         $32, %rsi
+	LONG $0x0070820f; WORD $0x0000             // jb           LBB11_12, $112(%rip)
+	WORD $0x3145; BYTE $0xc0                   // xorl         %r8d, %r8d
+	WORD $0x8948; BYTE $0xf3                   // movq         %rsi, %rbx
+	WORD $0x894c; BYTE $0xcf                   // movq         %r9, %rdi
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB11_7:
+	LONG $0x6f7e81c4; WORD $0x0304 // vmovdqu      (%r11,%r8), %ymm0
+	LONG $0xcb74fdc5               // vpcmpeqb     %ymm3, %ymm0, %ymm1
+	LONG $0xd474fdc5               // vpcmpeqb     %ymm4, %ymm0, %ymm2
+	LONG $0xc9ebedc5               // vpor         %ymm1, %ymm2, %ymm1
+	LONG $0xd5dbfdc5               // vpand        %ymm5, %ymm0, %ymm2
+	LONG $0xd674edc5               // vpcmpeqb     %ymm6, %ymm2, %ymm2
+	LONG $0xcaebf5c5               // vpor         %ymm2, %ymm1, %ymm1
+	LONG $0x7f7e81c4; WORD $0x0704 // vmovdqu      %ymm0, (%r15,%r8)
+	LONG $0xc1d7fdc5               // vpmovmskb    %ymm1, %eax
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x0180850f; WORD $0x0000 // jne          LBB11_8, $384(%rip)
+	LONG $0xe0538d4c               // leaq         $-32(%rbx), %r10
+	LONG $0xe0478d48               // leaq         $-32(%rdi), %rax
+	LONG $0x20c08349               // addq         $32, %r8
+	LONG $0x40fb8348               // cmpq         $64, %rbx
+	WORD $0x9d0f; BYTE $0xc1       // setge        %cl
+	LONG $0x00108c0f; WORD $0x0000 // jl           LBB11_11, $16(%rip)
+	WORD $0x894c; BYTE $0xd3       // movq         %r10, %rbx
+	LONG $0x3fff8348               // cmpq         $63, %rdi
+	WORD $0x8948; BYTE $0xc7       // movq         %rax, %rdi
+	LONG $0xffa78f0f; WORD $0xffff // jg           LBB11_7, $-89(%rip)
+
+LBB11_11:
+	LONG $0x03248d4f         // leaq         (%r11,%r8), %r12
+	WORD $0x014d; BYTE $0xf8 // addq         %r15, %r8
+
+LBB11_12:
+	WORD $0xc984                           // testb        %cl, %cl
+	LONG $0x0078840f; WORD $0x0000         // je           LBB11_38, $120(%rip)
+	LONG $0x6f7ec1c4; WORD $0x2404         // vmovdqu      (%r12), %ymm0
+	LONG $0xcb74fdc5                       // vpcmpeqb     %ymm3, %ymm0, %ymm1
+	LONG $0xd474fdc5                       // vpcmpeqb     %ymm4, %ymm0, %ymm2
+	LONG $0xc9ebedc5                       // vpor         %ymm1, %ymm2, %ymm1
+	LONG $0xc5dbfdc5                       // vpand        %ymm5, %ymm0, %ymm0
+	LONG $0xc674fdc5                       // vpcmpeqb     %ymm6, %ymm0, %ymm0
+	LONG $0xc0ebf5c5                       // vpor         %ymm0, %ymm1, %ymm0
+	LONG $0xc8d7fdc5                       // vpmovmskb    %ymm0, %ecx
+	QUAD $0x000100000000ba48; WORD $0x0000 // movabsq      $4294967296, %rdx
+	WORD $0x0948; BYTE $0xd1               // orq          %rdx, %rcx
+	LONG $0xd1bc0f4c                       // bsfq         %rcx, %r10
+	LONG $0x243c8b49                       // movq         (%r12), %rdi
+	LONG $0x244c8b49; BYTE $0x08           // movq         $8(%r12), %rcx
+	WORD $0x3949; BYTE $0xc2               // cmpq         %rax, %r10
+	LONG $0x01188e0f; WORD $0x0000         // jle          LBB11_14, $280(%rip)
+	LONG $0x10f88348                       // cmpq         $16, %rax
+	LONG $0x015b820f; WORD $0x0000         // jb           LBB11_27, $347(%rip)
+	WORD $0x8949; BYTE $0x38               // movq         %rdi, (%r8)
+	LONG $0x08488949                       // movq         %rcx, $8(%r8)
+	LONG $0x24548d4d; BYTE $0x10           // leaq         $16(%r12), %r10
+	LONG $0x10c08349                       // addq         $16, %r8
+	LONG $0xf0708d4c                       // leaq         $-16(%rax), %r14
+	LONG $0x08fe8349                       // cmpq         $8, %r14
+	LONG $0x014d830f; WORD $0x0000         // jae          LBB11_30, $333(%rip)
+	LONG $0x00015ae9; BYTE $0x00           // jmp          LBB11_31, $346(%rip)
+	LONG $0x90909090; WORD $0x9090         // .p2align 4, 0x90
+
+LBB11_38:
+	WORD $0xf8c5; BYTE $0x77       // vzeroupper
+	LONG $0x10fa8349               // cmpq         $16, %r10
+	WORD $0x9d0f; BYTE $0xc1       // setge        %cl
+	LONG $0x01828c0f; WORD $0x0000 // jl           LBB11_39, $386(%rip)
+	LONG $0x10f88348               // cmpq         $16, %rax
+	QUAD $0xfffffe143d6ff9c5       // vmovdqa      $-492(%rip), %xmm7  /* LCPI11_4(%rip) */
+	QUAD $0xfffffe1c056f79c5       // vmovdqa      $-484(%rip), %xmm8  /* LCPI11_5(%rip) */
+	QUAD $0xfffffe240d6f79c5       // vmovdqa      $-476(%rip), %xmm9  /* LCPI11_6(%rip) */
+	QUAD $0xfffffe2c156f79c5       // vmovdqa      $-468(%rip), %xmm10  /* LCPI11_7(%rip) */
+	LONG $0x02078c0f; WORD $0x0000 // jl           LBB11_41, $519(%rip)
+	WORD $0x894c; BYTE $0xdf       // movq         %r11, %rdi
+	WORD $0x294c; BYTE $0xe7       // subq         %r12, %rdi
+	QUAD $0xfffffd681d6ffdc5       // vmovdqa      $-664(%rip), %ymm3  /* LCPI11_0(%rip) */
+	QUAD $0xfffffd80256ffdc5       // vmovdqa      $-640(%rip), %ymm4  /* LCPI11_1(%rip) */
+	QUAD $0xfffffd982d6ffdc5       // vmovdqa      $-616(%rip), %ymm5  /* LCPI11_2(%rip) */
+	QUAD $0xfffffdb0356ffdc5       // vmovdqa      $-592(%rip), %ymm6  /* LCPI11_3(%rip) */
+
+	// .p2align 4, 0x90
+LBB11_43:
+	LONG $0x6f7ac1c4; WORD $0x2404                     // vmovdqu      (%r12), %xmm0
+	LONG $0xcf74f9c5                                   // vpcmpeqb     %xmm7, %xmm0, %xmm1
+	LONG $0xd074b9c5                                   // vpcmpeqb     %xmm0, %xmm8, %xmm2
+	LONG $0xc9ebe9c5                                   // vpor         %xmm1, %xmm2, %xmm1
+	LONG $0xd0dbb1c5                                   // vpand        %xmm0, %xmm9, %xmm2
+	LONG $0xd274a9c5                                   // vpcmpeqb     %xmm2, %xmm10, %xmm2
+	LONG $0xcaebf1c5                                   // vpor         %xmm2, %xmm1, %xmm1
+	LONG $0x7f7ac1c4; BYTE $0x00                       // vmovdqu      %xmm0, (%r8)
+	LONG $0xc9d7f9c5                                   // vpmovmskb    %xmm1, %ecx
+	WORD $0xc985                                       // testl        %ecx, %ecx
+	LONG $0x0083850f; WORD $0x0000                     // jne          LBB11_44, $131(%rip)
+	LONG $0x10c48349                                   // addq         $16, %r12
+	LONG $0x10c08349                                   // addq         $16, %r8
+	LONG $0xf0728d4d                                   // leaq         $-16(%r10), %r14
+	LONG $0xf0688d4c                                   // leaq         $-16(%rax), %r13
+	LONG $0x20fa8349                                   // cmpq         $32, %r10
+	WORD $0x9d0f; BYTE $0xc1                           // setge        %cl
+	LONG $0x012c8c0f; WORD $0x0000                     // jl           LBB11_47, $300(%rip)
+	LONG $0xf0c78348                                   // addq         $-16, %rdi
+	WORD $0x894d; BYTE $0xf2                           // movq         %r14, %r10
+	LONG $0x1ff88348                                   // cmpq         $31, %rax
+	WORD $0x894c; BYTE $0xe8                           // movq         %r13, %rax
+	LONG $0xffa08f0f; WORD $0xffff                     // jg           LBB11_43, $-96(%rip)
+	LONG $0x000113e9; BYTE $0x00                       // jmp          LBB11_47, $275(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB11_8:
+	LONG $0xe0bc0f44               // bsfl         %eax, %r12d
+	WORD $0x014d; BYTE $0xc4       // addq         %r8, %r12
+	WORD $0x854d; BYTE $0xe4       // testq        %r12, %r12
+	LONG $0x0460890f; WORD $0x0000 // jns          LBB11_84, $1120(%rip)
+	LONG $0x00057ae9; BYTE $0x00   // jmp          LBB11_83, $1402(%rip)
+
+LBB11_14:
+	LONG $0x10fa8341               // cmpl         $16, %r10d
+	LONG $0x0223820f; WORD $0x0000 // jb           LBB11_15, $547(%rip)
+	WORD $0x8949; BYTE $0x38       // movq         %rdi, (%r8)
+	LONG $0x08488949               // movq         %rcx, $8(%r8)
+	LONG $0x24748d4d; BYTE $0x10   // leaq         $16(%r12), %r14
+	LONG $0x10c08349               // addq         $16, %r8
+	LONG $0xf0428d49               // leaq         $-16(%r10), %rax
+	LONG $0x08f88348               // cmpq         $8, %rax
+	LONG $0x0215830f; WORD $0x0000 // jae          LBB11_18, $533(%rip)
+	LONG $0x000222e9; BYTE $0x00   // jmp          LBB11_19, $546(%rip)
+
+LBB11_44:
+	LONG $0xc1bc0f66                           // bsfw         %cx, %ax
+	LONG $0xe0b70f44                           // movzwl       %ax, %r12d
+	WORD $0x2949; BYTE $0xfc                   // subq         %rdi, %r12
+	LONG $0xdc2d8d4c; WORD $0x00e8; BYTE $0x00 // leaq         $59612(%rip), %r13  /* __HtmlQuoteTab(%rip) */
+	WORD $0x854d; BYTE $0xe4                   // testq        %r12, %r12
+	LONG $0x0413890f; WORD $0x0000             // jns          LBB11_84, $1043(%rip)
+	LONG $0x00052de9; BYTE $0x00               // jmp          LBB11_83, $1325(%rip)
+
+LBB11_27:
+	WORD $0x894d; BYTE $0xe2       // movq         %r12, %r10
+	WORD $0x8949; BYTE $0xc6       // movq         %rax, %r14
+	LONG $0x08fe8349               // cmpq         $8, %r14
+	LONG $0x0012820f; WORD $0x0000 // jb           LBB11_31, $18(%rip)
+
+LBB11_30:
+	WORD $0x8b49; BYTE $0x0a // movq         (%r10), %rcx
+	WORD $0x8949; BYTE $0x08 // movq         %rcx, (%r8)
+	LONG $0x08c28349         // addq         $8, %r10
+	LONG $0x08c08349         // addq         $8, %r8
+	LONG $0xf8c68349         // addq         $-8, %r14
+
+LBB11_31:
+	LONG $0x04fe8349               // cmpq         $4, %r14
+	LONG $0x020e8d0f; WORD $0x0000 // jge          LBB11_32, $526(%rip)
+	LONG $0x02fe8349               // cmpq         $2, %r14
+	LONG $0x0220830f; WORD $0x0000 // jae          LBB11_34, $544(%rip)
+
+LBB11_35:
+	WORD $0x854d; BYTE $0xf6       // testq        %r14, %r14
+	LONG $0x0007840f; WORD $0x0000 // je           LBB11_37, $7(%rip)
+
+LBB11_36:
+	LONG $0x0ab60f41         // movzbl       (%r10), %ecx
+	WORD $0x8841; BYTE $0x08 // movb         %cl, (%r8)
+
+LBB11_37:
+	WORD $0x014c; BYTE $0xe0       // addq         %r12, %rax
+	WORD $0xf748; BYTE $0xd0       // notq         %rax
+	WORD $0x014c; BYTE $0xd8       // addq         %r11, %rax
+	WORD $0x8949; BYTE $0xc4       // movq         %rax, %r12
+	WORD $0x854d; BYTE $0xe4       // testq        %r12, %r12
+	LONG $0x03b3890f; WORD $0x0000 // jns          LBB11_84, $947(%rip)
+	LONG $0x0004cde9; BYTE $0x00   // jmp          LBB11_83, $1229(%rip)
+
+LBB11_39:
+	WORD $0x8949; BYTE $0xc5 // movq         %rax, %r13
+	WORD $0x894d; BYTE $0xd6 // movq         %r10, %r14
+	QUAD $0xfffffc101d6ffdc5 // vmovdqa      $-1008(%rip), %ymm3  /* LCPI11_0(%rip) */
+	QUAD $0xfffffc28256ffdc5 // vmovdqa      $-984(%rip), %ymm4  /* LCPI11_1(%rip) */
+	QUAD $0xfffffc402d6ffdc5 // vmovdqa      $-960(%rip), %ymm5  /* LCPI11_2(%rip) */
+	QUAD $0xfffffc58356ffdc5 // vmovdqa      $-936(%rip), %ymm6  /* LCPI11_3(%rip) */
+	QUAD $0xfffffc703d6ff9c5 // vmovdqa      $-912(%rip), %xmm7  /* LCPI11_4(%rip) */
+	QUAD $0xfffffc78056f79c5 // vmovdqa      $-904(%rip), %xmm8  /* LCPI11_5(%rip) */
+	QUAD $0xfffffc800d6f79c5 // vmovdqa      $-896(%rip), %xmm9  /* LCPI11_6(%rip) */
+	QUAD $0xfffffc88156f79c5 // vmovdqa      $-888(%rip), %xmm10  /* LCPI11_7(%rip) */
+
+LBB11_47:
+	WORD $0xc984                   // testb        %cl, %cl
+	LONG $0x008f840f; WORD $0x0000 // je           LBB11_48, $143(%rip)
+
+LBB11_58:
+	LONG $0x6f7ac1c4; WORD $0x2404 // vmovdqu      (%r12), %xmm0
+	LONG $0xcf74f9c5               // vpcmpeqb     %xmm7, %xmm0, %xmm1
+	LONG $0xd074b9c5               // vpcmpeqb     %xmm0, %xmm8, %xmm2
+	LONG $0xc9ebe9c5               // vpor         %xmm1, %xmm2, %xmm1
+	LONG $0xd0dbb1c5               // vpand        %xmm0, %xmm9, %xmm2
+	LONG $0xd274a9c5               // vpcmpeqb     %xmm2, %xmm10, %xmm2
+	LONG $0xcaebf1c5               // vpor         %xmm2, %xmm1, %xmm1
+	LONG $0xc1d7f9c5               // vpmovmskb    %xmm1, %eax
+	LONG $0x0100000d; BYTE $0x00   // orl          $65536, %eax
+	WORD $0xbc0f; BYTE $0xc0       // bsfl         %eax, %eax
+	LONG $0x7ef9e1c4; BYTE $0xc1   // vmovq        %xmm0, %rcx
+	WORD $0x3949; BYTE $0xc5       // cmpq         %rax, %r13
+	LONG $0x01d08d0f; WORD $0x0000 // jge          LBB11_59, $464(%rip)
+	LONG $0x08fd8349               // cmpq         $8, %r13
+	LONG $0x0210820f; WORD $0x0000 // jb           LBB11_70, $528(%rip)
+	WORD $0x8949; BYTE $0x08       // movq         %rcx, (%r8)
+	LONG $0x24448d49; BYTE $0x08   // leaq         $8(%r12), %rax
+	LONG $0x08c08349               // addq         $8, %r8
+	LONG $0xf87d8d49               // leaq         $-8(%r13), %rdi
+	LONG $0x04ff8348               // cmpq         $4, %rdi
+	LONG $0x02068d0f; WORD $0x0000 // jge          LBB11_73, $518(%rip)
+	LONG $0x000212e9; BYTE $0x00   // jmp          LBB11_74, $530(%rip)
+
+LBB11_41:
+	WORD $0x8949; BYTE $0xc5       // movq         %rax, %r13
+	WORD $0x894d; BYTE $0xd6       // movq         %r10, %r14
+	QUAD $0xfffffb611d6ffdc5       // vmovdqa      $-1183(%rip), %ymm3  /* LCPI11_0(%rip) */
+	QUAD $0xfffffb79256ffdc5       // vmovdqa      $-1159(%rip), %ymm4  /* LCPI11_1(%rip) */
+	QUAD $0xfffffb912d6ffdc5       // vmovdqa      $-1135(%rip), %ymm5  /* LCPI11_2(%rip) */
+	QUAD $0xfffffba9356ffdc5       // vmovdqa      $-1111(%rip), %ymm6  /* LCPI11_3(%rip) */
+	WORD $0xc984                   // testb        %cl, %cl
+	LONG $0xff71850f; WORD $0xffff // jne          LBB11_58, $-143(%rip)
+
+LBB11_48:
+	WORD $0x854d; BYTE $0xf6                           // testq        %r14, %r14
+	LONG $0x00768e0f; WORD $0x0000                     // jle          LBB11_56, $118(%rip)
+	WORD $0x854d; BYTE $0xed                           // testq        %r13, %r13
+	LONG $0x006d8e0f; WORD $0x0000                     // jle          LBB11_56, $109(%rip)
+	WORD $0xc931                                       // xorl         %ecx, %ecx
+	WORD $0xc031                                       // xorl         %eax, %eax
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB11_51:
+	LONG $0x3cb60f41; BYTE $0x0c           // movzbl       (%r12,%rcx), %edi
+	LONG $0x3eff8348                       // cmpq         $62, %rdi
+	LONG $0x0014870f; WORD $0x0000         // ja           LBB11_52, $20(%rip)
+	QUAD $0x004000000000ba48; WORD $0x5000 // movabsq      $5764607797912141824, %rdx
+	LONG $0xfaa30f48                       // btq          %rdi, %rdx
+	LONG $0x0164820f; WORD $0x0000         // jb           LBB11_80, $356(%rip)
+
+LBB11_52:
+	LONG $0x00e2ff81; WORD $0x0000 // cmpl         $226, %edi
+	LONG $0x0158840f; WORD $0x0000 // je           LBB11_80, $344(%rip)
+	LONG $0x061c8d49               // leaq         (%r14,%rax), %rbx
+	LONG $0x083c8841               // movb         %dil, (%r8,%rcx)
+	LONG $0xff788d48               // leaq         $-1(%rax), %rdi
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0x00138c0f; WORD $0x0000 // jl           LBB11_55, $19(%rip)
+	WORD $0x014c; BYTE $0xe8       // addq         %r13, %rax
+	WORD $0xff48; BYTE $0xc1       // incq         %rcx
+	LONG $0x01f88348               // cmpq         $1, %rax
+	WORD $0x8948; BYTE $0xf8       // movq         %rdi, %rax
+	LONG $0xffa88f0f; WORD $0xffff // jg           LBB11_51, $-88(%rip)
+
+LBB11_55:
+	WORD $0x2949; BYTE $0xfc // subq         %rdi, %r12
+	WORD $0x0149; BYTE $0xfe // addq         %rdi, %r14
+
+LBB11_56:
+	WORD $0x854d; BYTE $0xf6                   // testq        %r14, %r14
+	LONG $0x082d8d4c; WORD $0x00e7; BYTE $0x00 // leaq         $59144(%rip), %r13  /* __HtmlQuoteTab(%rip) */
+	LONG $0x0229840f; WORD $0x0000             // je           LBB11_57, $553(%rip)
+	WORD $0xf749; BYTE $0xd4                   // notq         %r12
+	WORD $0x014d; BYTE $0xdc                   // addq         %r11, %r12
+	WORD $0x854d; BYTE $0xe4                   // testq        %r12, %r12
+	LONG $0x0233890f; WORD $0x0000             // jns          LBB11_84, $563(%rip)
+	LONG $0x00034de9; BYTE $0x00               // jmp          LBB11_83, $845(%rip)
+
+LBB11_15:
+	WORD $0x894d; BYTE $0xe6       // movq         %r12, %r14
+	WORD $0x894c; BYTE $0xd0       // movq         %r10, %rax
+	LONG $0x08f88348               // cmpq         $8, %rax
+	LONG $0x0012820f; WORD $0x0000 // jb           LBB11_19, $18(%rip)
+
+LBB11_18:
+	WORD $0x8b49; BYTE $0x0e // movq         (%r14), %rcx
+	WORD $0x8949; BYTE $0x08 // movq         %rcx, (%r8)
+	LONG $0x08c68349         // addq         $8, %r14
+	LONG $0x08c08349         // addq         $8, %r8
+	LONG $0xf8c08348         // addq         $-8, %rax
+
+LBB11_19:
+	LONG $0x04f88348               // cmpq         $4, %rax
+	LONG $0x006c830f; WORD $0x0000 // jae          LBB11_20, $108(%rip)
+	LONG $0x02f88348               // cmpq         $2, %rax
+	LONG $0x007e830f; WORD $0x0000 // jae          LBB11_22, $126(%rip)
+
+LBB11_23:
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0007840f; WORD $0x0000 // je           LBB11_25, $7(%rip)
+
+LBB11_24:
+	LONG $0x06b60f41         // movzbl       (%r14), %eax
+	WORD $0x8841; BYTE $0x00 // movb         %al, (%r8)
+
+LBB11_25:
+	WORD $0x294d; BYTE $0xdc       // subq         %r11, %r12
+	WORD $0x014d; BYTE $0xd4       // addq         %r10, %r12
+	WORD $0x854d; BYTE $0xe4       // testq        %r12, %r12
+	LONG $0x01d9890f; WORD $0x0000 // jns          LBB11_84, $473(%rip)
+	LONG $0x0002f3e9; BYTE $0x00   // jmp          LBB11_83, $755(%rip)
+
+LBB11_32:
+	WORD $0x8b41; BYTE $0x0a       // movl         (%r10), %ecx
+	WORD $0x8941; BYTE $0x08       // movl         %ecx, (%r8)
+	LONG $0x04c28349               // addq         $4, %r10
+	LONG $0x04c08349               // addq         $4, %r8
+	LONG $0xfcc68349               // addq         $-4, %r14
+	LONG $0x02fe8349               // cmpq         $2, %r14
+	LONG $0xfde0820f; WORD $0xffff // jb           LBB11_35, $-544(%rip)
+
+LBB11_34:
+	LONG $0x0ab70f41               // movzwl       (%r10), %ecx
+	LONG $0x08894166               // movw         %cx, (%r8)
+	LONG $0x02c28349               // addq         $2, %r10
+	LONG $0x02c08349               // addq         $2, %r8
+	LONG $0xfec68349               // addq         $-2, %r14
+	WORD $0x854d; BYTE $0xf6       // testq        %r14, %r14
+	LONG $0xfdcc850f; WORD $0xffff // jne          LBB11_36, $-564(%rip)
+	LONG $0xfffdcee9; BYTE $0xff   // jmp          LBB11_37, $-562(%rip)
+
+LBB11_20:
+	WORD $0x8b41; BYTE $0x0e       // movl         (%r14), %ecx
+	WORD $0x8941; BYTE $0x08       // movl         %ecx, (%r8)
+	LONG $0x04c68349               // addq         $4, %r14
+	LONG $0x04c08349               // addq         $4, %r8
+	LONG $0xfcc08348               // addq         $-4, %rax
+	LONG $0x02f88348               // cmpq         $2, %rax
+	LONG $0xff82820f; WORD $0xffff // jb           LBB11_23, $-126(%rip)
+
+LBB11_22:
+	LONG $0x0eb70f41               // movzwl       (%r14), %ecx
+	LONG $0x08894166               // movw         %cx, (%r8)
+	LONG $0x02c68349               // addq         $2, %r14
+	LONG $0x02c08349               // addq         $2, %r8
+	LONG $0xfec08348               // addq         $-2, %rax
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0xff6e850f; WORD $0xffff // jne          LBB11_24, $-146(%rip)
+	LONG $0xffff70e9; BYTE $0xff   // jmp          LBB11_25, $-144(%rip)
+
+LBB11_59:
+	WORD $0xf883; BYTE $0x08                   // cmpl         $8, %eax
+	LONG $0x009c820f; WORD $0x0000             // jb           LBB11_60, $156(%rip)
+	WORD $0x8949; BYTE $0x08                   // movq         %rcx, (%r8)
+	LONG $0x24548d4d; BYTE $0x08               // leaq         $8(%r12), %r10
+	LONG $0x08c08349                           // addq         $8, %r8
+	LONG $0xf8788d48                           // leaq         $-8(%rax), %rdi
+	LONG $0xf82d8d4c; WORD $0x00e5; BYTE $0x00 // leaq         $58872(%rip), %r13  /* __HtmlQuoteTab(%rip) */
+	LONG $0x04ff8348                           // cmpq         $4, %rdi
+	LONG $0x0092830f; WORD $0x0000             // jae          LBB11_63, $146(%rip)
+	LONG $0x00009fe9; BYTE $0x00               // jmp          LBB11_64, $159(%rip)
+
+LBB11_80:
+	WORD $0x294d; BYTE $0xdc                   // subq         %r11, %r12
+	WORD $0x2949; BYTE $0xc4                   // subq         %rax, %r12
+	LONG $0xdc2d8d4c; WORD $0x00e5; BYTE $0x00 // leaq         $58844(%rip), %r13  /* __HtmlQuoteTab(%rip) */
+	WORD $0x854d; BYTE $0xe4                   // testq        %r12, %r12
+	LONG $0x0113890f; WORD $0x0000             // jns          LBB11_84, $275(%rip)
+	LONG $0x00022de9; BYTE $0x00               // jmp          LBB11_83, $557(%rip)
+
+LBB11_70:
+	WORD $0x894c; BYTE $0xe0       // movq         %r12, %rax
+	WORD $0x894c; BYTE $0xef       // movq         %r13, %rdi
+	LONG $0x04ff8348               // cmpq         $4, %rdi
+	LONG $0x00118c0f; WORD $0x0000 // jl           LBB11_74, $17(%rip)
+
+LBB11_73:
+	WORD $0x088b             // movl         (%rax), %ecx
+	WORD $0x8941; BYTE $0x08 // movl         %ecx, (%r8)
+	LONG $0x04c08348         // addq         $4, %rax
+	LONG $0x04c08349         // addq         $4, %r8
+	LONG $0xfcc78348         // addq         $-4, %rdi
+
+LBB11_74:
+	LONG $0x02ff8348               // cmpq         $2, %rdi
+	LONG $0x0087830f; WORD $0x0000 // jae          LBB11_75, $135(%rip)
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0x0006840f; WORD $0x0000 // je           LBB11_78, $6(%rip)
+
+LBB11_77:
+	WORD $0xb60f; BYTE $0x00 // movzbl       (%rax), %eax
+	WORD $0x8841; BYTE $0x00 // movb         %al, (%r8)
+
+LBB11_78:
+	WORD $0x014d; BYTE $0xe5                   // addq         %r12, %r13
+	WORD $0xf749; BYTE $0xd5                   // notq         %r13
+	WORD $0x014d; BYTE $0xdd                   // addq         %r11, %r13
+	WORD $0x894d; BYTE $0xec                   // movq         %r13, %r12
+	LONG $0x812d8d4c; WORD $0x00e5; BYTE $0x00 // leaq         $58753(%rip), %r13  /* __HtmlQuoteTab(%rip) */
+	WORD $0x854d; BYTE $0xe4                   // testq        %r12, %r12
+	LONG $0x00b8890f; WORD $0x0000             // jns          LBB11_84, $184(%rip)
+	LONG $0x0001d2e9; BYTE $0x00               // jmp          LBB11_83, $466(%rip)
+
+LBB11_60:
+	WORD $0x894d; BYTE $0xe2                   // movq         %r12, %r10
+	WORD $0x8948; BYTE $0xc7                   // movq         %rax, %rdi
+	LONG $0x662d8d4c; WORD $0x00e5; BYTE $0x00 // leaq         $58726(%rip), %r13  /* __HtmlQuoteTab(%rip) */
+	LONG $0x04ff8348                           // cmpq         $4, %rdi
+	LONG $0x0012820f; WORD $0x0000             // jb           LBB11_64, $18(%rip)
+
+LBB11_63:
+	WORD $0x8b41; BYTE $0x0a // movl         (%r10), %ecx
+	WORD $0x8941; BYTE $0x08 // movl         %ecx, (%r8)
+	LONG $0x04c28349         // addq         $4, %r10
+	LONG $0x04c08349         // addq         $4, %r8
+	LONG $0xfcc78348         // addq         $-4, %rdi
+
+LBB11_64:
+	LONG $0x02ff8348               // cmpq         $2, %rdi
+	LONG $0x0045830f; WORD $0x0000 // jae          LBB11_65, $69(%rip)
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0x0007840f; WORD $0x0000 // je           LBB11_68, $7(%rip)
+
+LBB11_67:
+	LONG $0x0ab60f41         // movzbl       (%r10), %ecx
+	WORD $0x8841; BYTE $0x08 // movb         %cl, (%r8)
+
+LBB11_68:
+	WORD $0x294d; BYTE $0xdc       // subq         %r11, %r12
+	WORD $0x0149; BYTE $0xc4       // addq         %rax, %r12
+	WORD $0x854d; BYTE $0xe4       // testq        %r12, %r12
+	LONG $0x0061890f; WORD $0x0000 // jns          LBB11_84, $97(%rip)
+	LONG $0x00017be9; BYTE $0x00   // jmp          LBB11_83, $379(%rip)
+
+LBB11_75:
+	WORD $0xb70f; BYTE $0x08       // movzwl       (%rax), %ecx
+	LONG $0x08894166               // movw         %cx, (%r8)
+	LONG $0x02c08348               // addq         $2, %rax
+	LONG $0x02c08349               // addq         $2, %r8
+	LONG $0xfec78348               // addq         $-2, %rdi
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0xff66850f; WORD $0xffff // jne          LBB11_77, $-154(%rip)
+	LONG $0xffff67e9; BYTE $0xff   // jmp          LBB11_78, $-153(%rip)
+
+LBB11_65:
+	LONG $0x0ab70f41               // movzwl       (%r10), %ecx
+	LONG $0x08894166               // movw         %cx, (%r8)
+	LONG $0x02c28349               // addq         $2, %r10
+	LONG $0x02c08349               // addq         $2, %r8
+	LONG $0xfec78348               // addq         $-2, %rdi
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0xffa7850f; WORD $0xffff // jne          LBB11_67, $-89(%rip)
+	LONG $0xffffa9e9; BYTE $0xff   // jmp          LBB11_68, $-87(%rip)
+
+LBB11_57:
+	WORD $0x294d; BYTE $0xdc                               // subq         %r11, %r12
+	WORD $0x854d; BYTE $0xe4                               // testq        %r12, %r12
+	LONG $0x012c880f; WORD $0x0000                         // js           LBB11_83, $300(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB11_84:
+	WORD $0x014d; BYTE $0xe3       // addq         %r12, %r11
+	WORD $0x014d; BYTE $0xe7       // addq         %r12, %r15
+	WORD $0x294c; BYTE $0xe6       // subq         %r12, %rsi
+	LONG $0x01338e0f; WORD $0x0000 // jle          LBB11_85, $307(%rip)
+	WORD $0x294d; BYTE $0xe1       // subq         %r12, %r9
+	LONG $0x0bb60f41               // movzbl       (%r11), %ecx
+	WORD $0xf980; BYTE $0xe2       // cmpb         $-30, %cl
+	LONG $0x00b2840f; WORD $0x0000 // je           LBB11_88, $178(%rip)
+	WORD $0x894c; BYTE $0xd8       // movq         %r11, %rax
+
+LBB11_92:
+	WORD $0xb60f; BYTE $0xc9               // movzbl       %cl, %ecx
+	LONG $0x04e1c148                       // shlq         $4, %rcx
+	LONG $0x293c8b4a                       // movq         (%rcx,%r13), %rdi
+	WORD $0x6348; BYTE $0xdf               // movslq       %edi, %rbx
+	WORD $0x2949; BYTE $0xd9               // subq         %rbx, %r9
+	LONG $0x01208c0f; WORD $0x0000         // jl           LBB11_93, $288(%rip)
+	LONG $0x20e7c148                       // shlq         $32, %rdi
+	WORD $0x014c; BYTE $0xe9               // addq         %r13, %rcx
+	LONG $0x08c18348                       // addq         $8, %rcx
+	QUAD $0x000300000001ba48; WORD $0x0000 // movabsq      $12884901889, %rdx
+	WORD $0x3948; BYTE $0xd7               // cmpq         %rdx, %rdi
+	LONG $0x00298c0f; WORD $0x0000         // jl           LBB11_97, $41(%rip)
+	WORD $0x398b                           // movl         (%rcx), %edi
+	WORD $0x8941; BYTE $0x3f               // movl         %edi, (%r15)
+	LONG $0x04c18348                       // addq         $4, %rcx
+	LONG $0x04578d4d                       // leaq         $4(%r15), %r10
+	LONG $0xfc7b8d48                       // leaq         $-4(%rbx), %rdi
+	LONG $0x02ff8348                       // cmpq         $2, %rdi
+	LONG $0x001e830f; WORD $0x0000         // jae          LBB11_100, $30(%rip)
+	LONG $0x00002ce9; BYTE $0x00           // jmp          LBB11_101, $44(%rip)
+	QUAD $0x9090909090909090; BYTE $0x90   // .p2align 4, 0x90
+
+LBB11_97:
+	WORD $0x894d; BYTE $0xfa       // movq         %r15, %r10
+	WORD $0x8948; BYTE $0xdf       // movq         %rbx, %rdi
+	LONG $0x02ff8348               // cmpq         $2, %rdi
+	LONG $0x0013820f; WORD $0x0000 // jb           LBB11_101, $19(%rip)
+
+LBB11_100:
+	WORD $0xb70f; BYTE $0x11 // movzwl       (%rcx), %edx
+	LONG $0x12894166         // movw         %dx, (%r10)
+	LONG $0x02c18348         // addq         $2, %rcx
+	LONG $0x02c28349         // addq         $2, %r10
+	LONG $0xfec78348         // addq         $-2, %rdi
+
+LBB11_101:
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0x0006840f; WORD $0x0000 // je           LBB11_103, $6(%rip)
+	WORD $0xb60f; BYTE $0x09       // movzbl       (%rcx), %ecx
+	WORD $0x8841; BYTE $0x0a       // movb         %cl, (%r10)
+
+LBB11_103:
+	WORD $0x0149; BYTE $0xdf // addq         %rbx, %r15
+
+LBB11_104:
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	LONG $0xff4e8d48               // leaq         $-1(%rsi), %rcx
+	WORD $0x8949; BYTE $0xc3       // movq         %rax, %r11
+	LONG $0x01fe8348               // cmpq         $1, %rsi
+	WORD $0x8948; BYTE $0xce       // movq         %rcx, %rsi
+	LONG $0xf8d4870f; WORD $0xffff // ja           LBB11_2, $-1836(%rip)
+	LONG $0x000074e9; BYTE $0x00   // jmp          LBB11_105, $116(%rip)
+
+LBB11_88:
+	LONG $0x03fe8348               // cmpq         $3, %rsi
+	LONG $0x0029820f; WORD $0x0000 // jb           LBB11_94, $41(%rip)
+	LONG $0x017b8041; BYTE $0x80   // cmpb         $-128, $1(%r11)
+	LONG $0x001e850f; WORD $0x0000 // jne          LBB11_94, $30(%rip)
+	LONG $0x4bb60f41; BYTE $0x02   // movzbl       $2(%r11), %ecx
+	WORD $0xc889                   // movl         %ecx, %eax
+	WORD $0xfe24                   // andb         $-2, %al
+	WORD $0xa83c                   // cmpb         $-88, %al
+	LONG $0x000d850f; WORD $0x0000 // jne          LBB11_94, $13(%rip)
+	LONG $0x02438d49               // leaq         $2(%r11), %rax
+	LONG $0xfec68348               // addq         $-2, %rsi
+	LONG $0xffff1ee9; BYTE $0xff   // jmp          LBB11_92, $-226(%rip)
+
+LBB11_94:
+	WORD $0x854d; BYTE $0xc9       // testq        %r9, %r9
+	LONG $0x00578e0f; WORD $0x0000 // jle          LBB11_3, $87(%rip)
+	LONG $0xe207c641               // movb         $-30, (%r15)
+	WORD $0xff49; BYTE $0xc7       // incq         %r15
+	WORD $0xff49; BYTE $0xc9       // decq         %r9
+	WORD $0x894c; BYTE $0xd8       // movq         %r11, %rax
+	LONG $0xffff96e9; BYTE $0xff   // jmp          LBB11_104, $-106(%rip)
+
+LBB11_83:
+	LONG $0xc84d8b48             // movq         $-56(%rbp), %rcx
+	WORD $0x014c; BYTE $0xe1     // addq         %r12, %rcx
+	WORD $0xf748; BYTE $0xd1     // notq         %rcx
+	WORD $0x014c; BYTE $0xf9     // addq         %r15, %rcx
+	LONG $0xc0458b48             // movq         $-64(%rbp), %rax
+	WORD $0x8948; BYTE $0x08     // movq         %rcx, (%rax)
+	LONG $0xd0458b48             // movq         $-48(%rbp), %rax
+	WORD $0x294c; BYTE $0xd8     // subq         %r11, %rax
+	WORD $0x014c; BYTE $0xe0     // addq         %r12, %rax
+	LONG $0x00002ce9; BYTE $0x00 // jmp          LBB11_106, $44(%rip)
+
+LBB11_85:
+	WORD $0x894c; BYTE $0xd8 // movq         %r11, %rax
+
+LBB11_105:
+	LONG $0xc87d2b4c             // subq         $-56(%rbp), %r15
+	LONG $0xc04d8b48             // movq         $-64(%rbp), %rcx
+	WORD $0x894c; BYTE $0x39     // movq         %r15, (%rcx)
+	LONG $0xd0452b48             // subq         $-48(%rbp), %rax
+	LONG $0x000015e9; BYTE $0x00 // jmp          LBB11_106, $21(%rip)
+
+LBB11_93:
+	LONG $0xc87d2b4c         // subq         $-56(%rbp), %r15
+	LONG $0xc0458b48         // movq         $-64(%rbp), %rax
+	WORD $0x894c; BYTE $0x38 // movq         %r15, (%rax)
+
+LBB11_3:
+	WORD $0xf749; BYTE $0xd3 // notq         %r11
+	LONG $0xd05d034c         // addq         $-48(%rbp), %r11
+	WORD $0x894c; BYTE $0xd8 // movq         %r11, %rax
+
+LBB11_106:
+	LONG $0x18c48348         // addq         $24, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	BYTE $0xc3               // retq
+
+	// .p2align 4, 0x90
+_atof_eisel_lemire64:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5741                   // pushq        %r15
+	WORD $0x5641                   // pushq        %r14
+	WORD $0x5441                   // pushq        %r12
+	BYTE $0x53                     // pushq        %rbx
+	LONG $0xfea4868d; WORD $0xffff // leal         $-348(%rsi), %eax
+	LONG $0xfffd483d; BYTE $0xff   // cmpl         $-696, %eax
+	LONG $0x0122820f; WORD $0x0000 // jb           LBB12_1, $290(%rip)
+	WORD $0x8949; BYTE $0xc8       // movq         %rcx, %r8
+	WORD $0x8941; BYTE $0xd1       // movl         %edx, %r9d
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0x000d840f; WORD $0x0000 // je           LBB12_4, $13(%rip)
+	LONG $0xd7bd0f4c               // bsrq         %rdi, %r10
+	LONG $0x3ff28349               // xorq         $63, %r10
+	LONG $0x000006e9; BYTE $0x00   // jmp          LBB12_5, $6(%rip)
+
+LBB12_4:
+	LONG $0x0040ba41; WORD $0x0000 // movl         $64, %r10d
+
+LBB12_5:
+	WORD $0x8944; BYTE $0xd1                   // movl         %r10d, %ecx
+	WORD $0xd348; BYTE $0xe7                   // shlq         %cl, %rdi
+	LONG $0x015c8e8d; WORD $0x0000             // leal         $348(%rsi), %ecx
+	LONG $0x04e1c148                           // shlq         $4, %rcx
+	LONG $0x3b258d4c; WORD $0x006d; BYTE $0x00 // leaq         $27963(%rip), %r12  /* _POW10_M128_TAB(%rip) */
+	WORD $0x8948; BYTE $0xf8                   // movq         %rdi, %rax
+	LONG $0x2164f74a; BYTE $0x08               // mulq         $8(%rcx,%r12)
+	WORD $0x8949; BYTE $0xc7                   // movq         %rax, %r15
+	WORD $0x8949; BYTE $0xd3                   // movq         %rdx, %r11
+	WORD $0x8944; BYTE $0xdb                   // movl         %r11d, %ebx
+	LONG $0x01ffe381; WORD $0x0000             // andl         $511, %ebx
+	LONG $0xfffb8148; WORD $0x0001; BYTE $0x00 // cmpq         $511, %rbx
+	LONG $0x0050850f; WORD $0x0000             // jne          LBB12_11, $80(%rip)
+	WORD $0x8949; BYTE $0xfe                   // movq         %rdi, %r14
+	WORD $0xf749; BYTE $0xd6                   // notq         %r14
+	WORD $0x894c; BYTE $0xfa                   // movq         %r15, %rdx
+	WORD $0x394d; BYTE $0xf7                   // cmpq         %r14, %r15
+	LONG $0x0041860f; WORD $0x0000             // jbe          LBB12_13, $65(%rip)
+	WORD $0x8948; BYTE $0xf8                   // movq         %rdi, %rax
+	LONG $0x2124f74a                           // mulq         (%rcx,%r12)
+	WORD $0x014c; BYTE $0xfa                   // addq         %r15, %rdx
+	LONG $0x00d38349                           // adcq         $0, %r11
+	WORD $0x8944; BYTE $0xd9                   // movl         %r11d, %ecx
+	WORD $0xd1f7                               // notl         %ecx
+	LONG $0x37e1c148                           // shlq         $55, %rcx
+	LONG $0x0013850f; WORD $0x0000             // jne          LBB12_12, $19(%rip)
+	LONG $0xfffa8348                           // cmpq         $-1, %rdx
+	LONG $0x0009850f; WORD $0x0000             // jne          LBB12_12, $9(%rip)
+	WORD $0x394c; BYTE $0xf0                   // cmpq         %r14, %rax
+	LONG $0x0083870f; WORD $0x0000             // ja           LBB12_1, $131(%rip)
+
+LBB12_12:
+	WORD $0x8944; BYTE $0xdb       // movl         %r11d, %ebx
+	LONG $0x01ffe381; WORD $0x0000 // andl         $511, %ebx
+	LONG $0x000003e9; BYTE $0x00   // jmp          LBB12_13, $3(%rip)
+
+LBB12_11:
+	WORD $0x894c; BYTE $0xfa // movq         %r15, %rdx
+
+LBB12_13:
+	WORD $0x894c; BYTE $0xd8       // movq         %r11, %rax
+	LONG $0x3fe8c148               // shrq         $63, %rax
+	WORD $0x488d; BYTE $0x09       // leal         $9(%rax), %ecx
+	WORD $0xd349; BYTE $0xeb       // shrq         %cl, %r11
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0x0018850f; WORD $0x0000 // jne          LBB12_17, $24(%rip)
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x000f850f; WORD $0x0000 // jne          LBB12_17, $15(%rip)
+	WORD $0x8944; BYTE $0xd9       // movl         %r11d, %ecx
+	WORD $0xe183; BYTE $0x03       // andl         $3, %ecx
+	WORD $0xf983; BYTE $0x01       // cmpl         $1, %ecx
+	LONG $0x0044840f; WORD $0x0000 // je           LBB12_1, $68(%rip)
+
+LBB12_17:
+	LONG $0x526ace69; WORD $0x0003             // imull        $217706, %esi, %ecx
+	WORD $0xf9c1; BYTE $0x10                   // sarl         $16, %ecx
+	LONG $0x043fc181; WORD $0x0000             // addl         $1087, %ecx
+	WORD $0x6348; BYTE $0xf1                   // movslq       %ecx, %rsi
+	WORD $0x294c; BYTE $0xd6                   // subq         %r10, %rsi
+	WORD $0x8944; BYTE $0xda                   // movl         %r11d, %edx
+	WORD $0xe283; BYTE $0x01                   // andl         $1, %edx
+	WORD $0x014c; BYTE $0xda                   // addq         %r11, %rdx
+	WORD $0x8948; BYTE $0xd1                   // movq         %rdx, %rcx
+	LONG $0x36e9c148                           // shrq         $54, %rcx
+	WORD $0x0148; BYTE $0xf0                   // addq         %rsi, %rax
+	LONG $0x01f98348                           // cmpq         $1, %rcx
+	LONG $0x00d88348                           // sbbq         $0, %rax
+	LONG $0x01b08d48; WORD $0xfff8; BYTE $0xff // leaq         $-2047(%rax), %rsi
+	LONG $0x02fe8148; WORD $0xfff8; BYTE $0xff // cmpq         $-2046, %rsi
+	LONG $0x000b830f; WORD $0x0000             // jae          LBB12_19, $11(%rip)
+
+LBB12_1:
+	WORD $0xc031 // xorl         %eax, %eax
+
+LBB12_20:
+	BYTE $0x5b   // popq         %rbx
+	WORD $0x5c41 // popq         %r12
+	WORD $0x5e41 // popq         %r14
+	WORD $0x5f41 // popq         %r15
+	BYTE $0x5d   // popq         %rbp
+	BYTE $0xc3   // retq
+
+LBB12_19:
+	LONG $0x01f98348                       // cmpq         $1, %rcx
+	WORD $0x02b1                           // movb         $2, %cl
+	WORD $0xd980; BYTE $0x00               // sbbb         $0, %cl
+	WORD $0xd348; BYTE $0xea               // shrq         %cl, %rdx
+	LONG $0x34e0c148                       // shlq         $52, %rax
+	QUAD $0xffffffffffffb948; WORD $0x000f // movabsq      $4503599627370495, %rcx
+	WORD $0x2148; BYTE $0xd1               // andq         %rdx, %rcx
+	WORD $0x0948; BYTE $0xc1               // orq          %rax, %rcx
+	QUAD $0x000000000000b848; WORD $0x8000 // movabsq      $-9223372036854775808, %rax
+	WORD $0x0948; BYTE $0xc8               // orq          %rcx, %rax
+	LONG $0xfff98341                       // cmpl         $-1, %r9d
+	LONG $0xc1450f48                       // cmovneq      %rcx, %rax
+	WORD $0x8949; BYTE $0x00               // movq         %rax, (%r8)
+	WORD $0x01b0                           // movb         $1, %al
+	LONG $0xffffb8e9; BYTE $0xff           // jmp          LBB12_20, $-72(%rip)
+	QUAD $0x0000000000000000               // .p2align 5, 0x00
+
+LCPI13_0:
+	QUAD $0x0000000000000000 // .space 8, '\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000001 // .quad 1
+	QUAD $0x0000000000000001 // .quad 1
+	QUAD $0x0000000000000001 // .quad 1
+
+	// .p2align 3, 0x00
+LCPI13_1:
+	QUAD $0x0000000000000001 // .quad 1
+
+LCPI13_2:
+	QUAD $0x0000000000002710 // .quad 10000
+
+LCPI13_3:
+	QUAD $0x000000000000000a // .quad 10
+	QUAD $0x9090909090909090 // .p2align 4, 0x90
+
+_decimal_to_f64:
+	BYTE $0x55                             // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5               // movq         %rsp, %rbp
+	WORD $0x5741                           // pushq        %r15
+	WORD $0x5641                           // pushq        %r14
+	WORD $0x5541                           // pushq        %r13
+	WORD $0x5441                           // pushq        %r12
+	BYTE $0x53                             // pushq        %rbx
+	BYTE $0x50                             // pushq        %rax
+	WORD $0x8948; BYTE $0xf3               // movq         %rsi, %rbx
+	WORD $0x8949; BYTE $0xff               // movq         %rdi, %r15
+	QUAD $0x000000000000bd49; WORD $0x0010 // movabsq      $4503599627370496, %r13
+	LONG $0x00107f83                       // cmpl         $0, $16(%rdi)
+	LONG $0x0021840f; WORD $0x0000         // je           LBB13_3, $33(%rip)
+	LONG $0x14478b41                       // movl         $20(%r15), %eax
+	LONG $0x0001363d; BYTE $0x00           // cmpl         $310, %eax
+	LONG $0x001d8e0f; WORD $0x0000         // jle          LBB13_4, $29(%rip)
+
+LBB13_2:
+	WORD $0x3145; BYTE $0xe4               // xorl         %r12d, %r12d
+	QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq      $9218868437227405312, %r14
+	LONG $0x000566e9; BYTE $0x00           // jmp          LBB13_74, $1382(%rip)
+
+LBB13_3:
+	WORD $0x3145; BYTE $0xf6     // xorl         %r14d, %r14d
+	WORD $0x3145; BYTE $0xe4     // xorl         %r12d, %r12d
+	LONG $0x00055be9; BYTE $0x00 // jmp          LBB13_74, $1371(%rip)
+
+LBB13_4:
+	WORD $0x3145; BYTE $0xe4       // xorl         %r12d, %r12d
+	LONG $0xfffeb63d; BYTE $0xff   // cmpl         $-330, %eax
+	LONG $0x00088d0f; WORD $0x0000 // jge          LBB13_6, $8(%rip)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	LONG $0x000545e9; BYTE $0x00   // jmp          LBB13_74, $1349(%rip)
+
+LBB13_6:
+	WORD $0xc085                                       // testl        %eax, %eax
+	LONG $0xd05d8948                                   // movq         %rbx, $-48(%rbp)
+	LONG $0x00aa8e0f; WORD $0x0000                     // jle          LBB13_17, $170(%rip)
+	WORD $0x3145; BYTE $0xe4                           // xorl         %r12d, %r12d
+	LONG $0xd0358d4c; WORD $0x0096; BYTE $0x00         // leaq         $38608(%rip), %r14  /* _POW_TAB(%rip) */
+	LONG $0x000039e9; BYTE $0x00                       // jmp          LBB13_11, $57(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB13_8:
+	LONG $0xffffe5be; BYTE $0xff   // movl         $-27, %esi
+	LONG $0x00001bbb; BYTE $0x00   // movl         $27, %ebx
+	LONG $0x107f8341; BYTE $0x00   // cmpl         $0, $16(%r15)
+	LONG $0x000a840f; WORD $0x0000 // je           LBB13_10, $10(%rip)
+
+LBB13_9:
+	WORD $0xdef7                 // negl         %esi
+	WORD $0x894c; BYTE $0xff     // movq         %r15, %rdi
+	LONG $0x006301e8; BYTE $0x00 // callq        _right_shift, $25345(%rip)
+
+LBB13_10:
+	WORD $0x0141; BYTE $0xdc       // addl         %ebx, %r12d
+	LONG $0x14478b41               // movl         $20(%r15), %eax
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x00628e0f; WORD $0x0000 // jle          LBB13_17, $98(%rip)
+
+LBB13_11:
+	WORD $0xf883; BYTE $0x08       // cmpl         $8, %eax
+	LONG $0xffc9870f; WORD $0xffff // ja           LBB13_8, $-55(%rip)
+	WORD $0xc089                   // movl         %eax, %eax
+	LONG $0x861c8b41               // movl         (%r14,%rax,4), %ebx
+	LONG $0x107f8341; BYTE $0x00   // cmpl         $0, $16(%r15)
+	LONG $0xffd7840f; WORD $0xffff // je           LBB13_10, $-41(%rip)
+	WORD $0xde89                   // movl         %ebx, %esi
+	WORD $0xdef7                   // negl         %esi
+	WORD $0xfe83; BYTE $0xc3       // cmpl         $-61, %esi
+	LONG $0xffc0870f; WORD $0xffff // ja           LBB13_9, $-64(%rip)
+	WORD $0x894d; BYTE $0xf5       // movq         %r14, %r13
+	QUAD $0x9090909090909090       // .p2align 4, 0x90
+
+LBB13_15:
+	WORD $0x8941; BYTE $0xf6               // movl         %esi, %r14d
+	WORD $0x894c; BYTE $0xff               // movq         %r15, %rdi
+	LONG $0x00003cbe; BYTE $0x00           // movl         $60, %esi
+	LONG $0x0062b0e8; BYTE $0x00           // callq        _right_shift, $25264(%rip)
+	LONG $0x3c768d41                       // leal         $60(%r14), %esi
+	LONG $0x88fe8341                       // cmpl         $-120, %r14d
+	LONG $0xffe2820f; WORD $0xffff         // jb           LBB13_15, $-30(%rip)
+	WORD $0x894d; BYTE $0xee               // movq         %r13, %r14
+	QUAD $0x000000000000bd49; WORD $0x0010 // movabsq      $4503599627370496, %r13
+	LONG $0xffff85e9; BYTE $0xff           // jmp          LBB13_9, $-123(%rip)
+
+LBB13_17:
+	LONG $0x29358d4c; WORD $0x0096; BYTE $0x00 // leaq         $38441(%rip), %r14  /* _POW_TAB(%rip) */
+	LONG $0x000025e9; BYTE $0x00               // jmp          LBB13_19, $37(%rip)
+
+LBB13_23:
+	LONG $0x00001bbb; BYTE $0x00   // movl         $27, %ebx
+	LONG $0x107f8341; BYTE $0x00   // cmpl         $0, $16(%r15)
+	LONG $0x0012840f; WORD $0x0000 // je           LBB13_18, $18(%rip)
+	LONG $0x90909090               // .p2align 4, 0x90
+
+LBB13_25:
+	WORD $0x894c; BYTE $0xff     // movq         %r15, %rdi
+	WORD $0xde89                 // movl         %ebx, %esi
+	LONG $0x006076e8; BYTE $0x00 // callq        _left_shift, $24694(%rip)
+	LONG $0x14478b41             // movl         $20(%r15), %eax
+
+LBB13_18:
+	WORD $0x2941; BYTE $0xdc // subl         %ebx, %r12d
+
+LBB13_19:
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x0017880f; WORD $0x0000 // js           LBB13_22, $23(%rip)
+	LONG $0x0032850f; WORD $0x0000 // jne          LBB13_26, $50(%rip)
+	WORD $0x8b49; BYTE $0x0f       // movq         (%r15), %rcx
+	WORD $0x3980; BYTE $0x35       // cmpb         $53, (%rcx)
+	LONG $0x000e8c0f; WORD $0x0000 // jl           LBB13_24, $14(%rip)
+	LONG $0x000021e9; BYTE $0x00   // jmp          LBB13_26, $33(%rip)
+
+	// .p2align 4, 0x90
+LBB13_22:
+	WORD $0xf883; BYTE $0xf8       // cmpl         $-8, %eax
+	LONG $0xffb3820f; WORD $0xffff // jb           LBB13_23, $-77(%rip)
+
+LBB13_24:
+	WORD $0xc189                   // movl         %eax, %ecx
+	WORD $0xd9f7                   // negl         %ecx
+	LONG $0x8e1c8b41               // movl         (%r14,%rcx,4), %ebx
+	LONG $0x107f8341; BYTE $0x00   // cmpl         $0, $16(%r15)
+	LONG $0xffb4850f; WORD $0xffff // jne          LBB13_25, $-76(%rip)
+	LONG $0xffffbde9; BYTE $0xff   // jmp          LBB13_18, $-67(%rip)
+
+LBB13_26:
+	LONG $0x02fc8141; WORD $0xfffc; BYTE $0xff                           // cmpl         $-1022, %r12d
+	LONG $0x00568f0f; WORD $0x0000                                       // jg           LBB13_32, $86(%rip)
+	LONG $0x107f8341; BYTE $0x00                                         // cmpl         $0, $16(%r15)
+	LONG $0xd05d8b48                                                     // movq         $-48(%rbp), %rbx
+	LONG $0x0075840f; WORD $0x0000                                       // je           LBB13_35, $117(%rip)
+	LONG $0xc6fc8141; WORD $0xfffb; BYTE $0xff                           // cmpl         $-1082, %r12d
+	LONG $0x0073870f; WORD $0x0000                                       // ja           LBB13_36, $115(%rip)
+	LONG $0xc1c48141; WORD $0x0003; BYTE $0x00                           // addl         $961, %r12d
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB13_30:
+	WORD $0x894c; BYTE $0xff       // movq         %r15, %rdi
+	LONG $0x00003cbe; BYTE $0x00   // movl         $60, %esi
+	LONG $0x0061d3e8; BYTE $0x00   // callq        _right_shift, $25043(%rip)
+	LONG $0x3cc48341               // addl         $60, %r12d
+	LONG $0x88fc8341               // cmpl         $-120, %r12d
+	LONG $0xffe5820f; WORD $0xffff // jb           LBB13_30, $-27(%rip)
+	LONG $0x3cc48341               // addl         $60, %r12d
+	LONG $0x000040e9; BYTE $0x00   // jmp          LBB13_37, $64(%rip)
+
+LBB13_32:
+	LONG $0x00fc8141; WORD $0x0004; BYTE $0x00 // cmpl         $1024, %r12d
+	LONG $0xd05d8b48                           // movq         $-48(%rbp), %rbx
+	QUAD $0x000000000000be49; WORD $0x7ff0     // movabsq      $9218868437227405312, %r14
+	LONG $0x00088e0f; WORD $0x0000             // jle          LBB13_34, $8(%rip)
+	WORD $0x3145; BYTE $0xe4                   // xorl         %r12d, %r12d
+	LONG $0x000398e9; BYTE $0x00               // jmp          LBB13_74, $920(%rip)
+
+LBB13_34:
+	WORD $0xff41; BYTE $0xcc     // decl         %r12d
+	WORD $0x8945; BYTE $0xe6     // movl         %r12d, %r14d
+	LONG $0x000026e9; BYTE $0x00 // jmp          LBB13_38, $38(%rip)
+
+LBB13_35:
+	LONG $0xfc02be41; WORD $0xffff // movl         $-1022, %r14d
+	LONG $0x000033e9; BYTE $0x00   // jmp          LBB13_40, $51(%rip)
+
+LBB13_36:
+	LONG $0xfdc48141; WORD $0x0003; BYTE $0x00 // addl         $1021, %r12d
+
+LBB13_37:
+	WORD $0xf741; BYTE $0xdc       // negl         %r12d
+	WORD $0x894c; BYTE $0xff       // movq         %r15, %rdi
+	WORD $0x8944; BYTE $0xe6       // movl         %r12d, %esi
+	LONG $0x00616ee8; BYTE $0x00   // callq        _right_shift, $24942(%rip)
+	LONG $0xfc02be41; WORD $0xffff // movl         $-1022, %r14d
+
+LBB13_38:
+	LONG $0x107f8341; BYTE $0x00   // cmpl         $0, $16(%r15)
+	LONG $0x000d840f; WORD $0x0000 // je           LBB13_40, $13(%rip)
+	WORD $0x894c; BYTE $0xff       // movq         %r15, %rdi
+	LONG $0x000035be; BYTE $0x00   // movl         $53, %esi
+	LONG $0x005f60e8; BYTE $0x00   // callq        _left_shift, $24416(%rip)
+
+LBB13_40:
+	LONG $0x14478b41                           // movl         $20(%r15), %eax
+	LONG $0xffc4c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r12
+	WORD $0xf883; BYTE $0x14                   // cmpl         $20, %eax
+	LONG $0x031c8f0f; WORD $0x0000             // jg           LBB13_73, $796(%rip)
+	WORD $0xc085                               // testl        %eax, %eax
+	LONG $0x00558e0f; WORD $0x0000             // jle          LBB13_46, $85(%rip)
+	LONG $0x10578b41                           // movl         $16(%r15), %edx
+	WORD $0xf631                               // xorl         %esi, %esi
+	WORD $0xd285                               // testl        %edx, %edx
+	WORD $0x4e0f; BYTE $0xd6                   // cmovlel      %esi, %edx
+	LONG $0xff488d4c                           // leaq         $-1(%rax), %r9
+	WORD $0x3949; BYTE $0xd1                   // cmpq         %rdx, %r9
+	LONG $0xca430f4c                           // cmovaeq      %rdx, %r9
+	LONG $0x01418d4d                           // leaq         $1(%r9), %r8
+	WORD $0x3145; BYTE $0xe4                   // xorl         %r12d, %r12d
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB13_43:
+	WORD $0x3948; BYTE $0xf2       // cmpq         %rsi, %rdx
+	LONG $0x002e840f; WORD $0x0000 // je           LBB13_47, $46(%rip)
+	LONG $0xa43c8d4b               // leaq         (%r12,%r12,4), %rdi
+	WORD $0x8b49; BYTE $0x0f       // movq         (%r15), %rcx
+	LONG $0x0cbe0f48; BYTE $0x31   // movsbq       (%rcx,%rsi), %rcx
+	LONG $0x79248d4c               // leaq         (%rcx,%rdi,2), %r12
+	LONG $0xd0c48349               // addq         $-48, %r12
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0xffd7850f; WORD $0xffff // jne          LBB13_43, $-41(%rip)
+	WORD $0x894d; BYTE $0xc1       // movq         %r8, %r9
+	LONG $0x000006e9; BYTE $0x00   // jmp          LBB13_47, $6(%rip)
+
+LBB13_46:
+	WORD $0x3145; BYTE $0xc9 // xorl         %r9d, %r9d
+	WORD $0x3145; BYTE $0xe4 // xorl         %r12d, %r12d
+
+LBB13_47:
+	WORD $0x3944; BYTE $0xc8               // cmpl         %r9d, %eax
+	LONG $0x022f8e0f; WORD $0x0000         // jle          LBB13_60, $559(%rip)
+	WORD $0xc289                           // movl         %eax, %edx
+	WORD $0x2944; BYTE $0xca               // subl         %r9d, %edx
+	WORD $0xfa83; BYTE $0x10               // cmpl         $16, %edx
+	LONG $0x020d820f; WORD $0x0000         // jb           LBB13_58, $525(%rip)
+	WORD $0x8941; BYTE $0xd0               // movl         %edx, %r8d
+	LONG $0x6ef9c1c4; BYTE $0xc4           // vmovq        %r12, %xmm0
+	QUAD $0xfffcc005027de3c4; WORD $0xfcff // vpblendd     $252, $-832(%rip), %ymm0, %ymm0  /* LCPI13_0(%rip) */
+	LONG $0xf0e08341                       // andl         $-16, %r8d
+	LONG $0xf0488d41                       // leal         $-16(%r8), %ecx
+	WORD $0xcf89                           // movl         %ecx, %edi
+	WORD $0xefc1; BYTE $0x04               // shrl         $4, %edi
+	WORD $0xc7ff                           // incl         %edi
+	WORD $0xfe89                           // movl         %edi, %esi
+	WORD $0xe683; BYTE $0x03               // andl         $3, %esi
+	WORD $0xf983; BYTE $0x30               // cmpl         $48, %ecx
+	LONG $0x0016830f; WORD $0x0000         // jae          LBB13_51, $22(%rip)
+	QUAD $0xfffcba15597de2c4; BYTE $0xff   // vpbroadcastq $-838(%rip), %ymm2  /* LCPI13_1(%rip) */
+	LONG $0xda6ffdc5                       // vmovdqa      %ymm2, %ymm3
+	LONG $0xca6ffdc5                       // vmovdqa      %ymm2, %ymm1
+	LONG $0x00007ee9; BYTE $0x00           // jmp          LBB13_53, $126(%rip)
+
+LBB13_51:
+	WORD $0xe783; BYTE $0xfc             // andl         $-4, %edi
+	QUAD $0xfffca115597de2c4; BYTE $0xff // vpbroadcastq $-863(%rip), %ymm2  /* LCPI13_1(%rip) */
+	QUAD $0xfffca025597de2c4; BYTE $0xff // vpbroadcastq $-864(%rip), %ymm4  /* LCPI13_2(%rip) */
+	LONG $0xda6ffdc5                     // vmovdqa      %ymm2, %ymm3
+	LONG $0xca6ffdc5                     // vmovdqa      %ymm2, %ymm1
+
+	// .p2align 4, 0x90
+LBB13_52:
+	LONG $0xecf4fdc5               // vpmuludq     %ymm4, %ymm0, %ymm5
+	LONG $0xd073fdc5; BYTE $0x20   // vpsrlq       $32, %ymm0, %ymm0
+	LONG $0xc4f4fdc5               // vpmuludq     %ymm4, %ymm0, %ymm0
+	LONG $0xf073fdc5; BYTE $0x20   // vpsllq       $32, %ymm0, %ymm0
+	LONG $0xc0d4d5c5               // vpaddq       %ymm0, %ymm5, %ymm0
+	LONG $0xecf4edc5               // vpmuludq     %ymm4, %ymm2, %ymm5
+	LONG $0xd273edc5; BYTE $0x20   // vpsrlq       $32, %ymm2, %ymm2
+	LONG $0xd4f4edc5               // vpmuludq     %ymm4, %ymm2, %ymm2
+	LONG $0xf273edc5; BYTE $0x20   // vpsllq       $32, %ymm2, %ymm2
+	LONG $0xd2d4d5c5               // vpaddq       %ymm2, %ymm5, %ymm2
+	LONG $0xecf4e5c5               // vpmuludq     %ymm4, %ymm3, %ymm5
+	LONG $0xd373e5c5; BYTE $0x20   // vpsrlq       $32, %ymm3, %ymm3
+	LONG $0xdcf4e5c5               // vpmuludq     %ymm4, %ymm3, %ymm3
+	LONG $0xf373e5c5; BYTE $0x20   // vpsllq       $32, %ymm3, %ymm3
+	LONG $0xdbd4d5c5               // vpaddq       %ymm3, %ymm5, %ymm3
+	LONG $0xecf4f5c5               // vpmuludq     %ymm4, %ymm1, %ymm5
+	LONG $0xd173f5c5; BYTE $0x20   // vpsrlq       $32, %ymm1, %ymm1
+	LONG $0xccf4f5c5               // vpmuludq     %ymm4, %ymm1, %ymm1
+	LONG $0xf173f5c5; BYTE $0x20   // vpsllq       $32, %ymm1, %ymm1
+	LONG $0xc9d4d5c5               // vpaddq       %ymm1, %ymm5, %ymm1
+	WORD $0xc783; BYTE $0xfc       // addl         $-4, %edi
+	LONG $0xff9f850f; WORD $0xffff // jne          LBB13_52, $-97(%rip)
+
+LBB13_53:
+	WORD $0xf685                                             // testl        %esi, %esi
+	LONG $0x0077840f; WORD $0x0000                           // je           LBB13_56, $119(%rip)
+	QUAD $0xfffc2e25597de2c4; BYTE $0xff                     // vpbroadcastq $-978(%rip), %ymm4  /* LCPI13_3(%rip) */
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB13_55:
+	LONG $0xecf4fdc5               // vpmuludq     %ymm4, %ymm0, %ymm5
+	LONG $0xd073fdc5; BYTE $0x20   // vpsrlq       $32, %ymm0, %ymm0
+	LONG $0xc4f4fdc5               // vpmuludq     %ymm4, %ymm0, %ymm0
+	LONG $0xf073fdc5; BYTE $0x20   // vpsllq       $32, %ymm0, %ymm0
+	LONG $0xc0d4d5c5               // vpaddq       %ymm0, %ymm5, %ymm0
+	LONG $0xecf4edc5               // vpmuludq     %ymm4, %ymm2, %ymm5
+	LONG $0xd273edc5; BYTE $0x20   // vpsrlq       $32, %ymm2, %ymm2
+	LONG $0xd4f4edc5               // vpmuludq     %ymm4, %ymm2, %ymm2
+	LONG $0xf273edc5; BYTE $0x20   // vpsllq       $32, %ymm2, %ymm2
+	LONG $0xd2d4d5c5               // vpaddq       %ymm2, %ymm5, %ymm2
+	LONG $0xecf4e5c5               // vpmuludq     %ymm4, %ymm3, %ymm5
+	LONG $0xd373e5c5; BYTE $0x20   // vpsrlq       $32, %ymm3, %ymm3
+	LONG $0xdcf4e5c5               // vpmuludq     %ymm4, %ymm3, %ymm3
+	LONG $0xf373e5c5; BYTE $0x20   // vpsllq       $32, %ymm3, %ymm3
+	LONG $0xdbd4d5c5               // vpaddq       %ymm3, %ymm5, %ymm3
+	LONG $0xecf4f5c5               // vpmuludq     %ymm4, %ymm1, %ymm5
+	LONG $0xd173f5c5; BYTE $0x20   // vpsrlq       $32, %ymm1, %ymm1
+	LONG $0xccf4f5c5               // vpmuludq     %ymm4, %ymm1, %ymm1
+	LONG $0xf173f5c5; BYTE $0x20   // vpsllq       $32, %ymm1, %ymm1
+	LONG $0xc9d4d5c5               // vpaddq       %ymm1, %ymm5, %ymm1
+	WORD $0xceff                   // decl         %esi
+	LONG $0xffa0850f; WORD $0xffff // jne          LBB13_55, $-96(%rip)
+
+LBB13_56:
+	LONG $0xd273ddc5; BYTE $0x20   // vpsrlq       $32, %ymm2, %ymm4
+	LONG $0xe0f4ddc5               // vpmuludq     %ymm0, %ymm4, %ymm4
+	LONG $0xd073d5c5; BYTE $0x20   // vpsrlq       $32, %ymm0, %ymm5
+	LONG $0xedf4edc5               // vpmuludq     %ymm5, %ymm2, %ymm5
+	LONG $0xe4d4d5c5               // vpaddq       %ymm4, %ymm5, %ymm4
+	LONG $0xf473ddc5; BYTE $0x20   // vpsllq       $32, %ymm4, %ymm4
+	LONG $0xc0f4edc5               // vpmuludq     %ymm0, %ymm2, %ymm0
+	LONG $0xc4d4fdc5               // vpaddq       %ymm4, %ymm0, %ymm0
+	LONG $0xd373edc5; BYTE $0x20   // vpsrlq       $32, %ymm3, %ymm2
+	LONG $0xd0f4edc5               // vpmuludq     %ymm0, %ymm2, %ymm2
+	LONG $0xd073ddc5; BYTE $0x20   // vpsrlq       $32, %ymm0, %ymm4
+	LONG $0xe4f4e5c5               // vpmuludq     %ymm4, %ymm3, %ymm4
+	LONG $0xd2d4ddc5               // vpaddq       %ymm2, %ymm4, %ymm2
+	LONG $0xf273edc5; BYTE $0x20   // vpsllq       $32, %ymm2, %ymm2
+	LONG $0xc0f4e5c5               // vpmuludq     %ymm0, %ymm3, %ymm0
+	LONG $0xc2d4fdc5               // vpaddq       %ymm2, %ymm0, %ymm0
+	LONG $0xd173edc5; BYTE $0x20   // vpsrlq       $32, %ymm1, %ymm2
+	LONG $0xd0f4edc5               // vpmuludq     %ymm0, %ymm2, %ymm2
+	LONG $0xd073e5c5; BYTE $0x20   // vpsrlq       $32, %ymm0, %ymm3
+	LONG $0xdbf4f5c5               // vpmuludq     %ymm3, %ymm1, %ymm3
+	LONG $0xd2d4e5c5               // vpaddq       %ymm2, %ymm3, %ymm2
+	LONG $0xf273edc5; BYTE $0x20   // vpsllq       $32, %ymm2, %ymm2
+	LONG $0xc0f4f5c5               // vpmuludq     %ymm0, %ymm1, %ymm0
+	LONG $0xc2d4fdc5               // vpaddq       %ymm2, %ymm0, %ymm0
+	LONG $0x397de3c4; WORD $0x01c1 // vextracti128 $1, %ymm0, %xmm1
+	LONG $0xd073e9c5; BYTE $0x20   // vpsrlq       $32, %xmm0, %xmm2
+	LONG $0xd1f4e9c5               // vpmuludq     %xmm1, %xmm2, %xmm2
+	LONG $0xd173e1c5; BYTE $0x20   // vpsrlq       $32, %xmm1, %xmm3
+	LONG $0xdbf4f9c5               // vpmuludq     %xmm3, %xmm0, %xmm3
+	LONG $0xd2d4e1c5               // vpaddq       %xmm2, %xmm3, %xmm2
+	LONG $0xf273e9c5; BYTE $0x20   // vpsllq       $32, %xmm2, %xmm2
+	LONG $0xc1f4f9c5               // vpmuludq     %xmm1, %xmm0, %xmm0
+	LONG $0xc2d4f9c5               // vpaddq       %xmm2, %xmm0, %xmm0
+	LONG $0xc870f9c5; BYTE $0xee   // vpshufd      $238, %xmm0, %xmm1
+	LONG $0xd073e9c5; BYTE $0x20   // vpsrlq       $32, %xmm0, %xmm2
+	LONG $0xd1f4e9c5               // vpmuludq     %xmm1, %xmm2, %xmm2
+	LONG $0xd870f9c5; BYTE $0xff   // vpshufd      $255, %xmm0, %xmm3
+	LONG $0xdbf4f9c5               // vpmuludq     %xmm3, %xmm0, %xmm3
+	LONG $0xd2d4e1c5               // vpaddq       %xmm2, %xmm3, %xmm2
+	LONG $0xf273e9c5; BYTE $0x20   // vpsllq       $32, %xmm2, %xmm2
+	LONG $0xc1f4f9c5               // vpmuludq     %xmm1, %xmm0, %xmm0
+	LONG $0xc2d4f9c5               // vpaddq       %xmm2, %xmm0, %xmm0
+	LONG $0x7ef9c1c4; BYTE $0xc4   // vmovq        %xmm0, %r12
+	WORD $0x3944; BYTE $0xc2       // cmpl         %r8d, %edx
+	LONG $0x0017840f; WORD $0x0000 // je           LBB13_60, $23(%rip)
+	WORD $0x0145; BYTE $0xc1       // addl         %r8d, %r9d
+
+LBB13_58:
+	WORD $0xc289             // movl         %eax, %edx
+	WORD $0x2944; BYTE $0xca // subl         %r9d, %edx
+
+	// .p2align 4, 0x90
+LBB13_59:
+	WORD $0x014d; BYTE $0xe4       // addq         %r12, %r12
+	LONG $0xa4248d4f               // leaq         (%r12,%r12,4), %r12
+	WORD $0xcaff                   // decl         %edx
+	LONG $0xfff1850f; WORD $0xffff // jne          LBB13_59, $-15(%rip)
+
+LBB13_60:
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x004b880f; WORD $0x0000 // js           LBB13_67, $75(%rip)
+	LONG $0x10578b41               // movl         $16(%r15), %edx
+	WORD $0xc239                   // cmpl         %eax, %edx
+	LONG $0x003f8e0f; WORD $0x0000 // jle          LBB13_67, $63(%rip)
+	WORD $0x8b49; BYTE $0x37       // movq         (%r15), %rsi
+	LONG $0x060cb60f               // movzbl       (%rsi,%rax), %ecx
+	WORD $0xf980; BYTE $0x35       // cmpb         $53, %cl
+	LONG $0x00b2850f; WORD $0x0000 // jne          LBB13_69, $178(%rip)
+	WORD $0x788d; BYTE $0x01       // leal         $1(%rax), %edi
+	WORD $0xd739                   // cmpl         %edx, %edi
+	LONG $0x00a7850f; WORD $0x0000 // jne          LBB13_69, $167(%rip)
+	WORD $0x01b2                   // movb         $1, %dl
+	LONG $0x1c7f8341; BYTE $0x00   // cmpl         $0, $28(%r15)
+	LONG $0x0019850f; WORD $0x0000 // jne          LBB13_70, $25(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x000e840f; WORD $0x0000 // je           LBB13_67, $14(%rip)
+	WORD $0xc8ff                   // decl         %eax
+	LONG $0x0614b60f               // movzbl       (%rsi,%rax), %edx
+	WORD $0xe280; BYTE $0x01       // andb         $1, %dl
+	LONG $0x000002e9; BYTE $0x00   // jmp          LBB13_70, $2(%rip)
+
+LBB13_67:
+	WORD $0xd231 // xorl         %edx, %edx
+
+LBB13_70:
+	WORD $0xb60f; BYTE $0xc2                   // movzbl       %dl, %eax
+	WORD $0x0149; BYTE $0xc4                   // addq         %rax, %r12
+	QUAD $0x000000000000b848; WORD $0x0020     // movabsq      $9007199254740992, %rax
+	WORD $0x3949; BYTE $0xc4                   // cmpq         %rax, %r12
+	LONG $0x0013850f; WORD $0x0000             // jne          LBB13_73, $19(%rip)
+	LONG $0xfefe8141; WORD $0x0003; BYTE $0x00 // cmpl         $1022, %r14d
+	LONG $0xfaad8f0f; WORD $0xffff             // jg           LBB13_2, $-1363(%rip)
+	WORD $0xff41; BYTE $0xc6                   // incl         %r14d
+	WORD $0x894d; BYTE $0xec                   // movq         %r13, %r12
+
+LBB13_73:
+	WORD $0x894c; BYTE $0xe0                   // movq         %r12, %rax
+	WORD $0x214c; BYTE $0xe8                   // andq         %r13, %rax
+	LONG $0xffc68141; WORD $0x0003; BYTE $0x00 // addl         $1023, %r14d
+	LONG $0xffe68141; WORD $0x0007; BYTE $0x00 // andl         $2047, %r14d
+	LONG $0x34e6c149                           // shlq         $52, %r14
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0xf0440f4c                           // cmoveq       %rax, %r14
+
+LBB13_74:
+	WORD $0xff49; BYTE $0xcd               // decq         %r13
+	WORD $0x214d; BYTE $0xe5               // andq         %r12, %r13
+	WORD $0x094d; BYTE $0xf5               // orq          %r14, %r13
+	QUAD $0x000000000000b848; WORD $0x8000 // movabsq      $-9223372036854775808, %rax
+	WORD $0x094c; BYTE $0xe8               // orq          %r13, %rax
+	LONG $0x187f8341; BYTE $0x00           // cmpl         $0, $24(%r15)
+	LONG $0xc5440f49                       // cmoveq       %r13, %rax
+	WORD $0x8948; BYTE $0x03               // movq         %rax, (%rbx)
+	WORD $0xc031                           // xorl         %eax, %eax
+	LONG $0x08c48348                       // addq         $8, %rsp
+	BYTE $0x5b                             // popq         %rbx
+	WORD $0x5c41                           // popq         %r12
+	WORD $0x5d41                           // popq         %r13
+	WORD $0x5e41                           // popq         %r14
+	WORD $0x5f41                           // popq         %r15
+	BYTE $0x5d                             // popq         %rbp
+	WORD $0xf8c5; BYTE $0x77               // vzeroupper
+	BYTE $0xc3                             // retq
+
+LBB13_69:
+	WORD $0xf980; BYTE $0x35     // cmpb         $53, %cl
+	WORD $0x9d0f; BYTE $0xc2     // setge        %dl
+	LONG $0xffff74e9; BYTE $0xff // jmp          LBB13_70, $-140(%rip)
+
+	// .p2align 4, 0x90
+_atof_native:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5741                   // pushq        %r15
+	WORD $0x5641                   // pushq        %r14
+	WORD $0x5541                   // pushq        %r13
+	WORD $0x5441                   // pushq        %r12
+	BYTE $0x53                     // pushq        %rbx
+	LONG $0x28ec8348               // subq         $40, %rsp
+	QUAD $0x00000000d045c748       // movq         $0, $-48(%rbp)
+	LONG $0xb0558948               // movq         %rdx, $-80(%rbp)
+	LONG $0xb84d8948               // movq         %rcx, $-72(%rbp)
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x0197840f; WORD $0x0000 // je           LBB14_18, $407(%rip)
+	LONG $0x10f98348               // cmpq         $16, %rcx
+	LONG $0x0008830f; WORD $0x0000 // jae          LBB14_3, $8(%rip)
+	WORD $0x3145; BYTE $0xd2       // xorl         %r10d, %r10d
+	LONG $0x000174e9; BYTE $0x00   // jmp          LBB14_17, $372(%rip)
+
+LBB14_3:
+	LONG $0x80f98148; WORD $0x0000; BYTE $0x00 // cmpq         $128, %rcx
+	LONG $0x0008830f; WORD $0x0000             // jae          LBB14_5, $8(%rip)
+	WORD $0x3145; BYTE $0xd2                   // xorl         %r10d, %r10d
+	LONG $0x000129e9; BYTE $0x00               // jmp          LBB14_14, $297(%rip)
+
+LBB14_5:
+	WORD $0x8949; BYTE $0xca       // movq         %rcx, %r10
+	LONG $0x80e28349               // andq         $-128, %r10
+	LONG $0x80428d49               // leaq         $-128(%r10), %rax
+	WORD $0x8949; BYTE $0xc1       // movq         %rax, %r9
+	LONG $0x07e9c149               // shrq         $7, %r9
+	WORD $0xff49; BYTE $0xc1       // incq         %r9
+	WORD $0x8945; BYTE $0xc8       // movl         %r9d, %r8d
+	LONG $0x03e08341               // andl         $3, %r8d
+	LONG $0x01803d48; WORD $0x0000 // cmpq         $384, %rax
+	LONG $0x0007830f; WORD $0x0000 // jae          LBB14_7, $7(%rip)
+	WORD $0xdb31                   // xorl         %ebx, %ebx
+	LONG $0x0000a4e9; BYTE $0x00   // jmp          LBB14_9, $164(%rip)
+
+LBB14_7:
+	LONG $0xfce18349               // andq         $-4, %r9
+	WORD $0xdb31                   // xorl         %ebx, %ebx
+	LONG $0xc057f8c5               // vxorps       %xmm0, %xmm0, %xmm0
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB14_8:
+	LONG $0x0411fcc5; BYTE $0x1a               // vmovups      %ymm0, (%rdx,%rbx)
+	LONG $0x4411fcc5; WORD $0x201a             // vmovups      %ymm0, $32(%rdx,%rbx)
+	LONG $0x4411fcc5; WORD $0x401a             // vmovups      %ymm0, $64(%rdx,%rbx)
+	LONG $0x4411fcc5; WORD $0x601a             // vmovups      %ymm0, $96(%rdx,%rbx)
+	QUAD $0x0000801a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $128(%rdx,%rbx)
+	QUAD $0x0000a01a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $160(%rdx,%rbx)
+	QUAD $0x0000c01a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $192(%rdx,%rbx)
+	QUAD $0x0000e01a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $224(%rdx,%rbx)
+	QUAD $0x0001001a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $256(%rdx,%rbx)
+	QUAD $0x0001201a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $288(%rdx,%rbx)
+	QUAD $0x0001401a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $320(%rdx,%rbx)
+	QUAD $0x0001601a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $352(%rdx,%rbx)
+	QUAD $0x0001801a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $384(%rdx,%rbx)
+	QUAD $0x0001a01a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $416(%rdx,%rbx)
+	QUAD $0x0001c01a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $448(%rdx,%rbx)
+	QUAD $0x0001e01a8411fcc5; BYTE $0x00       // vmovups      %ymm0, $480(%rdx,%rbx)
+	LONG $0x00c38148; WORD $0x0002; BYTE $0x00 // addq         $512, %rbx
+	LONG $0xfcc18349                           // addq         $-4, %r9
+	LONG $0xff6c850f; WORD $0xffff             // jne          LBB14_8, $-148(%rip)
+
+LBB14_9:
+	WORD $0x854d; BYTE $0xc0       // testq        %r8, %r8
+	LONG $0x003b840f; WORD $0x0000 // je           LBB14_12, $59(%rip)
+	LONG $0x130c8d4c               // leaq         (%rbx,%rdx), %r9
+	LONG $0x60c18349               // addq         $96, %r9
+	LONG $0x07e0c149               // shlq         $7, %r8
+	WORD $0xdb31                   // xorl         %ebx, %ebx
+	LONG $0xc057f8c5               // vxorps       %xmm0, %xmm0, %xmm0
+	BYTE $0x90                     // .p2align 4, 0x90
+
+LBB14_11:
+	LONG $0x117cc1c4; WORD $0x1944; BYTE $0xa0 // vmovups      %ymm0, $-96(%r9,%rbx)
+	LONG $0x117cc1c4; WORD $0x1944; BYTE $0xc0 // vmovups      %ymm0, $-64(%r9,%rbx)
+	LONG $0x117cc1c4; WORD $0x1944; BYTE $0xe0 // vmovups      %ymm0, $-32(%r9,%rbx)
+	LONG $0x117cc1c4; WORD $0x1904             // vmovups      %ymm0, (%r9,%rbx)
+	LONG $0x80eb8348                           // subq         $-128, %rbx
+	WORD $0x3949; BYTE $0xd8                   // cmpq         %rbx, %r8
+	LONG $0xffd8850f; WORD $0xffff             // jne          LBB14_11, $-40(%rip)
+
+LBB14_12:
+	WORD $0x3949; BYTE $0xca       // cmpq         %rcx, %r10
+	LONG $0x0050840f; WORD $0x0000 // je           LBB14_18, $80(%rip)
+	WORD $0xc1f6; BYTE $0x70       // testb        $112, %cl
+	LONG $0x0036840f; WORD $0x0000 // je           LBB14_17, $54(%rip)
+
+LBB14_14:
+	WORD $0x894c; BYTE $0xd0 // movq         %r10, %rax
+	WORD $0x8949; BYTE $0xca // movq         %rcx, %r10
+	LONG $0xf0e28349         // andq         $-16, %r10
+	LONG $0xc057f8c5         // vxorps       %xmm0, %xmm0, %xmm0
+	QUAD $0x9090909090909090 // .p2align 4, 0x90
+
+LBB14_15:
+	LONG $0x0411f8c5; BYTE $0x02   // vmovups      %xmm0, (%rdx,%rax)
+	LONG $0x10c08348               // addq         $16, %rax
+	WORD $0x3949; BYTE $0xc2       // cmpq         %rax, %r10
+	LONG $0xffee850f; WORD $0xffff // jne          LBB14_15, $-18(%rip)
+	WORD $0x3949; BYTE $0xca       // cmpq         %rcx, %r10
+	LONG $0x0016840f; WORD $0x0000 // je           LBB14_18, $22(%rip)
+	LONG $0x90909090; BYTE $0x90   // .p2align 4, 0x90
+
+LBB14_17:
+	LONG $0x1204c642; BYTE $0x00   // movb         $0, (%rdx,%r10)
+	WORD $0xff49; BYTE $0xc2       // incq         %r10
+	WORD $0x394c; BYTE $0xd1       // cmpq         %r10, %rcx
+	LONG $0xffef850f; WORD $0xffff // jne          LBB14_17, $-17(%rip)
+
+LBB14_18:
+	LONG $0x00c045c7; WORD $0x0000; BYTE $0x00 // movl         $0, $-64(%rbp)
+	QUAD $0x00000000c845c748                   // movq         $0, $-56(%rbp)
+	WORD $0x3145; BYTE $0xc0                   // xorl         %r8d, %r8d
+	WORD $0x3f80; BYTE $0x2d                   // cmpb         $45, (%rdi)
+	LONG $0x001b850f; WORD $0x0000             // jne          LBB14_19, $27(%rip)
+	LONG $0x01c845c7; WORD $0x0000; BYTE $0x00 // movl         $1, $-56(%rbp)
+	LONG $0x0001bd41; WORD $0x0000             // movl         $1, %r13d
+	WORD $0x3949; BYTE $0xf5                   // cmpq         %rsi, %r13
+	LONG $0x00118c0f; WORD $0x0000             // jl           LBB14_22, $17(%rip)
+	LONG $0x0001b5e9; BYTE $0x00               // jmp          LBB14_54, $437(%rip)
+
+LBB14_19:
+	WORD $0x3145; BYTE $0xed       // xorl         %r13d, %r13d
+	WORD $0x3949; BYTE $0xf5       // cmpq         %rsi, %r13
+	LONG $0x01a98d0f; WORD $0x0000 // jge          LBB14_54, $425(%rip)
+
+LBB14_22:
+	WORD $0xb741; BYTE $0x01                   // movb         $1, %r15b
+	WORD $0x3145; BYTE $0xc0                   // xorl         %r8d, %r8d
+	WORD $0x3145; BYTE $0xc9                   // xorl         %r9d, %r9d
+	WORD $0x3145; BYTE $0xe4                   // xorl         %r12d, %r12d
+	WORD $0x3145; BYTE $0xdb                   // xorl         %r11d, %r11d
+	WORD $0xdb31                               // xorl         %ebx, %ebx
+	LONG $0x000027e9; BYTE $0x00               // jmp          LBB14_23, $39(%rip)
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB14_33:
+	LONG $0x000001bb; BYTE $0x00   // movl         $1, %ebx
+	WORD $0x8945; BYTE $0xdc       // movl         %r11d, %r12d
+	WORD $0x2e3c                   // cmpb         $46, %al
+	LONG $0x0095850f; WORD $0x0000 // jne          LBB14_36, $149(%rip)
+
+LBB14_34:
+	WORD $0xff49; BYTE $0xc5       // incq         %r13
+	WORD $0x3949; BYTE $0xf5       // cmpq         %rsi, %r13
+	LONG $0xc79c0f41               // setl         %r15b
+	LONG $0x007c840f; WORD $0x0000 // je           LBB14_35, $124(%rip)
+
+LBB14_23:
+	WORD $0x8941; BYTE $0xda                   // movl         %ebx, %r10d
+	WORD $0x8945; BYTE $0xe6                   // movl         %r12d, %r14d
+	LONG $0x04b60f42; BYTE $0x2f               // movzbl       (%rdi,%r13), %eax
+	WORD $0x588d; BYTE $0xd0                   // leal         $-48(%rax), %ebx
+	WORD $0xfb80; BYTE $0x09                   // cmpb         $9, %bl
+	LONG $0xffc9870f; WORD $0xffff             // ja           LBB14_33, $-55(%rip)
+	WORD $0x303c                               // cmpb         $48, %al
+	LONG $0x0021850f; WORD $0x0000             // jne          LBB14_29, $33(%rip)
+	WORD $0x8545; BYTE $0xdb                   // testl        %r11d, %r11d
+	LONG $0x0043840f; WORD $0x0000             // je           LBB14_26, $67(%rip)
+	WORD $0x6349; BYTE $0xd8                   // movslq       %r8d, %rbx
+	WORD $0x3948; BYTE $0xcb                   // cmpq         %rcx, %rbx
+	LONG $0x0018820f; WORD $0x0000             // jb           LBB14_32, $24(%rip)
+	LONG $0x000019e9; BYTE $0x00               // jmp          LBB14_28, $25(%rip)
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB14_29:
+	WORD $0x6349; BYTE $0xdb       // movslq       %r11d, %rbx
+	WORD $0x3948; BYTE $0xcb       // cmpq         %rcx, %rbx
+	LONG $0x0014830f; WORD $0x0000 // jae          LBB14_30, $20(%rip)
+
+LBB14_32:
+	WORD $0x0488; BYTE $0x1a // movb         %al, (%rdx,%rbx)
+	WORD $0xff41; BYTE $0xc0 // incl         %r8d
+
+LBB14_28:
+	WORD $0x8945; BYTE $0xf4     // movl         %r14d, %r12d
+	WORD $0x8945; BYTE $0xc3     // movl         %r8d, %r11d
+	WORD $0x8944; BYTE $0xd3     // movl         %r10d, %ebx
+	LONG $0xffff90e9; BYTE $0xff // jmp          LBB14_34, $-112(%rip)
+
+LBB14_30:
+	LONG $0x0001b941; WORD $0x0000 // movl         $1, %r9d
+	LONG $0x000006e9; BYTE $0x00   // jmp          LBB14_31, $6(%rip)
+
+LBB14_26:
+	WORD $0xff41; BYTE $0xce // decl         %r14d
+	WORD $0x3145; BYTE $0xdb // xorl         %r11d, %r11d
+
+LBB14_31:
+	WORD $0x8945; BYTE $0xf4     // movl         %r14d, %r12d
+	WORD $0x8944; BYTE $0xd3     // movl         %r10d, %ebx
+	LONG $0xffff74e9; BYTE $0xff // jmp          LBB14_34, $-140(%rip)
+
+LBB14_35:
+	WORD $0x8945; BYTE $0xe6 // movl         %r12d, %r14d
+	WORD $0x8949; BYTE $0xf5 // movq         %rsi, %r13
+	WORD $0x8941; BYTE $0xda // movl         %ebx, %r10d
+
+LBB14_36:
+	LONG $0xc4758944               // movl         %r14d, $-60(%rbp)
+	LONG $0xcc4d8944               // movl         %r9d, $-52(%rbp)
+	LONG $0xc0458944               // movl         %r8d, $-64(%rbp)
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0x0012840f; WORD $0x0000 // je           LBB14_37, $18(%rip)
+	WORD $0x8945; BYTE $0xf0       // movl         %r14d, %r8d
+	LONG $0x01c7f641               // testb        $1, %r15b
+	LONG $0x0013850f; WORD $0x0000 // jne          LBB14_40, $19(%rip)
+	LONG $0x0000c4e9; BYTE $0x00   // jmp          LBB14_55, $196(%rip)
+
+LBB14_37:
+	LONG $0xc4458944               // movl         %r8d, $-60(%rbp)
+	LONG $0x01c7f641               // testb        $1, %r15b
+	LONG $0x00b6840f; WORD $0x0000 // je           LBB14_55, $182(%rip)
+
+LBB14_40:
+	WORD $0x8944; BYTE $0xe8       // movl         %r13d, %eax
+	LONG $0x070cb60f               // movzbl       (%rdi,%rax), %ecx
+	WORD $0xc983; BYTE $0x20       // orl          $32, %ecx
+	WORD $0xf983; BYTE $0x65       // cmpl         $101, %ecx
+	LONG $0x00a3850f; WORD $0x0000 // jne          LBB14_55, $163(%rip)
+	LONG $0x0754b60f; BYTE $0x01   // movzbl       $1(%rdi,%rax), %edx
+	WORD $0xfa83; BYTE $0x2d       // cmpl         $45, %edx
+	LONG $0x0017840f; WORD $0x0000 // je           LBB14_45, $23(%rip)
+	LONG $0x000001b9; BYTE $0x00   // movl         $1, %ecx
+	WORD $0xfa83; BYTE $0x2b       // cmpl         $43, %edx
+	LONG $0x0028850f; WORD $0x0000 // jne          LBB14_43, $40(%rip)
+	LONG $0x02c58341               // addl         $2, %r13d
+	LONG $0x000009e9; BYTE $0x00   // jmp          LBB14_46, $9(%rip)
+
+LBB14_45:
+	LONG $0x02c58341             // addl         $2, %r13d
+	LONG $0xffffffb9; BYTE $0xff // movl         $-1, %ecx
+
+LBB14_46:
+	WORD $0x8944; BYTE $0xe8       // movl         %r13d, %eax
+	WORD $0x6348; BYTE $0xd0       // movslq       %eax, %rdx
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0x3948; BYTE $0xf2       // cmpq         %rsi, %rdx
+	LONG $0x00168c0f; WORD $0x0000 // jl           LBB14_48, $22(%rip)
+	LONG $0x000055e9; BYTE $0x00   // jmp          LBB14_53, $85(%rip)
+
+LBB14_43:
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x6348; BYTE $0xd0       // movslq       %eax, %rdx
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0x3948; BYTE $0xf2       // cmpq         %rsi, %rdx
+	LONG $0x00448d0f; WORD $0x0000 // jge          LBB14_53, $68(%rip)
+
+LBB14_48:
+	WORD $0xc031                               // xorl         %eax, %eax
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+LBB14_49:
+	LONG $0x171cbe0f               // movsbl       (%rdi,%rdx), %ebx
+	WORD $0xfb83; BYTE $0x30       // cmpl         $48, %ebx
+	LONG $0x00298c0f; WORD $0x0000 // jl           LBB14_53, $41(%rip)
+	WORD $0xfb80; BYTE $0x39       // cmpb         $57, %bl
+	LONG $0x0020870f; WORD $0x0000 // ja           LBB14_53, $32(%rip)
+	LONG $0x00270f3d; BYTE $0x00   // cmpl         $9999, %eax
+	LONG $0x00158f0f; WORD $0x0000 // jg           LBB14_53, $21(%rip)
+	WORD $0x048d; BYTE $0x80       // leal         (%rax,%rax,4), %eax
+	WORD $0x048d; BYTE $0x43       // leal         (%rbx,%rax,2), %eax
+	WORD $0xc083; BYTE $0xd0       // addl         $-48, %eax
+	WORD $0xff48; BYTE $0xc2       // incq         %rdx
+	WORD $0x3948; BYTE $0xd6       // cmpq         %rdx, %rsi
+	LONG $0xffca850f; WORD $0xffff // jne          LBB14_49, $-54(%rip)
+
+LBB14_53:
+	WORD $0xaf0f; BYTE $0xc1 // imull        %ecx, %eax
+	WORD $0x0141; BYTE $0xc0 // addl         %eax, %r8d
+
+LBB14_54:
+	LONG $0xc4458944 // movl         %r8d, $-60(%rbp)
+
+LBB14_55:
+	LONG $0xb07d8d48                           // leaq         $-80(%rbp), %rdi
+	LONG $0xd0758d48                           // leaq         $-48(%rbp), %rsi
+	WORD $0xf8c5; BYTE $0x77                   // vzeroupper
+	LONG $0xfff650e8; BYTE $0xff               // callq        _decimal_to_f64, $-2480(%rip)
+	LONG $0x4510fbc5; BYTE $0xd0               // vmovsd       $-48(%rbp), %xmm0
+	LONG $0x28c48348                           // addq         $40, %rsp
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5c41                               // popq         %r12
+	WORD $0x5d41                               // popq         %r13
+	WORD $0x5e41                               // popq         %r14
+	WORD $0x5f41                               // popq         %r15
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+_value:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x28ec8348                           // subq         $40, %rsp
+	WORD $0x894d; BYTE $0xc7                   // movq         %r8, %r15
+	WORD $0x8949; BYTE $0xce                   // movq         %rcx, %r14
+	WORD $0x8948; BYTE $0xf3                   // movq         %rsi, %rbx
+	WORD $0x8949; BYTE $0xfc                   // movq         %rdi, %r12
+	LONG $0xd0558948                           // movq         %rdx, $-48(%rbp)
+	LONG $0xb07d8948                           // movq         %rdi, $-80(%rbp)
+	LONG $0xb8758948                           // movq         %rsi, $-72(%rbp)
+	LONG $0xb07d8d48                           // leaq         $-80(%rbp), %rdi
+	LONG $0xd0758d48                           // leaq         $-48(%rbp), %rsi
+	LONG $0x00067ae8; BYTE $0x00               // callq        _advance_ns, $1658(%rip)
+	WORD $0xbe0f; BYTE $0xc0                   // movsbl       %al, %eax
+	WORD $0xf883; BYTE $0x7d                   // cmpl         $125, %eax
+	LONG $0x00bc870f; WORD $0x0000             // ja           LBB15_11, $188(%rip)
+	LONG $0x9f0d8d48; WORD $0x0003; BYTE $0x00 // leaq         $927(%rip), %rcx  /* LJTI15_0(%rip) */
+	LONG $0x81046348                           // movslq       (%rcx,%rax,4), %rax
+	WORD $0x0148; BYTE $0xc8                   // addq         %rcx, %rax
+	JMP  AX
+
+LBB15_2:
+	LONG $0xc875894c               // movq         %r14, $-56(%rbp)
+	LONG $0xd0758b4c               // movq         $-48(%rbp), %r14
+	LONG $0xff6e8d4d               // leaq         $-1(%r14), %r13
+	LONG $0xd06d894c               // movq         %r13, $-48(%rbp)
+	LONG $0x02c7f641               // testb        $2, %r15b
+	LONG $0x001a850f; WORD $0x0000 // jne          LBB15_4, $26(%rip)
+	LONG $0xb07d8d48               // leaq         $-80(%rbp), %rdi
+	LONG $0xd0758d48               // leaq         $-48(%rbp), %rsi
+	LONG $0xc8558b48               // movq         $-56(%rbp), %rdx
+	LONG $0x000e53e8; BYTE $0x00   // callq        _vnumber, $3667(%rip)
+	LONG $0xd07d8b4c               // movq         $-48(%rbp), %r15
+	LONG $0x00034de9; BYTE $0x00   // jmp          LBB15_58, $845(%rip)
+
+LBB15_4:
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x2c3c8043; BYTE $0x2d   // cmpb         $45, (%r12,%r13)
+	LONG $0x2c3c8d4f               // leaq         (%r12,%r13), %r15
+	WORD $0x940f; BYTE $0xc0       // sete         %al
+	WORD $0x0149; BYTE $0xc7       // addq         %rax, %r15
+	WORD $0x2948; BYTE $0xc3       // subq         %rax, %rbx
+	LONG $0x030c840f; WORD $0x0000 // je           LBB15_53, $780(%rip)
+	WORD $0x3949; BYTE $0xdd       // cmpq         %rbx, %r13
+	LONG $0x000e830f; WORD $0x0000 // jae          LBB15_7, $14(%rip)
+	LONG $0x07b60f41               // movzbl       (%r15), %eax
+	WORD $0xc604                   // addb         $-58, %al
+	WORD $0xf63c                   // cmpb         $-10, %al
+	LONG $0x0307820f; WORD $0x0000 // jb           LBB15_55, $775(%rip)
+
+LBB15_7:
+	WORD $0x894c; BYTE $0xff                   // movq         %r15, %rdi
+	WORD $0x8948; BYTE $0xde                   // movq         %rbx, %rsi
+	LONG $0x0020dee8; BYTE $0x00               // callq        _do_skip_number, $8414(%rip)
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0x02ed880f; WORD $0x0000             // js           LBB15_54, $749(%rip)
+	WORD $0x0149; BYTE $0xc7                   // addq         %rax, %r15
+	WORD $0x294d; BYTE $0xe7                   // subq         %r12, %r15
+	WORD $0x854d; BYTE $0xf6                   // testq        %r14, %r14
+	LONG $0x02f28e0f; WORD $0x0000             // jle          LBB15_57, $754(%rip)
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	LONG $0x0800c748; WORD $0x0000; BYTE $0x00 // movq         $8, (%rax)
+	LONG $0x1868894c                           // movq         %r13, $24(%rax)
+	LONG $0x0002e5e9; BYTE $0x00               // jmp          LBB15_58, $741(%rip)
+
+LBB15_10:
+	LONG $0x0106c749; WORD $0x0000; BYTE $0x00 // movq         $1, (%r14)
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0x0002d5e9; BYTE $0x00               // jmp          LBB15_58, $725(%rip)
+
+LBB15_11:
+	LONG $0xfe06c749; WORD $0xffff; BYTE $0xff // movq         $-2, (%r14)
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	WORD $0xff49; BYTE $0xcf                   // decq         %r15
+	LONG $0x0002c2e9; BYTE $0x00               // jmp          LBB15_58, $706(%rip)
+
+LBB15_12:
+	QUAD $0xffffffffc045c748                   // movq         $-1, $-64(%rbp)
+	LONG $0xd0658b4c                           // movq         $-48(%rbp), %r12
+	LONG $0xb07d8d48                           // leaq         $-80(%rbp), %rdi
+	LONG $0xc0558d48                           // leaq         $-64(%rbp), %rdx
+	WORD $0x894c; BYTE $0xe6                   // movq         %r12, %rsi
+	WORD $0x894c; BYTE $0xf9                   // movq         %r15, %rcx
+	LONG $0x000980e8; BYTE $0x00               // callq        _advance_string, $2432(%rip)
+	WORD $0x8949; BYTE $0xc7                   // movq         %rax, %r15
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0x0174880f; WORD $0x0000             // js           LBB15_32, $372(%rip)
+	LONG $0xd07d894c                           // movq         %r15, $-48(%rbp)
+	LONG $0x1066894d                           // movq         %r12, $16(%r14)
+	LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq         $7, (%r14)
+	LONG $0xc0458b48                           // movq         $-64(%rbp), %rax
+	WORD $0x394c; BYTE $0xf8                   // cmpq         %r15, %rax
+	LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rcx
+	LONG $0xc84c0f48                           // cmovlq       %rax, %rcx
+	LONG $0x184e8949                           // movq         %rcx, $24(%r14)
+	LONG $0x00026de9; BYTE $0x00               // jmp          LBB15_58, $621(%rip)
+
+LBB15_14:
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl        $-2147483648, %r15d
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0x00000bba; BYTE $0x00               // movl         $11, %edx
+	LONG $0x00011ae9; BYTE $0x00               // jmp          LBB15_31, $282(%rip)
+
+LBB15_15:
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl        $-2147483648, %r15d
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0x00000aba; BYTE $0x00               // movl         $10, %edx
+	LONG $0x000100e9; BYTE $0x00               // jmp          LBB15_31, $256(%rip)
+
+LBB15_16:
+	LONG $0x0506c749; WORD $0x0000; BYTE $0x00 // movq         $5, (%r14)
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0x000229e9; BYTE $0x00               // jmp          LBB15_58, $553(%rip)
+
+LBB15_17:
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl        $-2147483648, %r15d
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0x00000cba; BYTE $0x00               // movl         $12, %edx
+	LONG $0x0000d6e9; BYTE $0x00               // jmp          LBB15_31, $214(%rip)
+
+LBB15_18:
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0xfc4b8d48                           // leaq         $-4(%rbx), %rcx
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x3949; BYTE $0xcf                   // cmpq         %rcx, %r15
+	LONG $0x008a870f; WORD $0x0000             // ja           LBB15_25, $138(%rip)
+	LONG $0x3c0c8b43                           // movl         (%r12,%r15), %ecx
+	LONG $0x6c61f981; WORD $0x6573             // cmpl         $1702063201, %ecx
+	LONG $0x00d3850f; WORD $0x0000             // jne          LBB15_33, $211(%rip)
+	LONG $0x04c78349                           // addq         $4, %r15
+	LONG $0x000004b8; BYTE $0x00               // movl         $4, %eax
+	LONG $0x000069e9; BYTE $0x00               // jmp          LBB15_24, $105(%rip)
+
+LBB15_21:
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0xfd4b8d48                           // leaq         $-3(%rbx), %rcx
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x3949; BYTE $0xcf                   // cmpq         %rcx, %r15
+	LONG $0x0054870f; WORD $0x0000             // ja           LBB15_25, $84(%rip)
+	LONG $0x3c4c8b43; BYTE $0xff               // movl         $-1(%r12,%r15), %ecx
+	LONG $0x756ef981; WORD $0x6c6c             // cmpl         $1819047278, %ecx
+	LONG $0x00db850f; WORD $0x0000             // jne          LBB15_37, $219(%rip)
+	LONG $0x03c78349                           // addq         $3, %r15
+	LONG $0x000002b8; BYTE $0x00               // movl         $2, %eax
+	LONG $0x000032e9; BYTE $0x00               // jmp          LBB15_24, $50(%rip)
+
+LBB15_26:
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0xfd4b8d48                           // leaq         $-3(%rbx), %rcx
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x3949; BYTE $0xcf                   // cmpq         %rcx, %r15
+	LONG $0x001d870f; WORD $0x0000             // ja           LBB15_25, $29(%rip)
+	LONG $0x3c4c8b43; BYTE $0xff               // movl         $-1(%r12,%r15), %ecx
+	LONG $0x7274f981; WORD $0x6575             // cmpl         $1702195828, %ecx
+	LONG $0x00e2850f; WORD $0x0000             // jne          LBB15_41, $226(%rip)
+	LONG $0x03c78349                           // addq         $3, %r15
+	LONG $0x000003b8; BYTE $0x00               // movl         $3, %eax
+
+LBB15_24:
+	WORD $0x894c; BYTE $0xfb // movq         %r15, %rbx
+
+LBB15_25:
+	LONG $0xd05d8948             // movq         %rbx, $-48(%rbp)
+	WORD $0x8949; BYTE $0xdf     // movq         %rbx, %r15
+	WORD $0x8949; BYTE $0x06     // movq         %rax, (%r14)
+	LONG $0x00015ee9; BYTE $0x00 // jmp          LBB15_58, $350(%rip)
+
+LBB15_29:
+	LONG $0x0606c749; WORD $0x0000; BYTE $0x00 // movq         $6, (%r14)
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0x00014ee9; BYTE $0x00               // jmp          LBB15_58, $334(%rip)
+
+LBB15_30:
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl        $-2147483648, %r15d
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0x00000dba; BYTE $0x00               // movl         $13, %edx
+
+LBB15_31:
+	LONG $0xd1440f48             // cmoveq       %rcx, %rdx
+	WORD $0x940f; BYTE $0xc0     // sete         %al
+	WORD $0x8949; BYTE $0x16     // movq         %rdx, (%r14)
+	LONG $0xd07d8b4c             // movq         $-48(%rbp), %r15
+	WORD $0x2949; BYTE $0xc7     // subq         %rax, %r15
+	LONG $0x000123e9; BYTE $0x00 // jmp          LBB15_58, $291(%rip)
+
+LBB15_32:
+	LONG $0xd05d8948             // movq         %rbx, $-48(%rbp)
+	WORD $0x894d; BYTE $0x3e     // movq         %r15, (%r14)
+	WORD $0x8949; BYTE $0xdf     // movq         %rbx, %r15
+	LONG $0x000114e9; BYTE $0x00 // jmp          LBB15_58, $276(%rip)
+
+LBB15_33:
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	WORD $0xf980; BYTE $0x61                   // cmpb         $97, %cl
+	LONG $0x00d5850f; WORD $0x0000             // jne          LBB15_49, $213(%rip)
+	LONG $0x3c7c8043; WORD $0x6c01             // cmpb         $108, $1(%r12,%r15)
+	LONG $0x00aa850f; WORD $0x0000             // jne          LBB15_46, $170(%rip)
+	LONG $0x3c7c8043; WORD $0x7302             // cmpb         $115, $2(%r12,%r15)
+	LONG $0x00b5850f; WORD $0x0000             // jne          LBB15_47, $181(%rip)
+	LONG $0x044f8d49                           // leaq         $4(%r15), %rcx
+	LONG $0x3c7c8043; WORD $0x6503             // cmpb         $101, $3(%r12,%r15)
+	LONG $0x037f8d4d                           // leaq         $3(%r15), %r15
+	LONG $0xf9440f4c                           // cmoveq       %rcx, %r15
+	LONG $0x0000a2e9; BYTE $0x00               // jmp          LBB15_48, $162(%rip)
+
+LBB15_37:
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	WORD $0xf980; BYTE $0x6e                   // cmpb         $110, %cl
+	LONG $0x006c850f; WORD $0x0000             // jne          LBB15_45, $108(%rip)
+	LONG $0x3c3c8043; BYTE $0x75               // cmpb         $117, (%r12,%r15)
+	LONG $0x0077850f; WORD $0x0000             // jne          LBB15_51, $119(%rip)
+	LONG $0x3c7c8043; WORD $0x6c01             // cmpb         $108, $1(%r12,%r15)
+	LONG $0x0068850f; WORD $0x0000             // jne          LBB15_50, $104(%rip)
+	LONG $0x034f8d49                           // leaq         $3(%r15), %rcx
+	LONG $0x3c7c8043; WORD $0x6c02             // cmpb         $108, $2(%r12,%r15)
+	LONG $0x027f8d4d                           // leaq         $2(%r15), %r15
+	LONG $0xf9440f4c                           // cmoveq       %rcx, %r15
+	LONG $0x000054e9; BYTE $0x00               // jmp          LBB15_51, $84(%rip)
+
+LBB15_41:
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	WORD $0xf980; BYTE $0x74                   // cmpb         $116, %cl
+	LONG $0x002e850f; WORD $0x0000             // jne          LBB15_45, $46(%rip)
+	LONG $0x3c3c8043; BYTE $0x72               // cmpb         $114, (%r12,%r15)
+	LONG $0x0039850f; WORD $0x0000             // jne          LBB15_51, $57(%rip)
+	LONG $0x3c7c8043; WORD $0x7501             // cmpb         $117, $1(%r12,%r15)
+	LONG $0x002a850f; WORD $0x0000             // jne          LBB15_50, $42(%rip)
+	LONG $0x034f8d49                           // leaq         $3(%r15), %rcx
+	LONG $0x3c7c8043; WORD $0x6502             // cmpb         $101, $2(%r12,%r15)
+	LONG $0x027f8d4d                           // leaq         $2(%r15), %r15
+	LONG $0xf9440f4c                           // cmoveq       %rcx, %r15
+	LONG $0x000016e9; BYTE $0x00               // jmp          LBB15_51, $22(%rip)
+
+LBB15_45:
+	WORD $0xff49; BYTE $0xcf     // decq         %r15
+	WORD $0x8949; BYTE $0x06     // movq         %rax, (%r14)
+	LONG $0x00004ee9; BYTE $0x00 // jmp          LBB15_58, $78(%rip)
+
+LBB15_46:
+	WORD $0xff49; BYTE $0xc7     // incq         %r15
+	LONG $0x000013e9; BYTE $0x00 // jmp          LBB15_48, $19(%rip)
+
+LBB15_50:
+	WORD $0xff49; BYTE $0xc7 // incq         %r15
+
+LBB15_51:
+	LONG $0xd07d894c             // movq         %r15, $-48(%rbp)
+	WORD $0x8949; BYTE $0x06     // movq         %rax, (%r14)
+	LONG $0x000037e9; BYTE $0x00 // jmp          LBB15_58, $55(%rip)
+
+LBB15_47:
+	LONG $0x02c78349 // addq         $2, %r15
+
+LBB15_48:
+	LONG $0xd07d894c // movq         %r15, $-48(%rbp)
+
+LBB15_49:
+	WORD $0x8949; BYTE $0x06     // movq         %rax, (%r14)
+	LONG $0x000027e9; BYTE $0x00 // jmp          LBB15_58, $39(%rip)
+
+LBB15_53:
+	LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r13
+	LONG $0x00000de9; BYTE $0x00               // jmp          LBB15_56, $13(%rip)
+
+LBB15_54:
+	WORD $0xf748; BYTE $0xd0 // notq         %rax
+	WORD $0x0149; BYTE $0xc7 // addq         %rax, %r15
+
+LBB15_55:
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+
+LBB15_56:
+	WORD $0x294d; BYTE $0xe7 // subq         %r12, %r15
+	LONG $0xd07d894c         // movq         %r15, $-48(%rbp)
+
+LBB15_57:
+	LONG $0xc8458b48         // movq         $-56(%rbp), %rax
+	WORD $0x894c; BYTE $0x28 // movq         %r13, (%rax)
+
+LBB15_58:
+	WORD $0x894c; BYTE $0xf8 // movq         %r15, %rax
+	LONG $0x28c48348         // addq         $40, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+	WORD $0x9090; BYTE $0x90 // .p2align 2, 0x90
+
+	// .set L15_0_set_10, LBB15_10-LJTI15_0
+	// .set L15_0_set_11, LBB15_11-LJTI15_0
+	// .set L15_0_set_12, LBB15_12-LJTI15_0
+	// .set L15_0_set_14, LBB15_14-LJTI15_0
+	// .set L15_0_set_2, LBB15_2-LJTI15_0
+	// .set L15_0_set_15, LBB15_15-LJTI15_0
+	// .set L15_0_set_16, LBB15_16-LJTI15_0
+	// .set L15_0_set_17, LBB15_17-LJTI15_0
+	// .set L15_0_set_18, LBB15_18-LJTI15_0
+	// .set L15_0_set_21, LBB15_21-LJTI15_0
+	// .set L15_0_set_26, LBB15_26-LJTI15_0
+	// .set L15_0_set_29, LBB15_29-LJTI15_0
+	// .set L15_0_set_30, LBB15_30-LJTI15_0
+LJTI15_0:
+	LONG $0xfffffd06                                   // .long L15_0_set_10
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd29                                   // .long L15_0_set_12
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd7e                                   // .long L15_0_set_14
+	LONG $0xfffffc6a                                   // .long L15_0_set_2
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffc6a                                   // .long L15_0_set_2
+	LONG $0xfffffc6a                                   // .long L15_0_set_2
+	LONG $0xfffffc6a                                   // .long L15_0_set_2
+	LONG $0xfffffc6a                                   // .long L15_0_set_2
+	LONG $0xfffffc6a                                   // .long L15_0_set_2
+	LONG $0xfffffc6a                                   // .long L15_0_set_2
+	LONG $0xfffffc6a                                   // .long L15_0_set_2
+	LONG $0xfffffc6a                                   // .long L15_0_set_2
+	LONG $0xfffffc6a                                   // .long L15_0_set_2
+	LONG $0xfffffc6a                                   // .long L15_0_set_2
+	LONG $0xfffffd98                                   // .long L15_0_set_15
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffdb2                                   // .long L15_0_set_16
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffdc2                                   // .long L15_0_set_17
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffddc                                   // .long L15_0_set_18
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffe12                                   // .long L15_0_set_21
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffe49                                   // .long L15_0_set_26
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffe8d                                   // .long L15_0_set_29
+	LONG $0xfffffd16                                   // .long L15_0_set_11
+	LONG $0xfffffe9d                                   // .long L15_0_set_30
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .p2align 5, 0x00
+
+LCPI16_0:
+	QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, '                '
+	QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, '                '
+
+LCPI16_1:
+	QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'
+	QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'
+
+LCPI16_2:
+	QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n'
+	QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n'
+
+LCPI16_3:
+	QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r'
+	QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r'
+
+	// .p2align 4, 0x00
+LCPI16_4:
+	QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, '                '
+
+LCPI16_5:
+	QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'
+
+LCPI16_6:
+	QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n'
+
+LCPI16_7:
+	QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r'
+
+	// .p2align 4, 0x90
+_advance_ns:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	BYTE $0x53                     // pushq        %rbx
+	WORD $0x8b4c; BYTE $0x1e       // movq         (%rsi), %r11
+	WORD $0x8b4c; BYTE $0x0f       // movq         (%rdi), %r9
+	LONG $0x08478b4c               // movq         $8(%rdi), %r8
+	WORD $0x394d; BYTE $0xc3       // cmpq         %r8, %r11
+	LONG $0x0021830f; WORD $0x0000 // jae          LBB16_4, $33(%rip)
+	LONG $0x04b60f43; BYTE $0x19   // movzbl       (%r9,%r11), %eax
+	WORD $0xf883; BYTE $0x0d       // cmpl         $13, %eax
+	LONG $0x0013840f; WORD $0x0000 // je           LBB16_4, $19(%rip)
+	WORD $0xf883; BYTE $0x20       // cmpl         $32, %eax
+	LONG $0x000a840f; WORD $0x0000 // je           LBB16_4, $10(%rip)
+	WORD $0xf504                   // addb         $-11, %al
+	WORD $0xfe3c                   // cmpb         $-2, %al
+	LONG $0x0284820f; WORD $0x0000 // jb           LBB16_48, $644(%rip)
+
+LBB16_4:
+	LONG $0x01438d49               // leaq         $1(%r11), %rax
+	WORD $0x394c; BYTE $0xc0       // cmpq         %r8, %rax
+	LONG $0x0023830f; WORD $0x0000 // jae          LBB16_9, $35(%rip)
+	LONG $0x0cb60f41; BYTE $0x01   // movzbl       (%r9,%rax), %ecx
+	WORD $0xf983; BYTE $0x0d       // cmpl         $13, %ecx
+	LONG $0x0015840f; WORD $0x0000 // je           LBB16_9, $21(%rip)
+	WORD $0xf983; BYTE $0x20       // cmpl         $32, %ecx
+	LONG $0x000c840f; WORD $0x0000 // je           LBB16_9, $12(%rip)
+	WORD $0xc180; BYTE $0xf5       // addb         $-11, %cl
+	WORD $0xf980; BYTE $0xfe       // cmpb         $-2, %cl
+	LONG $0x0060820f; WORD $0x0000 // jb           LBB16_8, $96(%rip)
+
+LBB16_9:
+	LONG $0x02438d49               // leaq         $2(%r11), %rax
+	WORD $0x394c; BYTE $0xc0       // cmpq         %r8, %rax
+	LONG $0x0023830f; WORD $0x0000 // jae          LBB16_14, $35(%rip)
+	LONG $0x0cb60f41; BYTE $0x01   // movzbl       (%r9,%rax), %ecx
+	WORD $0xf983; BYTE $0x0d       // cmpl         $13, %ecx
+	LONG $0x0015840f; WORD $0x0000 // je           LBB16_14, $21(%rip)
+	WORD $0xf983; BYTE $0x20       // cmpl         $32, %ecx
+	LONG $0x000c840f; WORD $0x0000 // je           LBB16_14, $12(%rip)
+	WORD $0xc180; BYTE $0xf5       // addb         $-11, %cl
+	WORD $0xf980; BYTE $0xfe       // cmpb         $-2, %cl
+	LONG $0x0030820f; WORD $0x0000 // jb           LBB16_8, $48(%rip)
+
+LBB16_14:
+	LONG $0x03438d49               // leaq         $3(%r11), %rax
+	WORD $0x394c; BYTE $0xc0       // cmpq         %r8, %rax
+	LONG $0x002b830f; WORD $0x0000 // jae          LBB16_19, $43(%rip)
+	LONG $0x0cb60f41; BYTE $0x01   // movzbl       (%r9,%rax), %ecx
+	WORD $0xf983; BYTE $0x0d       // cmpl         $13, %ecx
+	LONG $0x001d840f; WORD $0x0000 // je           LBB16_19, $29(%rip)
+	WORD $0xf983; BYTE $0x20       // cmpl         $32, %ecx
+	LONG $0x0014840f; WORD $0x0000 // je           LBB16_19, $20(%rip)
+	WORD $0xc180; BYTE $0xf5       // addb         $-11, %cl
+	WORD $0xf980; BYTE $0xfe       // cmpb         $-2, %cl
+	LONG $0x0008830f; WORD $0x0000 // jae          LBB16_19, $8(%rip)
+
+LBB16_8:
+	WORD $0x8949; BYTE $0xc3     // movq         %rax, %r11
+	LONG $0x0001ece9; BYTE $0x00 // jmp          LBB16_48, $492(%rip)
+
+LBB16_19:
+	LONG $0x04c38349                       // addq         $4, %r11
+	WORD $0x394d; BYTE $0xd8               // cmpq         %r11, %r8
+	LONG $0x01bf860f; WORD $0x0000         // jbe          LBB16_44, $447(%rip)
+	LONG $0x191c8d4b                       // leaq         (%r9,%r11), %rbx
+	WORD $0x894c; BYTE $0xc1               // movq         %r8, %rcx
+	WORD $0x294c; BYTE $0xd9               // subq         %r11, %rcx
+	LONG $0x0068840f; WORD $0x0000         // je           LBB16_28, $104(%rip)
+	WORD $0xd889                           // movl         %ebx, %eax
+	WORD $0xe083; BYTE $0x1f               // andl         $31, %eax
+	LONG $0x005d840f; WORD $0x0000         // je           LBB16_28, $93(%rip)
+	LONG $0x000005ba; BYTE $0x00           // movl         $5, %edx
+	WORD $0x294c; BYTE $0xc2               // subq         %r8, %rdx
+	QUAD $0x000100002600b948; WORD $0x0000 // movabsq      $4294977024, %rcx
+	LONG $0x90909090; BYTE $0x90           // .p2align 4, 0x90
+
+LBB16_23:
+	LONG $0x04be0f43; BYTE $0x19   // movsbl       (%r9,%r11), %eax
+	WORD $0xf883; BYTE $0x20       // cmpl         $32, %eax
+	LONG $0x0193870f; WORD $0x0000 // ja           LBB16_46, $403(%rip)
+	LONG $0xc1a30f48               // btq          %rax, %rcx
+	LONG $0x0189830f; WORD $0x0000 // jae          LBB16_46, $393(%rip)
+	LONG $0x1a1c8d4a               // leaq         (%rdx,%r11), %rbx
+	LONG $0x01438d49               // leaq         $1(%r11), %rax
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x0012840f; WORD $0x0000 // je           LBB16_27, $18(%rip)
+	LONG $0x191c8d43               // leal         (%r9,%r11), %ebx
+	WORD $0xc3ff                   // incl         %ebx
+	WORD $0x8949; BYTE $0xc3       // movq         %rax, %r11
+	WORD $0xe383; BYTE $0x1f       // andl         $31, %ebx
+	LONG $0xffc4850f; WORD $0xffff // jne          LBB16_23, $-60(%rip)
+
+LBB16_27:
+	LONG $0x011c8d49         // leaq         (%r9,%rax), %rbx
+	WORD $0x894c; BYTE $0xc1 // movq         %r8, %rcx
+	WORD $0x2948; BYTE $0xc1 // subq         %rax, %rcx
+
+LBB16_28:
+	LONG $0x20f98348                       // cmpq         $32, %rcx
+	LONG $0x0073820f; WORD $0x0000         // jb           LBB16_32, $115(%rip)
+	WORD $0x894c; BYTE $0xc8               // movq         %r9, %rax
+	WORD $0x2948; BYTE $0xd8               // subq         %rbx, %rax
+	QUAD $0xfffffdd2056ffdc5               // vmovdqa      $-558(%rip), %ymm0  /* LCPI16_0(%rip) */
+	QUAD $0xfffffdea0d6ffdc5               // vmovdqa      $-534(%rip), %ymm1  /* LCPI16_1(%rip) */
+	QUAD $0xfffffe02156ffdc5               // vmovdqa      $-510(%rip), %ymm2  /* LCPI16_2(%rip) */
+	QUAD $0xfffffe1a1d6ffdc5               // vmovdqa      $-486(%rip), %ymm3  /* LCPI16_3(%rip) */
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB16_30:
+	LONG $0x236ffdc5               // vmovdqa      (%rbx), %ymm4
+	LONG $0xe874ddc5               // vpcmpeqb     %ymm0, %ymm4, %ymm5
+	LONG $0xf174ddc5               // vpcmpeqb     %ymm1, %ymm4, %ymm6
+	LONG $0xeeebd5c5               // vpor         %ymm6, %ymm5, %ymm5
+	LONG $0xf274ddc5               // vpcmpeqb     %ymm2, %ymm4, %ymm6
+	LONG $0xe374ddc5               // vpcmpeqb     %ymm3, %ymm4, %ymm4
+	LONG $0xe6ebddc5               // vpor         %ymm6, %ymm4, %ymm4
+	LONG $0xe5ebddc5               // vpor         %ymm5, %ymm4, %ymm4
+	LONG $0xd4d7fdc5               // vpmovmskb    %ymm4, %edx
+	WORD $0xfa83; BYTE $0xff       // cmpl         $-1, %edx
+	LONG $0x00e8850f; WORD $0x0000 // jne          LBB16_45, $232(%rip)
+	LONG $0x20c38348               // addq         $32, %rbx
+	LONG $0xe0c18348               // addq         $-32, %rcx
+	LONG $0xe0c08348               // addq         $-32, %rax
+	LONG $0x1ff98348               // cmpq         $31, %rcx
+	LONG $0xffbd870f; WORD $0xffff // ja           LBB16_30, $-67(%rip)
+
+LBB16_32:
+	WORD $0xf8c5; BYTE $0x77       // vzeroupper
+	LONG $0x10f98348               // cmpq         $16, %rcx
+	LONG $0x006a820f; WORD $0x0000 // jb           LBB16_36, $106(%rip)
+	WORD $0x894d; BYTE $0xca       // movq         %r9, %r10
+	WORD $0x2949; BYTE $0xda       // subq         %rbx, %r10
+	QUAD $0xfffffdd2056ff9c5       // vmovdqa      $-558(%rip), %xmm0  /* LCPI16_4(%rip) */
+	QUAD $0xfffffdda0d6ff9c5       // vmovdqa      $-550(%rip), %xmm1  /* LCPI16_5(%rip) */
+	QUAD $0xfffffde2156ff9c5       // vmovdqa      $-542(%rip), %xmm2  /* LCPI16_6(%rip) */
+	QUAD $0xfffffdea1d6ff9c5       // vmovdqa      $-534(%rip), %xmm3  /* LCPI16_7(%rip) */
+
+LBB16_34:
+	LONG $0x236ff9c5               // vmovdqa      (%rbx), %xmm4
+	LONG $0xe874d9c5               // vpcmpeqb     %xmm0, %xmm4, %xmm5
+	LONG $0xf174d9c5               // vpcmpeqb     %xmm1, %xmm4, %xmm6
+	LONG $0xeeebd1c5               // vpor         %xmm6, %xmm5, %xmm5
+	LONG $0xf274d9c5               // vpcmpeqb     %xmm2, %xmm4, %xmm6
+	LONG $0xe374d9c5               // vpcmpeqb     %xmm3, %xmm4, %xmm4
+	LONG $0xe6ebd9c5               // vpor         %xmm6, %xmm4, %xmm4
+	LONG $0xe5ebd9c5               // vpor         %xmm5, %xmm4, %xmm4
+	LONG $0xc4d7f9c5               // vpmovmskb    %xmm4, %eax
+	LONG $0xfff88366               // cmpw         $-1, %ax
+	LONG $0x009b850f; WORD $0x0000 // jne          LBB16_49, $155(%rip)
+	LONG $0x10c38348               // addq         $16, %rbx
+	LONG $0xf0c18348               // addq         $-16, %rcx
+	LONG $0xf0c28349               // addq         $-16, %r10
+	LONG $0x0ff98348               // cmpq         $15, %rcx
+	LONG $0xffbc870f; WORD $0xffff // ja           LBB16_34, $-68(%rip)
+
+LBB16_36:
+	WORD $0x8548; BYTE $0xc9               // testq        %rcx, %rcx
+	LONG $0x0036840f; WORD $0x0000         // je           LBB16_42, $54(%rip)
+	LONG $0x0b148d4c                       // leaq         (%rbx,%rcx), %r10
+	WORD $0xc031                           // xorl         %eax, %eax
+	QUAD $0x000100002600bb49; WORD $0x0000 // movabsq      $4294977024, %r11
+
+LBB16_38:
+	LONG $0x0314be0f               // movsbl       (%rbx,%rax), %edx
+	WORD $0xfa83; BYTE $0x20       // cmpl         $32, %edx
+	LONG $0x007c870f; WORD $0x0000 // ja           LBB16_51, $124(%rip)
+	LONG $0xd3a30f49               // btq          %rdx, %r11
+	LONG $0x0072830f; WORD $0x0000 // jae          LBB16_51, $114(%rip)
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3948; BYTE $0xc1       // cmpq         %rax, %rcx
+	LONG $0xffdd850f; WORD $0xffff // jne          LBB16_38, $-35(%rip)
+	WORD $0x894c; BYTE $0xd3       // movq         %r10, %rbx
+
+LBB16_42:
+	WORD $0x294c; BYTE $0xcb       // subq         %r9, %rbx
+	WORD $0x8949; BYTE $0xdb       // movq         %rbx, %r11
+	WORD $0x394d; BYTE $0xc3       // cmpq         %r8, %r11
+	LONG $0x0022820f; WORD $0x0000 // jb           LBB16_47, $34(%rip)
+	LONG $0x000047e9; BYTE $0x00   // jmp          LBB16_50, $71(%rip)
+
+LBB16_44:
+	WORD $0x894c; BYTE $0x1e     // movq         %r11, (%rsi)
+	LONG $0x00003fe9; BYTE $0x00 // jmp          LBB16_50, $63(%rip)
+
+LBB16_45:
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	WORD $0xd2f7             // notl         %edx
+	LONG $0xdabc0f44         // bsfl         %edx, %r11d
+	WORD $0x2949; BYTE $0xc3 // subq         %rax, %r11
+
+LBB16_46:
+	WORD $0x394d; BYTE $0xc3       // cmpq         %r8, %r11
+	LONG $0x002a830f; WORD $0x0000 // jae          LBB16_50, $42(%rip)
+
+LBB16_47:
+	WORD $0x8b4c; BYTE $0x0f // movq         (%rdi), %r9
+
+LBB16_48:
+	LONG $0x01438d49             // leaq         $1(%r11), %rax
+	WORD $0x8948; BYTE $0x06     // movq         %rax, (%rsi)
+	LONG $0x04b60f43; BYTE $0x19 // movzbl       (%r9,%r11), %eax
+	WORD $0xbe0f; BYTE $0xc0     // movsbl       %al, %eax
+	BYTE $0x5b                   // popq         %rbx
+	BYTE $0x5d                   // popq         %rbp
+	BYTE $0xc3                   // retq
+
+LBB16_49:
+	WORD $0xb70f; BYTE $0xc0       // movzwl       %ax, %eax
+	WORD $0xd0f7                   // notl         %eax
+	LONG $0xd8bc0f44               // bsfl         %eax, %r11d
+	WORD $0x294d; BYTE $0xd3       // subq         %r10, %r11
+	WORD $0x394d; BYTE $0xc3       // cmpq         %r8, %r11
+	LONG $0xffd6820f; WORD $0xffff // jb           LBB16_47, $-42(%rip)
+
+LBB16_50:
+	WORD $0xc031             // xorl         %eax, %eax
+	WORD $0xbe0f; BYTE $0xc0 // movsbl       %al, %eax
+	BYTE $0x5b               // popq         %rbx
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB16_51:
+	WORD $0x294c; BYTE $0xcb                               // subq         %r9, %rbx
+	WORD $0x0148; BYTE $0xc3                               // addq         %rax, %rbx
+	WORD $0x8949; BYTE $0xdb                               // movq         %rbx, %r11
+	WORD $0x394d; BYTE $0xc3                               // cmpq         %r8, %r11
+	LONG $0xffbc820f; WORD $0xffff                         // jb           LBB16_47, $-68(%rip)
+	LONG $0xffffe1e9; BYTE $0xff                           // jmp          LBB16_50, $-31(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+_vstring:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x10ec8348                           // subq         $16, %rsp
+	WORD $0x8949; BYTE $0xd6                   // movq         %rdx, %r14
+	WORD $0x8948; BYTE $0xf3                   // movq         %rsi, %rbx
+	WORD $0x8949; BYTE $0xff                   // movq         %rdi, %r15
+	QUAD $0xffffffffd845c748                   // movq         $-1, $-40(%rbp)
+	WORD $0x8b4c; BYTE $0x26                   // movq         (%rsi), %r12
+	LONG $0xd8558d48                           // leaq         $-40(%rbp), %rdx
+	WORD $0x894c; BYTE $0xe6                   // movq         %r12, %rsi
+	LONG $0x0000c1e8; BYTE $0x00               // callq        _advance_string, $193(%rip)
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0x0029880f; WORD $0x0000             // js           LBB17_1, $41(%rip)
+	WORD $0x8948; BYTE $0x03                   // movq         %rax, (%rbx)
+	LONG $0x1066894d                           // movq         %r12, $16(%r14)
+	LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq         $7, (%r14)
+	LONG $0xd84d8b48                           // movq         $-40(%rbp), %rcx
+	WORD $0x3948; BYTE $0xc1                   // cmpq         %rax, %rcx
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xc14c0f48                           // cmovlq       %rcx, %rax
+	LONG $0x18468949                           // movq         %rax, $24(%r14)
+	LONG $0x00000ae9; BYTE $0x00               // jmp          LBB17_3, $10(%rip)
+
+LBB17_1:
+	LONG $0x084f8b49         // movq         $8(%r15), %rcx
+	WORD $0x8948; BYTE $0x0b // movq         %rcx, (%rbx)
+	WORD $0x8949; BYTE $0x06 // movq         %rax, (%r14)
+
+LBB17_3:
+	LONG $0x10c48348                                                             // addq         $16, %rsp
+	BYTE $0x5b                                                                   // popq         %rbx
+	WORD $0x5c41                                                                 // popq         %r12
+	WORD $0x5e41                                                                 // popq         %r14
+	WORD $0x5f41                                                                 // popq         %r15
+	BYTE $0x5d                                                                   // popq         %rbp
+	BYTE $0xc3                                                                   // retq
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .p2align 5, 0x00
+
+LCPI18_0:
+	QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
+	QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
+
+LCPI18_1:
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+
+LCPI18_2:
+	QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f'
+	QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f'
+
+	// .p2align 4, 0x90
+_advance_string:
+	WORD $0xc1f6; BYTE $0x20       // testb        $32, %cl
+	LONG $0x0005850f; WORD $0x0000 // jne          LBB18_2, $5(%rip)
+	LONG $0x005132e9; BYTE $0x00   // jmp          _advance_string_default, $20786(%rip)
+
+LBB18_2:
+	BYTE $0x55                                               // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                                 // movq         %rsp, %rbp
+	WORD $0x5741                                             // pushq        %r15
+	WORD $0x5641                                             // pushq        %r14
+	WORD $0x5541                                             // pushq        %r13
+	WORD $0x5441                                             // pushq        %r12
+	BYTE $0x53                                               // pushq        %rbx
+	LONG $0x087f8b4c                                         // movq         $8(%rdi), %r15
+	WORD $0x2949; BYTE $0xf7                                 // subq         %rsi, %r15
+	LONG $0x03a7840f; WORD $0x0000                           // je           LBB18_27, $935(%rip)
+	WORD $0x8b4c; BYTE $0x1f                                 // movq         (%rdi), %r11
+	LONG $0xff02c748; WORD $0xffff; BYTE $0xff               // movq         $-1, (%rdx)
+	LONG $0x40ff8349                                         // cmpq         $64, %r15
+	LONG $0x01f4820f; WORD $0x0000                           // jb           LBB18_28, $500(%rip)
+	LONG $0xffc0c749; WORD $0xffff; BYTE $0xff               // movq         $-1, %r8
+	WORD $0x3145; BYTE $0xf6                                 // xorl         %r14d, %r14d
+	QUAD $0xffffff52056ffdc5                                 // vmovdqa      $-174(%rip), %ymm0  /* LCPI18_0(%rip) */
+	QUAD $0xffffff6a0d6ffdc5                                 // vmovdqa      $-150(%rip), %ymm1  /* LCPI18_1(%rip) */
+	QUAD $0xffffff82156ffdc5                                 // vmovdqa      $-126(%rip), %ymm2  /* LCPI18_2(%rip) */
+	QUAD $0xaaaaaaaaaaaab949; WORD $0xaaaa                   // movabsq      $-6148914691236517206, %r9
+	QUAD $0x555555555555ba49; WORD $0x5555                   // movabsq      $6148914691236517205, %r10
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB18_5:
+	LONG $0x6f7ec1c4; WORD $0x331c             // vmovdqu      (%r11,%rsi), %ymm3
+	LONG $0x6f7ec1c4; WORD $0x3364; BYTE $0x20 // vmovdqu      $32(%r11,%rsi), %ymm4
+	LONG $0xe874e5c5                           // vpcmpeqb     %ymm0, %ymm3, %ymm5
+	LONG $0xe5d77dc5                           // vpmovmskb    %ymm5, %r12d
+	LONG $0xe874ddc5                           // vpcmpeqb     %ymm0, %ymm4, %ymm5
+	LONG $0xcdd7fdc5                           // vpmovmskb    %ymm5, %ecx
+	LONG $0xe974e5c5                           // vpcmpeqb     %ymm1, %ymm3, %ymm5
+	LONG $0xc5d7fdc5                           // vpmovmskb    %ymm5, %eax
+	LONG $0xe974ddc5                           // vpcmpeqb     %ymm1, %ymm4, %ymm5
+	LONG $0xddd7fdc5                           // vpmovmskb    %ymm5, %ebx
+	LONG $0xeadaddc5                           // vpminub      %ymm2, %ymm4, %ymm5
+	LONG $0xe574ddc5                           // vpcmpeqb     %ymm5, %ymm4, %ymm4
+	LONG $0xfcd7fdc5                           // vpmovmskb    %ymm4, %edi
+	LONG $0x20e1c148                           // shlq         $32, %rcx
+	WORD $0x0949; BYTE $0xcc                   // orq          %rcx, %r12
+	LONG $0x20e3c148                           // shlq         $32, %rbx
+	LONG $0x20e7c148                           // shlq         $32, %rdi
+	WORD $0x0948; BYTE $0xd8                   // orq          %rbx, %rax
+	LONG $0x0044850f; WORD $0x0000             // jne          LBB18_11, $68(%rip)
+	WORD $0x854d; BYTE $0xf6                   // testq        %r14, %r14
+	LONG $0x004f850f; WORD $0x0000             // jne          LBB18_13, $79(%rip)
+	WORD $0x3145; BYTE $0xf6                   // xorl         %r14d, %r14d
+
+LBB18_8:
+	LONG $0xe2dae5c5               // vpminub      %ymm2, %ymm3, %ymm4
+	LONG $0xdc74e5c5               // vpcmpeqb     %ymm4, %ymm3, %ymm3
+	LONG $0xc3d7fdc5               // vpmovmskb    %ymm3, %eax
+	WORD $0x0948; BYTE $0xc7       // orq          %rax, %rdi
+	WORD $0x854d; BYTE $0xe4       // testq        %r12, %r12
+	LONG $0x006e850f; WORD $0x0000 // jne          LBB18_14, $110(%rip)
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0x00b3850f; WORD $0x0000 // jne          LBB18_20, $179(%rip)
+	LONG $0xc0c78349               // addq         $-64, %r15
+	LONG $0x40c68348               // addq         $64, %rsi
+	LONG $0x3fff8349               // cmpq         $63, %r15
+	LONG $0xff70870f; WORD $0xffff // ja           LBB18_5, $-144(%rip)
+	LONG $0x0000bce9; BYTE $0x00   // jmp          LBB18_22, $188(%rip)
+
+LBB18_11:
+	LONG $0xfff88349               // cmpq         $-1, %r8
+	LONG $0x000a850f; WORD $0x0000 // jne          LBB18_13, $10(%rip)
+	LONG $0xc0bc0f4c               // bsfq         %rax, %r8
+	WORD $0x0149; BYTE $0xf0       // addq         %rsi, %r8
+	WORD $0x894c; BYTE $0x02       // movq         %r8, (%rdx)
+
+LBB18_13:
+	WORD $0x894c; BYTE $0xf1     // movq         %r14, %rcx
+	WORD $0xf748; BYTE $0xd1     // notq         %rcx
+	WORD $0x2148; BYTE $0xc1     // andq         %rax, %rcx
+	LONG $0x092c8d4c             // leaq         (%rcx,%rcx), %r13
+	WORD $0x094d; BYTE $0xf5     // orq          %r14, %r13
+	WORD $0x894c; BYTE $0xeb     // movq         %r13, %rbx
+	WORD $0xf748; BYTE $0xd3     // notq         %rbx
+	WORD $0x2148; BYTE $0xc3     // andq         %rax, %rbx
+	WORD $0x214c; BYTE $0xcb     // andq         %r9, %rbx
+	WORD $0x3145; BYTE $0xf6     // xorl         %r14d, %r14d
+	WORD $0x0148; BYTE $0xcb     // addq         %rcx, %rbx
+	LONG $0xc6920f41             // setb         %r14b
+	WORD $0x0148; BYTE $0xdb     // addq         %rbx, %rbx
+	WORD $0x314c; BYTE $0xd3     // xorq         %r10, %rbx
+	WORD $0x214c; BYTE $0xeb     // andq         %r13, %rbx
+	WORD $0xf748; BYTE $0xd3     // notq         %rbx
+	WORD $0x2149; BYTE $0xdc     // andq         %rbx, %r12
+	LONG $0xffff7ae9; BYTE $0xff // jmp          LBB18_8, $-134(%rip)
+
+LBB18_14:
+	LONG $0xc4bc0f49               // bsfq         %r12, %rax
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0x0021840f; WORD $0x0000 // je           LBB18_18, $33(%rip)
+	LONG $0xcfbc0f48               // bsfq         %rdi, %rcx
+	WORD $0x3948; BYTE $0xc1       // cmpq         %rax, %rcx
+	LONG $0x0022820f; WORD $0x0000 // jb           LBB18_19, $34(%rip)
+
+LBB18_16:
+	WORD $0x0148; BYTE $0xf0 // addq         %rsi, %rax
+	WORD $0xff48; BYTE $0xc0 // incq         %rax
+
+LBB18_17:
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	BYTE $0xc3               // retq
+
+LBB18_18:
+	LONG $0x000040b9; BYTE $0x00   // movl         $64, %ecx
+	WORD $0x3948; BYTE $0xc1       // cmpq         %rax, %rcx
+	LONG $0xffde830f; WORD $0xffff // jae          LBB18_16, $-34(%rip)
+
+LBB18_19:
+	WORD $0x0148; BYTE $0xf1                   // addq         %rsi, %rcx
+	WORD $0x8948; BYTE $0x0a                   // movq         %rcx, (%rdx)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	LONG $0xffffd2e9; BYTE $0xff               // jmp          LBB18_17, $-46(%rip)
+
+LBB18_20:
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	LONG $0xfff88349                           // cmpq         $-1, %r8
+	LONG $0xffc1850f; WORD $0xffff             // jne          LBB18_17, $-63(%rip)
+	LONG $0xcfbc0f48                           // bsfq         %rdi, %rcx
+	WORD $0x0148; BYTE $0xf1                   // addq         %rsi, %rcx
+	WORD $0x8948; BYTE $0x0a                   // movq         %rcx, (%rdx)
+	LONG $0xffffb2e9; BYTE $0xff               // jmp          LBB18_17, $-78(%rip)
+
+LBB18_22:
+	WORD $0x014c; BYTE $0xde       // addq         %r11, %rsi
+	LONG $0x20ff8349               // cmpq         $32, %r15
+	LONG $0x0107820f; WORD $0x0000 // jb           LBB18_38, $263(%rip)
+
+LBB18_23:
+	LONG $0x066ffec5               // vmovdqu      (%rsi), %ymm0
+	QUAD $0xfffffdb60d74fdc5       // vpcmpeqb     $-586(%rip), %ymm0, %ymm1  /* LCPI18_0(%rip) */
+	LONG $0xc9d77dc5               // vpmovmskb    %ymm1, %r9d
+	QUAD $0xfffffdca0d74fdc5       // vpcmpeqb     $-566(%rip), %ymm0, %ymm1  /* LCPI18_1(%rip) */
+	LONG $0xc1d7fdc5               // vpmovmskb    %ymm1, %eax
+	QUAD $0xfffffdde0ddafdc5       // vpminub      $-546(%rip), %ymm0, %ymm1  /* LCPI18_2(%rip) */
+	LONG $0xc174fdc5               // vpcmpeqb     %ymm1, %ymm0, %ymm0
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x003e850f; WORD $0x0000 // jne          LBB18_29, $62(%rip)
+	WORD $0x854d; BYTE $0xf6       // testq        %r14, %r14
+	LONG $0x004f850f; WORD $0x0000 // jne          LBB18_31, $79(%rip)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	LONG $0xd8d7fdc5               // vpmovmskb    %ymm0, %ebx
+	WORD $0x854d; BYTE $0xc9       // testq        %r9, %r9
+	LONG $0x007c840f; WORD $0x0000 // je           LBB18_32, $124(%rip)
+
+LBB18_26:
+	LONG $0xd1bc0f4d             // bsfq         %r9, %r10
+	LONG $0x000079e9; BYTE $0x00 // jmp          LBB18_33, $121(%rip)
+
+LBB18_28:
+	WORD $0x014c; BYTE $0xde                   // addq         %r11, %rsi
+	LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r8
+	WORD $0x3145; BYTE $0xf6                   // xorl         %r14d, %r14d
+	LONG $0x20ff8349                           // cmpq         $32, %r15
+	LONG $0xff97830f; WORD $0xffff             // jae          LBB18_23, $-105(%rip)
+	LONG $0x000099e9; BYTE $0x00               // jmp          LBB18_38, $153(%rip)
+
+LBB18_29:
+	LONG $0xfff88349               // cmpq         $-1, %r8
+	LONG $0x0010850f; WORD $0x0000 // jne          LBB18_31, $16(%rip)
+	WORD $0x8948; BYTE $0xf1       // movq         %rsi, %rcx
+	WORD $0x294c; BYTE $0xd9       // subq         %r11, %rcx
+	LONG $0xc0bc0f4c               // bsfq         %rax, %r8
+	WORD $0x0149; BYTE $0xc8       // addq         %rcx, %r8
+	WORD $0x894c; BYTE $0x02       // movq         %r8, (%rdx)
+
+LBB18_31:
+	WORD $0x8944; BYTE $0xf1       // movl         %r14d, %ecx
+	WORD $0xd1f7                   // notl         %ecx
+	WORD $0xc121                   // andl         %eax, %ecx
+	WORD $0x3c8d; BYTE $0x09       // leal         (%rcx,%rcx), %edi
+	LONG $0x4e1c8d41               // leal         (%r14,%rcx,2), %ebx
+	WORD $0xd7f7                   // notl         %edi
+	WORD $0xc721                   // andl         %eax, %edi
+	LONG $0xaaaae781; WORD $0xaaaa // andl         $-1431655766, %edi
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	WORD $0xcf01                   // addl         %ecx, %edi
+	LONG $0xc6920f41               // setb         %r14b
+	WORD $0xff01                   // addl         %edi, %edi
+	LONG $0x5555f781; WORD $0x5555 // xorl         $1431655765, %edi
+	WORD $0xdf21                   // andl         %ebx, %edi
+	WORD $0xd7f7                   // notl         %edi
+	WORD $0x2141; BYTE $0xf9       // andl         %edi, %r9d
+	LONG $0xd8d7fdc5               // vpmovmskb    %ymm0, %ebx
+	WORD $0x854d; BYTE $0xc9       // testq        %r9, %r9
+	LONG $0xff84850f; WORD $0xffff // jne          LBB18_26, $-124(%rip)
+
+LBB18_32:
+	LONG $0x0040ba41; WORD $0x0000 // movl         $64, %r10d
+
+LBB18_33:
+	WORD $0xbc0f; BYTE $0xc3       // bsfl         %ebx, %eax
+	LONG $0x000040bf; BYTE $0x00   // movl         $64, %edi
+	WORD $0x450f; BYTE $0xf8       // cmovnel      %eax, %edi
+	WORD $0x854d; BYTE $0xc9       // testq        %r9, %r9
+	LONG $0x0018840f; WORD $0x0000 // je           LBB18_36, $24(%rip)
+	WORD $0x294c; BYTE $0xde       // subq         %r11, %rsi
+	WORD $0x3949; BYTE $0xfa       // cmpq         %rdi, %r10
+	LONG $0x00ad870f; WORD $0x0000 // ja           LBB18_49, $173(%rip)
+	LONG $0x16048d4a               // leaq         (%rsi,%r10), %rax
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	LONG $0xfffeaee9; BYTE $0xff   // jmp          LBB18_17, $-338(%rip)
+
+LBB18_36:
+	WORD $0xdb85                   // testl        %ebx, %ebx
+	LONG $0x00a1850f; WORD $0x0000 // jne          LBB18_50, $161(%rip)
+	LONG $0x20c68348               // addq         $32, %rsi
+	LONG $0xe0c78349               // addq         $-32, %r15
+
+LBB18_38:
+	WORD $0x854d; BYTE $0xf6                   // testq        %r14, %r14
+	LONG $0x00a7850f; WORD $0x0000             // jne          LBB18_51, $167(%rip)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x854d; BYTE $0xff                   // testq        %r15, %r15
+	LONG $0xfe85840f; WORD $0xffff             // je           LBB18_17, $-379(%rip)
+
+LBB18_40:
+	WORD $0xb60f; BYTE $0x3e                   // movzbl       (%rsi), %edi
+	WORD $0xff83; BYTE $0x22                   // cmpl         $34, %edi
+	LONG $0x005e840f; WORD $0x0000             // je           LBB18_48, $94(%rip)
+	WORD $0xff83; BYTE $0x5c                   // cmpl         $92, %edi
+	LONG $0x0027840f; WORD $0x0000             // je           LBB18_45, $39(%rip)
+	LONG $0x1fff8040                           // cmpb         $31, %dil
+	LONG $0x00be860f; WORD $0x0000             // jbe          LBB18_55, $190(%rip)
+	LONG $0xffc7c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rdi
+	LONG $0x000001bb; BYTE $0x00               // movl         $1, %ebx
+
+LBB18_44:
+	WORD $0x0148; BYTE $0xde       // addq         %rbx, %rsi
+	WORD $0x0149; BYTE $0xff       // addq         %rdi, %r15
+	LONG $0xffc9850f; WORD $0xffff // jne          LBB18_40, $-55(%rip)
+	LONG $0xfffe49e9; BYTE $0xff   // jmp          LBB18_17, $-439(%rip)
+
+LBB18_45:
+	LONG $0x01ff8349                           // cmpq         $1, %r15
+	LONG $0xfe3f840f; WORD $0xffff             // je           LBB18_17, $-449(%rip)
+	LONG $0xfec7c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rdi
+	LONG $0x000002bb; BYTE $0x00               // movl         $2, %ebx
+	LONG $0xfff88349                           // cmpq         $-1, %r8
+	LONG $0xffcf850f; WORD $0xffff             // jne          LBB18_44, $-49(%rip)
+	WORD $0x8949; BYTE $0xf0                   // movq         %rsi, %r8
+	WORD $0x294d; BYTE $0xd8                   // subq         %r11, %r8
+	WORD $0x894c; BYTE $0x02                   // movq         %r8, (%rdx)
+	LONG $0xffffc1e9; BYTE $0xff               // jmp          LBB18_44, $-63(%rip)
+
+LBB18_48:
+	WORD $0x294c; BYTE $0xde     // subq         %r11, %rsi
+	WORD $0xff48; BYTE $0xc6     // incq         %rsi
+	WORD $0x8948; BYTE $0xf0     // movq         %rsi, %rax
+	LONG $0xfffe0de9; BYTE $0xff // jmp          LBB18_17, $-499(%rip)
+
+LBB18_49:
+	WORD $0x0148; BYTE $0xfe     // addq         %rdi, %rsi
+	LONG $0x000060e9; BYTE $0x00 // jmp          LBB18_56, $96(%rip)
+
+LBB18_50:
+	WORD $0x294c; BYTE $0xde                   // subq         %r11, %rsi
+	WORD $0xc089                               // movl         %eax, %eax
+	WORD $0x0148; BYTE $0xf0                   // addq         %rsi, %rax
+	WORD $0x8948; BYTE $0x02                   // movq         %rax, (%rdx)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	LONG $0xfffdeee9; BYTE $0xff               // jmp          LBB18_17, $-530(%rip)
+
+LBB18_51:
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x0031840f; WORD $0x0000 // je           LBB18_27, $49(%rip)
+	LONG $0xfff88349               // cmpq         $-1, %r8
+	LONG $0x000c850f; WORD $0x0000 // jne          LBB18_54, $12(%rip)
+	WORD $0x894d; BYTE $0xd8       // movq         %r11, %r8
+	WORD $0xf749; BYTE $0xd0       // notq         %r8
+	WORD $0x0149; BYTE $0xf0       // addq         %rsi, %r8
+	WORD $0x894c; BYTE $0x02       // movq         %r8, (%rdx)
+
+LBB18_54:
+	WORD $0xff48; BYTE $0xc6                   // incq         %rsi
+	WORD $0xff49; BYTE $0xcf                   // decq         %r15
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x854d; BYTE $0xff                   // testq        %r15, %r15
+	LONG $0xff34850f; WORD $0xffff             // jne          LBB18_40, $-204(%rip)
+	LONG $0xfffdb4e9; BYTE $0xff               // jmp          LBB18_17, $-588(%rip)
+
+LBB18_27:
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xfffda8e9; BYTE $0xff               // jmp          LBB18_17, $-600(%rip)
+
+LBB18_55:
+	WORD $0x294c; BYTE $0xde // subq         %r11, %rsi
+
+LBB18_56:
+	WORD $0x8948; BYTE $0x32                   // movq         %rsi, (%rdx)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	LONG $0xfffd96e9; BYTE $0xff               // jmp          LBB18_17, $-618(%rip)
+	WORD $0x0000; BYTE $0x00                   // .p2align 4, 0x00
+
+LCPI19_0:
+	LONG $0x43300000 // .long 1127219200
+	LONG $0x45300000 // .long 1160773632
+	LONG $0x00000000 // .long 0
+	LONG $0x00000000 // .long 0
+
+LCPI19_1:
+	QUAD $0x4330000000000000 // .quad 0x4330000000000000
+	QUAD $0x4530000000000000 // .quad 0x4530000000000000
+
+	// .p2align 3, 0x00
+LCPI19_2:
+	QUAD $0x430c6bf526340000 // .quad 0x430c6bf526340000
+
+LCPI19_3:
+	QUAD $0xc30c6bf526340000 // .quad 0xc30c6bf526340000
+
+	// .p2align 4, 0x90
+_vnumber:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x38ec8348                           // subq         $56, %rsp
+	WORD $0x8948; BYTE $0xd3                   // movq         %rdx, %rbx
+	WORD $0x8949; BYTE $0xf6                   // movq         %rsi, %r14
+	WORD $0x8b48; BYTE $0x06                   // movq         (%rsi), %rax
+	WORD $0x8b4c; BYTE $0x3f                   // movq         (%rdi), %r15
+	LONG $0x086f8b4c                           // movq         $8(%rdi), %r13
+	LONG $0x20528b4c                           // movq         $32(%rdx), %r10
+	LONG $0x285a8b4c                           // movq         $40(%rdx), %r11
+	LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq         $9, (%rdx)
+	LONG $0xc057f9c5                           // vxorpd       %xmm0, %xmm0, %xmm0
+	LONG $0x4211f9c5; BYTE $0x08               // vmovupd      %xmm0, $8(%rdx)
+	WORD $0x8b48; BYTE $0x0e                   // movq         (%rsi), %rcx
+	LONG $0x184a8948                           // movq         %rcx, $24(%rdx)
+	WORD $0x394c; BYTE $0xe8                   // cmpq         %r13, %rax
+	LONG $0x02c9830f; WORD $0x0000             // jae          LBB19_51, $713(%rip)
+	LONG $0x0cb60f41; BYTE $0x07               // movzbl       (%r15,%rax), %ecx
+	LONG $0x000001bf; BYTE $0x00               // movl         $1, %edi
+	WORD $0xf980; BYTE $0x2d                   // cmpb         $45, %cl
+	LONG $0x0016850f; WORD $0x0000             // jne          LBB19_4, $22(%rip)
+	WORD $0xff48; BYTE $0xc0                   // incq         %rax
+	WORD $0x394c; BYTE $0xe8                   // cmpq         %r13, %rax
+	LONG $0x02aa830f; WORD $0x0000             // jae          LBB19_51, $682(%rip)
+	LONG $0x0cb60f41; BYTE $0x07               // movzbl       (%r15,%rax), %ecx
+	LONG $0xffffffbf; BYTE $0xff               // movl         $-1, %edi
+
+LBB19_4:
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB19_6, $15(%rip)
+
+LBB19_5:
+	WORD $0x8949; BYTE $0x06                   // movq         %rax, (%r14)
+	LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq         $-2, (%rbx)
+	LONG $0x00028fe9; BYTE $0x00               // jmp          LBB19_52, $655(%rip)
+
+LBB19_6:
+	WORD $0xf980; BYTE $0x30               // cmpb         $48, %cl
+	LONG $0x0032850f; WORD $0x0000         // jne          LBB19_10, $50(%rip)
+	LONG $0x01488d48                       // leaq         $1(%rax), %rcx
+	WORD $0x394c; BYTE $0xe8               // cmpq         %r13, %rax
+	LONG $0x00a6830f; WORD $0x0000         // jae          LBB19_18, $166(%rip)
+	LONG $0x14b60f41; BYTE $0x0f           // movzbl       (%r15,%rcx), %edx
+	WORD $0xc283; BYTE $0xd2               // addl         $-46, %edx
+	WORD $0xfa83; BYTE $0x37               // cmpl         $55, %edx
+	LONG $0x0095870f; WORD $0x0000         // ja           LBB19_18, $149(%rip)
+	QUAD $0x000000800001be48; WORD $0x0080 // movabsq      $36028797027352577, %rsi
+	LONG $0xd6a30f48                       // btq          %rdx, %rsi
+	LONG $0x0081830f; WORD $0x0000         // jae          LBB19_18, $129(%rip)
+
+LBB19_10:
+	WORD $0x7d89; BYTE $0xd4       // movl         %edi, $-44(%rbp)
+	WORD $0x01b1                   // movb         $1, %cl
+	WORD $0x4d89; BYTE $0xc8       // movl         %ecx, $-56(%rbp)
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	LONG $0x0063830f; WORD $0x0000 // jae          LBB19_17, $99(%rip)
+	WORD $0x3145; BYTE $0xe4       // xorl         %r12d, %r12d
+	LONG $0xffd0b941; WORD $0xffff // movl         $4294967248, %r9d
+	WORD $0x3145; BYTE $0xc0       // xorl         %r8d, %r8d
+	WORD $0xc931                   // xorl         %ecx, %ecx
+	LONG $0x000012e9; BYTE $0x00   // jmp          LBB19_13, $18(%rip)
+	LONG $0x90909090               // .p2align 4, 0x90
+
+LBB19_12:
+	WORD $0xc1ff                   // incl         %ecx
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3949; BYTE $0xc5       // cmpq         %rax, %r13
+	LONG $0x0036840f; WORD $0x0000 // je           LBB19_16, $54(%rip)
+
+LBB19_13:
+	LONG $0x14be0f49; BYTE $0x07   // movsbq       (%r15,%rax), %rdx
+	WORD $0x7a8d; BYTE $0xd0       // leal         $-48(%rdx), %edi
+	LONG $0x09ff8040               // cmpb         $9, %dil
+	LONG $0x0041870f; WORD $0x0000 // ja           LBB19_19, $65(%rip)
+	LONG $0x12f88341               // cmpl         $18, %r8d
+	LONG $0xffd68f0f; WORD $0xffff // jg           LBB19_12, $-42(%rip)
+	LONG $0xa43c8d4b               // leaq         (%r12,%r12,4), %rdi
+	WORD $0x0144; BYTE $0xca       // addl         %r9d, %edx
+	LONG $0x7a248d4c               // leaq         (%rdx,%rdi,2), %r12
+	WORD $0xff41; BYTE $0xc0       // incl         %r8d
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3949; BYTE $0xc5       // cmpq         %rax, %r13
+	LONG $0xffca850f; WORD $0xffff // jne          LBB19_13, $-54(%rip)
+
+LBB19_16:
+	WORD $0x894c; BYTE $0xe8     // movq         %r13, %rax
+	LONG $0x00005be9; BYTE $0x00 // jmp          LBB19_24, $91(%rip)
+
+LBB19_17:
+	WORD $0xc931                 // xorl         %ecx, %ecx
+	WORD $0x3145; BYTE $0xc0     // xorl         %r8d, %r8d
+	WORD $0x3145; BYTE $0xe4     // xorl         %r12d, %r12d
+	LONG $0x00004ee9; BYTE $0x00 // jmp          LBB19_24, $78(%rip)
+
+LBB19_18:
+	WORD $0x8949; BYTE $0x0e     // movq         %rcx, (%r14)
+	LONG $0x0001cbe9; BYTE $0x00 // jmp          LBB19_52, $459(%rip)
+
+LBB19_19:
+	WORD $0xfa80; BYTE $0x2e                   // cmpb         $46, %dl
+	LONG $0x003d850f; WORD $0x0000             // jne          LBB19_24, $61(%rip)
+	LONG $0x01508d48                           // leaq         $1(%rax), %rdx
+	LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq         $8, (%rbx)
+	WORD $0x394c; BYTE $0xea                   // cmpq         %r13, %rdx
+	LONG $0x01a4830f; WORD $0x0000             // jae          LBB19_51, $420(%rip)
+	LONG $0x44b60f41; WORD $0x0107             // movzbl       $1(%r15,%rax), %eax
+	WORD $0xc604                               // addb         $-58, %al
+	WORD $0xf53c                               // cmpb         $-11, %al
+	LONG $0x000f870f; WORD $0x0000             // ja           LBB19_23, $15(%rip)
+	WORD $0x8949; BYTE $0x16                   // movq         %rdx, (%r14)
+	LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq         $-2, (%rbx)
+	LONG $0x00018fe9; BYTE $0x00               // jmp          LBB19_52, $399(%rip)
+
+LBB19_23:
+	LONG $0x00c845c7; WORD $0x0000; BYTE $0x00 // movl         $0, $-56(%rbp)
+	WORD $0x8948; BYTE $0xd0                   // movq         %rdx, %rax
+
+LBB19_24:
+	WORD $0xd231                                       // xorl         %edx, %edx
+	WORD $0xc985                                       // testl        %ecx, %ecx
+	WORD $0x9f0f; BYTE $0xc2                           // setg         %dl
+	WORD $0x5589; BYTE $0xbc                           // movl         %edx, $-68(%rbp)
+	WORD $0x854d; BYTE $0xe4                           // testq        %r12, %r12
+	LONG $0x005d850f; WORD $0x0000                     // jne          LBB19_33, $93(%rip)
+	WORD $0xc985                                       // testl        %ecx, %ecx
+	LONG $0x0055850f; WORD $0x0000                     // jne          LBB19_33, $85(%rip)
+	WORD $0x394c; BYTE $0xe8                           // cmpq         %r13, %rax
+	LONG $0x0044830f; WORD $0x0000                     // jae          LBB19_31, $68(%rip)
+	WORD $0xc689                                       // movl         %eax, %esi
+	WORD $0x2944; BYTE $0xee                           // subl         %r13d, %esi
+	WORD $0x3145; BYTE $0xc0                           // xorl         %r8d, %r8d
+	WORD $0xc931                                       // xorl         %ecx, %ecx
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB19_28:
+	LONG $0x073c8041; BYTE $0x30   // cmpb         $48, (%r15,%rax)
+	LONG $0x0029850f; WORD $0x0000 // jne          LBB19_32, $41(%rip)
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0xc9ff                   // decl         %ecx
+	WORD $0x3949; BYTE $0xc5       // cmpq         %rax, %r13
+	LONG $0xffe7850f; WORD $0xffff // jne          LBB19_28, $-25(%rip)
+	WORD $0x3145; BYTE $0xe4       // xorl         %r12d, %r12d
+	WORD $0x458b; BYTE $0xc8       // movl         $-56(%rbp), %eax
+	WORD $0xc084                   // testb        %al, %al
+	LONG $0x0144850f; WORD $0x0000 // jne          LBB19_54, $324(%rip)
+
+LBB19_59:
+	WORD $0x558b; BYTE $0xd4     // movl         $-44(%rbp), %edx
+	LONG $0x000173e9; BYTE $0x00 // jmp          LBB19_60, $371(%rip)
+
+LBB19_31:
+	WORD $0xc931             // xorl         %ecx, %ecx
+	WORD $0x3145; BYTE $0xc0 // xorl         %r8d, %r8d
+
+LBB19_32:
+	WORD $0x3145; BYTE $0xe4 // xorl         %r12d, %r12d
+
+LBB19_33:
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	LONG $0x004c830f; WORD $0x0000 // jae          LBB19_39, $76(%rip)
+	LONG $0x12f88341               // cmpl         $18, %r8d
+	LONG $0x00428f0f; WORD $0x0000 // jg           LBB19_39, $66(%rip)
+	LONG $0xffd0b941; WORD $0xffff // movl         $4294967248, %r9d
+
+	// .p2align 4, 0x90
+LBB19_36:
+	LONG $0x14b60f41; BYTE $0x07   // movzbl       (%r15,%rax), %edx
+	WORD $0x7a8d; BYTE $0xd0       // leal         $-48(%rdx), %edi
+	LONG $0x09ff8040               // cmpb         $9, %dil
+	LONG $0x002a870f; WORD $0x0000 // ja           LBB19_39, $42(%rip)
+	LONG $0xa43c8d4b               // leaq         (%r12,%r12,4), %rdi
+	WORD $0x0144; BYTE $0xca       // addl         %r9d, %edx
+	LONG $0x7a248d4c               // leaq         (%rdx,%rdi,2), %r12
+	WORD $0xc9ff                   // decl         %ecx
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	LONG $0x0011830f; WORD $0x0000 // jae          LBB19_39, $17(%rip)
+	LONG $0x01508d41               // leal         $1(%r8), %edx
+	LONG $0x12f88341               // cmpl         $18, %r8d
+	WORD $0x8941; BYTE $0xd0       // movl         %edx, %r8d
+	LONG $0xffc48c0f; WORD $0xffff // jl           LBB19_36, $-60(%rip)
+
+LBB19_39:
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	LONG $0x00c6830f; WORD $0x0000 // jae          LBB19_53, $198(%rip)
+	LONG $0x34b60f41; BYTE $0x07   // movzbl       (%r15,%rax), %esi
+	WORD $0x568d; BYTE $0xd0       // leal         $-48(%rsi), %edx
+	WORD $0xfa80; BYTE $0x09       // cmpb         $9, %dl
+	LONG $0x0030870f; WORD $0x0000 // ja           LBB19_45, $48(%rip)
+	LONG $0xff558d49               // leaq         $-1(%r13), %rdx
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB19_42:
+	WORD $0x3948; BYTE $0xc2                   // cmpq         %rax, %rdx
+	LONG $0x0180840f; WORD $0x0000             // je           LBB19_58, $384(%rip)
+	LONG $0x74b60f41; WORD $0x0107             // movzbl       $1(%r15,%rax), %esi
+	WORD $0x7e8d; BYTE $0xd0                   // leal         $-48(%rsi), %edi
+	WORD $0xff48; BYTE $0xc0                   // incq         %rax
+	LONG $0x09ff8040                           // cmpb         $9, %dil
+	LONG $0xffe1860f; WORD $0xffff             // jbe          LBB19_42, $-31(%rip)
+	LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl         $1, $-68(%rbp)
+
+LBB19_45:
+	LONG $0xd6b60f40                           // movzbl       %sil, %edx
+	WORD $0xca83; BYTE $0x20                   // orl          $32, %edx
+	WORD $0xfa83; BYTE $0x65                   // cmpl         $101, %edx
+	LONG $0x0075850f; WORD $0x0000             // jne          LBB19_53, $117(%rip)
+	LONG $0x01788d48                           // leaq         $1(%rax), %rdi
+	LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq         $8, (%rbx)
+	WORD $0x394c; BYTE $0xef                   // cmpq         %r13, %rdi
+	LONG $0x0048830f; WORD $0x0000             // jae          LBB19_51, $72(%rip)
+	LONG $0x34b60f41; BYTE $0x3f               // movzbl       (%r15,%rdi), %esi
+	WORD $0xfe83; BYTE $0x2d                   // cmpl         $45, %esi
+	LONG $0x000f840f; WORD $0x0000             // je           LBB19_49, $15(%rip)
+	LONG $0x0001b841; WORD $0x0000             // movl         $1, %r8d
+	WORD $0xfe83; BYTE $0x2b                   // cmpl         $43, %esi
+	LONG $0x02a8850f; WORD $0x0000             // jne          LBB19_86, $680(%rip)
+
+LBB19_49:
+	LONG $0x02c08348               // addq         $2, %rax
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	WORD $0x558b; BYTE $0xd4       // movl         $-44(%rbp), %edx
+	LONG $0x001b830f; WORD $0x0000 // jae          LBB19_51, $27(%rip)
+	WORD $0xff31                   // xorl         %edi, %edi
+	LONG $0x2bfe8040               // cmpb         $43, %sil
+	LONG $0xc7940f40               // sete         %dil
+	LONG $0x3f048d44               // leal         (%rdi,%rdi), %r8d
+	WORD $0xff41; BYTE $0xc8       // decl         %r8d
+	LONG $0x34b60f41; BYTE $0x07   // movzbl       (%r15,%rax), %esi
+	LONG $0x000283e9; BYTE $0x00   // jmp          LBB19_87, $643(%rip)
+
+LBB19_51:
+	WORD $0x894d; BYTE $0x2e                   // movq         %r13, (%r14)
+	LONG $0xff03c748; WORD $0xffff; BYTE $0xff // movq         $-1, (%rbx)
+
+LBB19_52:
+	LONG $0x38c48348 // addq         $56, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5d41     // popq         %r13
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB19_53:
+	WORD $0xce89                   // movl         %ecx, %esi
+	WORD $0x8949; BYTE $0xc5       // movq         %rax, %r13
+	WORD $0x458b; BYTE $0xc8       // movl         $-56(%rbp), %eax
+	WORD $0xc084                   // testb        %al, %al
+	LONG $0xfebc840f; WORD $0xffff // je           LBB19_59, $-324(%rip)
+
+LBB19_54:
+	WORD $0xf685                           // testl        %esi, %esi
+	WORD $0x558b; BYTE $0xd4               // movl         $-44(%rbp), %edx
+	LONG $0x0025850f; WORD $0x0000         // jne          LBB19_57, $37(%rip)
+	QUAD $0x000000000000b848; WORD $0x8000 // movabsq      $-9223372036854775808, %rax
+	WORD $0x6348; BYTE $0xca               // movslq       %edx, %rcx
+	WORD $0x854d; BYTE $0xe4               // testq        %r12, %r12
+	LONG $0x00e7890f; WORD $0x0000         // jns          LBB19_68, $231(%rip)
+	WORD $0x894c; BYTE $0xe7               // movq         %r12, %rdi
+	WORD $0x2148; BYTE $0xcf               // andq         %rcx, %rdi
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x00d8840f; WORD $0x0000         // je           LBB19_68, $216(%rip)
+
+LBB19_57:
+	LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq         $8, (%rbx)
+
+LBB19_60:
+	LONG $0x6ef9c1c4; BYTE $0xc4               // vmovq        %r12, %xmm0
+	QUAD $0xfffffc510562f9c5                   // vpunpckldq   $-943(%rip), %xmm0, %xmm0  /* LCPI19_0(%rip) */
+	QUAD $0x00000000b045c748                   // movq         $0, $-80(%rbp)
+	QUAD $0xfffffc51055cf9c5                   // vsubpd       $-943(%rip), %xmm0, %xmm0  /* LCPI19_1(%rip) */
+	LONG $0x0579e3c4; WORD $0x01c8             // vpermilpd    $1, %xmm0, %xmm1
+	LONG $0xc058f3c5                           // vaddsd       %xmm0, %xmm1, %xmm0
+	LONG $0x4511fbc5; BYTE $0xc0               // vmovsd       %xmm0, $-64(%rbp)
+	WORD $0x894c; BYTE $0xe0                   // movq         %r12, %rax
+	LONG $0x34e8c148                           // shrq         $52, %rax
+	LONG $0x010d850f; WORD $0x0000             // jne          LBB19_73, $269(%rip)
+	LONG $0x7ef9e1c4; BYTE $0xc1               // vmovq        %xmm0, %rcx
+	WORD $0xd089                               // movl         %edx, %eax
+	WORD $0xe8c1; BYTE $0x1f                   // shrl         $31, %eax
+	LONG $0x3fe0c148                           // shlq         $63, %rax
+	WORD $0x0948; BYTE $0xc8                   // orq          %rcx, %rax
+	LONG $0xc0458948                           // movq         %rax, $-64(%rbp)
+	WORD $0x854d; BYTE $0xe4                   // testq        %r12, %r12
+	LONG $0x018a840f; WORD $0x0000             // je           LBB19_81, $394(%rip)
+	WORD $0xf685                               // testl        %esi, %esi
+	LONG $0x0182840f; WORD $0x0000             // je           LBB19_81, $386(%rip)
+	LONG $0x6ef9e1c4; BYTE $0xc0               // vmovq        %rax, %xmm0
+	WORD $0x468d; BYTE $0xff                   // leal         $-1(%rsi), %eax
+	WORD $0xf883; BYTE $0x24                   // cmpl         $36, %eax
+	LONG $0x0040870f; WORD $0x0000             // ja           LBB19_66, $64(%rip)
+	WORD $0xfe83; BYTE $0x17                   // cmpl         $23, %esi
+	LONG $0x0093820f; WORD $0x0000             // jb           LBB19_69, $147(%rip)
+	WORD $0x468d; BYTE $0xea                   // leal         $-22(%rsi), %eax
+	LONG $0xab0d8d48; WORD $0x00ed; BYTE $0x00 // leaq         $60843(%rip), %rcx  /* _P10_TAB(%rip) */
+	LONG $0x0459fbc5; BYTE $0xc1               // vmulsd       (%rcx,%rax,8), %xmm0, %xmm0
+	LONG $0x4511fbc5; BYTE $0xc0               // vmovsd       %xmm0, $-64(%rbp)
+	LONG $0x000016b8; BYTE $0x00               // movl         $22, %eax
+	LONG $0x000077e9; BYTE $0x00               // jmp          LBB19_70, $119(%rip)
+
+LBB19_58:
+	LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl         $1, $-68(%rbp)
+	WORD $0xce89                               // movl         %ecx, %esi
+	WORD $0x458b; BYTE $0xc8                   // movl         $-56(%rbp), %eax
+	WORD $0xc084                               // testb        %al, %al
+	LONG $0xff1e850f; WORD $0xffff             // jne          LBB19_54, $-226(%rip)
+	LONG $0xfffdd5e9; BYTE $0xff               // jmp          LBB19_59, $-555(%rip)
+
+LBB19_66:
+	WORD $0xfe83; BYTE $0xea                   // cmpl         $-22, %esi
+	LONG $0x008d820f; WORD $0x0000             // jb           LBB19_73, $141(%rip)
+	WORD $0xdef7                               // negl         %esi
+	LONG $0x6c058d48; WORD $0x00ed; BYTE $0x00 // leaq         $60780(%rip), %rax  /* _P10_TAB(%rip) */
+	LONG $0x045efbc5; BYTE $0xf0               // vdivsd       (%rax,%rsi,8), %xmm0, %xmm0
+	LONG $0x4511fbc5; BYTE $0xc0               // vmovsd       %xmm0, $-64(%rbp)
+	LONG $0x0000d7e9; BYTE $0x00               // jmp          LBB19_77, $215(%rip)
+
+LBB19_68:
+	LONG $0x6ef9c1c4; BYTE $0xc4   // vmovq        %r12, %xmm0
+	LONG $0xe1af0f4c               // imulq        %rcx, %r12
+	QUAD $0xfffffb7c0562f9c5       // vpunpckldq   $-1156(%rip), %xmm0, %xmm0  /* LCPI19_0(%rip) */
+	QUAD $0xfffffb84055cf9c5       // vsubpd       $-1148(%rip), %xmm0, %xmm0  /* LCPI19_1(%rip) */
+	LONG $0x1063894c               // movq         %r12, $16(%rbx)
+	LONG $0x0579e3c4; WORD $0x01c8 // vpermilpd    $1, %xmm0, %xmm1
+	LONG $0xc058f3c5               // vaddsd       %xmm0, %xmm1, %xmm0
+	WORD $0x2148; BYTE $0xc8       // andq         %rcx, %rax
+	LONG $0x7ef9e1c4; BYTE $0xc1   // vmovq        %xmm0, %rcx
+	WORD $0x0948; BYTE $0xc1       // orq          %rax, %rcx
+	LONG $0x084b8948               // movq         %rcx, $8(%rbx)
+	LONG $0x000109e9; BYTE $0x00   // jmp          LBB19_85, $265(%rip)
+
+LBB19_69:
+	WORD $0xf089 // movl         %esi, %eax
+
+LBB19_70:
+	QUAD $0xfffffb68052ef9c5                   // vucomisd     $-1176(%rip), %xmm0  /* LCPI19_2(%rip) */
+	LONG $0x002a870f; WORD $0x0000             // ja           LBB19_73, $42(%rip)
+	QUAD $0xfffffb620d10fbc5                   // vmovsd       $-1182(%rip), %xmm1  /* LCPI19_3(%rip) */
+	LONG $0xc82ef9c5                           // vucomisd     %xmm0, %xmm1
+	LONG $0x0018870f; WORD $0x0000             // ja           LBB19_73, $24(%rip)
+	WORD $0xc089                               // movl         %eax, %eax
+	LONG $0xf70d8d48; WORD $0x00ec; BYTE $0x00 // leaq         $60663(%rip), %rcx  /* _P10_TAB(%rip) */
+	LONG $0x0459fbc5; BYTE $0xc1               // vmulsd       (%rcx,%rax,8), %xmm0, %xmm0
+	LONG $0x4511fbc5; BYTE $0xc0               // vmovsd       %xmm0, $-64(%rbp)
+	LONG $0x000062e9; BYTE $0x00               // jmp          LBB19_77, $98(%rip)
+
+LBB19_73:
+	LONG $0xa05d894c               // movq         %r11, $-96(%rbp)
+	LONG $0xc855894c               // movq         %r10, $-56(%rbp)
+	LONG $0xc04d8d48               // leaq         $-64(%rbp), %rcx
+	WORD $0x894c; BYTE $0xe7       // movq         %r12, %rdi
+	LONG $0xa8758948               // movq         %rsi, $-88(%rbp)
+	LONG $0xffe0c0e8; BYTE $0xff   // callq        _atof_eisel_lemire64, $-8000(%rip)
+	WORD $0xc084                   // testb        %al, %al
+	LONG $0x004c840f; WORD $0x0000 // je           LBB19_79, $76(%rip)
+	LONG $0x00bc7d83               // cmpl         $0, $-68(%rbp)
+	LONG $0x006d840f; WORD $0x0000 // je           LBB19_80, $109(%rip)
+	WORD $0xff49; BYTE $0xc4       // incq         %r12
+	LONG $0xb04d8d48               // leaq         $-80(%rbp), %rcx
+	WORD $0x894c; BYTE $0xe7       // movq         %r12, %rdi
+	LONG $0xa8758b48               // movq         $-88(%rbp), %rsi
+	WORD $0x558b; BYTE $0xd4       // movl         $-44(%rbp), %edx
+	LONG $0xffe098e8; BYTE $0xff   // callq        _atof_eisel_lemire64, $-8040(%rip)
+	WORD $0xc084                   // testb        %al, %al
+	LONG $0x0024840f; WORD $0x0000 // je           LBB19_79, $36(%rip)
+	LONG $0x4d10fbc5; BYTE $0xb0   // vmovsd       $-80(%rbp), %xmm1
+	LONG $0x4510fbc5; BYTE $0xc0   // vmovsd       $-64(%rbp), %xmm0
+	LONG $0xc82ef9c5               // vucomisd     %xmm0, %xmm1
+	LONG $0x0010850f; WORD $0x0000 // jne          LBB19_79, $16(%rip)
+	LONG $0x000a8a0f; WORD $0x0000 // jp           LBB19_79, $10(%rip)
+
+LBB19_77:
+	LONG $0x7ef9e1c4; BYTE $0xc0 // vmovq        %xmm0, %rax
+	LONG $0x00002fe9; BYTE $0x00 // jmp          LBB19_81, $47(%rip)
+
+LBB19_79:
+	WORD $0x8b49; BYTE $0x06     // movq         (%r14), %rax
+	WORD $0x0149; BYTE $0xc7     // addq         %rax, %r15
+	WORD $0x894c; BYTE $0xee     // movq         %r13, %rsi
+	WORD $0x2948; BYTE $0xc6     // subq         %rax, %rsi
+	WORD $0x894c; BYTE $0xff     // movq         %r15, %rdi
+	LONG $0xc8558b48             // movq         $-56(%rbp), %rdx
+	LONG $0xa04d8b48             // movq         $-96(%rbp), %rcx
+	LONG $0xffe810e8; BYTE $0xff // callq        _atof_native, $-6128(%rip)
+	LONG $0x4511fbc5; BYTE $0xc0 // vmovsd       %xmm0, $-64(%rbp)
+	LONG $0x7ef9e1c4; BYTE $0xc0 // vmovq        %xmm0, %rax
+	LONG $0x000009e9; BYTE $0x00 // jmp          LBB19_82, $9(%rip)
+
+LBB19_80:
+	LONG $0xc0458b48 // movq         $-64(%rbp), %rax
+
+LBB19_81:
+	LONG $0x6ef9e1c4; BYTE $0xc0 // vmovq        %rax, %xmm0
+
+LBB19_82:
+	QUAD $0x000000000000b948; WORD $0x8000     // movabsq      $-9223372036854775808, %rcx
+	WORD $0xff48; BYTE $0xc9                   // decq         %rcx
+	WORD $0x2148; BYTE $0xc1                   // andq         %rax, %rcx
+	QUAD $0x000000000000b848; WORD $0x7ff0     // movabsq      $9218868437227405312, %rax
+	WORD $0x3948; BYTE $0xc1                   // cmpq         %rax, %rcx
+	LONG $0x0007850f; WORD $0x0000             // jne          LBB19_84, $7(%rip)
+	LONG $0xf803c748; WORD $0xffff; BYTE $0xff // movq         $-8, (%rbx)
+
+LBB19_84:
+	LONG $0x4311fbc5; BYTE $0x08 // vmovsd       %xmm0, $8(%rbx)
+
+LBB19_85:
+	WORD $0x894d; BYTE $0x2e     // movq         %r13, (%r14)
+	LONG $0xfffd8de9; BYTE $0xff // jmp          LBB19_52, $-627(%rip)
+
+LBB19_86:
+	WORD $0x8948; BYTE $0xf8 // movq         %rdi, %rax
+	WORD $0x558b; BYTE $0xd4 // movl         $-44(%rbp), %edx
+
+LBB19_87:
+	LONG $0xc6c68040               // addb         $-58, %sil
+	LONG $0xf6fe8040               // cmpb         $-10, %sil
+	LONG $0xfadb820f; WORD $0xffff // jb           LBB19_5, $-1317(%rip)
+	WORD $0xf631                   // xorl         %esi, %esi
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	LONG $0x0035830f; WORD $0x0000 // jae          LBB19_93, $53(%rip)
+	WORD $0xf631                   // xorl         %esi, %esi
+
+LBB19_90:
+	LONG $0x0cb60f45; BYTE $0x07   // movzbl       (%r15,%rax), %r9d
+	LONG $0xd0798d41               // leal         $-48(%r9), %edi
+	LONG $0x09ff8040               // cmpb         $9, %dil
+	LONG $0x0020870f; WORD $0x0000 // ja           LBB19_93, $32(%rip)
+	LONG $0x2710fe81; WORD $0x0000 // cmpl         $10000, %esi
+	WORD $0x3c8d; BYTE $0xb6       // leal         (%rsi,%rsi,4), %edi
+	LONG $0x797c8d41; BYTE $0xd0   // leal         $-48(%r9,%rdi,2), %edi
+	WORD $0x4c0f; BYTE $0xf7       // cmovll       %edi, %esi
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3949; BYTE $0xc5       // cmpq         %rax, %r13
+	LONG $0xffd0850f; WORD $0xffff // jne          LBB19_90, $-48(%rip)
+	WORD $0x894c; BYTE $0xe8       // movq         %r13, %rax
+
+LBB19_93:
+	LONG $0xf0af0f41                                                     // imull        %r8d, %esi
+	WORD $0xce01                                                         // addl         %ecx, %esi
+	WORD $0x8949; BYTE $0xc5                                             // movq         %rax, %r13
+	LONG $0xfffd81e9; BYTE $0xff                                         // jmp          LBB19_60, $-639(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+_vsigned:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	BYTE $0x53                                 // pushq        %rbx
+	WORD $0x8b48; BYTE $0x06                   // movq         (%rsi), %rax
+	WORD $0x8b4c; BYTE $0x0f                   // movq         (%rdi), %r9
+	LONG $0x085f8b4c                           // movq         $8(%rdi), %r11
+	LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq         $9, (%rdx)
+	LONG $0xc057f8c5                           // vxorps       %xmm0, %xmm0, %xmm0
+	LONG $0x4211f8c5; BYTE $0x08               // vmovups      %xmm0, $8(%rdx)
+	WORD $0x8b48; BYTE $0x0e                   // movq         (%rsi), %rcx
+	LONG $0x184a8948                           // movq         %rcx, $24(%rdx)
+	WORD $0x394c; BYTE $0xd8                   // cmpq         %r11, %rax
+	LONG $0x0046830f; WORD $0x0000             // jae          LBB20_1, $70(%rip)
+	LONG $0x0cb60f41; BYTE $0x01               // movzbl       (%r9,%rax), %ecx
+	LONG $0x0001b841; WORD $0x0000             // movl         $1, %r8d
+	WORD $0xf980; BYTE $0x2d                   // cmpb         $45, %cl
+	LONG $0x0018850f; WORD $0x0000             // jne          LBB20_5, $24(%rip)
+	WORD $0xff48; BYTE $0xc0                   // incq         %rax
+	WORD $0x394c; BYTE $0xd8                   // cmpq         %r11, %rax
+	LONG $0x0026830f; WORD $0x0000             // jae          LBB20_1, $38(%rip)
+	LONG $0x0cb60f41; BYTE $0x01               // movzbl       (%r9,%rax), %ecx
+	LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r8
+
+LBB20_5:
+	WORD $0x798d; BYTE $0xc6                   // leal         $-58(%rcx), %edi
+	LONG $0xf5ff8040                           // cmpb         $-11, %dil
+	LONG $0x001a870f; WORD $0x0000             // ja           LBB20_7, $26(%rip)
+	WORD $0x8948; BYTE $0x06                   // movq         %rax, (%rsi)
+	LONG $0xfe02c748; WORD $0xffff; BYTE $0xff // movq         $-2, (%rdx)
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB20_1:
+	WORD $0x894c; BYTE $0x1e                   // movq         %r11, (%rsi)
+	LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq         $-1, (%rdx)
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB20_7:
+	WORD $0xf980; BYTE $0x30               // cmpb         $48, %cl
+	LONG $0x0032850f; WORD $0x0000         // jne          LBB20_12, $50(%rip)
+	LONG $0x01508d4c                       // leaq         $1(%rax), %r10
+	WORD $0x394c; BYTE $0xd8               // cmpq         %r11, %rax
+	LONG $0x007f830f; WORD $0x0000         // jae          LBB20_11, $127(%rip)
+	LONG $0x3cb60f43; BYTE $0x11           // movzbl       (%r9,%r10), %edi
+	WORD $0xc783; BYTE $0xd2               // addl         $-46, %edi
+	WORD $0xff83; BYTE $0x37               // cmpl         $55, %edi
+	LONG $0x006e870f; WORD $0x0000         // ja           LBB20_11, $110(%rip)
+	QUAD $0x000000800001b948; WORD $0x0080 // movabsq      $36028797027352577, %rcx
+	LONG $0xf9a30f48                       // btq          %rdi, %rcx
+	LONG $0x005a830f; WORD $0x0000         // jae          LBB20_11, $90(%rip)
+
+LBB20_12:
+	WORD $0x394c; BYTE $0xd8                   // cmpq         %r11, %rax
+	WORD $0x894d; BYTE $0xda                   // movq         %r11, %r10
+	LONG $0xd0470f4c                           // cmovaq       %rax, %r10
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB20_13:
+	WORD $0x394c; BYTE $0xd8       // cmpq         %r11, %rax
+	LONG $0x007d830f; WORD $0x0000 // jae          LBB20_23, $125(%rip)
+	LONG $0x3cbe0f49; BYTE $0x01   // movsbq       (%r9,%rax), %rdi
+	WORD $0x5f8d; BYTE $0xd0       // leal         $-48(%rdi), %ebx
+	WORD $0xfb80; BYTE $0x09       // cmpb         $9, %bl
+	LONG $0x0033870f; WORD $0x0000 // ja           LBB20_18, $51(%rip)
+	LONG $0x0ac96b48               // imulq        $10, %rcx, %rcx
+	LONG $0x0013800f; WORD $0x0000 // jo           LBB20_17, $19(%rip)
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0xc783; BYTE $0xd0       // addl         $-48, %edi
+	LONG $0xf8af0f49               // imulq        %r8, %rdi
+	WORD $0x0148; BYTE $0xf9       // addq         %rdi, %rcx
+	LONG $0xffc9810f; WORD $0xffff // jno          LBB20_13, $-55(%rip)
+
+LBB20_17:
+	WORD $0xff48; BYTE $0xc8                   // decq         %rax
+	WORD $0x8948; BYTE $0x06                   // movq         %rax, (%rsi)
+	LONG $0xfb02c748; WORD $0xffff; BYTE $0xff // movq         $-5, (%rdx)
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB20_11:
+	WORD $0x894c; BYTE $0x16 // movq         %r10, (%rsi)
+	BYTE $0x5b               // popq         %rbx
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB20_18:
+	WORD $0x394c; BYTE $0xd8       // cmpq         %r11, %rax
+	LONG $0x002d830f; WORD $0x0000 // jae          LBB20_22, $45(%rip)
+	LONG $0x3cb60f41; BYTE $0x01   // movzbl       (%r9,%rax), %edi
+	WORD $0xff83; BYTE $0x2e       // cmpl         $46, %edi
+	LONG $0x0012840f; WORD $0x0000 // je           LBB20_25, $18(%rip)
+	WORD $0xff83; BYTE $0x45       // cmpl         $69, %edi
+	LONG $0x0009840f; WORD $0x0000 // je           LBB20_25, $9(%rip)
+	WORD $0xff83; BYTE $0x65       // cmpl         $101, %edi
+	LONG $0x000d850f; WORD $0x0000 // jne          LBB20_22, $13(%rip)
+
+LBB20_25:
+	WORD $0x8948; BYTE $0x06                   // movq         %rax, (%rsi)
+	LONG $0xfa02c748; WORD $0xffff; BYTE $0xff // movq         $-6, (%rdx)
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB20_22:
+	WORD $0x8949; BYTE $0xc2 // movq         %rax, %r10
+
+LBB20_23:
+	WORD $0x894c; BYTE $0x16 // movq         %r10, (%rsi)
+	LONG $0x104a8948         // movq         %rcx, $16(%rdx)
+	BYTE $0x5b               // popq         %rbx
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+	// .p2align 4, 0x90
+_vunsigned:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5641                               // pushq        %r14
+	BYTE $0x53                                 // pushq        %rbx
+	WORD $0x8949; BYTE $0xd0                   // movq         %rdx, %r8
+	WORD $0x8b48; BYTE $0x0e                   // movq         (%rsi), %rcx
+	WORD $0x8b4c; BYTE $0x0f                   // movq         (%rdi), %r9
+	LONG $0x08778b4c                           // movq         $8(%rdi), %r14
+	LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq         $9, (%rdx)
+	LONG $0xc057f8c5                           // vxorps       %xmm0, %xmm0, %xmm0
+	LONG $0x4211f8c5; BYTE $0x08               // vmovups      %xmm0, $8(%rdx)
+	WORD $0x8b48; BYTE $0x06                   // movq         (%rsi), %rax
+	LONG $0x18428948                           // movq         %rax, $24(%rdx)
+	WORD $0x394c; BYTE $0xf1                   // cmpq         %r14, %rcx
+	LONG $0x001c830f; WORD $0x0000             // jae          LBB21_1, $28(%rip)
+	LONG $0x04b60f41; BYTE $0x09               // movzbl       (%r9,%rcx), %eax
+	WORD $0x2d3c                               // cmpb         $45, %al
+	LONG $0x001e850f; WORD $0x0000             // jne          LBB21_4, $30(%rip)
+
+LBB21_3:
+	WORD $0x8948; BYTE $0x0e                   // movq         %rcx, (%rsi)
+	LONG $0xfa00c749; WORD $0xffff; BYTE $0xff // movq         $-6, (%r8)
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5e41                               // popq         %r14
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB21_1:
+	WORD $0x894c; BYTE $0x36                   // movq         %r14, (%rsi)
+	LONG $0xff00c749; WORD $0xffff; BYTE $0xff // movq         $-1, (%r8)
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5e41                               // popq         %r14
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB21_4:
+	WORD $0x508d; BYTE $0xc6                   // leal         $-58(%rax), %edx
+	WORD $0xfa80; BYTE $0xf5                   // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000             // ja           LBB21_6, $15(%rip)
+	WORD $0x8948; BYTE $0x0e                   // movq         %rcx, (%rsi)
+	LONG $0xfe00c749; WORD $0xffff; BYTE $0xff // movq         $-2, (%r8)
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5e41                               // popq         %r14
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB21_6:
+	WORD $0x303c                           // cmpb         $48, %al
+	LONG $0x0026850f; WORD $0x0000         // jne          LBB21_10, $38(%rip)
+	LONG $0x44b60f41; WORD $0x0109         // movzbl       $1(%r9,%rcx), %eax
+	WORD $0xc083; BYTE $0xd2               // addl         $-46, %eax
+	WORD $0xf883; BYTE $0x37               // cmpl         $55, %eax
+	LONG $0x00c0870f; WORD $0x0000         // ja           LBB21_9, $192(%rip)
+	QUAD $0x000000800001ba48; WORD $0x0080 // movabsq      $36028797027352577, %rdx
+	LONG $0xc2a30f48                       // btq          %rax, %rdx
+	LONG $0x00ac830f; WORD $0x0000         // jae          LBB21_9, $172(%rip)
+
+LBB21_10:
+	WORD $0x3949; BYTE $0xce       // cmpq         %rcx, %r14
+	WORD $0x8949; BYTE $0xca       // movq         %rcx, %r10
+	LONG $0xd6470f4d               // cmovaq       %r14, %r10
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x000abb41; WORD $0x0000 // movl         $10, %r11d
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB21_11:
+	WORD $0x394c; BYTE $0xf1       // cmpq         %r14, %rcx
+	LONG $0x007f830f; WORD $0x0000 // jae          LBB21_22, $127(%rip)
+	LONG $0x1cbe0f41; BYTE $0x09   // movsbl       (%r9,%rcx), %ebx
+	WORD $0x538d; BYTE $0xd0       // leal         $-48(%rbx), %edx
+	WORD $0xfa80; BYTE $0x09       // cmpb         $9, %dl
+	LONG $0x0042870f; WORD $0x0000 // ja           LBB21_17, $66(%rip)
+	WORD $0xf749; BYTE $0xe3       // mulq         %r11
+	LONG $0x0027800f; WORD $0x0000 // jo           LBB21_16, $39(%rip)
+	WORD $0xff48; BYTE $0xc1       // incq         %rcx
+	WORD $0xc383; BYTE $0xd0       // addl         $-48, %ebx
+	WORD $0xff31                   // xorl         %edi, %edi
+	WORD $0x0148; BYTE $0xd8       // addq         %rbx, %rax
+	LONG $0xc7920f40               // setb         %dil
+	WORD $0x8948; BYTE $0xfa       // movq         %rdi, %rdx
+	WORD $0xf748; BYTE $0xda       // negq         %rdx
+	WORD $0x3148; BYTE $0xd7       // xorq         %rdx, %rdi
+	LONG $0x0009850f; WORD $0x0000 // jne          LBB21_16, $9(%rip)
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0xffb6890f; WORD $0xffff // jns          LBB21_11, $-74(%rip)
+
+LBB21_16:
+	WORD $0xff48; BYTE $0xc9                   // decq         %rcx
+	WORD $0x8948; BYTE $0x0e                   // movq         %rcx, (%rsi)
+	LONG $0xfb00c749; WORD $0xffff; BYTE $0xff // movq         $-5, (%r8)
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5e41                               // popq         %r14
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB21_17:
+	WORD $0x394c; BYTE $0xf1       // cmpq         %r14, %rcx
+	LONG $0x0020830f; WORD $0x0000 // jae          LBB21_21, $32(%rip)
+	LONG $0x14b60f41; BYTE $0x09   // movzbl       (%r9,%rcx), %edx
+	WORD $0xfa83; BYTE $0x2e       // cmpl         $46, %edx
+	LONG $0xff0e840f; WORD $0xffff // je           LBB21_3, $-242(%rip)
+	WORD $0xfa83; BYTE $0x45       // cmpl         $69, %edx
+	LONG $0xff05840f; WORD $0xffff // je           LBB21_3, $-251(%rip)
+	WORD $0xfa83; BYTE $0x65       // cmpl         $101, %edx
+	LONG $0xfefc840f; WORD $0xffff // je           LBB21_3, $-260(%rip)
+
+LBB21_21:
+	WORD $0x8949; BYTE $0xca // movq         %rcx, %r10
+
+LBB21_22:
+	WORD $0x894c; BYTE $0x16 // movq         %r10, (%rsi)
+	LONG $0x10408949         // movq         %rax, $16(%r8)
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5e41             // popq         %r14
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB21_9:
+	WORD $0xff48; BYTE $0xc1 // incq         %rcx
+	WORD $0x8948; BYTE $0x0e // movq         %rcx, (%rsi)
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5e41             // popq         %r14
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+	BYTE $0x00               // .p2align 4, 0x00
+
+LCPI22_0:
+	QUAD $0x0000000000000001 // .quad 1
+	QUAD $0x0000000000000005 // .quad 5
+
+	// .p2align 4, 0x90
+_skip_array:
+	BYTE $0x55                                               // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                                 // movq         %rsp, %rbp
+	WORD $0x8948; BYTE $0xd0                                 // movq         %rdx, %rax
+	WORD $0x8948; BYTE $0xf2                                 // movq         %rsi, %rdx
+	WORD $0x8948; BYTE $0xfe                                 // movq         %rdi, %rsi
+	QUAD $0xffffffdb0528f8c5                                 // vmovaps      $-37(%rip), %xmm0  /* LCPI22_0(%rip) */
+	LONG $0x0011f8c5                                         // vmovups      %xmm0, (%rax)
+	WORD $0x8948; BYTE $0xc7                                 // movq         %rax, %rdi
+	BYTE $0x5d                                               // popq         %rbp
+	LONG $0x00000ee9; BYTE $0x00                             // jmp          _fsm_exec, $14(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+_fsm_exec:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x18ec8348                           // subq         $24, %rsp
+	LONG $0xc04d8948                           // movq         %rcx, $-64(%rbp)
+	LONG $0x003f8348                           // cmpq         $0, (%rdi)
+	LONG $0x03f4840f; WORD $0x0000             // je           LBB23_2, $1012(%rip)
+	WORD $0x8948; BYTE $0xd3                   // movq         %rdx, %rbx
+	WORD $0x8949; BYTE $0xf6                   // movq         %rsi, %r14
+	WORD $0x8949; BYTE $0xff                   // movq         %rdi, %r15
+	LONG $0xffc4c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r12
+	LONG $0xc8758948                           // movq         %rsi, $-56(%rbp)
+	LONG $0x000034e9; BYTE $0x00               // jmp          LBB23_7, $52(%rip)
+
+LBB23_3:
+	WORD $0x8b49; BYTE $0x0f                   // movq         (%r15), %rcx
+	LONG $0x000006b8; BYTE $0x00               // movl         $6, %eax
+	LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq         $4095, %rcx
+	LONG $0x03df8f0f; WORD $0x0000             // jg           LBB23_65, $991(%rip)
+	WORD $0x9090; BYTE $0x90                   // .p2align 4, 0x90
+
+LBB23_4:
+	LONG $0x01518d48         // leaq         $1(%rcx), %rdx
+	WORD $0x8949; BYTE $0x17 // movq         %rdx, (%r15)
+	WORD $0x8948; BYTE $0xca // movq         %rcx, %rdx
+
+LBB23_5:
+	LONG $0xd7448949; BYTE $0x08 // movq         %rax, $8(%r15,%rdx,8)
+
+LBB23_6:
+	LONG $0x003f8349               // cmpq         $0, (%r15)
+	WORD $0x894c; BYTE $0xe0       // movq         %r12, %rax
+	LONG $0x03f7840f; WORD $0x0000 // je           LBB23_56, $1015(%rip)
+
+LBB23_7:
+	WORD $0x894c; BYTE $0xf7       // movq         %r14, %rdi
+	WORD $0x8948; BYTE $0xde       // movq         %rbx, %rsi
+	LONG $0xffee69e8; BYTE $0xff   // callq        _advance_ns, $-4503(%rip)
+	WORD $0xc084                   // testb        %al, %al
+	LONG $0x0394840f; WORD $0x0000 // je           LBB23_2, $916(%rip)
+	LONG $0xfffc8349               // cmpq         $-1, %r12
+	LONG $0x0006850f; WORD $0x0000 // jne          LBB23_10, $6(%rip)
+	WORD $0x8b4c; BYTE $0x23       // movq         (%rbx), %r12
+	WORD $0xff49; BYTE $0xcc       // decq         %r12
+
+LBB23_10:
+	WORD $0xbe0f; BYTE $0xf0                   // movsbl       %al, %esi
+	WORD $0x8b49; BYTE $0x0f                   // movq         (%r15), %rcx
+	LONG $0xff518d48                           // leaq         $-1(%rcx), %rdx
+	LONG $0xcf3c8b41                           // movl         (%r15,%rcx,8), %edi
+	WORD $0xcfff                               // decl         %edi
+	WORD $0xff83; BYTE $0x05                   // cmpl         $5, %edi
+	LONG $0x0036870f; WORD $0x0000             // ja           LBB23_14, $54(%rip)
+	WORD $0x894d; BYTE $0xf0                   // movq         %r14, %r8
+	WORD $0x894d; BYTE $0xe6                   // movq         %r12, %r14
+	WORD $0x8949; BYTE $0xdc                   // movq         %rbx, %r12
+	LONG $0xc41d8d48; WORD $0x0004; BYTE $0x00 // leaq         $1220(%rip), %rbx  /* LJTI23_0(%rip) */
+	LONG $0xbb3c6348                           // movslq       (%rbx,%rdi,4), %rdi
+	WORD $0x0148; BYTE $0xdf                   // addq         %rbx, %rdi
+	JMP  DI
+
+LBB23_12:
+	WORD $0xfe83; BYTE $0x2c       // cmpl         $44, %esi
+	WORD $0x894c; BYTE $0xe3       // movq         %r12, %rbx
+	LONG $0x019a840f; WORD $0x0000 // je           LBB23_33, $410(%rip)
+	WORD $0xfe83; BYTE $0x5d       // cmpl         $93, %esi
+	WORD $0x894d; BYTE $0xf4       // movq         %r14, %r12
+	LONG $0x0177840f; WORD $0x0000 // je           LBB23_32, $375(%rip)
+	LONG $0x000367e9; BYTE $0x00   // jmp          LBB23_61, $871(%rip)
+
+LBB23_14:
+	WORD $0x8949; BYTE $0x17                   // movq         %rdx, (%r15)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	WORD $0xfe83; BYTE $0x7b                   // cmpl         $123, %esi
+	LONG $0x00b4860f; WORD $0x0000             // jbe          LBB23_25, $180(%rip)
+	LONG $0x00036de9; BYTE $0x00               // jmp          LBB23_56, $877(%rip)
+
+LBB23_15:
+	WORD $0xfe83; BYTE $0x7d                   // cmpl         $125, %esi
+	WORD $0x894c; BYTE $0xe3                   // movq         %r12, %rbx
+	WORD $0x894d; BYTE $0xf4                   // movq         %r14, %r12
+	LONG $0x014b840f; WORD $0x0000             // je           LBB23_32, $331(%rip)
+	WORD $0xfe83; BYTE $0x2c                   // cmpl         $44, %esi
+	LONG $0x0337850f; WORD $0x0000             // jne          LBB23_61, $823(%rip)
+	LONG $0x000003b8; BYTE $0x00               // movl         $3, %eax
+	LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq         $4095, %rcx
+	WORD $0x894d; BYTE $0xc6                   // movq         %r8, %r14
+	LONG $0xff2d8e0f; WORD $0xffff             // jle          LBB23_4, $-211(%rip)
+	LONG $0x000304e9; BYTE $0x00               // jmp          LBB23_65, $772(%rip)
+
+LBB23_18:
+	WORD $0x223c                   // cmpb         $34, %al
+	LONG $0x0315850f; WORD $0x0000 // jne          LBB23_61, $789(%rip)
+	QUAD $0x00000004cf04c749       // movq         $4, (%r15,%rcx,8)
+	WORD $0x894c; BYTE $0xc7       // movq         %r8, %rdi
+	LONG $0x241c8b49               // movq         (%r12), %rbx
+	WORD $0x8948; BYTE $0xde       // movq         %rbx, %rsi
+	LONG $0xd0558d48               // leaq         $-48(%rbp), %rdx
+	LONG $0xc04d8b48               // movq         $-64(%rbp), %rcx
+	LONG $0xfff191e8; BYTE $0xff   // callq        _advance_string, $-3695(%rip)
+	WORD $0x8949; BYTE $0xc5       // movq         %rax, %r13
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0126890f; WORD $0x0000 // jns          LBB23_35, $294(%rip)
+	LONG $0xd0458b48               // movq         $-48(%rbp), %rax
+	LONG $0x000126e9; BYTE $0x00   // jmp          LBB23_36, $294(%rip)
+
+LBB23_21:
+	WORD $0x3a3c                   // cmpb         $58, %al
+	LONG $0x02d9850f; WORD $0x0000 // jne          LBB23_61, $729(%rip)
+	WORD $0x894c; BYTE $0xe3       // movq         %r12, %rbx
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0x894d; BYTE $0xf4       // movq         %r14, %r12
+	WORD $0x894d; BYTE $0xc6       // movq         %r8, %r14
+	LONG $0xfffedee9; BYTE $0xff   // jmp          LBB23_5, $-290(%rip)
+
+LBB23_23:
+	WORD $0x5d3c                               // cmpb         $93, %al
+	WORD $0x894c; BYTE $0xe3                   // movq         %r12, %rbx
+	WORD $0x894d; BYTE $0xf4                   // movq         %r14, %r12
+	LONG $0x00c6840f; WORD $0x0000             // je           LBB23_32, $198(%rip)
+	QUAD $0x00000001cf04c749                   // movq         $1, (%r15,%rcx,8)
+	WORD $0x894d; BYTE $0xc6                   // movq         %r8, %r14
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	WORD $0xfe83; BYTE $0x7b                   // cmpl         $123, %esi
+	LONG $0x02be870f; WORD $0x0000             // ja           LBB23_56, $702(%rip)
+
+LBB23_25:
+	WORD $0xf189                               // movl         %esi, %ecx
+	LONG $0xe6158d48; WORD $0x0003; BYTE $0x00 // leaq         $998(%rip), %rdx  /* LJTI23_1(%rip) */
+	LONG $0x8a0c6348                           // movslq       (%rdx,%rcx,4), %rcx
+	WORD $0x0148; BYTE $0xd1                   // addq         %rdx, %rcx
+	LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r13
+	JMP  CX
+
+LBB23_26:
+	WORD $0x894c; BYTE $0xf0       // movq         %r14, %rax
+	WORD $0x8b4c; BYTE $0x33       // movq         (%rbx), %r14
+	LONG $0xff6e8d4d               // leaq         $-1(%r14), %r13
+	WORD $0x8b48; BYTE $0x38       // movq         (%rax), %rdi
+	WORD $0x014c; BYTE $0xef       // addq         %r13, %rdi
+	LONG $0x08708b48               // movq         $8(%rax), %rsi
+	WORD $0x294c; BYTE $0xee       // subq         %r13, %rsi
+	LONG $0x0007f6e8; BYTE $0x00   // callq        _do_skip_number, $2038(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0255880f; WORD $0x0000 // js           LBB23_60, $597(%rip)
+	WORD $0x8b48; BYTE $0x0b       // movq         (%rbx), %rcx
+	WORD $0x0148; BYTE $0xc8       // addq         %rcx, %rax
+	WORD $0xff48; BYTE $0xc8       // decq         %rax
+	WORD $0x8948; BYTE $0x03       // movq         %rax, (%rbx)
+	WORD $0x854d; BYTE $0xf6       // testq        %r14, %r14
+	LONG $0xc8758b4c               // movq         $-56(%rbp), %r14
+	LONG $0xfe638f0f; WORD $0xffff // jg           LBB23_6, $-413(%rip)
+	LONG $0x000219e9; BYTE $0x00   // jmp          LBB23_57, $537(%rip)
+
+LBB23_28:
+	WORD $0xfe83; BYTE $0x7d       // cmpl         $125, %esi
+	WORD $0x894c; BYTE $0xe3       // movq         %r12, %rbx
+	WORD $0x894d; BYTE $0xf4       // movq         %r14, %r12
+	LONG $0x0040840f; WORD $0x0000 // je           LBB23_32, $64(%rip)
+	WORD $0xfe83; BYTE $0x22       // cmpl         $34, %esi
+	LONG $0x022c850f; WORD $0x0000 // jne          LBB23_61, $556(%rip)
+	QUAD $0x00000002cf04c749       // movq         $2, (%r15,%rcx,8)
+	WORD $0x894c; BYTE $0xc7       // movq         %r8, %rdi
+	WORD $0x8949; BYTE $0xde       // movq         %rbx, %r14
+	WORD $0x8b4c; BYTE $0x33       // movq         (%rbx), %r14
+	WORD $0x894c; BYTE $0xf6       // movq         %r14, %rsi
+	LONG $0xd0558d48               // leaq         $-48(%rbp), %rdx
+	LONG $0xc04d8b48               // movq         $-64(%rbp), %rcx
+	LONG $0xfff0a6e8; BYTE $0xff   // callq        _advance_string, $-3930(%rip)
+	WORD $0x8949; BYTE $0xc5       // movq         %rax, %r13
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0063890f; WORD $0x0000 // jns          LBB23_37, $99(%rip)
+	LONG $0xd0458b48               // movq         $-48(%rbp), %rax
+	LONG $0x000063e9; BYTE $0x00   // jmp          LBB23_38, $99(%rip)
+	BYTE $0x90                     // .p2align 4, 0x90
+
+LBB23_32:
+	WORD $0x8949; BYTE $0x17       // movq         %rdx, (%r15)
+	WORD $0x894d; BYTE $0xe5       // movq         %r12, %r13
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	WORD $0x894d; BYTE $0xc6       // movq         %r8, %r14
+	LONG $0xfe0a850f; WORD $0xffff // jne          LBB23_7, $-502(%rip)
+	LONG $0x0001b3e9; BYTE $0x00   // jmp          LBB23_57, $435(%rip)
+
+LBB23_33:
+	LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq         $4095, %rcx
+	LONG $0x01b88f0f; WORD $0x0000             // jg           LBB23_65, $440(%rip)
+	WORD $0x894d; BYTE $0xf4                   // movq         %r14, %r12
+	WORD $0xc031                               // xorl         %eax, %eax
+	WORD $0x894d; BYTE $0xc6                   // movq         %r8, %r14
+	LONG $0xfffdcfe9; BYTE $0xff               // jmp          LBB23_4, $-561(%rip)
+
+LBB23_35:
+	WORD $0xff48; BYTE $0xcb // decq         %rbx
+	WORD $0x894c; BYTE $0xe8 // movq         %r13, %rax
+	WORD $0x8949; BYTE $0xdd // movq         %rbx, %r13
+
+LBB23_36:
+	WORD $0x894c; BYTE $0xe3       // movq         %r12, %rbx
+	LONG $0x24048949               // movq         %rax, (%r12)
+	WORD $0x854d; BYTE $0xed       // testq        %r13, %r13
+	LONG $0xc8458b48               // movq         $-56(%rbp), %rax
+	WORD $0x894d; BYTE $0xf4       // movq         %r14, %r12
+	WORD $0x8949; BYTE $0xc6       // movq         %rax, %r14
+	LONG $0xfdbb890f; WORD $0xffff // jns          LBB23_6, $-581(%rip)
+	LONG $0x000171e9; BYTE $0x00   // jmp          LBB23_57, $369(%rip)
+
+LBB23_37:
+	WORD $0xff49; BYTE $0xce // decq         %r14
+	WORD $0x894c; BYTE $0xe8 // movq         %r13, %rax
+	WORD $0x894d; BYTE $0xf5 // movq         %r14, %r13
+
+LBB23_38:
+	WORD $0x8948; BYTE $0x03                   // movq         %rax, (%rbx)
+	WORD $0x854d; BYTE $0xed                   // testq        %r13, %r13
+	LONG $0xc8758b4c                           // movq         $-56(%rbp), %r14
+	LONG $0x0158880f; WORD $0x0000             // js           LBB23_57, $344(%rip)
+	WORD $0x8b49; BYTE $0x0f                   // movq         (%r15), %rcx
+	LONG $0x000004b8; BYTE $0x00               // movl         $4, %eax
+	LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq         $4095, %rcx
+	LONG $0xfd798e0f; WORD $0xffff             // jle          LBB23_4, $-647(%rip)
+	LONG $0x000150e9; BYTE $0x00               // jmp          LBB23_65, $336(%rip)
+
+LBB23_40:
+	WORD $0x894c; BYTE $0xf7       // movq         %r14, %rdi
+	WORD $0x8949; BYTE $0xde       // movq         %rbx, %r14
+	WORD $0x8b48; BYTE $0x1b       // movq         (%rbx), %rbx
+	WORD $0x8948; BYTE $0xde       // movq         %rbx, %rsi
+	LONG $0xd0558d48               // leaq         $-48(%rbp), %rdx
+	LONG $0xc04d8b48               // movq         $-64(%rbp), %rcx
+	LONG $0xffefebe8; BYTE $0xff   // callq        _advance_string, $-4117(%rip)
+	WORD $0x8949; BYTE $0xc5       // movq         %rax, %r13
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x00f1890f; WORD $0x0000 // jns          LBB23_53, $241(%rip)
+	LONG $0xd0458b48               // movq         $-48(%rbp), %rax
+	LONG $0x0000f1e9; BYTE $0x00   // jmp          LBB23_54, $241(%rip)
+
+LBB23_42:
+	WORD $0x8b4c; BYTE $0x2b       // movq         (%rbx), %r13
+	WORD $0x8b49; BYTE $0x3e       // movq         (%r14), %rdi
+	WORD $0x014c; BYTE $0xef       // addq         %r13, %rdi
+	LONG $0x08768b49               // movq         $8(%r14), %rsi
+	WORD $0x294c; BYTE $0xee       // subq         %r13, %rsi
+	LONG $0x0006b1e8; BYTE $0x00   // callq        _do_skip_number, $1713(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0143880f; WORD $0x0000 // js           LBB23_70, $323(%rip)
+	WORD $0x0148; BYTE $0x03       // addq         %rax, (%rbx)
+	WORD $0x854d; BYTE $0xed       // testq        %r13, %r13
+	LONG $0xfd2b8f0f; WORD $0xffff // jg           LBB23_6, $-725(%rip)
+	LONG $0x000144e9; BYTE $0x00   // jmp          LBB23_72, $324(%rip)
+
+LBB23_44:
+	WORD $0x8b49; BYTE $0x0f                   // movq         (%r15), %rcx
+	LONG $0x000005b8; BYTE $0x00               // movl         $5, %eax
+	LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq         $4095, %rcx
+	LONG $0xfd028e0f; WORD $0xffff             // jle          LBB23_4, $-766(%rip)
+	LONG $0x0000d9e9; BYTE $0x00               // jmp          LBB23_65, $217(%rip)
+
+LBB23_45:
+	WORD $0x8b48; BYTE $0x03       // movq         (%rbx), %rax
+	LONG $0x084e8b49               // movq         $8(%r14), %rcx
+	LONG $0xfc518d48               // leaq         $-4(%rcx), %rdx
+	WORD $0x3948; BYTE $0xd0       // cmpq         %rdx, %rax
+	LONG $0x00ea870f; WORD $0x0000 // ja           LBB23_67, $234(%rip)
+	WORD $0x8b49; BYTE $0x0e       // movq         (%r14), %rcx
+	WORD $0x148b; BYTE $0x01       // movl         (%rcx,%rax), %edx
+	LONG $0x6c61fa81; WORD $0x6573 // cmpl         $1702063201, %edx
+	LONG $0x015b850f; WORD $0x0000 // jne          LBB23_77, $347(%rip)
+	LONG $0x04488d48               // leaq         $4(%rax), %rcx
+	WORD $0x8948; BYTE $0x0b       // movq         %rcx, (%rbx)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0xfcd68f0f; WORD $0xffff // jg           LBB23_6, $-810(%rip)
+	LONG $0x0000d2e9; BYTE $0x00   // jmp          LBB23_68, $210(%rip)
+
+LBB23_48:
+	WORD $0x8b48; BYTE $0x03       // movq         (%rbx), %rax
+	LONG $0x084e8b49               // movq         $8(%r14), %rcx
+	LONG $0xfd518d48               // leaq         $-3(%rcx), %rdx
+	WORD $0x3948; BYTE $0xd0       // cmpq         %rdx, %rax
+	LONG $0x00af870f; WORD $0x0000 // ja           LBB23_67, $175(%rip)
+	WORD $0x8b49; BYTE $0x0e       // movq         (%r14), %rcx
+	QUAD $0x6c6c756eff017c81       // cmpl         $1819047278, $-1(%rcx,%rax)
+	LONG $0x002a840f; WORD $0x0000 // je           LBB23_52, $42(%rip)
+	LONG $0x0000cde9; BYTE $0x00   // jmp          LBB23_73, $205(%rip)
+
+LBB23_50:
+	WORD $0x8b48; BYTE $0x03       // movq         (%rbx), %rax
+	LONG $0x084e8b49               // movq         $8(%r14), %rcx
+	LONG $0xfd518d48               // leaq         $-3(%rcx), %rdx
+	WORD $0x3948; BYTE $0xd0       // cmpq         %rdx, %rax
+	LONG $0x0085870f; WORD $0x0000 // ja           LBB23_67, $133(%rip)
+	WORD $0x8b49; BYTE $0x0e       // movq         (%r14), %rcx
+	QUAD $0x65757274ff017c81       // cmpl         $1702195828, $-1(%rcx,%rax)
+	LONG $0x0149850f; WORD $0x0000 // jne          LBB23_82, $329(%rip)
+
+LBB23_52:
+	LONG $0x03488d48               // leaq         $3(%rax), %rcx
+	WORD $0x8948; BYTE $0x0b       // movq         %rcx, (%rbx)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0xfc728f0f; WORD $0xffff // jg           LBB23_6, $-910(%rip)
+	LONG $0x00006ee9; BYTE $0x00   // jmp          LBB23_68, $110(%rip)
+
+LBB23_53:
+	WORD $0xff48; BYTE $0xcb // decq         %rbx
+	WORD $0x894c; BYTE $0xe8 // movq         %r13, %rax
+	WORD $0x8949; BYTE $0xdd // movq         %rbx, %r13
+
+LBB23_54:
+	WORD $0x894c; BYTE $0xf3       // movq         %r14, %rbx
+	WORD $0x8949; BYTE $0x06       // movq         %rax, (%r14)
+	WORD $0x854d; BYTE $0xed       // testq        %r13, %r13
+	LONG $0xc8758b4c               // movq         $-56(%rbp), %r14
+	LONG $0xfc51890f; WORD $0xffff // jns          LBB23_6, $-943(%rip)
+	LONG $0x000007e9; BYTE $0x00   // jmp          LBB23_57, $7(%rip)
+
+LBB23_2:
+	LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r13
+
+LBB23_57:
+	WORD $0x894c; BYTE $0xe8 // movq         %r13, %rax
+	LONG $0x18c48348         // addq         $24, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB23_65:
+	LONG $0xf9c5c749; WORD $0xffff; BYTE $0xff // movq         $-7, %r13
+	LONG $0xffffe2e9; BYTE $0xff               // jmp          LBB23_57, $-30(%rip)
+
+LBB23_60:
+	WORD $0x8b48; BYTE $0x0b // movq         (%rbx), %rcx
+	WORD $0x2948; BYTE $0xc1 // subq         %rax, %rcx
+	LONG $0xfec18348         // addq         $-2, %rcx
+	WORD $0x8948; BYTE $0x0b // movq         %rcx, (%rbx)
+
+LBB23_61:
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+	LONG $0xffffc9e9; BYTE $0xff               // jmp          LBB23_57, $-55(%rip)
+
+LBB23_67:
+	WORD $0x8948; BYTE $0x0b                   // movq         %rcx, (%rbx)
+	LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r13
+	LONG $0xffffbae9; BYTE $0xff               // jmp          LBB23_57, $-70(%rip)
+
+LBB23_68:
+	WORD $0xff48; BYTE $0xc8 // decq         %rax
+
+LBB23_56:
+	WORD $0x8949; BYTE $0xc5     // movq         %rax, %r13
+	LONG $0xffffafe9; BYTE $0xff // jmp          LBB23_57, $-81(%rip)
+
+LBB23_70:
+	WORD $0xf748; BYTE $0xd0                   // notq         %rax
+	WORD $0x0148; BYTE $0x03                   // addq         %rax, (%rbx)
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+	LONG $0xffff9de9; BYTE $0xff               // jmp          LBB23_57, $-99(%rip)
+
+LBB23_72:
+	WORD $0xff49; BYTE $0xcd     // decq         %r13
+	LONG $0xffff95e9; BYTE $0xff // jmp          LBB23_57, $-107(%rip)
+
+LBB23_73:
+	LONG $0xff508d48                           // leaq         $-1(%rax), %rdx
+	WORD $0x8948; BYTE $0x13                   // movq         %rdx, (%rbx)
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+	LONG $0xff017c80; BYTE $0x6e               // cmpb         $110, $-1(%rcx,%rax)
+	LONG $0xff7c850f; WORD $0xffff             // jne          LBB23_57, $-132(%rip)
+	WORD $0x8948; BYTE $0x03                   // movq         %rax, (%rbx)
+	LONG $0x75013c80                           // cmpb         $117, (%rcx,%rax)
+	LONG $0xff6f850f; WORD $0xffff             // jne          LBB23_57, $-145(%rip)
+	LONG $0x01508d48                           // leaq         $1(%rax), %rdx
+	WORD $0x8948; BYTE $0x13                   // movq         %rdx, (%rbx)
+	LONG $0x01017c80; BYTE $0x6c               // cmpb         $108, $1(%rcx,%rax)
+	LONG $0xff5d850f; WORD $0xffff             // jne          LBB23_57, $-163(%rip)
+	LONG $0x02508d48                           // leaq         $2(%rax), %rdx
+	WORD $0x8948; BYTE $0x13                   // movq         %rdx, (%rbx)
+	LONG $0x02017c80; BYTE $0x6c               // cmpb         $108, $2(%rcx,%rax)
+	LONG $0xff4b850f; WORD $0xffff             // jne          LBB23_57, $-181(%rip)
+	LONG $0x00009ce9; BYTE $0x00               // jmp          LBB23_86, $156(%rip)
+
+LBB23_77:
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+	WORD $0xfa80; BYTE $0x61                   // cmpb         $97, %dl
+	LONG $0xff36850f; WORD $0xffff             // jne          LBB23_57, $-202(%rip)
+	LONG $0x01508d48                           // leaq         $1(%rax), %rdx
+	WORD $0x8948; BYTE $0x13                   // movq         %rdx, (%rbx)
+	LONG $0x01017c80; BYTE $0x6c               // cmpb         $108, $1(%rcx,%rax)
+	LONG $0xff24850f; WORD $0xffff             // jne          LBB23_57, $-220(%rip)
+	LONG $0x02508d48                           // leaq         $2(%rax), %rdx
+	WORD $0x8948; BYTE $0x13                   // movq         %rdx, (%rbx)
+	LONG $0x02017c80; BYTE $0x73               // cmpb         $115, $2(%rcx,%rax)
+	LONG $0xff12850f; WORD $0xffff             // jne          LBB23_57, $-238(%rip)
+	LONG $0x03508d48                           // leaq         $3(%rax), %rdx
+	WORD $0x8948; BYTE $0x13                   // movq         %rdx, (%rbx)
+	LONG $0x03017c80; BYTE $0x65               // cmpb         $101, $3(%rcx,%rax)
+	LONG $0xff00850f; WORD $0xffff             // jne          LBB23_57, $-256(%rip)
+	LONG $0x04c08348                           // addq         $4, %rax
+	WORD $0x8948; BYTE $0x03                   // movq         %rax, (%rbx)
+	LONG $0xfffef4e9; BYTE $0xff               // jmp          LBB23_57, $-268(%rip)
+
+LBB23_82:
+	LONG $0xff508d48                           // leaq         $-1(%rax), %rdx
+	WORD $0x8948; BYTE $0x13                   // movq         %rdx, (%rbx)
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+	LONG $0xff017c80; BYTE $0x74               // cmpb         $116, $-1(%rcx,%rax)
+	LONG $0xfedb850f; WORD $0xffff             // jne          LBB23_57, $-293(%rip)
+	WORD $0x8948; BYTE $0x03                   // movq         %rax, (%rbx)
+	LONG $0x72013c80                           // cmpb         $114, (%rcx,%rax)
+	LONG $0xfece850f; WORD $0xffff             // jne          LBB23_57, $-306(%rip)
+	LONG $0x01508d48                           // leaq         $1(%rax), %rdx
+	WORD $0x8948; BYTE $0x13                   // movq         %rdx, (%rbx)
+	LONG $0x01017c80; BYTE $0x75               // cmpb         $117, $1(%rcx,%rax)
+	LONG $0xfebc850f; WORD $0xffff             // jne          LBB23_57, $-324(%rip)
+	LONG $0x02508d48                           // leaq         $2(%rax), %rdx
+	WORD $0x8948; BYTE $0x13                   // movq         %rdx, (%rbx)
+	LONG $0x02017c80; BYTE $0x65               // cmpb         $101, $2(%rcx,%rax)
+	LONG $0xfeaa850f; WORD $0xffff             // jne          LBB23_57, $-342(%rip)
+
+LBB23_86:
+	LONG $0x03c08348             // addq         $3, %rax
+	WORD $0x8948; BYTE $0x03     // movq         %rax, (%rbx)
+	LONG $0xfffe9ee9; BYTE $0xff // jmp          LBB23_57, $-354(%rip)
+
+	// .p2align 2, 0x90
+	// .set L23_0_set_12, LBB23_12-LJTI23_0
+	// .set L23_0_set_15, LBB23_15-LJTI23_0
+	// .set L23_0_set_18, LBB23_18-LJTI23_0
+	// .set L23_0_set_21, LBB23_21-LJTI23_0
+	// .set L23_0_set_23, LBB23_23-LJTI23_0
+	// .set L23_0_set_28, LBB23_28-LJTI23_0
+LJTI23_0:
+	LONG $0xfffffb45 // .long L23_0_set_12
+	LONG $0xfffffb7a // .long L23_0_set_15
+	LONG $0xfffffbac // .long L23_0_set_18
+	LONG $0xfffffbe8 // .long L23_0_set_21
+	LONG $0xfffffc00 // .long L23_0_set_23
+	LONG $0xfffffc85 // .long L23_0_set_28
+
+	// .set L23_1_set_57, LBB23_57-LJTI23_1
+	// .set L23_1_set_56, LBB23_56-LJTI23_1
+	// .set L23_1_set_40, LBB23_40-LJTI23_1
+	// .set L23_1_set_42, LBB23_42-LJTI23_1
+	// .set L23_1_set_26, LBB23_26-LJTI23_1
+	// .set L23_1_set_44, LBB23_44-LJTI23_1
+	// .set L23_1_set_45, LBB23_45-LJTI23_1
+	// .set L23_1_set_48, LBB23_48-LJTI23_1
+	// .set L23_1_set_50, LBB23_50-LJTI23_1
+	// .set L23_1_set_3, LBB23_3-LJTI23_1
+LJTI23_1:
+	LONG $0xfffffe86                           // .long L23_1_set_57
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffd48                           // .long L23_1_set_40
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffd76                           // .long L23_1_set_42
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffc2a                           // .long L23_1_set_26
+	LONG $0xfffffc2a                           // .long L23_1_set_26
+	LONG $0xfffffc2a                           // .long L23_1_set_26
+	LONG $0xfffffc2a                           // .long L23_1_set_26
+	LONG $0xfffffc2a                           // .long L23_1_set_26
+	LONG $0xfffffc2a                           // .long L23_1_set_26
+	LONG $0xfffffc2a                           // .long L23_1_set_26
+	LONG $0xfffffc2a                           // .long L23_1_set_26
+	LONG $0xfffffc2a                           // .long L23_1_set_26
+	LONG $0xfffffc2a                           // .long L23_1_set_26
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffda5                           // .long L23_1_set_44
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffdbf                           // .long L23_1_set_45
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffdfa                           // .long L23_1_set_48
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffe24                           // .long L23_1_set_50
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffecf                           // .long L23_1_set_56
+	LONG $0xfffffaa4                           // .long L23_1_set_3
+	QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00
+
+LCPI24_0:
+	QUAD $0x0000000000000001 // .quad 1
+	QUAD $0x0000000000000006 // .quad 6
+
+	// .p2align 4, 0x90
+_skip_object:
+	BYTE $0x55                                               // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                                 // movq         %rsp, %rbp
+	WORD $0x8948; BYTE $0xd0                                 // movq         %rdx, %rax
+	WORD $0x8948; BYTE $0xf2                                 // movq         %rsi, %rdx
+	WORD $0x8948; BYTE $0xfe                                 // movq         %rdi, %rsi
+	QUAD $0xffffffdb0528f8c5                                 // vmovaps      $-37(%rip), %xmm0  /* LCPI24_0(%rip) */
+	LONG $0x0011f8c5                                         // vmovups      %xmm0, (%rax)
+	WORD $0x8948; BYTE $0xc7                                 // movq         %rax, %rdi
+	BYTE $0x5d                                               // popq         %rbp
+	LONG $0xfff83ee9; BYTE $0xff                             // jmp          _fsm_exec, $-1986(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+_skip_string:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5641                   // pushq        %r14
+	BYTE $0x53                     // pushq        %rbx
+	LONG $0x10ec8348               // subq         $16, %rsp
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	WORD $0x8949; BYTE $0xf6       // movq         %rsi, %r14
+	WORD $0x8b48; BYTE $0x1e       // movq         (%rsi), %rbx
+	LONG $0xe8558d48               // leaq         $-24(%rbp), %rdx
+	WORD $0x8948; BYTE $0xde       // movq         %rbx, %rsi
+	LONG $0xffeaf0e8; BYTE $0xff   // callq        _advance_string, $-5392(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0009890f; WORD $0x0000 // jns          LBB25_1, $9(%rip)
+	LONG $0xe84d8b48               // movq         $-24(%rbp), %rcx
+	LONG $0x000009e9; BYTE $0x00   // jmp          LBB25_3, $9(%rip)
+
+LBB25_1:
+	WORD $0xff48; BYTE $0xcb // decq         %rbx
+	WORD $0x8948; BYTE $0xc1 // movq         %rax, %rcx
+	WORD $0x8948; BYTE $0xd8 // movq         %rbx, %rax
+
+LBB25_3:
+	WORD $0x8949; BYTE $0x0e             // movq         %rcx, (%r14)
+	LONG $0x10c48348                     // addq         $16, %rsp
+	BYTE $0x5b                           // popq         %rbx
+	WORD $0x5e41                         // popq         %r14
+	BYTE $0x5d                           // popq         %rbp
+	BYTE $0xc3                           // retq
+	QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90
+
+_skip_negative:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5641                   // pushq        %r14
+	BYTE $0x53                     // pushq        %rbx
+	WORD $0x8949; BYTE $0xf6       // movq         %rsi, %r14
+	WORD $0x8b48; BYTE $0x1e       // movq         (%rsi), %rbx
+	WORD $0x8b48; BYTE $0x07       // movq         (%rdi), %rax
+	WORD $0x0148; BYTE $0xd8       // addq         %rbx, %rax
+	LONG $0x08778b48               // movq         $8(%rdi), %rsi
+	WORD $0x2948; BYTE $0xde       // subq         %rbx, %rsi
+	WORD $0x8948; BYTE $0xc7       // movq         %rax, %rdi
+	LONG $0x00018ee8; BYTE $0x00   // callq        _do_skip_number, $398(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x000b880f; WORD $0x0000 // js           LBB26_1, $11(%rip)
+	WORD $0x0149; BYTE $0x06       // addq         %rax, (%r14)
+	WORD $0xff48; BYTE $0xcb       // decq         %rbx
+	LONG $0x00000de9; BYTE $0x00   // jmp          LBB26_3, $13(%rip)
+
+LBB26_1:
+	WORD $0xf748; BYTE $0xd0                   // notq         %rax
+	WORD $0x0149; BYTE $0x06                   // addq         %rax, (%r14)
+	LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rbx
+
+LBB26_3:
+	WORD $0x8948; BYTE $0xd8                                                         // movq         %rbx, %rax
+	BYTE $0x5b                                                                       // popq         %rbx
+	WORD $0x5e41                                                                     // popq         %r14
+	BYTE $0x5d                                                                       // popq         %rbp
+	BYTE $0xc3                                                                       // retq
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000; LONG $0x00000000; BYTE $0x00 // .p2align 5, 0x00
+
+LCPI27_0:
+	QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++'
+	QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++'
+
+LCPI27_1:
+	QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------'
+	QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------'
+
+LCPI27_2:
+	QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
+	QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
+
+LCPI27_3:
+	QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................'
+	QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................'
+
+LCPI27_4:
+	QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE'
+	QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE'
+
+LCPI27_5:
+	QUAD $0xd0d0d0d0d0d0d0d0; QUAD $0xd0d0d0d0d0d0d0d0 // .space 16, '\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0'
+	QUAD $0xd0d0d0d0d0d0d0d0; QUAD $0xd0d0d0d0d0d0d0d0 // .space 16, '\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0'
+
+LCPI27_6:
+	QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'
+	QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'
+
+	// .p2align 4, 0x00
+LCPI27_7:
+	QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++'
+
+LCPI27_8:
+	QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------'
+
+LCPI27_9:
+	QUAD $0xd0d0d0d0d0d0d0d0; QUAD $0xd0d0d0d0d0d0d0d0 // .space 16, '\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0'
+
+LCPI27_10:
+	QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'
+
+LCPI27_11:
+	QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
+
+LCPI27_12:
+	QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................'
+
+LCPI27_13:
+	QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE'
+
+	// .p2align 4, 0x90
+_do_skip_number:
+	BYTE $0x55                             // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5               // movq         %rsp, %rbp
+	WORD $0x5741                           // pushq        %r15
+	WORD $0x5641                           // pushq        %r14
+	WORD $0x5441                           // pushq        %r12
+	BYTE $0x53                             // pushq        %rbx
+	WORD $0x8548; BYTE $0xf6               // testq        %rsi, %rsi
+	LONG $0x03a4840f; WORD $0x0000         // je           LBB27_1, $932(%rip)
+	WORD $0x3f80; BYTE $0x30               // cmpb         $48, (%rdi)
+	LONG $0x0033850f; WORD $0x0000         // jne          LBB27_6, $51(%rip)
+	LONG $0x000001b8; BYTE $0x00           // movl         $1, %eax
+	LONG $0x01fe8348                       // cmpq         $1, %rsi
+	LONG $0x04b8840f; WORD $0x0000         // je           LBB27_81, $1208(%rip)
+	LONG $0x014fb60f                       // movzbl       $1(%rdi), %ecx
+	WORD $0xc183; BYTE $0xd2               // addl         $-46, %ecx
+	WORD $0xf983; BYTE $0x37               // cmpl         $55, %ecx
+	LONG $0x04a8870f; WORD $0x0000         // ja           LBB27_81, $1192(%rip)
+	QUAD $0x000000800001ba48; WORD $0x0080 // movabsq      $36028797027352577, %rdx
+	LONG $0xcaa30f48                       // btq          %rcx, %rdx
+	LONG $0x0494830f; WORD $0x0000         // jae          LBB27_81, $1172(%rip)
+
+LBB27_6:
+	LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r9
+	LONG $0x20fe8348                           // cmpq         $32, %rsi
+	LONG $0x048f820f; WORD $0x0000             // jb           LBB27_7, $1167(%rip)
+	WORD $0xc031                               // xorl         %eax, %eax
+	QUAD $0xfffffe45056ffdc5                   // vmovdqa      $-443(%rip), %ymm0  /* LCPI27_0(%rip) */
+	QUAD $0xfffffe5d0d6ffdc5                   // vmovdqa      $-419(%rip), %ymm1  /* LCPI27_1(%rip) */
+	QUAD $0xfffffe75156ffdc5                   // vmovdqa      $-395(%rip), %ymm2  /* LCPI27_2(%rip) */
+	QUAD $0xfffffe8d1d6ffdc5                   // vmovdqa      $-371(%rip), %ymm3  /* LCPI27_3(%rip) */
+	QUAD $0xfffffea5256ffdc5                   // vmovdqa      $-347(%rip), %ymm4  /* LCPI27_4(%rip) */
+	QUAD $0xfffffebd2d6ffdc5                   // vmovdqa      $-323(%rip), %ymm5  /* LCPI27_5(%rip) */
+	QUAD $0xfffffed5356ffdc5                   // vmovdqa      $-299(%rip), %ymm6  /* LCPI27_6(%rip) */
+	LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r8
+	LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r10
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB27_9:
+	LONG $0x3c6ffec5; BYTE $0x07   // vmovdqu      (%rdi,%rax), %ymm7
+	LONG $0xc07445c5               // vpcmpeqb     %ymm0, %ymm7, %ymm8
+	LONG $0xc97445c5               // vpcmpeqb     %ymm1, %ymm7, %ymm9
+	LONG $0xeb3541c4; BYTE $0xc0   // vpor         %ymm8, %ymm9, %ymm8
+	LONG $0xcadb45c5               // vpand        %ymm2, %ymm7, %ymm9
+	LONG $0xcc7435c5               // vpcmpeqb     %ymm4, %ymm9, %ymm9
+	LONG $0xd37445c5               // vpcmpeqb     %ymm3, %ymm7, %ymm10
+	LONG $0xd77dc1c4; BYTE $0xd2   // vpmovmskb    %ymm10, %edx
+	LONG $0xd77d41c4; BYTE $0xf9   // vpmovmskb    %ymm9, %r15d
+	LONG $0xd77d41c4; BYTE $0xd8   // vpmovmskb    %ymm8, %r11d
+	LONG $0xfdfcc5c5               // vpaddb       %ymm5, %ymm7, %ymm7
+	LONG $0xdeda45c5               // vpminub      %ymm6, %ymm7, %ymm11
+	LONG $0xff74a5c5               // vpcmpeqb     %ymm7, %ymm11, %ymm7
+	LONG $0xeb2d41c4; BYTE $0xc9   // vpor         %ymm9, %ymm10, %ymm9
+	LONG $0xffebb5c5               // vpor         %ymm7, %ymm9, %ymm7
+	LONG $0xffebbdc5               // vpor         %ymm7, %ymm8, %ymm7
+	LONG $0xcfd7fdc5               // vpmovmskb    %ymm7, %ecx
+	WORD $0xf748; BYTE $0xd1       // notq         %rcx
+	LONG $0xf1bc0f4c               // bsfq         %rcx, %r14
+	LONG $0x20fe8341               // cmpl         $32, %r14d
+	LONG $0x0017840f; WORD $0x0000 // je           LBB27_11, $23(%rip)
+	LONG $0xffffffbb; BYTE $0xff   // movl         $-1, %ebx
+	WORD $0x8944; BYTE $0xf1       // movl         %r14d, %ecx
+	WORD $0xe3d3                   // shll         %cl, %ebx
+	WORD $0xd3f7                   // notl         %ebx
+	WORD $0xda21                   // andl         %ebx, %edx
+	WORD $0x2141; BYTE $0xdf       // andl         %ebx, %r15d
+	WORD $0x2144; BYTE $0xdb       // andl         %r11d, %ebx
+	WORD $0x8941; BYTE $0xdb       // movl         %ebx, %r11d
+
+LBB27_11:
+	WORD $0x4a8d; BYTE $0xff       // leal         $-1(%rdx), %ecx
+	WORD $0xd121                   // andl         %edx, %ecx
+	LONG $0x0384850f; WORD $0x0000 // jne          LBB27_12, $900(%rip)
+	LONG $0xff4f8d41               // leal         $-1(%r15), %ecx
+	WORD $0x2144; BYTE $0xf9       // andl         %r15d, %ecx
+	LONG $0x0377850f; WORD $0x0000 // jne          LBB27_12, $887(%rip)
+	LONG $0xff4b8d41               // leal         $-1(%r11), %ecx
+	WORD $0x2144; BYTE $0xd9       // andl         %r11d, %ecx
+	LONG $0x036a850f; WORD $0x0000 // jne          LBB27_12, $874(%rip)
+	WORD $0xd285                   // testl        %edx, %edx
+	LONG $0x0013840f; WORD $0x0000 // je           LBB27_19, $19(%rip)
+	WORD $0xbc0f; BYTE $0xca       // bsfl         %edx, %ecx
+	LONG $0xfffa8349               // cmpq         $-1, %r10
+	LONG $0x035d850f; WORD $0x0000 // jne          LBB27_82, $861(%rip)
+	WORD $0x0148; BYTE $0xc1       // addq         %rax, %rcx
+	WORD $0x8949; BYTE $0xca       // movq         %rcx, %r10
+
+LBB27_19:
+	WORD $0x8545; BYTE $0xff       // testl        %r15d, %r15d
+	LONG $0x0014840f; WORD $0x0000 // je           LBB27_22, $20(%rip)
+	LONG $0xcfbc0f41               // bsfl         %r15d, %ecx
+	LONG $0xfff88349               // cmpq         $-1, %r8
+	LONG $0x0340850f; WORD $0x0000 // jne          LBB27_82, $832(%rip)
+	WORD $0x0148; BYTE $0xc1       // addq         %rax, %rcx
+	WORD $0x8949; BYTE $0xc8       // movq         %rcx, %r8
+
+LBB27_22:
+	WORD $0x8545; BYTE $0xdb       // testl        %r11d, %r11d
+	LONG $0x0014840f; WORD $0x0000 // je           LBB27_25, $20(%rip)
+	LONG $0xcbbc0f41               // bsfl         %r11d, %ecx
+	LONG $0xfff98349               // cmpq         $-1, %r9
+	LONG $0x0323850f; WORD $0x0000 // jne          LBB27_82, $803(%rip)
+	WORD $0x0148; BYTE $0xc1       // addq         %rax, %rcx
+	WORD $0x8949; BYTE $0xc9       // movq         %rcx, %r9
+
+LBB27_25:
+	LONG $0x20fe8341               // cmpl         $32, %r14d
+	LONG $0x021e850f; WORD $0x0000 // jne          LBB27_83, $542(%rip)
+	LONG $0xe0c68348               // addq         $-32, %rsi
+	LONG $0x20c08348               // addq         $32, %rax
+	LONG $0x1ffe8348               // cmpq         $31, %rsi
+	LONG $0xfef8870f; WORD $0xffff // ja           LBB27_9, $-264(%rip)
+	WORD $0xf8c5; BYTE $0x77       // vzeroupper
+	WORD $0x0148; BYTE $0xf8       // addq         %rdi, %rax
+	WORD $0x8949; BYTE $0xc6       // movq         %rax, %r14
+	LONG $0x10fe8348               // cmpq         $16, %rsi
+	LONG $0x014f820f; WORD $0x0000 // jb           LBB27_49, $335(%rip)
+
+LBB27_29:
+	WORD $0x894d; BYTE $0xf3     // movq         %r14, %r11
+	WORD $0x2949; BYTE $0xfb     // subq         %rdi, %r11
+	WORD $0xc031                 // xorl         %eax, %eax
+	QUAD $0xfffffdb5056f79c5     // vmovdqa      $-587(%rip), %xmm8  /* LCPI27_7(%rip) */
+	QUAD $0xfffffdbd0d6f79c5     // vmovdqa      $-579(%rip), %xmm9  /* LCPI27_8(%rip) */
+	QUAD $0xfffffdc5156f79c5     // vmovdqa      $-571(%rip), %xmm10  /* LCPI27_9(%rip) */
+	QUAD $0xfffffdcd1d6ff9c5     // vmovdqa      $-563(%rip), %xmm3  /* LCPI27_10(%rip) */
+	QUAD $0xfffffdd5256ff9c5     // vmovdqa      $-555(%rip), %xmm4  /* LCPI27_11(%rip) */
+	QUAD $0xfffffddd2d6ff9c5     // vmovdqa      $-547(%rip), %xmm5  /* LCPI27_12(%rip) */
+	QUAD $0xfffffde5356ff9c5     // vmovdqa      $-539(%rip), %xmm6  /* LCPI27_13(%rip) */
+	LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB27_30:
+	LONG $0x6f7ac1c4; WORD $0x063c // vmovdqu      (%r14,%rax), %xmm7
+	LONG $0xc774b9c5               // vpcmpeqb     %xmm7, %xmm8, %xmm0
+	LONG $0xcf74b1c5               // vpcmpeqb     %xmm7, %xmm9, %xmm1
+	LONG $0xc0ebf1c5               // vpor         %xmm0, %xmm1, %xmm0
+	LONG $0xcffca9c5               // vpaddb       %xmm7, %xmm10, %xmm1
+	LONG $0xd3daf1c5               // vpminub      %xmm3, %xmm1, %xmm2
+	LONG $0xca74f1c5               // vpcmpeqb     %xmm2, %xmm1, %xmm1
+	LONG $0xd4dbc1c5               // vpand        %xmm4, %xmm7, %xmm2
+	LONG $0xd674e9c5               // vpcmpeqb     %xmm6, %xmm2, %xmm2
+	LONG $0xfd74c1c5               // vpcmpeqb     %xmm5, %xmm7, %xmm7
+	LONG $0xd7d7f9c5               // vpmovmskb    %xmm7, %edx
+	LONG $0xe2d779c5               // vpmovmskb    %xmm2, %r12d
+	LONG $0xf8d779c5               // vpmovmskb    %xmm0, %r15d
+	LONG $0xd7ebe9c5               // vpor         %xmm7, %xmm2, %xmm2
+	LONG $0xc0ebe9c5               // vpor         %xmm0, %xmm2, %xmm0
+	LONG $0xc1ebf9c5               // vpor         %xmm1, %xmm0, %xmm0
+	LONG $0xc8d7f9c5               // vpmovmskb    %xmm0, %ecx
+	WORD $0xd1f7                   // notl         %ecx
+	WORD $0xbc0f; BYTE $0xc9       // bsfl         %ecx, %ecx
+	WORD $0xf983; BYTE $0x10       // cmpl         $16, %ecx
+	LONG $0x0014840f; WORD $0x0000 // je           LBB27_32, $20(%rip)
+	LONG $0xffffffbb; BYTE $0xff   // movl         $-1, %ebx
+	WORD $0xe3d3                   // shll         %cl, %ebx
+	WORD $0xd3f7                   // notl         %ebx
+	WORD $0xda21                   // andl         %ebx, %edx
+	WORD $0x2141; BYTE $0xdc       // andl         %ebx, %r12d
+	WORD $0x2144; BYTE $0xfb       // andl         %r15d, %ebx
+	WORD $0x8941; BYTE $0xdf       // movl         %ebx, %r15d
+
+LBB27_32:
+	WORD $0x5a8d; BYTE $0xff       // leal         $-1(%rdx), %ebx
+	WORD $0xd321                   // andl         %edx, %ebx
+	LONG $0x0243850f; WORD $0x0000 // jne          LBB27_33, $579(%rip)
+	LONG $0x245c8d41; BYTE $0xff   // leal         $-1(%r12), %ebx
+	WORD $0x2144; BYTE $0xe3       // andl         %r12d, %ebx
+	LONG $0x0235850f; WORD $0x0000 // jne          LBB27_33, $565(%rip)
+	LONG $0xff5f8d41               // leal         $-1(%r15), %ebx
+	WORD $0x2144; BYTE $0xfb       // andl         %r15d, %ebx
+	LONG $0x0228850f; WORD $0x0000 // jne          LBB27_33, $552(%rip)
+	WORD $0xd285                   // testl        %edx, %edx
+	LONG $0x0016840f; WORD $0x0000 // je           LBB27_40, $22(%rip)
+	WORD $0xbc0f; BYTE $0xd2       // bsfl         %edx, %edx
+	LONG $0xfffa8349               // cmpq         $-1, %r10
+	LONG $0x0223850f; WORD $0x0000 // jne          LBB27_84, $547(%rip)
+	WORD $0x014c; BYTE $0xda       // addq         %r11, %rdx
+	WORD $0x0148; BYTE $0xc2       // addq         %rax, %rdx
+	WORD $0x8949; BYTE $0xd2       // movq         %rdx, %r10
+
+LBB27_40:
+	WORD $0x8545; BYTE $0xe4       // testl        %r12d, %r12d
+	LONG $0x0017840f; WORD $0x0000 // je           LBB27_43, $23(%rip)
+	LONG $0xd4bc0f41               // bsfl         %r12d, %edx
+	LONG $0xfff88349               // cmpq         $-1, %r8
+	LONG $0x0203850f; WORD $0x0000 // jne          LBB27_84, $515(%rip)
+	WORD $0x014c; BYTE $0xda       // addq         %r11, %rdx
+	WORD $0x0148; BYTE $0xc2       // addq         %rax, %rdx
+	WORD $0x8949; BYTE $0xd0       // movq         %rdx, %r8
+
+LBB27_43:
+	WORD $0x8545; BYTE $0xff       // testl        %r15d, %r15d
+	LONG $0x0017840f; WORD $0x0000 // je           LBB27_46, $23(%rip)
+	LONG $0xd7bc0f41               // bsfl         %r15d, %edx
+	LONG $0xfff98349               // cmpq         $-1, %r9
+	LONG $0x01e3850f; WORD $0x0000 // jne          LBB27_84, $483(%rip)
+	WORD $0x014c; BYTE $0xda       // addq         %r11, %rdx
+	WORD $0x0148; BYTE $0xc2       // addq         %rax, %rdx
+	WORD $0x8949; BYTE $0xd1       // movq         %rdx, %r9
+
+LBB27_46:
+	WORD $0xf983; BYTE $0x10       // cmpl         $16, %ecx
+	LONG $0x00dd850f; WORD $0x0000 // jne          LBB27_65, $221(%rip)
+	LONG $0xf0c68348               // addq         $-16, %rsi
+	LONG $0x10c08348               // addq         $16, %rax
+	LONG $0x0ffe8348               // cmpq         $15, %rsi
+	LONG $0xfef9870f; WORD $0xffff // ja           LBB27_30, $-263(%rip)
+	WORD $0x0149; BYTE $0xc6       // addq         %rax, %r14
+
+LBB27_49:
+	WORD $0x8548; BYTE $0xf6                   // testq        %rsi, %rsi
+	LONG $0x00c7840f; WORD $0x0000             // je           LBB27_67, $199(%rip)
+	LONG $0x361c8d4d                           // leaq         (%r14,%rsi), %r11
+	WORD $0x894c; BYTE $0xf2                   // movq         %r14, %rdx
+	WORD $0x2948; BYTE $0xfa                   // subq         %rdi, %rdx
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0xda3d8d4c; WORD $0x0001; BYTE $0x00 // leaq         $474(%rip), %r15  /* LJTI27_0(%rip) */
+	LONG $0x000031e9; BYTE $0x00               // jmp          LBB27_51, $49(%rip)
+
+LBB27_53:
+	WORD $0xf983; BYTE $0x65       // cmpl         $101, %ecx
+	LONG $0x00a3850f; WORD $0x0000 // jne          LBB27_66, $163(%rip)
+
+LBB27_54:
+	LONG $0xfff88349                                         // cmpq         $-1, %r8
+	LONG $0x0180850f; WORD $0x0000                           // jne          LBB27_59, $384(%rip)
+	LONG $0x02048d4c                                         // leaq         (%rdx,%rax), %r8
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB27_63:
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3948; BYTE $0xc6       // cmpq         %rax, %rsi
+	LONG $0x012d840f; WORD $0x0000 // je           LBB27_64, $301(%rip)
+
+LBB27_51:
+	LONG $0x0cbe0f41; BYTE $0x06   // movsbl       (%r14,%rax), %ecx
+	WORD $0x598d; BYTE $0xd0       // leal         $-48(%rcx), %ebx
+	WORD $0xfb83; BYTE $0x0a       // cmpl         $10, %ebx
+	LONG $0xffe3820f; WORD $0xffff // jb           LBB27_63, $-29(%rip)
+	WORD $0x598d; BYTE $0xd5       // leal         $-43(%rcx), %ebx
+	WORD $0xfb83; BYTE $0x1a       // cmpl         $26, %ebx
+	LONG $0xffb2870f; WORD $0xffff // ja           LBB27_53, $-78(%rip)
+	LONG $0x9f0c6349               // movslq       (%r15,%rbx,4), %rcx
+	WORD $0x014c; BYTE $0xf9       // addq         %r15, %rcx
+	JMP  CX
+
+LBB27_61:
+	LONG $0xfff98349               // cmpq         $-1, %r9
+	LONG $0x0132850f; WORD $0x0000 // jne          LBB27_59, $306(%rip)
+	LONG $0x020c8d4c               // leaq         (%rdx,%rax), %r9
+	LONG $0xffffbbe9; BYTE $0xff   // jmp          LBB27_63, $-69(%rip)
+
+LBB27_57:
+	LONG $0xfffa8349               // cmpq         $-1, %r10
+	LONG $0x011f850f; WORD $0x0000 // jne          LBB27_59, $287(%rip)
+	LONG $0x02148d4c               // leaq         (%rdx,%rax), %r10
+	LONG $0xffffa8e9; BYTE $0xff   // jmp          LBB27_63, $-88(%rip)
+
+LBB27_1:
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0x000120e9; BYTE $0x00               // jmp          LBB27_81, $288(%rip)
+
+LBB27_83:
+	WORD $0x0149; BYTE $0xc6                   // addq         %rax, %r14
+	WORD $0x0149; BYTE $0xfe                   // addq         %rdi, %r14
+	WORD $0xf8c5; BYTE $0x77                   // vzeroupper
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x854d; BYTE $0xd2                   // testq        %r10, %r10
+	LONG $0x001d850f; WORD $0x0000             // jne          LBB27_68, $29(%rip)
+	LONG $0x000102e9; BYTE $0x00               // jmp          LBB27_81, $258(%rip)
+
+LBB27_65:
+	WORD $0xc989             // movl         %ecx, %ecx
+	WORD $0x0149; BYTE $0xce // addq         %rcx, %r14
+
+LBB27_66:
+	WORD $0x0149; BYTE $0xc6 // addq         %rax, %r14
+
+LBB27_67:
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x854d; BYTE $0xd2                   // testq        %r10, %r10
+	LONG $0x00ea840f; WORD $0x0000             // je           LBB27_81, $234(%rip)
+
+LBB27_68:
+	WORD $0x854d; BYTE $0xc9       // testq        %r9, %r9
+	LONG $0x00e1840f; WORD $0x0000 // je           LBB27_81, $225(%rip)
+	WORD $0x854d; BYTE $0xc0       // testq        %r8, %r8
+	LONG $0x00d8840f; WORD $0x0000 // je           LBB27_81, $216(%rip)
+	WORD $0x2949; BYTE $0xfe       // subq         %rdi, %r14
+	LONG $0xff468d49               // leaq         $-1(%r14), %rax
+	WORD $0x3949; BYTE $0xc2       // cmpq         %rax, %r10
+	LONG $0x0033840f; WORD $0x0000 // je           LBB27_73, $51(%rip)
+	WORD $0x3949; BYTE $0xc1       // cmpq         %rax, %r9
+	LONG $0x002a840f; WORD $0x0000 // je           LBB27_73, $42(%rip)
+	WORD $0x3949; BYTE $0xc0       // cmpq         %rax, %r8
+	LONG $0x0021840f; WORD $0x0000 // je           LBB27_73, $33(%rip)
+	WORD $0x854d; BYTE $0xc9       // testq        %r9, %r9
+	LONG $0x00238e0f; WORD $0x0000 // jle          LBB27_77, $35(%rip)
+	LONG $0xff418d49               // leaq         $-1(%r9), %rax
+	WORD $0x3949; BYTE $0xc0       // cmpq         %rax, %r8
+	LONG $0x0016840f; WORD $0x0000 // je           LBB27_77, $22(%rip)
+	WORD $0xf749; BYTE $0xd1       // notq         %r9
+	WORD $0x894c; BYTE $0xc8       // movq         %r9, %rax
+	LONG $0x000095e9; BYTE $0x00   // jmp          LBB27_81, $149(%rip)
+
+LBB27_73:
+	WORD $0xf749; BYTE $0xde     // negq         %r14
+	WORD $0x894c; BYTE $0xf0     // movq         %r14, %rax
+	LONG $0x00008ae9; BYTE $0x00 // jmp          LBB27_81, $138(%rip)
+
+LBB27_77:
+	WORD $0x894c; BYTE $0xd0       // movq         %r10, %rax
+	WORD $0x094c; BYTE $0xc0       // orq          %r8, %rax
+	WORD $0x990f; BYTE $0xc0       // setns        %al
+	LONG $0x0014880f; WORD $0x0000 // js           LBB27_80, $20(%rip)
+	WORD $0x394d; BYTE $0xc2       // cmpq         %r8, %r10
+	LONG $0x000b8c0f; WORD $0x0000 // jl           LBB27_80, $11(%rip)
+	WORD $0xf749; BYTE $0xd2       // notq         %r10
+	WORD $0x894c; BYTE $0xd0       // movq         %r10, %rax
+	LONG $0x000067e9; BYTE $0x00   // jmp          LBB27_81, $103(%rip)
+
+LBB27_80:
+	LONG $0xff488d49             // leaq         $-1(%r8), %rcx
+	WORD $0x3949; BYTE $0xca     // cmpq         %rcx, %r10
+	WORD $0xf749; BYTE $0xd0     // notq         %r8
+	LONG $0xc6450f4d             // cmovneq      %r14, %r8
+	WORD $0xc084                 // testb        %al, %al
+	LONG $0xc6440f4d             // cmoveq       %r14, %r8
+	WORD $0x894c; BYTE $0xc0     // movq         %r8, %rax
+	LONG $0x00004be9; BYTE $0x00 // jmp          LBB27_81, $75(%rip)
+
+LBB27_64:
+	WORD $0x894d; BYTE $0xde                   // movq         %r11, %r14
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x854d; BYTE $0xd2                   // testq        %r10, %r10
+	LONG $0xff4e850f; WORD $0xffff             // jne          LBB27_68, $-178(%rip)
+	LONG $0x000033e9; BYTE $0x00               // jmp          LBB27_81, $51(%rip)
+
+LBB27_12:
+	WORD $0xbc0f; BYTE $0xc9     // bsfl         %ecx, %ecx
+	LONG $0x000002e9; BYTE $0x00 // jmp          LBB27_13, $2(%rip)
+
+LBB27_82:
+	WORD $0xc989 // movl         %ecx, %ecx
+
+LBB27_13:
+	WORD $0xf748; BYTE $0xd0     // notq         %rax
+	WORD $0x2948; BYTE $0xc8     // subq         %rcx, %rax
+	LONG $0x00001ee9; BYTE $0x00 // jmp          LBB27_81, $30(%rip)
+
+LBB27_33:
+	WORD $0xbc0f; BYTE $0xcb     // bsfl         %ebx, %ecx
+	LONG $0x00000ae9; BYTE $0x00 // jmp          LBB27_34, $10(%rip)
+
+LBB27_59:
+	WORD $0x294c; BYTE $0xf7     // subq         %r14, %rdi
+	LONG $0x000008e9; BYTE $0x00 // jmp          LBB27_60, $8(%rip)
+
+LBB27_84:
+	WORD $0xd189 // movl         %edx, %ecx
+
+LBB27_34:
+	WORD $0x294c; BYTE $0xf7 // subq         %r14, %rdi
+	WORD $0x2948; BYTE $0xcf // subq         %rcx, %rdi
+
+LBB27_60:
+	WORD $0xf748; BYTE $0xd0 // notq         %rax
+	WORD $0x0148; BYTE $0xf8 // addq         %rdi, %rax
+
+LBB27_81:
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	BYTE $0xc3               // retq
+
+LBB27_7:
+	LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r8
+	LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r10
+	WORD $0x8949; BYTE $0xfe                   // movq         %rdi, %r14
+	LONG $0x10fe8348                           // cmpq         $16, %rsi
+	LONG $0xfcc0830f; WORD $0xffff             // jae          LBB27_29, $-832(%rip)
+	LONG $0xfffe0ae9; BYTE $0xff               // jmp          LBB27_49, $-502(%rip)
+
+	// .p2align 2, 0x90
+	// .set L27_0_set_61, LBB27_61-LJTI27_0
+	// .set L27_0_set_66, LBB27_66-LJTI27_0
+	// .set L27_0_set_57, LBB27_57-LJTI27_0
+	// .set L27_0_set_54, LBB27_54-LJTI27_0
+LJTI27_0:
+	LONG $0xfffffe82 // .long L27_0_set_61
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffe82 // .long L27_0_set_61
+	LONG $0xfffffe95 // .long L27_0_set_57
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffed7 // .long L27_0_set_66
+	LONG $0xfffffe34 // .long L27_0_set_54
+	LONG $0x90909090 // .p2align 4, 0x90
+
+_skip_positive:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5641                   // pushq        %r14
+	BYTE $0x53                     // pushq        %rbx
+	WORD $0x8949; BYTE $0xf6       // movq         %rsi, %r14
+	WORD $0x8b48; BYTE $0x1e       // movq         (%rsi), %rbx
+	WORD $0xff48; BYTE $0xcb       // decq         %rbx
+	WORD $0x8b48; BYTE $0x07       // movq         (%rdi), %rax
+	WORD $0x0148; BYTE $0xd8       // addq         %rbx, %rax
+	LONG $0x08778b48               // movq         $8(%rdi), %rsi
+	WORD $0x2948; BYTE $0xde       // subq         %rbx, %rsi
+	WORD $0x8948; BYTE $0xc7       // movq         %rax, %rdi
+	LONG $0xfffa5be8; BYTE $0xff   // callq        _do_skip_number, $-1445(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x000e880f; WORD $0x0000 // js           LBB28_1, $14(%rip)
+	WORD $0x8b49; BYTE $0x0e       // movq         (%r14), %rcx
+	WORD $0x0148; BYTE $0xc1       // addq         %rax, %rcx
+	WORD $0xff48; BYTE $0xc9       // decq         %rcx
+	LONG $0x000011e9; BYTE $0x00   // jmp          LBB28_3, $17(%rip)
+
+LBB28_1:
+	WORD $0x8b49; BYTE $0x0e                   // movq         (%r14), %rcx
+	WORD $0x2948; BYTE $0xc1                   // subq         %rax, %rcx
+	LONG $0xfec18348                           // addq         $-2, %rcx
+	LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rbx
+
+LBB28_3:
+	WORD $0x8949; BYTE $0x0e // movq         %rcx, (%r14)
+	WORD $0x8948; BYTE $0xd8 // movq         %rbx, %rax
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5e41             // popq         %r14
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+	QUAD $0x9090909090909090 // .p2align 4, 0x90
+
+_skip_number:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5741                   // pushq        %r15
+	WORD $0x5641                   // pushq        %r14
+	WORD $0x5441                   // pushq        %r12
+	BYTE $0x53                     // pushq        %rbx
+	WORD $0x8949; BYTE $0xf6       // movq         %rsi, %r14
+	WORD $0x8b4c; BYTE $0x27       // movq         (%rdi), %r12
+	LONG $0x08778b48               // movq         $8(%rdi), %rsi
+	WORD $0x8b4d; BYTE $0x3e       // movq         (%r14), %r15
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x3c3c8043; BYTE $0x2d   // cmpb         $45, (%r12,%r15)
+	LONG $0x3c1c8d4b               // leaq         (%r12,%r15), %rbx
+	WORD $0x940f; BYTE $0xc0       // sete         %al
+	WORD $0x0148; BYTE $0xc3       // addq         %rax, %rbx
+	WORD $0x2948; BYTE $0xc6       // subq         %rax, %rsi
+	LONG $0x003c840f; WORD $0x0000 // je           LBB29_6, $60(%rip)
+	WORD $0x3949; BYTE $0xf7       // cmpq         %rsi, %r15
+	LONG $0x000d830f; WORD $0x0000 // jae          LBB29_3, $13(%rip)
+	WORD $0xb60f; BYTE $0x03       // movzbl       (%rbx), %eax
+	WORD $0xc604                   // addb         $-58, %al
+	WORD $0xf63c                   // cmpb         $-10, %al
+	LONG $0x0038820f; WORD $0x0000 // jb           LBB29_8, $56(%rip)
+
+LBB29_3:
+	WORD $0x8948; BYTE $0xdf       // movq         %rbx, %rdi
+	LONG $0xfff9d0e8; BYTE $0xff   // callq        _do_skip_number, $-1584(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0021880f; WORD $0x0000 // js           LBB29_7, $33(%rip)
+	WORD $0x0148; BYTE $0xc3       // addq         %rax, %rbx
+
+LBB29_5:
+	WORD $0x294c; BYTE $0xe3 // subq         %r12, %rbx
+	WORD $0x8949; BYTE $0x1e // movq         %rbx, (%r14)
+	WORD $0x894c; BYTE $0xf8 // movq         %r15, %rax
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB29_6:
+	LONG $0xffc7c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r15
+	LONG $0xffffe2e9; BYTE $0xff               // jmp          LBB29_5, $-30(%rip)
+
+LBB29_7:
+	WORD $0xf748; BYTE $0xd0 // notq         %rax
+	WORD $0x0148; BYTE $0xc3 // addq         %rax, %rbx
+
+LBB29_8:
+	LONG $0xfec7c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r15
+	LONG $0xffffd0e9; BYTE $0xff               // jmp          LBB29_5, $-48(%rip)
+	LONG $0x00000000                           // .p2align 4, 0x00
+
+LCPI30_0:
+	LONG $0x00000001 // .long 1
+	LONG $0x00000000 // .long 0
+	LONG $0x00000000 // .long 0
+	LONG $0x00000000 // .long 0
+
+	// .p2align 4, 0x90
+_skip_one:
+	BYTE $0x55                                               // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                                 // movq         %rsp, %rbp
+	WORD $0x8948; BYTE $0xd0                                 // movq         %rdx, %rax
+	WORD $0x8948; BYTE $0xf2                                 // movq         %rsi, %rdx
+	WORD $0x8948; BYTE $0xfe                                 // movq         %rdi, %rsi
+	QUAD $0xffffffdb0528f8c5                                 // vmovaps      $-37(%rip), %xmm0  /* LCPI30_0(%rip) */
+	LONG $0x0011f8c5                                         // vmovups      %xmm0, (%rax)
+	WORD $0x8948; BYTE $0xc7                                 // movq         %rax, %rdi
+	BYTE $0x5d                                               // popq         %rbp
+	LONG $0xffef8ee9; BYTE $0xff                             // jmp          _fsm_exec, $-4210(%rip)
+	QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00
+
+LCPI31_0:
+	LONG $0x00000001 // .long 1
+	LONG $0x00000000 // .long 0
+	LONG $0x00000000 // .long 0
+	LONG $0x00000000 // .long 0
+
+	// .p2align 4, 0x90
+_validate_one:
+	BYTE $0x55                           // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5             // movq         %rsp, %rbp
+	WORD $0x8948; BYTE $0xd0             // movq         %rdx, %rax
+	WORD $0x8948; BYTE $0xf2             // movq         %rsi, %rdx
+	WORD $0x8948; BYTE $0xfe             // movq         %rdi, %rsi
+	QUAD $0xffffffdb0528f8c5             // vmovaps      $-37(%rip), %xmm0  /* LCPI31_0(%rip) */
+	LONG $0x0011f8c5                     // vmovups      %xmm0, (%rax)
+	LONG $0x000020b9; BYTE $0x00         // movl         $32, %ecx
+	WORD $0x8948; BYTE $0xc7             // movq         %rax, %rdi
+	BYTE $0x5d                           // popq         %rbp
+	LONG $0xffef49e9; BYTE $0xff         // jmp          _fsm_exec, $-4279(%rip)
+	QUAD $0x0000000000000000; BYTE $0x00 // .p2align 5, 0x00
+
+LCPI32_0:
+	QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,'
+	QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,'
+
+LCPI32_1:
+	QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
+	QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
+
+LCPI32_2:
+	QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]'
+	QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]'
+
+LCPI32_6:
+	QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
+	QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
+
+LCPI32_7:
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+
+LCPI32_8:
+	QUAD $0x7b7b7b7b7b7b7b7b; QUAD $0x7b7b7b7b7b7b7b7b // .space 16, '{{{{{{{{{{{{{{{{'
+	QUAD $0x7b7b7b7b7b7b7b7b; QUAD $0x7b7b7b7b7b7b7b7b // .space 16, '{{{{{{{{{{{{{{{{'
+
+LCPI32_9:
+	QUAD $0x7d7d7d7d7d7d7d7d; QUAD $0x7d7d7d7d7d7d7d7d // .space 16, '}}}}}}}}}}}}}}}}'
+	QUAD $0x7d7d7d7d7d7d7d7d; QUAD $0x7d7d7d7d7d7d7d7d // .space 16, '}}}}}}}}}}}}}}}}'
+
+LCPI32_10:
+	QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b // .space 16, '[[[[[[[[[[[[[[[['
+	QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b // .space 16, '[[[[[[[[[[[[[[[['
+
+	// .p2align 4, 0x00
+LCPI32_3:
+	QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,'
+
+LCPI32_4:
+	QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
+
+LCPI32_5:
+	QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]'
+
+	// .p2align 4, 0x90
+_skip_one_fast:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0xe0e48348                           // andq         $-32, %rsp
+	LONG $0x80ec8148; WORD $0x0000; BYTE $0x00 // subq         $128, %rsp
+	WORD $0x8949; BYTE $0xf6                   // movq         %rsi, %r14
+	WORD $0x8949; BYTE $0xff                   // movq         %rdi, %r15
+	LONG $0xffdccde8; BYTE $0xff               // callq        _advance_ns, $-9011(%rip)
+	WORD $0x8b49; BYTE $0x16                   // movq         (%r14), %rdx
+	LONG $0xff628d4c                           // leaq         $-1(%rdx), %r12
+	WORD $0xbe0f; BYTE $0xc8                   // movsbl       %al, %ecx
+	WORD $0xf983; BYTE $0x7b                   // cmpl         $123, %ecx
+	LONG $0x0176870f; WORD $0x0000             // ja           LBB32_23, $374(%rip)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0x04358d48; WORD $0x0009; BYTE $0x00 // leaq         $2308(%rip), %rsi  /* LJTI32_0(%rip) */
+	LONG $0x8e0c6348                           // movslq       (%rsi,%rcx,4), %rcx
+	WORD $0x0148; BYTE $0xf1                   // addq         %rsi, %rcx
+	JMP  CX
+
+LBB32_2:
+	WORD $0x8b49; BYTE $0x07                                 // movq         (%r15), %rax
+	LONG $0x08778b49                                         // movq         $8(%r15), %rsi
+	WORD $0x8948; BYTE $0xf1                                 // movq         %rsi, %rcx
+	WORD $0x2948; BYTE $0xd1                                 // subq         %rdx, %rcx
+	LONG $0x20f98348                                         // cmpq         $32, %rcx
+	LONG $0x082c820f; WORD $0x0000                           // jb           LBB32_87, $2092(%rip)
+	WORD $0x8948; BYTE $0xd1                                 // movq         %rdx, %rcx
+	WORD $0xf748; BYTE $0xd9                                 // negq         %rcx
+	QUAD $0xfffffe5e056ffdc5                                 // vmovdqa      $-418(%rip), %ymm0  /* LCPI32_0(%rip) */
+	QUAD $0xfffffe760d6ffdc5                                 // vmovdqa      $-394(%rip), %ymm1  /* LCPI32_1(%rip) */
+	QUAD $0xfffffe8e156ffdc5                                 // vmovdqa      $-370(%rip), %ymm2  /* LCPI32_2(%rip) */
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB32_4:
+	LONG $0x1c6ffec5; BYTE $0x10   // vmovdqu      (%rax,%rdx), %ymm3
+	LONG $0xe074e5c5               // vpcmpeqb     %ymm0, %ymm3, %ymm4
+	LONG $0xd9dbe5c5               // vpand        %ymm1, %ymm3, %ymm3
+	LONG $0xda74e5c5               // vpcmpeqb     %ymm2, %ymm3, %ymm3
+	LONG $0xdcebe5c5               // vpor         %ymm4, %ymm3, %ymm3
+	LONG $0xfbd7fdc5               // vpmovmskb    %ymm3, %edi
+	WORD $0xff85                   // testl        %edi, %edi
+	LONG $0x00ca850f; WORD $0x0000 // jne          LBB32_18, $202(%rip)
+	LONG $0x20c28348               // addq         $32, %rdx
+	LONG $0x0e3c8d48               // leaq         (%rsi,%rcx), %rdi
+	LONG $0xe0c78348               // addq         $-32, %rdi
+	LONG $0xe0c18348               // addq         $-32, %rcx
+	LONG $0x1fff8348               // cmpq         $31, %rdi
+	LONG $0xffc5870f; WORD $0xffff // ja           LBB32_4, $-59(%rip)
+	WORD $0x8948; BYTE $0xc2       // movq         %rax, %rdx
+	WORD $0x2948; BYTE $0xca       // subq         %rcx, %rdx
+	WORD $0x0148; BYTE $0xce       // addq         %rcx, %rsi
+	WORD $0x8948; BYTE $0xf1       // movq         %rsi, %rcx
+	LONG $0x10f98348               // cmpq         $16, %rcx
+	LONG $0x0055820f; WORD $0x0000 // jb           LBB32_10, $85(%rip)
+
+LBB32_7:
+	WORD $0x8948; BYTE $0xc6 // movq         %rax, %rsi
+	WORD $0x2948; BYTE $0xd6 // subq         %rdx, %rsi
+	QUAD $0xfffffee1056ff9c5 // vmovdqa      $-287(%rip), %xmm0  /* LCPI32_3(%rip) */
+	QUAD $0xfffffee90d6ff9c5 // vmovdqa      $-279(%rip), %xmm1  /* LCPI32_4(%rip) */
+	QUAD $0xfffffef1156ff9c5 // vmovdqa      $-271(%rip), %xmm2  /* LCPI32_5(%rip) */
+	BYTE $0x90               // .p2align 4, 0x90
+
+LBB32_8:
+	LONG $0x1a6ffac5               // vmovdqu      (%rdx), %xmm3
+	LONG $0xe074e1c5               // vpcmpeqb     %xmm0, %xmm3, %xmm4
+	LONG $0xd9dbe1c5               // vpand        %xmm1, %xmm3, %xmm3
+	LONG $0xda74e1c5               // vpcmpeqb     %xmm2, %xmm3, %xmm3
+	LONG $0xdcebe1c5               // vpor         %xmm4, %xmm3, %xmm3
+	LONG $0xfbd7f9c5               // vpmovmskb    %xmm3, %edi
+	WORD $0xff85                   // testl        %edi, %edi
+	LONG $0x0744850f; WORD $0x0000 // jne          LBB32_86, $1860(%rip)
+	LONG $0x10c28348               // addq         $16, %rdx
+	LONG $0xf0c18348               // addq         $-16, %rcx
+	LONG $0xf0c68348               // addq         $-16, %rsi
+	LONG $0x0ff98348               // cmpq         $15, %rcx
+	LONG $0xffca870f; WORD $0xffff // ja           LBB32_8, $-54(%rip)
+
+LBB32_10:
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x0034840f; WORD $0x0000 // je           LBB32_17, $52(%rip)
+	LONG $0x0a3c8d48               // leaq         (%rdx,%rcx), %rdi
+	WORD $0xf631                   // xorl         %esi, %esi
+
+LBB32_12:
+	LONG $0x321cb60f               // movzbl       (%rdx,%rsi), %ebx
+	WORD $0xfb83; BYTE $0x2c       // cmpl         $44, %ebx
+	LONG $0x0750840f; WORD $0x0000 // je           LBB32_88, $1872(%rip)
+	WORD $0xfb83; BYTE $0x7d       // cmpl         $125, %ebx
+	LONG $0x0747840f; WORD $0x0000 // je           LBB32_88, $1863(%rip)
+	WORD $0xfb83; BYTE $0x5d       // cmpl         $93, %ebx
+	LONG $0x073e840f; WORD $0x0000 // je           LBB32_88, $1854(%rip)
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0x3948; BYTE $0xf1       // cmpq         %rsi, %rcx
+	LONG $0xffd5850f; WORD $0xffff // jne          LBB32_12, $-43(%rip)
+	WORD $0x8948; BYTE $0xfa       // movq         %rdi, %rdx
+
+LBB32_17:
+	WORD $0x2948; BYTE $0xc2     // subq         %rax, %rdx
+	LONG $0x0003f3e9; BYTE $0x00 // jmp          LBB32_59, $1011(%rip)
+
+LBB32_18:
+	WORD $0xbc0f; BYTE $0xc7 // bsfl         %edi, %eax
+	WORD $0x2948; BYTE $0xc8 // subq         %rcx, %rax
+
+LBB32_19:
+	WORD $0x8949; BYTE $0x06 // movq         %rax, (%r14)
+
+LBB32_20:
+	WORD $0x894c; BYTE $0xe0 // movq         %r12, %rax
+
+LBB32_21:
+	LONG $0xd8658d48         // leaq         $-40(%rbp), %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	BYTE $0xc3               // retq
+
+LBB32_22:
+	LONG $0x03c28348               // addq         $3, %rdx
+	LONG $0x08573b49               // cmpq         $8(%r15), %rdx
+	LONG $0xffe0830f; WORD $0xffff // jae          LBB32_21, $-32(%rip)
+	LONG $0x0003c2e9; BYTE $0x00   // jmp          LBB32_59, $962(%rip)
+
+LBB32_23:
+	WORD $0x894d; BYTE $0x26                   // movq         %r12, (%r14)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	LONG $0xffffcce9; BYTE $0xff               // jmp          LBB32_21, $-52(%rip)
+
+LBB32_24:
+	WORD $0x8b49; BYTE $0x0f                   // movq         (%r15), %rcx
+	LONG $0x08578b4d                           // movq         $8(%r15), %r10
+	LONG $0x244c8948; BYTE $0x18               // movq         %rcx, $24(%rsp)
+	LONG $0x110c8d4c                           // leaq         (%rcx,%rdx), %r9
+	WORD $0x2949; BYTE $0xd2                   // subq         %rdx, %r10
+	LONG $0x20fa8349                           // cmpq         $32, %r10
+	LONG $0x06aa820f; WORD $0x0000             // jb           LBB32_33, $1706(%rip)
+	WORD $0xf631                               // xorl         %esi, %esi
+	QUAD $0xfffffd4e056ffdc5                   // vmovdqa      $-690(%rip), %ymm0  /* LCPI32_6(%rip) */
+	QUAD $0xfffffd660d6ffdc5                   // vmovdqa      $-666(%rip), %ymm1  /* LCPI32_7(%rip) */
+	WORD $0xdb31                               // xorl         %ebx, %ebx
+	WORD $0x3145; BYTE $0xff                   // xorl         %r15d, %r15d
+	LONG $0x00006ae9; BYTE $0x00               // jmp          LBB32_26, $106(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+LBB32_29:
+	WORD $0x8944; BYTE $0xf9                   // movl         %r15d, %ecx
+	WORD $0xd1f7                               // notl         %ecx
+	WORD $0xf921                               // andl         %edi, %ecx
+	LONG $0x09048d44                           // leal         (%rcx,%rcx), %r8d
+	WORD $0x0945; BYTE $0xf8                   // orl          %r15d, %r8d
+	WORD $0x8945; BYTE $0xc5                   // movl         %r8d, %r13d
+	WORD $0xf741; BYTE $0xd5                   // notl         %r13d
+	WORD $0x2141; BYTE $0xfd                   // andl         %edi, %r13d
+	LONG $0xaae58141; WORD $0xaaaa; BYTE $0xaa // andl         $-1431655766, %r13d
+	WORD $0x3145; BYTE $0xff                   // xorl         %r15d, %r15d
+	WORD $0x0141; BYTE $0xcd                   // addl         %ecx, %r13d
+	LONG $0xc7920f41                           // setb         %r15b
+	WORD $0x0145; BYTE $0xed                   // addl         %r13d, %r13d
+	LONG $0x55f58141; WORD $0x5555; BYTE $0x55 // xorl         $1431655765, %r13d
+	WORD $0x2145; BYTE $0xc5                   // andl         %r8d, %r13d
+	WORD $0xf741; BYTE $0xd5                   // notl         %r13d
+	WORD $0x2145; BYTE $0xeb                   // andl         %r13d, %r11d
+	WORD $0x854d; BYTE $0xdb                   // testq        %r11, %r11
+	LONG $0x004d850f; WORD $0x0000             // jne          LBB32_85, $77(%rip)
+
+LBB32_30:
+	LONG $0x20c38348               // addq         $32, %rbx
+	LONG $0x320c8d49               // leaq         (%r10,%rsi), %rcx
+	LONG $0xe0c18348               // addq         $-32, %rcx
+	LONG $0xe0c68348               // addq         $-32, %rsi
+	LONG $0x1ff98348               // cmpq         $31, %rcx
+	LONG $0x0615860f; WORD $0x0000 // jbe          LBB32_31, $1557(%rip)
+
+LBB32_26:
+	LONG $0x6f7ec1c4; WORD $0x1914 // vmovdqu      (%r9,%rbx), %ymm2
+	LONG $0xd874edc5               // vpcmpeqb     %ymm0, %ymm2, %ymm3
+	LONG $0xdbd77dc5               // vpmovmskb    %ymm3, %r11d
+	LONG $0xd174edc5               // vpcmpeqb     %ymm1, %ymm2, %ymm2
+	LONG $0xfad7fdc5               // vpmovmskb    %ymm2, %edi
+	WORD $0xff85                   // testl        %edi, %edi
+	LONG $0xff84850f; WORD $0xffff // jne          LBB32_29, $-124(%rip)
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0xff7b850f; WORD $0xffff // jne          LBB32_29, $-133(%rip)
+	WORD $0x3145; BYTE $0xff       // xorl         %r15d, %r15d
+	WORD $0x854d; BYTE $0xdb       // testq        %r11, %r11
+	LONG $0xffb3840f; WORD $0xffff // je           LBB32_30, $-77(%rip)
+
+LBB32_85:
+	LONG $0xc3bc0f41             // bsfl         %r11d, %eax
+	WORD $0x0148; BYTE $0xd0     // addq         %rdx, %rax
+	WORD $0x0148; BYTE $0xd8     // addq         %rbx, %rax
+	WORD $0xff48; BYTE $0xc0     // incq         %rax
+	LONG $0xfffedee9; BYTE $0xff // jmp          LBB32_19, $-290(%rip)
+
+LBB32_34:
+	LONG $0x084f8b49             // movq         $8(%r15), %rcx
+	WORD $0x2948; BYTE $0xd1     // subq         %rdx, %rcx
+	WORD $0x0349; BYTE $0x17     // addq         (%r15), %rdx
+	WORD $0x3145; BYTE $0xc9     // xorl         %r9d, %r9d
+	QUAD $0xfffffc98056ffdc5     // vmovdqa      $-872(%rip), %ymm0  /* LCPI32_7(%rip) */
+	QUAD $0xfffffc700d6ffdc5     // vmovdqa      $-912(%rip), %ymm1  /* LCPI32_6(%rip) */
+	LONG $0xd276e9c5             // vpcmpeqd     %xmm2, %xmm2, %xmm2
+	QUAD $0xfffffce41d6ffdc5     // vmovdqa      $-796(%rip), %ymm3  /* LCPI32_10(%rip) */
+	QUAD $0xfffffc3c256ffdc5     // vmovdqa      $-964(%rip), %ymm4  /* LCPI32_2(%rip) */
+	LONG $0x573041c4; BYTE $0xc9 // vxorps       %xmm9, %xmm9, %xmm9
+	WORD $0x3145; BYTE $0xd2     // xorl         %r10d, %r10d
+	WORD $0x3145; BYTE $0xdb     // xorl         %r11d, %r11d
+	WORD $0xf631                 // xorl         %esi, %esi
+	LONG $0x00001ce9; BYTE $0x00 // jmp          LBB32_36, $28(%rip)
+
+LBB32_35:
+	LONG $0x3ffdc149             // sarq         $63, %r13
+	LONG $0xb80f49f3; BYTE $0xc8 // popcntq      %r8, %rcx
+	WORD $0x0149; BYTE $0xcb     // addq         %rcx, %r11
+	LONG $0x40c28348             // addq         $64, %rdx
+	LONG $0x244c8b48; BYTE $0x18 // movq         $24(%rsp), %rcx
+	LONG $0xc0c18348             // addq         $-64, %rcx
+	WORD $0x894d; BYTE $0xe9     // movq         %r13, %r9
+
+LBB32_36:
+	LONG $0x40f98348               // cmpq         $64, %rcx
+	LONG $0x244c8948; BYTE $0x18   // movq         %rcx, $24(%rsp)
+	LONG $0x012b8c0f; WORD $0x0000 // jl           LBB32_43, $299(%rip)
+
+LBB32_37:
+	LONG $0x3a6ffec5                           // vmovdqu      (%rdx), %ymm7
+	LONG $0x726ffec5; BYTE $0x20               // vmovdqu      $32(%rdx), %ymm6
+	LONG $0xc07445c5                           // vpcmpeqb     %ymm0, %ymm7, %ymm8
+	LONG $0xd77dc1c4; BYTE $0xc8               // vpmovmskb    %ymm8, %ecx
+	LONG $0xc0744dc5                           // vpcmpeqb     %ymm0, %ymm6, %ymm8
+	LONG $0xd77dc1c4; BYTE $0xf8               // vpmovmskb    %ymm8, %edi
+	LONG $0x20e7c148                           // shlq         $32, %rdi
+	WORD $0x0948; BYTE $0xf9                   // orq          %rdi, %rcx
+	WORD $0x8948; BYTE $0xcf                   // movq         %rcx, %rdi
+	WORD $0x094c; BYTE $0xd7                   // orq          %r10, %rdi
+	LONG $0x000f850f; WORD $0x0000             // jne          LBB32_39, $15(%rip)
+	LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rcx
+	WORD $0x3145; BYTE $0xd2                   // xorl         %r10d, %r10d
+	LONG $0x000046e9; BYTE $0x00               // jmp          LBB32_40, $70(%rip)
+
+LBB32_39:
+	WORD $0x894c; BYTE $0xd7               // movq         %r10, %rdi
+	WORD $0xf748; BYTE $0xd7               // notq         %rdi
+	WORD $0x2148; BYTE $0xcf               // andq         %rcx, %rdi
+	LONG $0x3f2c8d4c                       // leaq         (%rdi,%rdi), %r13
+	WORD $0x094d; BYTE $0xd5               // orq          %r10, %r13
+	WORD $0x894d; BYTE $0xe8               // movq         %r13, %r8
+	WORD $0xf749; BYTE $0xd0               // notq         %r8
+	QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq      $-6148914691236517206, %rbx
+	WORD $0x2148; BYTE $0xd9               // andq         %rbx, %rcx
+	WORD $0x214c; BYTE $0xc1               // andq         %r8, %rcx
+	WORD $0x3145; BYTE $0xd2               // xorl         %r10d, %r10d
+	WORD $0x0148; BYTE $0xf9               // addq         %rdi, %rcx
+	LONG $0xc2920f41                       // setb         %r10b
+	WORD $0x0148; BYTE $0xc9               // addq         %rcx, %rcx
+	QUAD $0x555555555555bf48; WORD $0x5555 // movabsq      $6148914691236517205, %rdi
+	WORD $0x3148; BYTE $0xf9               // xorq         %rdi, %rcx
+	WORD $0x214c; BYTE $0xe9               // andq         %r13, %rcx
+	WORD $0xf748; BYTE $0xd1               // notq         %rcx
+
+LBB32_40:
+	LONG $0xc1744dc5                                       // vpcmpeqb     %ymm1, %ymm6, %ymm8
+	LONG $0xd77dc1c4; BYTE $0xf8                           // vpmovmskb    %ymm8, %edi
+	LONG $0x20e7c148                                       // shlq         $32, %rdi
+	LONG $0xc17445c5                                       // vpcmpeqb     %ymm1, %ymm7, %ymm8
+	LONG $0xd77dc1c4; BYTE $0xd8                           // vpmovmskb    %ymm8, %ebx
+	WORD $0x0948; BYTE $0xfb                               // orq          %rdi, %rbx
+	WORD $0x2148; BYTE $0xcb                               // andq         %rcx, %rbx
+	LONG $0x6ef9e1c4; BYTE $0xeb                           // vmovq        %rbx, %xmm5
+	LONG $0x4451e3c4; WORD $0x00ea                         // vpclmulqdq   $0, %xmm2, %xmm5, %xmm5
+	LONG $0x7ef9c1c4; BYTE $0xed                           // vmovq        %xmm5, %r13
+	WORD $0x314d; BYTE $0xcd                               // xorq         %r9, %r13
+	LONG $0xeb74c5c5                                       // vpcmpeqb     %ymm3, %ymm7, %ymm5
+	LONG $0xc5d77dc5                                       // vpmovmskb    %ymm5, %r8d
+	LONG $0xeb74cdc5                                       // vpcmpeqb     %ymm3, %ymm6, %ymm5
+	LONG $0xfdd7fdc5                                       // vpmovmskb    %ymm5, %edi
+	LONG $0x20e7c148                                       // shlq         $32, %rdi
+	WORD $0x0949; BYTE $0xf8                               // orq          %rdi, %r8
+	WORD $0x894d; BYTE $0xe9                               // movq         %r13, %r9
+	WORD $0xf749; BYTE $0xd1                               // notq         %r9
+	WORD $0x214d; BYTE $0xc8                               // andq         %r9, %r8
+	LONG $0xec74c5c5                                       // vpcmpeqb     %ymm4, %ymm7, %ymm5
+	LONG $0xddd7fdc5                                       // vpmovmskb    %ymm5, %ebx
+	LONG $0xec74cdc5                                       // vpcmpeqb     %ymm4, %ymm6, %ymm5
+	LONG $0xfdd7fdc5                                       // vpmovmskb    %ymm5, %edi
+	LONG $0x20e7c148                                       // shlq         $32, %rdi
+	WORD $0x0948; BYTE $0xfb                               // orq          %rdi, %rbx
+	WORD $0x214c; BYTE $0xcb                               // andq         %r9, %rbx
+	LONG $0xfee3840f; WORD $0xffff                         // je           LBB32_35, $-285(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB32_41:
+	LONG $0xff4b8d48               // leaq         $-1(%rbx), %rcx
+	WORD $0x8948; BYTE $0xcf       // movq         %rcx, %rdi
+	WORD $0x214c; BYTE $0xc7       // andq         %r8, %rdi
+	LONG $0xb80f48f3; BYTE $0xff   // popcntq      %rdi, %rdi
+	WORD $0x014c; BYTE $0xdf       // addq         %r11, %rdi
+	WORD $0x3948; BYTE $0xf7       // cmpq         %rsi, %rdi
+	LONG $0x0405860f; WORD $0x0000 // jbe          LBB32_84, $1029(%rip)
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0x2148; BYTE $0xcb       // andq         %rcx, %rbx
+	LONG $0xffd9850f; WORD $0xffff // jne          LBB32_41, $-39(%rip)
+	LONG $0xfffeaae9; BYTE $0xff   // jmp          LBB32_35, $-342(%rip)
+
+LBB32_43:
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x04688e0f; WORD $0x0000 // jle          LBB32_89, $1128(%rip)
+	LONG $0x4c297cc5; WORD $0x4024 // vmovaps      %ymm9, $64(%rsp)
+	LONG $0x4c297cc5; WORD $0x2024 // vmovaps      %ymm9, $32(%rsp)
+	WORD $0xd189                   // movl         %edx, %ecx
+	LONG $0x0fffe181; WORD $0x0000 // andl         $4095, %ecx
+	LONG $0x0fc1f981; WORD $0x0000 // cmpl         $4033, %ecx
+	LONG $0xfeac820f; WORD $0xffff // jb           LBB32_37, $-340(%rip)
+	LONG $0x247c8348; WORD $0x2018 // cmpq         $32, $24(%rsp)
+	LONG $0x0021820f; WORD $0x0000 // jb           LBB32_47, $33(%rip)
+	LONG $0x2a10fcc5               // vmovups      (%rdx), %ymm5
+	LONG $0x6c29fcc5; WORD $0x2024 // vmovaps      %ymm5, $32(%rsp)
+	LONG $0x20c28348               // addq         $32, %rdx
+	LONG $0x244c8b48; BYTE $0x18   // movq         $24(%rsp), %rcx
+	LONG $0xe0598d48               // leaq         $-32(%rcx), %rbx
+	LONG $0x247c8d48; BYTE $0x40   // leaq         $64(%rsp), %rdi
+	LONG $0x00000ae9; BYTE $0x00   // jmp          LBB32_48, $10(%rip)
+
+LBB32_47:
+	LONG $0x247c8d48; BYTE $0x20 // leaq         $32(%rsp), %rdi
+	LONG $0x245c8b48; BYTE $0x18 // movq         $24(%rsp), %rbx
+
+LBB32_48:
+	LONG $0x10fb8348               // cmpq         $16, %rbx
+	LONG $0x0058820f; WORD $0x0000 // jb           LBB32_49, $88(%rip)
+	LONG $0x2a10f8c5               // vmovups      (%rdx), %xmm5
+	LONG $0x2f11f8c5               // vmovups      %xmm5, (%rdi)
+	LONG $0x10c28348               // addq         $16, %rdx
+	LONG $0x10c78348               // addq         $16, %rdi
+	LONG $0xf0c38348               // addq         $-16, %rbx
+	LONG $0x08fb8348               // cmpq         $8, %rbx
+	LONG $0x0044830f; WORD $0x0000 // jae          LBB32_54, $68(%rip)
+
+LBB32_50:
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x0056820f; WORD $0x0000 // jb           LBB32_51, $86(%rip)
+
+LBB32_55:
+	WORD $0x0a8b                   // movl         (%rdx), %ecx
+	WORD $0x0f89                   // movl         %ecx, (%rdi)
+	LONG $0x04c28348               // addq         $4, %rdx
+	LONG $0x04c78348               // addq         $4, %rdi
+	LONG $0xfcc38348               // addq         $-4, %rbx
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0x0046830f; WORD $0x0000 // jae          LBB32_56, $70(%rip)
+
+LBB32_52:
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	LONG $0x24548d48; BYTE $0x20   // leaq         $32(%rsp), %rdx
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0058850f; WORD $0x0000 // jne          LBB32_57, $88(%rip)
+	LONG $0xfffe13e9; BYTE $0xff   // jmp          LBB32_37, $-493(%rip)
+
+LBB32_49:
+	LONG $0x08fb8348               // cmpq         $8, %rbx
+	LONG $0xffbc820f; WORD $0xffff // jb           LBB32_50, $-68(%rip)
+
+LBB32_54:
+	WORD $0x8b48; BYTE $0x0a       // movq         (%rdx), %rcx
+	WORD $0x8948; BYTE $0x0f       // movq         %rcx, (%rdi)
+	LONG $0x08c28348               // addq         $8, %rdx
+	LONG $0x08c78348               // addq         $8, %rdi
+	LONG $0xf8c38348               // addq         $-8, %rbx
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0xffaa830f; WORD $0xffff // jae          LBB32_55, $-86(%rip)
+
+LBB32_51:
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0xffba820f; WORD $0xffff // jb           LBB32_52, $-70(%rip)
+
+LBB32_56:
+	WORD $0xb70f; BYTE $0x0a       // movzwl       (%rdx), %ecx
+	WORD $0x8966; BYTE $0x0f       // movw         %cx, (%rdi)
+	LONG $0x02c28348               // addq         $2, %rdx
+	LONG $0x02c78348               // addq         $2, %rdi
+	LONG $0xfec38348               // addq         $-2, %rbx
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	LONG $0x24548d48; BYTE $0x20   // leaq         $32(%rsp), %rdx
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0xfdc0840f; WORD $0xffff // je           LBB32_37, $-576(%rip)
+
+LBB32_57:
+	WORD $0xb60f; BYTE $0x09     // movzbl       (%rcx), %ecx
+	WORD $0x0f88                 // movb         %cl, (%rdi)
+	LONG $0x24548d48; BYTE $0x20 // leaq         $32(%rsp), %rdx
+	LONG $0xfffdb1e9; BYTE $0xff // jmp          LBB32_37, $-591(%rip)
+
+LBB32_58:
+	LONG $0x04c28348               // addq         $4, %rdx
+	LONG $0x08573b49               // cmpq         $8(%r15), %rdx
+	LONG $0xfc19830f; WORD $0xffff // jae          LBB32_21, $-999(%rip)
+
+LBB32_59:
+	WORD $0x8949; BYTE $0x16     // movq         %rdx, (%r14)
+	LONG $0xfffc0ee9; BYTE $0xff // jmp          LBB32_20, $-1010(%rip)
+
+LBB32_60:
+	LONG $0x084f8b49             // movq         $8(%r15), %rcx
+	WORD $0x2948; BYTE $0xd1     // subq         %rdx, %rcx
+	WORD $0x0349; BYTE $0x17     // addq         (%r15), %rdx
+	WORD $0x3145; BYTE $0xc9     // xorl         %r9d, %r9d
+	QUAD $0xfffff9c5056ffdc5     // vmovdqa      $-1595(%rip), %ymm0  /* LCPI32_7(%rip) */
+	QUAD $0xfffff99d0d6ffdc5     // vmovdqa      $-1635(%rip), %ymm1  /* LCPI32_6(%rip) */
+	LONG $0xd276e9c5             // vpcmpeqd     %xmm2, %xmm2, %xmm2
+	QUAD $0xfffff9d11d6ffdc5     // vmovdqa      $-1583(%rip), %ymm3  /* LCPI32_8(%rip) */
+	QUAD $0xfffff9e9256ffdc5     // vmovdqa      $-1559(%rip), %ymm4  /* LCPI32_9(%rip) */
+	LONG $0x573041c4; BYTE $0xc9 // vxorps       %xmm9, %xmm9, %xmm9
+	WORD $0x3145; BYTE $0xd2     // xorl         %r10d, %r10d
+	WORD $0x3145; BYTE $0xdb     // xorl         %r11d, %r11d
+	WORD $0xf631                 // xorl         %esi, %esi
+	LONG $0x00001ce9; BYTE $0x00 // jmp          LBB32_62, $28(%rip)
+
+LBB32_61:
+	LONG $0x3ffdc149             // sarq         $63, %r13
+	LONG $0xb80f49f3; BYTE $0xc8 // popcntq      %r8, %rcx
+	WORD $0x0149; BYTE $0xcb     // addq         %rcx, %r11
+	LONG $0x40c28348             // addq         $64, %rdx
+	LONG $0x244c8b48; BYTE $0x18 // movq         $24(%rsp), %rcx
+	LONG $0xc0c18348             // addq         $-64, %rcx
+	WORD $0x894d; BYTE $0xe9     // movq         %r13, %r9
+
+LBB32_62:
+	LONG $0x40f98348               // cmpq         $64, %rcx
+	LONG $0x244c8948; BYTE $0x18   // movq         %rcx, $24(%rsp)
+	LONG $0x01288c0f; WORD $0x0000 // jl           LBB32_69, $296(%rip)
+
+LBB32_63:
+	LONG $0x3a6ffec5                           // vmovdqu      (%rdx), %ymm7
+	LONG $0x726ffec5; BYTE $0x20               // vmovdqu      $32(%rdx), %ymm6
+	LONG $0xc07445c5                           // vpcmpeqb     %ymm0, %ymm7, %ymm8
+	LONG $0xd77dc1c4; BYTE $0xc8               // vpmovmskb    %ymm8, %ecx
+	LONG $0xc0744dc5                           // vpcmpeqb     %ymm0, %ymm6, %ymm8
+	LONG $0xd77dc1c4; BYTE $0xf8               // vpmovmskb    %ymm8, %edi
+	LONG $0x20e7c148                           // shlq         $32, %rdi
+	WORD $0x0948; BYTE $0xf9                   // orq          %rdi, %rcx
+	WORD $0x8948; BYTE $0xcf                   // movq         %rcx, %rdi
+	WORD $0x094c; BYTE $0xd7                   // orq          %r10, %rdi
+	LONG $0x000f850f; WORD $0x0000             // jne          LBB32_65, $15(%rip)
+	LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rcx
+	WORD $0x3145; BYTE $0xd2                   // xorl         %r10d, %r10d
+	LONG $0x000046e9; BYTE $0x00               // jmp          LBB32_66, $70(%rip)
+
+LBB32_65:
+	WORD $0x894c; BYTE $0xd7               // movq         %r10, %rdi
+	WORD $0xf748; BYTE $0xd7               // notq         %rdi
+	WORD $0x2148; BYTE $0xcf               // andq         %rcx, %rdi
+	LONG $0x3f2c8d4c                       // leaq         (%rdi,%rdi), %r13
+	WORD $0x094d; BYTE $0xd5               // orq          %r10, %r13
+	WORD $0x894d; BYTE $0xe8               // movq         %r13, %r8
+	WORD $0xf749; BYTE $0xd0               // notq         %r8
+	QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq      $-6148914691236517206, %rbx
+	WORD $0x2148; BYTE $0xd9               // andq         %rbx, %rcx
+	WORD $0x214c; BYTE $0xc1               // andq         %r8, %rcx
+	WORD $0x3145; BYTE $0xd2               // xorl         %r10d, %r10d
+	WORD $0x0148; BYTE $0xf9               // addq         %rdi, %rcx
+	LONG $0xc2920f41                       // setb         %r10b
+	WORD $0x0148; BYTE $0xc9               // addq         %rcx, %rcx
+	QUAD $0x555555555555bf48; WORD $0x5555 // movabsq      $6148914691236517205, %rdi
+	WORD $0x3148; BYTE $0xf9               // xorq         %rdi, %rcx
+	WORD $0x214c; BYTE $0xe9               // andq         %r13, %rcx
+	WORD $0xf748; BYTE $0xd1               // notq         %rcx
+
+LBB32_66:
+	LONG $0xc1744dc5                       // vpcmpeqb     %ymm1, %ymm6, %ymm8
+	LONG $0xd77dc1c4; BYTE $0xf8           // vpmovmskb    %ymm8, %edi
+	LONG $0x20e7c148                       // shlq         $32, %rdi
+	LONG $0xc17445c5                       // vpcmpeqb     %ymm1, %ymm7, %ymm8
+	LONG $0xd77dc1c4; BYTE $0xd8           // vpmovmskb    %ymm8, %ebx
+	WORD $0x0948; BYTE $0xfb               // orq          %rdi, %rbx
+	WORD $0x2148; BYTE $0xcb               // andq         %rcx, %rbx
+	LONG $0x6ef9e1c4; BYTE $0xeb           // vmovq        %rbx, %xmm5
+	LONG $0x4451e3c4; WORD $0x00ea         // vpclmulqdq   $0, %xmm2, %xmm5, %xmm5
+	LONG $0x7ef9c1c4; BYTE $0xed           // vmovq        %xmm5, %r13
+	WORD $0x314d; BYTE $0xcd               // xorq         %r9, %r13
+	LONG $0xeb74c5c5                       // vpcmpeqb     %ymm3, %ymm7, %ymm5
+	LONG $0xc5d77dc5                       // vpmovmskb    %ymm5, %r8d
+	LONG $0xeb74cdc5                       // vpcmpeqb     %ymm3, %ymm6, %ymm5
+	LONG $0xfdd7fdc5                       // vpmovmskb    %ymm5, %edi
+	LONG $0x20e7c148                       // shlq         $32, %rdi
+	WORD $0x0949; BYTE $0xf8               // orq          %rdi, %r8
+	WORD $0x894d; BYTE $0xe9               // movq         %r13, %r9
+	WORD $0xf749; BYTE $0xd1               // notq         %r9
+	WORD $0x214d; BYTE $0xc8               // andq         %r9, %r8
+	LONG $0xec74c5c5                       // vpcmpeqb     %ymm4, %ymm7, %ymm5
+	LONG $0xddd7fdc5                       // vpmovmskb    %ymm5, %ebx
+	LONG $0xec74cdc5                       // vpcmpeqb     %ymm4, %ymm6, %ymm5
+	LONG $0xfdd7fdc5                       // vpmovmskb    %ymm5, %edi
+	LONG $0x20e7c148                       // shlq         $32, %rdi
+	WORD $0x0948; BYTE $0xfb               // orq          %rdi, %rbx
+	WORD $0x214c; BYTE $0xcb               // andq         %r9, %rbx
+	LONG $0xfee3840f; WORD $0xffff         // je           LBB32_61, $-285(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB32_67:
+	LONG $0xff4b8d48               // leaq         $-1(%rbx), %rcx
+	WORD $0x8948; BYTE $0xcf       // movq         %rcx, %rdi
+	WORD $0x214c; BYTE $0xc7       // andq         %r8, %rdi
+	LONG $0xb80f48f3; BYTE $0xff   // popcntq      %rdi, %rdi
+	WORD $0x014c; BYTE $0xdf       // addq         %r11, %rdi
+	WORD $0x3948; BYTE $0xf7       // cmpq         %rsi, %rdi
+	LONG $0x0135860f; WORD $0x0000 // jbe          LBB32_84, $309(%rip)
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0x2148; BYTE $0xcb       // andq         %rcx, %rbx
+	LONG $0xffd9850f; WORD $0xffff // jne          LBB32_67, $-39(%rip)
+	LONG $0xfffeade9; BYTE $0xff   // jmp          LBB32_61, $-339(%rip)
+
+LBB32_69:
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x01988e0f; WORD $0x0000 // jle          LBB32_89, $408(%rip)
+	LONG $0x4c297cc5; WORD $0x4024 // vmovaps      %ymm9, $64(%rsp)
+	LONG $0x4c297cc5; WORD $0x2024 // vmovaps      %ymm9, $32(%rsp)
+	WORD $0xd189                   // movl         %edx, %ecx
+	LONG $0x0fffe181; WORD $0x0000 // andl         $4095, %ecx
+	LONG $0x0fc1f981; WORD $0x0000 // cmpl         $4033, %ecx
+	LONG $0xfeaf820f; WORD $0xffff // jb           LBB32_63, $-337(%rip)
+	LONG $0x247c8348; WORD $0x2018 // cmpq         $32, $24(%rsp)
+	LONG $0x0021820f; WORD $0x0000 // jb           LBB32_73, $33(%rip)
+	LONG $0x2a10fcc5               // vmovups      (%rdx), %ymm5
+	LONG $0x6c29fcc5; WORD $0x2024 // vmovaps      %ymm5, $32(%rsp)
+	LONG $0x20c28348               // addq         $32, %rdx
+	LONG $0x244c8b48; BYTE $0x18   // movq         $24(%rsp), %rcx
+	LONG $0xe0598d48               // leaq         $-32(%rcx), %rbx
+	LONG $0x247c8d48; BYTE $0x40   // leaq         $64(%rsp), %rdi
+	LONG $0x00000ae9; BYTE $0x00   // jmp          LBB32_74, $10(%rip)
+
+LBB32_73:
+	LONG $0x247c8d48; BYTE $0x20 // leaq         $32(%rsp), %rdi
+	LONG $0x245c8b48; BYTE $0x18 // movq         $24(%rsp), %rbx
+
+LBB32_74:
+	LONG $0x10fb8348               // cmpq         $16, %rbx
+	LONG $0x0058820f; WORD $0x0000 // jb           LBB32_75, $88(%rip)
+	LONG $0x2a10f8c5               // vmovups      (%rdx), %xmm5
+	LONG $0x2f11f8c5               // vmovups      %xmm5, (%rdi)
+	LONG $0x10c28348               // addq         $16, %rdx
+	LONG $0x10c78348               // addq         $16, %rdi
+	LONG $0xf0c38348               // addq         $-16, %rbx
+	LONG $0x08fb8348               // cmpq         $8, %rbx
+	LONG $0x0044830f; WORD $0x0000 // jae          LBB32_80, $68(%rip)
+
+LBB32_76:
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x0056820f; WORD $0x0000 // jb           LBB32_77, $86(%rip)
+
+LBB32_81:
+	WORD $0x0a8b                   // movl         (%rdx), %ecx
+	WORD $0x0f89                   // movl         %ecx, (%rdi)
+	LONG $0x04c28348               // addq         $4, %rdx
+	LONG $0x04c78348               // addq         $4, %rdi
+	LONG $0xfcc38348               // addq         $-4, %rbx
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0x0046830f; WORD $0x0000 // jae          LBB32_82, $70(%rip)
+
+LBB32_78:
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	LONG $0x24548d48; BYTE $0x20   // leaq         $32(%rsp), %rdx
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0058850f; WORD $0x0000 // jne          LBB32_83, $88(%rip)
+	LONG $0xfffe16e9; BYTE $0xff   // jmp          LBB32_63, $-490(%rip)
+
+LBB32_75:
+	LONG $0x08fb8348               // cmpq         $8, %rbx
+	LONG $0xffbc820f; WORD $0xffff // jb           LBB32_76, $-68(%rip)
+
+LBB32_80:
+	WORD $0x8b48; BYTE $0x0a       // movq         (%rdx), %rcx
+	WORD $0x8948; BYTE $0x0f       // movq         %rcx, (%rdi)
+	LONG $0x08c28348               // addq         $8, %rdx
+	LONG $0x08c78348               // addq         $8, %rdi
+	LONG $0xf8c38348               // addq         $-8, %rbx
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0xffaa830f; WORD $0xffff // jae          LBB32_81, $-86(%rip)
+
+LBB32_77:
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0xffba820f; WORD $0xffff // jb           LBB32_78, $-70(%rip)
+
+LBB32_82:
+	WORD $0xb70f; BYTE $0x0a       // movzwl       (%rdx), %ecx
+	WORD $0x8966; BYTE $0x0f       // movw         %cx, (%rdi)
+	LONG $0x02c28348               // addq         $2, %rdx
+	LONG $0x02c78348               // addq         $2, %rdi
+	LONG $0xfec38348               // addq         $-2, %rbx
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	LONG $0x24548d48; BYTE $0x20   // leaq         $32(%rsp), %rdx
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0xfdc3840f; WORD $0xffff // je           LBB32_63, $-573(%rip)
+
+LBB32_83:
+	WORD $0xb60f; BYTE $0x09     // movzbl       (%rcx), %ecx
+	WORD $0x0f88                 // movb         %cl, (%rdi)
+	LONG $0x24548d48; BYTE $0x20 // leaq         $32(%rsp), %rdx
+	LONG $0xfffdb4e9; BYTE $0xff // jmp          LBB32_63, $-588(%rip)
+
+LBB32_84:
+	LONG $0x08478b49                           // movq         $8(%r15), %rax
+	LONG $0xcbbc0f48                           // bsfq         %rbx, %rcx
+	LONG $0x244c2b48; BYTE $0x18               // subq         $24(%rsp), %rcx
+	WORD $0x0148; BYTE $0xc8                   // addq         %rcx, %rax
+	WORD $0xff48; BYTE $0xc0                   // incq         %rax
+	WORD $0x8949; BYTE $0x06                   // movq         %rax, (%r14)
+	LONG $0x084f8b49                           // movq         $8(%r15), %rcx
+	WORD $0x3948; BYTE $0xc8                   // cmpq         %rcx, %rax
+	LONG $0xc8420f48                           // cmovbq       %rax, %rcx
+	WORD $0x8949; BYTE $0x0e                   // movq         %rcx, (%r14)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xe0470f4c                           // cmovaq       %rax, %r12
+	LONG $0xfff920e9; BYTE $0xff               // jmp          LBB32_20, $-1760(%rip)
+
+LBB32_86:
+	LONG $0xc7bc0f66             // bsfw         %di, %ax
+	WORD $0xb70f; BYTE $0xc0     // movzwl       %ax, %eax
+	WORD $0x2948; BYTE $0xf0     // subq         %rsi, %rax
+	LONG $0xfff90ee9; BYTE $0xff // jmp          LBB32_19, $-1778(%rip)
+
+LBB32_31:
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x003d850f; WORD $0x0000 // jne          LBB32_90, $61(%rip)
+	WORD $0x0149; BYTE $0xd9       // addq         %rbx, %r9
+	WORD $0x0149; BYTE $0xf2       // addq         %rsi, %r10
+
+LBB32_33:
+	WORD $0x854d; BYTE $0xd2       // testq        %r10, %r10
+	LONG $0x0070850f; WORD $0x0000 // jne          LBB32_94, $112(%rip)
+	LONG $0xfff8f7e9; BYTE $0xff   // jmp          LBB32_21, $-1801(%rip)
+
+LBB32_87:
+	WORD $0x0148; BYTE $0xc2       // addq         %rax, %rdx
+	LONG $0x10f98348               // cmpq         $16, %rcx
+	LONG $0xf844830f; WORD $0xffff // jae          LBB32_7, $-1980(%rip)
+	LONG $0xfff894e9; BYTE $0xff   // jmp          LBB32_10, $-1900(%rip)
+
+LBB32_88:
+	WORD $0x2948; BYTE $0xc2     // subq         %rax, %rdx
+	WORD $0x0148; BYTE $0xf2     // addq         %rsi, %rdx
+	LONG $0xfffcc1e9; BYTE $0xff // jmp          LBB32_59, $-831(%rip)
+
+LBB32_89:
+	LONG $0x084f8b49             // movq         $8(%r15), %rcx
+	WORD $0x8949; BYTE $0x0e     // movq         %rcx, (%r14)
+	LONG $0xfff8cee9; BYTE $0xff // jmp          LBB32_21, $-1842(%rip)
+
+LBB32_90:
+	WORD $0x3949; BYTE $0xda       // cmpq         %rbx, %r10
+	LONG $0xf8c5840f; WORD $0xffff // je           LBB32_21, $-1851(%rip)
+	WORD $0x0149; BYTE $0xd9       // addq         %rbx, %r9
+	WORD $0xff49; BYTE $0xc1       // incq         %r9
+	WORD $0xf748; BYTE $0xd3       // notq         %rbx
+	WORD $0x0149; BYTE $0xda       // addq         %rbx, %r10
+	WORD $0x854d; BYTE $0xd2       // testq        %r10, %r10
+	LONG $0x0024850f; WORD $0x0000 // jne          LBB32_94, $36(%rip)
+	LONG $0xfff8abe9; BYTE $0xff   // jmp          LBB32_21, $-1877(%rip)
+
+LBB32_92:
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0x000002b8; BYTE $0x00               // movl         $2, %eax
+	WORD $0x0149; BYTE $0xc1                   // addq         %rax, %r9
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x0149; BYTE $0xca                   // addq         %rcx, %r10
+	LONG $0xf88c840f; WORD $0xffff             // je           LBB32_21, $-1908(%rip)
+
+LBB32_94:
+	LONG $0x01b60f41                           // movzbl       (%r9), %eax
+	WORD $0xf883; BYTE $0x5c                   // cmpl         $92, %eax
+	LONG $0xffd4840f; WORD $0xffff             // je           LBB32_92, $-44(%rip)
+	WORD $0xf883; BYTE $0x22                   // cmpl         $34, %eax
+	LONG $0x0024840f; WORD $0x0000             // je           LBB32_97, $36(%rip)
+	LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rcx
+	LONG $0x000001b8; BYTE $0x00               // movl         $1, %eax
+	WORD $0x0149; BYTE $0xc1                   // addq         %rax, %r9
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x0149; BYTE $0xca                   // addq         %rcx, %r10
+	LONG $0xffcb850f; WORD $0xffff             // jne          LBB32_94, $-53(%rip)
+	LONG $0xfff852e9; BYTE $0xff               // jmp          LBB32_21, $-1966(%rip)
+
+LBB32_97:
+	LONG $0x244c2b4c; BYTE $0x18 // subq         $24(%rsp), %r9
+	WORD $0xff49; BYTE $0xc1     // incq         %r9
+	WORD $0x894d; BYTE $0x0e     // movq         %r9, (%r14)
+	LONG $0xfff83fe9; BYTE $0xff // jmp          LBB32_20, $-1985(%rip)
+	WORD $0x9090; BYTE $0x90     // .p2align 2, 0x90
+
+	// .set L32_0_set_21, LBB32_21-LJTI32_0
+	// .set L32_0_set_23, LBB32_23-LJTI32_0
+	// .set L32_0_set_24, LBB32_24-LJTI32_0
+	// .set L32_0_set_2, LBB32_2-LJTI32_0
+	// .set L32_0_set_34, LBB32_34-LJTI32_0
+	// .set L32_0_set_58, LBB32_58-LJTI32_0
+	// .set L32_0_set_22, LBB32_22-LJTI32_0
+	// .set L32_0_set_60, LBB32_60-LJTI32_0
+LJTI32_0:
+	LONG $0xfffff83f         // .long L32_0_set_21
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff873         // .long L32_0_set_24
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff705         // .long L32_0_set_2
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff705         // .long L32_0_set_2
+	LONG $0xfffff705         // .long L32_0_set_2
+	LONG $0xfffff705         // .long L32_0_set_2
+	LONG $0xfffff705         // .long L32_0_set_2
+	LONG $0xfffff705         // .long L32_0_set_2
+	LONG $0xfffff705         // .long L32_0_set_2
+	LONG $0xfffff705         // .long L32_0_set_2
+	LONG $0xfffff705         // .long L32_0_set_2
+	LONG $0xfffff705         // .long L32_0_set_2
+	LONG $0xfffff705         // .long L32_0_set_2
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff95b         // .long L32_0_set_34
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffffc18         // .long L32_0_set_58
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff851         // .long L32_0_set_22
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff851         // .long L32_0_set_22
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffff864         // .long L32_0_set_23
+	LONG $0xfffffc2e         // .long L32_0_set_60
+	QUAD $0x9090909090909090 // .p2align 4, 0x90
+
+_get_by_path:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5741                   // pushq        %r15
+	WORD $0x5641                   // pushq        %r14
+	WORD $0x5541                   // pushq        %r13
+	WORD $0x5441                   // pushq        %r12
+	BYTE $0x53                     // pushq        %rbx
+	LONG $0x38ec8348               // subq         $56, %rsp
+	WORD $0x8949; BYTE $0xf6       // movq         %rsi, %r14
+	WORD $0x8949; BYTE $0xff       // movq         %rdi, %r15
+	LONG $0x08428b48               // movq         $8(%rdx), %rax
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x041d840f; WORD $0x0000 // je           LBB33_67, $1053(%rip)
+	WORD $0x8b4c; BYTE $0x22       // movq         (%rdx), %r12
+	LONG $0x04e0c148               // shlq         $4, %rax
+	WORD $0x014c; BYTE $0xe0       // addq         %r12, %rax
+	LONG $0xa0458948               // movq         %rax, $-96(%rbp)
+
+LBB33_2:
+	WORD $0x894c; BYTE $0xff                                             // movq         %r15, %rdi
+	WORD $0x894c; BYTE $0xf6                                             // movq         %r14, %rsi
+	LONG $0xffd173e8; BYTE $0xff                                         // callq        _advance_ns, $-11917(%rip)
+	LONG $0x240c8b49                                                     // movq         (%r12), %rcx
+	LONG $0x1749b60f                                                     // movzbl       $23(%rcx), %ecx
+	WORD $0xe180; BYTE $0x1f                                             // andb         $31, %cl
+	WORD $0xf980; BYTE $0x18                                             // cmpb         $24, %cl
+	LONG $0x038f850f; WORD $0x0000                                       // jne          LBB33_61, $911(%rip)
+	WORD $0x7b3c                                                         // cmpb         $123, %al
+	LONG $0xd07d894c                                                     // movq         %r15, $-48(%rbp)
+	LONG $0xb865894c                                                     // movq         %r12, $-72(%rbp)
+	LONG $0x03f0850f; WORD $0x0000                                       // jne          LBB33_68, $1008(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB33_4:
+	WORD $0x894c; BYTE $0xff       // movq         %r15, %rdi
+	WORD $0x894c; BYTE $0xf6       // movq         %r14, %rsi
+	LONG $0xffd135e8; BYTE $0xff   // callq        _advance_ns, $-11979(%rip)
+	WORD $0x223c                   // cmpb         $34, %al
+	LONG $0x03ce850f; WORD $0x0000 // jne          LBB33_68, $974(%rip)
+	LONG $0x24448b49; BYTE $0x08   // movq         $8(%r12), %rax
+	WORD $0x8b4c; BYTE $0x28       // movq         (%rax), %r13
+	WORD $0x894c; BYTE $0xff       // movq         %r15, %rdi
+	LONG $0x08788b4c               // movq         $8(%rax), %r15
+	QUAD $0xffffffffb045c748       // movq         $-1, $-80(%rbp)
+	WORD $0x8b4d; BYTE $0x26       // movq         (%r14), %r12
+	WORD $0x894c; BYTE $0xe6       // movq         %r12, %rsi
+	LONG $0xb0558d48               // leaq         $-80(%rbp), %rdx
+	LONG $0x002647e8; BYTE $0x00   // callq        _advance_string_default, $9799(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x03b8880f; WORD $0x0000 // js           LBB33_70, $952(%rip)
+	WORD $0x8949; BYTE $0x06       // movq         %rax, (%r14)
+	LONG $0xb04d8b48               // movq         $-80(%rbp), %rcx
+	LONG $0xfff98348               // cmpq         $-1, %rcx
+	LONG $0x0009840f; WORD $0x0000 // je           LBB33_8, $9(%rip)
+	WORD $0x3948; BYTE $0xc1       // cmpq         %rax, %rcx
+	LONG $0x02018e0f; WORD $0x0000 // jle          LBB33_37, $513(%rip)
+
+LBB33_8:
+	WORD $0x894c; BYTE $0xe1               // movq         %r12, %rcx
+	WORD $0xf748; BYTE $0xd1               // notq         %rcx
+	WORD $0x0148; BYTE $0xc8               // addq         %rcx, %rax
+	WORD $0x394c; BYTE $0xf8               // cmpq         %r15, %rax
+	LONG $0x0062850f; WORD $0x0000         // jne          LBB33_13, $98(%rip)
+	LONG $0xd0458b48                       // movq         $-48(%rbp), %rax
+	WORD $0x034c; BYTE $0x20               // addq         (%rax), %r12
+	WORD $0xc931                           // xorl         %ecx, %ecx
+	WORD $0x894c; BYTE $0xe3               // movq         %r12, %rbx
+	WORD $0x894c; BYTE $0xef               // movq         %r13, %rdi
+	WORD $0x894c; BYTE $0xf8               // movq         %r15, %rax
+	WORD $0x894c; BYTE $0xea               // movq         %r13, %rdx
+	WORD $0x894c; BYTE $0xe6               // movq         %r12, %rsi
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB33_10:
+	LONG $0x20f88348               // cmpq         $32, %rax
+	LONG $0x0046820f; WORD $0x0000 // jb           LBB33_14, $70(%rip)
+	LONG $0x066ffec5               // vmovdqu      (%rsi), %ymm0
+	LONG $0x02f8fdc5               // vpsubb       (%rdx), %ymm0, %ymm0
+	LONG $0x20c68348               // addq         $32, %rsi
+	LONG $0x20c28348               // addq         $32, %rdx
+	LONG $0xe0c08348               // addq         $-32, %rax
+	LONG $0x20c78348               // addq         $32, %rdi
+	LONG $0x20c38348               // addq         $32, %rbx
+	LONG $0x20c18348               // addq         $32, %rcx
+	LONG $0x177de2c4; BYTE $0xc0   // vptest       %ymm0, %ymm0
+	LONG $0xffcb840f; WORD $0xffff // je           LBB33_10, $-53(%rip)
+	LONG $0x000090e9; BYTE $0x00   // jmp          LBB33_12, $144(%rip)
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB33_13:
+	WORD $0xdb31                         // xorl         %ebx, %ebx
+	LONG $0x00013ce9; BYTE $0x00         // jmp          LBB33_33, $316(%rip)
+	QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB33_14:
+	LONG $0x0fffe381; WORD $0x0000                         // andl         $4095, %ebx
+	LONG $0x0fe0fb81; WORD $0x0000                         // cmpl         $4064, %ebx
+	LONG $0x003e870f; WORD $0x0000                         // ja           LBB33_18, $62(%rip)
+	LONG $0x0fffe781; WORD $0x0000                         // andl         $4095, %edi
+	LONG $0x0fe1ff81; WORD $0x0000                         // cmpl         $4065, %edi
+	LONG $0x002c830f; WORD $0x0000                         // jae          LBB33_18, $44(%rip)
+	LONG $0x066ffec5                                       // vmovdqu      (%rsi), %ymm0
+	LONG $0x0274fdc5                                       // vpcmpeqb     (%rdx), %ymm0, %ymm0
+	LONG $0xc8d7fdc5                                       // vpmovmskb    %ymm0, %ecx
+	WORD $0xf983; BYTE $0xff                               // cmpl         $-1, %ecx
+	LONG $0x00ad840f; WORD $0x0000                         // je           LBB33_31, $173(%rip)
+	WORD $0xd1f7                                           // notl         %ecx
+	WORD $0xbc0f; BYTE $0xc9                               // bsfl         %ecx, %ecx
+	LONG $0x000098e9; BYTE $0x00                           // jmp          LBB33_25, $152(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB33_18:
+	LONG $0x10f88348                           // cmpq         $16, %rax
+	LONG $0x0027820f; WORD $0x0000             // jb           LBB33_21, $39(%rip)
+	LONG $0x6f7ac1c4; WORD $0x0c04             // vmovdqu      (%r12,%rcx), %xmm0
+	LONG $0xf879c1c4; WORD $0x0d44; BYTE $0x00 // vpsubb       (%r13,%rcx), %xmm0, %xmm0
+	LONG $0xf0c08348                           // addq         $-16, %rax
+	LONG $0x10c18348                           // addq         $16, %rcx
+	LONG $0x1779e2c4; BYTE $0xc0               // vptest       %xmm0, %xmm0
+	LONG $0xffd6840f; WORD $0xffff             // je           LBB33_18, $-42(%rip)
+
+LBB33_12:
+	WORD $0xc031                 // xorl         %eax, %eax
+	LONG $0x0000afe9; BYTE $0x00 // jmp          LBB33_32, $175(%rip)
+
+LBB33_21:
+	WORD $0x8944; BYTE $0xe2                   // movl         %r12d, %edx
+	WORD $0xca01                               // addl         %ecx, %edx
+	LONG $0x0fffe281; WORD $0x0000             // andl         $4095, %edx
+	LONG $0x0ff0fa81; WORD $0x0000             // cmpl         $4080, %edx
+	LONG $0x0055870f; WORD $0x0000             // ja           LBB33_27, $85(%rip)
+	LONG $0x29148d42                           // leal         (%rcx,%r13), %edx
+	LONG $0x0fffe281; WORD $0x0000             // andl         $4095, %edx
+	LONG $0x0ff1fa81; WORD $0x0000             // cmpl         $4081, %edx
+	LONG $0x003f830f; WORD $0x0000             // jae          LBB33_27, $63(%rip)
+	LONG $0x6f7ac1c4; WORD $0x0c04             // vmovdqu      (%r12,%rcx), %xmm0
+	LONG $0x6f7ac1c4; WORD $0x0d4c; BYTE $0x00 // vmovdqu      (%r13,%rcx), %xmm1
+	LONG $0xd1f8f9c5                           // vpsubb       %xmm1, %xmm0, %xmm2
+	LONG $0x1779e2c4; BYTE $0xd2               // vptest       %xmm2, %xmm2
+	LONG $0x001c840f; WORD $0x0000             // je           LBB33_31, $28(%rip)
+	LONG $0xc174f9c5                           // vpcmpeqb     %xmm1, %xmm0, %xmm0
+	LONG $0xc8d7f9c5                           // vpmovmskb    %xmm0, %ecx
+	WORD $0xd1f7                               // notl         %ecx
+	LONG $0xc9bc0f66                           // bsfw         %cx, %cx
+	WORD $0xb70f; BYTE $0xc9                   // movzwl       %cx, %ecx
+
+LBB33_25:
+	WORD $0x3948; BYTE $0xc8     // cmpq         %rcx, %rax
+	WORD $0x960f; BYTE $0xc0     // setbe        %al
+	LONG $0x00004ae9; BYTE $0x00 // jmp          LBB33_32, $74(%rip)
+
+LBB33_31:
+	WORD $0x01b0                 // movb         $1, %al
+	LONG $0x000043e9; BYTE $0x00 // jmp          LBB33_32, $67(%rip)
+
+LBB33_27:
+	WORD $0x01b0                   // movb         $1, %al
+	WORD $0x3949; BYTE $0xcf       // cmpq         %rcx, %r15
+	LONG $0x0038840f; WORD $0x0000 // je           LBB33_32, $56(%rip)
+	WORD $0xff49; BYTE $0xcf       // decq         %r15
+	LONG $0x90909090; BYTE $0x90   // .p2align 4, 0x90
+
+LBB33_29:
+	LONG $0x04b60f41; BYTE $0x0c                           // movzbl       (%r12,%rcx), %eax
+	LONG $0x0d443a41; BYTE $0x00                           // cmpb         (%r13,%rcx), %al
+	WORD $0x940f; BYTE $0xc0                               // sete         %al
+	LONG $0x001d850f; WORD $0x0000                         // jne          LBB33_32, $29(%rip)
+	LONG $0x01518d48                                       // leaq         $1(%rcx), %rdx
+	WORD $0x3949; BYTE $0xcf                               // cmpq         %rcx, %r15
+	WORD $0x8948; BYTE $0xd1                               // movq         %rdx, %rcx
+	LONG $0xffdd850f; WORD $0xffff                         // jne          LBB33_29, $-35(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB33_32:
+	WORD $0xb60f; BYTE $0xd8 // movzbl       %al, %ebx
+
+LBB33_33:
+	LONG $0xd07d8b4c // movq         $-48(%rbp), %r15
+
+LBB33_34:
+	LONG $0xb8658b4c               // movq         $-72(%rbp), %r12
+	WORD $0x894c; BYTE $0xff       // movq         %r15, %rdi
+	WORD $0x894c; BYTE $0xf6       // movq         %r14, %rsi
+	WORD $0xf8c5; BYTE $0x77       // vzeroupper
+	LONG $0xffcf17e8; BYTE $0xff   // callq        _advance_ns, $-12521(%rip)
+	WORD $0x3a3c                   // cmpb         $58, %al
+	LONG $0x01b0850f; WORD $0x0000 // jne          LBB33_68, $432(%rip)
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0186850f; WORD $0x0000 // jne          LBB33_66, $390(%rip)
+	WORD $0x894c; BYTE $0xff       // movq         %r15, %rdi
+	WORD $0x894c; BYTE $0xf6       // movq         %r14, %rsi
+	LONG $0xfff20be8; BYTE $0xff   // callq        _skip_one_fast, $-3573(%rip)
+	WORD $0x894c; BYTE $0xff       // movq         %r15, %rdi
+	WORD $0x894c; BYTE $0xf6       // movq         %r14, %rsi
+	LONG $0xffcef0e8; BYTE $0xff   // callq        _advance_ns, $-12560(%rip)
+	WORD $0x2c3c                   // cmpb         $44, %al
+	LONG $0xfda8840f; WORD $0xffff // je           LBB33_4, $-600(%rip)
+	LONG $0x000184e9; BYTE $0x00   // jmp          LBB33_68, $388(%rip)
+
+LBB33_37:
+	QUAD $0x00000000c845c748       // movq         $0, $-56(%rbp)
+	LONG $0xd04d8b48               // movq         $-48(%rbp), %rcx
+	WORD $0x8b48; BYTE $0x09       // movq         (%rcx), %rcx
+	WORD $0x0149; BYTE $0xcc       // addq         %rcx, %r12
+	LONG $0xc065894c               // movq         %r12, $-64(%rbp)
+	LONG $0x01348d48               // leaq         (%rcx,%rax), %rsi
+	WORD $0xff48; BYTE $0xce       // decq         %rsi
+	LONG $0x2f1c8d4b               // leaq         (%r15,%r13), %rbx
+	WORD $0x3949; BYTE $0xf4       // cmpq         %rsi, %r12
+	LONG $0x00c1830f; WORD $0x0000 // jae          LBB33_57, $193(%rip)
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x00b88e0f; WORD $0x0000 // jle          LBB33_57, $184(%rip)
+	LONG $0xd07d8b4c               // movq         $-48(%rbp), %r15
+	LONG $0xa8758948               // movq         %rsi, $-88(%rbp)
+
+LBB33_40:
+	LONG $0x04b60f41; BYTE $0x24   // movzbl       (%r12), %eax
+	WORD $0x5c3c                   // cmpb         $92, %al
+	LONG $0x005e850f; WORD $0x0000 // jne          LBB33_48, $94(%rip)
+	LONG $0xc07d8d48               // leaq         $-64(%rbp), %rdi
+	LONG $0xc8558d48               // leaq         $-56(%rbp), %rdx
+	LONG $0x0026eee8; BYTE $0x00   // callq        _unescape, $9966(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0156880f; WORD $0x0000 // js           LBB33_71, $342(%rip)
+	LONG $0x280c8d48               // leaq         (%rax,%rbp), %rcx
+	LONG $0xc8c18348               // addq         $-56, %rcx
+	WORD $0x3949; BYTE $0xdd       // cmpq         %rbx, %r13
+	LONG $0x0050830f; WORD $0x0000 // jae          LBB33_51, $80(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0047840f; WORD $0x0000 // je           LBB33_51, $71(%rip)
+	LONG $0xc8458d48               // leaq         $-56(%rbp), %rax
+
+LBB33_45:
+	LONG $0x55b60f41; BYTE $0x00   // movzbl       (%r13), %edx
+	WORD $0x103a                   // cmpb         (%rax), %dl
+	LONG $0x003a850f; WORD $0x0000 // jne          LBB33_52, $58(%rip)
+	WORD $0xff49; BYTE $0xc5       // incq         %r13
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3949; BYTE $0xdd       // cmpq         %rbx, %r13
+	LONG $0x002b830f; WORD $0x0000 // jae          LBB33_52, $43(%rip)
+	WORD $0x3948; BYTE $0xc8       // cmpq         %rcx, %rax
+	LONG $0xffdb820f; WORD $0xffff // jb           LBB33_45, $-37(%rip)
+	LONG $0x00001de9; BYTE $0x00   // jmp          LBB33_52, $29(%rip)
+
+LBB33_48:
+	LONG $0x00453a41               // cmpb         (%r13), %al
+	LONG $0x0052850f; WORD $0x0000 // jne          LBB33_60, $82(%rip)
+	WORD $0xff49; BYTE $0xc4       // incq         %r12
+	LONG $0xc065894c               // movq         %r12, $-64(%rbp)
+	WORD $0xff49; BYTE $0xc5       // incq         %r13
+	LONG $0x000015e9; BYTE $0x00   // jmp          LBB33_54, $21(%rip)
+
+LBB33_51:
+	LONG $0xc8458d48 // leaq         $-56(%rbp), %rax
+
+LBB33_52:
+	WORD $0x3948; BYTE $0xc8       // cmpq         %rcx, %rax
+	LONG $0x0036850f; WORD $0x0000 // jne          LBB33_60, $54(%rip)
+	LONG $0xc0658b4c               // movq         $-64(%rbp), %r12
+	LONG $0xa8758b48               // movq         $-88(%rbp), %rsi
+
+LBB33_54:
+	WORD $0x3949; BYTE $0xf4       // cmpq         %rsi, %r12
+	LONG $0x0012830f; WORD $0x0000 // jae          LBB33_58, $18(%rip)
+	WORD $0x3949; BYTE $0xdd       // cmpq         %rbx, %r13
+	LONG $0xff55820f; WORD $0xffff // jb           LBB33_40, $-171(%rip)
+	LONG $0x000004e9; BYTE $0x00   // jmp          LBB33_58, $4(%rip)
+
+LBB33_57:
+	LONG $0xd07d8b4c // movq         $-48(%rbp), %r15
+
+LBB33_58:
+	WORD $0x3149; BYTE $0xf4     // xorq         %rsi, %r12
+	WORD $0x3149; BYTE $0xdd     // xorq         %rbx, %r13
+	WORD $0xdb31                 // xorl         %ebx, %ebx
+	WORD $0x094d; BYTE $0xe5     // orq          %r12, %r13
+	WORD $0x940f; BYTE $0xc3     // sete         %bl
+	LONG $0xfffeb8e9; BYTE $0xff // jmp          LBB33_34, $-328(%rip)
+
+LBB33_60:
+	WORD $0xdb31                           // xorl         %ebx, %ebx
+	LONG $0xfffeb1e9; BYTE $0xff           // jmp          LBB33_34, $-335(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB33_61:
+	WORD $0xf980; BYTE $0x02       // cmpb         $2, %cl
+	LONG $0x0068850f; WORD $0x0000 // jne          LBB33_68, $104(%rip)
+	WORD $0x5b3c                   // cmpb         $91, %al
+	LONG $0x0060850f; WORD $0x0000 // jne          LBB33_68, $96(%rip)
+	LONG $0x24448b49; BYTE $0x08   // movq         $8(%r12), %rax
+	WORD $0x8b48; BYTE $0x18       // movq         (%rax), %rbx
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	LONG $0x90909090               // .p2align 4, 0x90
+
+LBB33_64:
+	WORD $0xff48; BYTE $0xcb       // decq         %rbx
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x00248e0f; WORD $0x0000 // jle          LBB33_66, $36(%rip)
+	WORD $0x894c; BYTE $0xff       // movq         %r15, %rdi
+	WORD $0x894c; BYTE $0xf6       // movq         %r14, %rsi
+	LONG $0xfff0a9e8; BYTE $0xff   // callq        _skip_one_fast, $-3927(%rip)
+	WORD $0x894c; BYTE $0xff       // movq         %r15, %rdi
+	WORD $0x894c; BYTE $0xf6       // movq         %r14, %rsi
+	LONG $0xffcd8ee8; BYTE $0xff   // callq        _advance_ns, $-12914(%rip)
+	WORD $0x2c3c                   // cmpb         $44, %al
+	LONG $0xffd6840f; WORD $0xffff // je           LBB33_64, $-42(%rip)
+	LONG $0x000022e9; BYTE $0x00   // jmp          LBB33_68, $34(%rip)
+	BYTE $0x90                     // .p2align 4, 0x90
+
+LBB33_66:
+	LONG $0x10c48349               // addq         $16, %r12
+	LONG $0xa0458b48               // movq         $-96(%rbp), %rax
+	WORD $0x3949; BYTE $0xc4       // cmpq         %rax, %r12
+	LONG $0xfbf1850f; WORD $0xffff // jne          LBB33_2, $-1039(%rip)
+
+LBB33_67:
+	WORD $0x894c; BYTE $0xff     // movq         %r15, %rdi
+	WORD $0x894c; BYTE $0xf6     // movq         %r14, %rsi
+	LONG $0xfff074e8; BYTE $0xff // callq        _skip_one_fast, $-3980(%rip)
+	LONG $0x00000ae9; BYTE $0x00 // jmp          LBB33_69, $10(%rip)
+
+LBB33_68:
+	WORD $0xff49; BYTE $0x0e                   // decq         (%r14)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+
+LBB33_69:
+	LONG $0x38c48348 // addq         $56, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5d41     // popq         %r13
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB33_70:
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	LONG $0x08408b48                           // movq         $8(%rax), %rax
+	WORD $0x8949; BYTE $0x06                   // movq         %rax, (%r14)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xffffdae9; BYTE $0xff               // jmp          LBB33_69, $-38(%rip)
+
+LBB33_71:
+	LONG $0xc04d8b48             // movq         $-64(%rbp), %rcx
+	WORD $0x2b49; BYTE $0x0f     // subq         (%r15), %rcx
+	WORD $0x8949; BYTE $0x0e     // movq         %rcx, (%r14)
+	LONG $0xffffcbe9; BYTE $0xff // jmp          LBB33_69, $-53(%rip)
+
+	// .p2align 4, 0x90
+_validate_utf8:
+	BYTE $0x55                             // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5               // movq         %rsp, %rbp
+	WORD $0x5741                           // pushq        %r15
+	WORD $0x5641                           // pushq        %r14
+	WORD $0x5441                           // pushq        %r12
+	BYTE $0x53                             // pushq        %rbx
+	BYTE $0x50                             // pushq        %rax
+	WORD $0x8b4c; BYTE $0x17               // movq         (%rdi), %r10
+	LONG $0x085f8b4c                       // movq         $8(%rdi), %r11
+	WORD $0x8b48; BYTE $0x0e               // movq         (%rsi), %rcx
+	WORD $0x014c; BYTE $0xd1               // addq         %r10, %rcx
+	LONG $0x1a048d4f                       // leaq         (%r10,%r11), %r8
+	LONG $0xfdc08349                       // addq         $-3, %r8
+	LONG $0x00000de9; BYTE $0x00           // jmp          LBB34_1, $13(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB34_19:
+	WORD $0x0148; BYTE $0xd9 // addq         %rbx, %rcx
+
+LBB34_1:
+	WORD $0x394c; BYTE $0xc1                                             // cmpq         %r8, %rcx
+	LONG $0x00e1830f; WORD $0x0000                                       // jae          LBB34_2, $225(%rip)
+	LONG $0x000001bb; BYTE $0x00                                         // movl         $1, %ebx
+	WORD $0x3980; BYTE $0x00                                             // cmpb         $0, (%rcx)
+	LONG $0xffe6890f; WORD $0xffff                                       // jns          LBB34_19, $-26(%rip)
+	WORD $0x018b                                                         // movl         (%rcx), %eax
+	WORD $0xc789                                                         // movl         %eax, %edi
+	LONG $0xc0f0e781; WORD $0x00c0                                       // andl         $12632304, %edi
+	LONG $0x80e0ff81; WORD $0x0080                                       // cmpl         $8421600, %edi
+	LONG $0x0030850f; WORD $0x0000                                       // jne          LBB34_10, $48(%rip)
+	WORD $0xc789                                                         // movl         %eax, %edi
+	LONG $0x200fe781; WORD $0x0000                                       // andl         $8207, %edi
+	LONG $0x200dff81; WORD $0x0000                                       // cmpl         $8205, %edi
+	LONG $0x001c840f; WORD $0x0000                                       // je           LBB34_10, $28(%rip)
+	LONG $0x000003bb; BYTE $0x00                                         // movl         $3, %ebx
+	WORD $0xff85                                                         // testl        %edi, %edi
+	LONG $0xffaf850f; WORD $0xffff                                       // jne          LBB34_19, $-81(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB34_10:
+	WORD $0xc789                   // movl         %eax, %edi
+	LONG $0xc0e0e781; WORD $0x0000 // andl         $49376, %edi
+	LONG $0x80c0ff81; WORD $0x0000 // cmpl         $32960, %edi
+	LONG $0x0010850f; WORD $0x0000 // jne          LBB34_12, $16(%rip)
+	WORD $0xc789                   // movl         %eax, %edi
+	LONG $0x000002bb; BYTE $0x00   // movl         $2, %ebx
+	WORD $0xe783; BYTE $0x1e       // andl         $30, %edi
+	LONG $0xff7c850f; WORD $0xffff // jne          LBB34_19, $-132(%rip)
+
+LBB34_12:
+	WORD $0xc789                   // movl         %eax, %edi
+	LONG $0xc0f8e781; WORD $0xc0c0 // andl         $-1061109512, %edi
+	LONG $0x80f0ff81; WORD $0x8080 // cmpl         $-2139062032, %edi
+	LONG $0x0026850f; WORD $0x0000 // jne          LBB34_16, $38(%rip)
+	WORD $0xc789                   // movl         %eax, %edi
+	LONG $0x3007e781; WORD $0x0000 // andl         $12295, %edi
+	LONG $0x0018840f; WORD $0x0000 // je           LBB34_16, $24(%rip)
+	LONG $0x000004bb; BYTE $0x00   // movl         $4, %ebx
+	WORD $0x04a8                   // testb        $4, %al
+	LONG $0xff4d840f; WORD $0xffff // je           LBB34_19, $-179(%rip)
+	LONG $0x00300325; BYTE $0x00   // andl         $12291, %eax
+	LONG $0xff42840f; WORD $0xffff // je           LBB34_19, $-190(%rip)
+
+LBB34_16:
+	WORD $0x8948; BYTE $0xcf                   // movq         %rcx, %rdi
+	WORD $0x294c; BYTE $0xd7                   // subq         %r10, %rdi
+	WORD $0x8b48; BYTE $0x1a                   // movq         (%rdx), %rbx
+	LONG $0x00fb8148; WORD $0x0010; BYTE $0x00 // cmpq         $4096, %rbx
+	LONG $0x0187830f; WORD $0x0000             // jae          LBB34_17, $391(%rip)
+	WORD $0x6348; BYTE $0xc7                   // movslq       %edi, %rax
+	LONG $0x017b8d48                           // leaq         $1(%rbx), %rdi
+	WORD $0x8948; BYTE $0x3a                   // movq         %rdi, (%rdx)
+	LONG $0xda448948; BYTE $0x08               // movq         %rax, $8(%rdx,%rbx,8)
+	LONG $0x000001bb; BYTE $0x00               // movl         $1, %ebx
+	LONG $0xffff13e9; BYTE $0xff               // jmp          LBB34_19, $-237(%rip)
+
+LBB34_2:
+	WORD $0x014d; BYTE $0xd3               // addq         %r10, %r11
+	WORD $0x394c; BYTE $0xd9               // cmpq         %r11, %rcx
+	LONG $0x013e830f; WORD $0x0000         // jae          LBB34_36, $318(%rip)
+	LONG $0xdc458d4c                       // leaq         $-36(%rbp), %r8
+	LONG $0xda4d8d4c                       // leaq         $-38(%rbp), %r9
+	LONG $0x000016e9; BYTE $0x00           // jmp          LBB34_4, $22(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB34_5:
+	WORD $0xff48; BYTE $0xc1       // incq         %rcx
+	WORD $0x394c; BYTE $0xd9       // cmpq         %r11, %rcx
+	LONG $0x011b830f; WORD $0x0000 // jae          LBB34_36, $283(%rip)
+
+LBB34_4:
+	WORD $0x3980; BYTE $0x00       // cmpb         $0, (%rcx)
+	LONG $0xffeb890f; WORD $0xffff // jns          LBB34_5, $-21(%rip)
+	LONG $0x00dc45c6               // movb         $0, $-36(%rbp)
+	LONG $0x00da45c6               // movb         $0, $-38(%rbp)
+	WORD $0x894c; BYTE $0xdb       // movq         %r11, %rbx
+	WORD $0x2948; BYTE $0xcb       // subq         %rcx, %rbx
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0x0035820f; WORD $0x0000 // jb           LBB34_21, $53(%rip)
+	LONG $0x21b60f44               // movzbl       (%rcx), %r12d
+	LONG $0x71b60f44; BYTE $0x01   // movzbl       $1(%rcx), %r14d
+	LONG $0xdc658844               // movb         %r12b, $-36(%rbp)
+	LONG $0x02798d4c               // leaq         $2(%rcx), %r15
+	LONG $0xfec38348               // addq         $-2, %rbx
+	WORD $0x894c; BYTE $0xcf       // movq         %r9, %rdi
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0029840f; WORD $0x0000 // je           LBB34_24, $41(%rip)
+
+LBB34_25:
+	LONG $0x07b60f41             // movzbl       (%r15), %eax
+	WORD $0x0788                 // movb         %al, (%rdi)
+	LONG $0x65b60f44; BYTE $0xdc // movzbl       $-36(%rbp), %r12d
+	LONG $0xda7db60f             // movzbl       $-38(%rbp), %edi
+	LONG $0x000017e9; BYTE $0x00 // jmp          LBB34_26, $23(%rip)
+
+LBB34_21:
+	WORD $0x3145; BYTE $0xe4       // xorl         %r12d, %r12d
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	WORD $0x894c; BYTE $0xc7       // movq         %r8, %rdi
+	WORD $0x8949; BYTE $0xcf       // movq         %rcx, %r15
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0xffd7850f; WORD $0xffff // jne          LBB34_25, $-41(%rip)
+
+LBB34_24:
+	WORD $0xff31 // xorl         %edi, %edi
+
+LBB34_26:
+	LONG $0xc7b60f40               // movzbl       %dil, %eax
+	WORD $0xe0c1; BYTE $0x10       // shll         $16, %eax
+	LONG $0xdeb60f41               // movzbl       %r14b, %ebx
+	WORD $0xe3c1; BYTE $0x08       // shll         $8, %ebx
+	WORD $0xc309                   // orl          %eax, %ebx
+	LONG $0xfcb60f41               // movzbl       %r12b, %edi
+	WORD $0xdf09                   // orl          %ebx, %edi
+	WORD $0xf889                   // movl         %edi, %eax
+	LONG $0xc0c0f025; BYTE $0x00   // andl         $12632304, %eax
+	LONG $0x8080e03d; BYTE $0x00   // cmpl         $8421600, %eax
+	LONG $0x001f850f; WORD $0x0000 // jne          LBB34_29, $31(%rip)
+	WORD $0xf889                   // movl         %edi, %eax
+	LONG $0x00200f25; BYTE $0x00   // andl         $8207, %eax
+	LONG $0x00200d3d; BYTE $0x00   // cmpl         $8205, %eax
+	LONG $0x000d840f; WORD $0x0000 // je           LBB34_29, $13(%rip)
+	LONG $0x000003bb; BYTE $0x00   // movl         $3, %ebx
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x0021850f; WORD $0x0000 // jne          LBB34_34, $33(%rip)
+
+	// .p2align 4, 0x90
+LBB34_29:
+	LONG $0x1ec4f641               // testb        $30, %r12b
+	LONG $0x0028840f; WORD $0x0000 // je           LBB34_31, $40(%rip)
+	LONG $0xc0e0e781; WORD $0x0000 // andl         $49376, %edi
+	LONG $0x000002bb; BYTE $0x00   // movl         $2, %ebx
+	LONG $0x80c0ff81; WORD $0x0000 // cmpl         $32960, %edi
+	LONG $0x0011850f; WORD $0x0000 // jne          LBB34_31, $17(%rip)
+
+LBB34_34:
+	WORD $0x0148; BYTE $0xd9       // addq         %rbx, %rcx
+	WORD $0x394c; BYTE $0xd9       // cmpq         %r11, %rcx
+	LONG $0xff1f820f; WORD $0xffff // jb           LBB34_4, $-225(%rip)
+	LONG $0x000035e9; BYTE $0x00   // jmp          LBB34_36, $53(%rip)
+
+LBB34_31:
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	WORD $0x294c; BYTE $0xd0                   // subq         %r10, %rax
+	WORD $0x8b48; BYTE $0x3a                   // movq         (%rdx), %rdi
+	LONG $0x00ff8148; WORD $0x0010; BYTE $0x00 // cmpq         $4096, %rdi
+	LONG $0x0034830f; WORD $0x0000             // jae          LBB34_32, $52(%rip)
+	WORD $0x9848                               // cltq
+	LONG $0x015f8d48                           // leaq         $1(%rdi), %rbx
+	WORD $0x8948; BYTE $0x1a                   // movq         %rbx, (%rdx)
+	LONG $0xfa448948; BYTE $0x08               // movq         %rax, $8(%rdx,%rdi,8)
+	LONG $0x000001bb; BYTE $0x00               // movl         $1, %ebx
+	WORD $0x0148; BYTE $0xd9                   // addq         %rbx, %rcx
+	WORD $0x394c; BYTE $0xd9                   // cmpq         %r11, %rcx
+	LONG $0xfee5820f; WORD $0xffff             // jb           LBB34_4, $-283(%rip)
+
+LBB34_36:
+	WORD $0x294c; BYTE $0xd1 // subq         %r10, %rcx
+	WORD $0x8948; BYTE $0x0e // movq         %rcx, (%rsi)
+	WORD $0xc031             // xorl         %eax, %eax
+
+LBB34_37:
+	LONG $0x08c48348 // addq         $8, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB34_32:
+	WORD $0x8948; BYTE $0x06                   // movq         %rax, (%rsi)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xffffe4e9; BYTE $0xff               // jmp          LBB34_37, $-28(%rip)
+
+LBB34_17:
+	WORD $0x8948; BYTE $0x3e                   // movq         %rdi, (%rsi)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xffffd5e9; BYTE $0xff               // jmp          LBB34_37, $-43(%rip)
+	LONG $0x00000000; WORD $0x0000             // .p2align 5, 0x00
+
+LCPI35_0:
+	QUAD $0x0f0f0f0f0f0f0f0f; QUAD $0x0f0f0f0f0f0f0f0f // .space 16, '\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f'
+	QUAD $0x0f0f0f0f0f0f0f0f; QUAD $0x0f0f0f0f0f0f0f0f // .space 16, '\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f'
+
+LCPI35_1:
+	BYTE $0x02 // .byte 2
+	BYTE $0x02 // .byte 2
+	BYTE $0x02 // .byte 2
+	BYTE $0x02 // .byte 2
+	BYTE $0x02 // .byte 2
+	BYTE $0x02 // .byte 2
+	BYTE $0x02 // .byte 2
+	BYTE $0x02 // .byte 2
+	BYTE $0x80 // .byte 128
+	BYTE $0x80 // .byte 128
+	BYTE $0x80 // .byte 128
+	BYTE $0x80 // .byte 128
+	BYTE $0x21 // .byte 33
+	BYTE $0x01 // .byte 1
+	BYTE $0x15 // .byte 21
+	BYTE $0x49 // .byte 73
+	BYTE $0x02 // .byte 2
+	BYTE $0x02 // .byte 2
+	BYTE $0x02 // .byte 2
+	BYTE $0x02 // .byte 2
+	BYTE $0x02 // .byte 2
+	BYTE $0x02 // .byte 2
+	BYTE $0x02 // .byte 2
+	BYTE $0x02 // .byte 2
+	BYTE $0x80 // .byte 128
+	BYTE $0x80 // .byte 128
+	BYTE $0x80 // .byte 128
+	BYTE $0x80 // .byte 128
+	BYTE $0x21 // .byte 33
+	BYTE $0x01 // .byte 1
+	BYTE $0x15 // .byte 21
+	BYTE $0x49 // .byte 73
+
+LCPI35_2:
+	BYTE $0xe7 // .byte 231
+	BYTE $0xa3 // .byte 163
+	BYTE $0x83 // .byte 131
+	BYTE $0x83 // .byte 131
+	BYTE $0x8b // .byte 139
+	BYTE $0xcb // .byte 203
+	BYTE $0xcb // .byte 203
+	BYTE $0xcb // .byte 203
+	BYTE $0xcb // .byte 203
+	BYTE $0xcb // .byte 203
+	BYTE $0xcb // .byte 203
+	BYTE $0xcb // .byte 203
+	BYTE $0xcb // .byte 203
+	BYTE $0xdb // .byte 219
+	BYTE $0xcb // .byte 203
+	BYTE $0xcb // .byte 203
+	BYTE $0xe7 // .byte 231
+	BYTE $0xa3 // .byte 163
+	BYTE $0x83 // .byte 131
+	BYTE $0x83 // .byte 131
+	BYTE $0x8b // .byte 139
+	BYTE $0xcb // .byte 203
+	BYTE $0xcb // .byte 203
+	BYTE $0xcb // .byte 203
+	BYTE $0xcb // .byte 203
+	BYTE $0xcb // .byte 203
+	BYTE $0xcb // .byte 203
+	BYTE $0xcb // .byte 203
+	BYTE $0xcb // .byte 203
+	BYTE $0xdb // .byte 219
+	BYTE $0xcb // .byte 203
+	BYTE $0xcb // .byte 203
+
+LCPI35_3:
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0xe6 // .byte 230
+	BYTE $0xae // .byte 174
+	BYTE $0xba // .byte 186
+	BYTE $0xba // .byte 186
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0xe6 // .byte 230
+	BYTE $0xae // .byte 174
+	BYTE $0xba // .byte 186
+	BYTE $0xba // .byte 186
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+	BYTE $0x01 // .byte 1
+
+LCPI35_4:
+	QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
+	QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
+
+LCPI35_5:
+	QUAD $0xefefefefefefefef; QUAD $0xefefefefefefefef // .space 16, '\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef'
+	QUAD $0xefefefefefefefef; QUAD $0xefefefefefefefef // .space 16, '\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef\xef'
+
+LCPI35_7:
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xff // .byte 255
+	BYTE $0xef // .byte 239
+	BYTE $0xdf // .byte 223
+	BYTE $0xbf // .byte 191
+
+LCPI35_8:
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+	// .p2align 3, 0x00
+LCPI35_6:
+	QUAD $0x8080808080808080 // .quad -9187201950435737472
+	QUAD $0x9090909090909090 // .p2align 4, 0x90
+
+_validate_utf8_fast:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0xe0e48348                           // andq         $-32, %rsp
+	LONG $0xa0ec8148; WORD $0x0000; BYTE $0x00 // subq         $160, %rsp
+	LONG $0x08578b4c                           // movq         $8(%rdi), %r10
+	WORD $0x854d; BYTE $0xd2                   // testq        %r10, %r10
+	LONG $0x0910840f; WORD $0x0000             // je           LBB35_22, $2320(%rip)
+	WORD $0x8b4c; BYTE $0x0f                   // movq         (%rdi), %r9
+	WORD $0x014d; BYTE $0xca                   // addq         %r9, %r10
+	LONG $0x80728d49                           // leaq         $-128(%r10), %rsi
+	LONG $0xc9eff1c5                           // vpxor        %xmm1, %xmm1, %xmm1
+	LONG $0xd2efe9c5                           // vpxor        %xmm2, %xmm2, %xmm2
+	LONG $0xc0eff9c5                           // vpxor        %xmm0, %xmm0, %xmm0
+	WORD $0x894c; BYTE $0xc8                   // movq         %r9, %rax
+	WORD $0x394c; BYTE $0xce                   // cmpq         %r9, %rsi
+	LONG $0x0366860f; WORD $0x0000             // jbe          LBB35_12, $870(%rip)
+	QUAD $0xfffffea9256ffdc5                   // vmovdqa      $-343(%rip), %ymm4  /* LCPI35_0(%rip) */
+	QUAD $0xfffffee1356ffdc5                   // vmovdqa      $-287(%rip), %ymm6  /* LCPI35_2(%rip) */
+	QUAD $0xfffffef93d6ffdc5                   // vmovdqa      $-263(%rip), %ymm7  /* LCPI35_3(%rip) */
+	QUAD $0xffffff11056f7dc5                   // vmovdqa      $-239(%rip), %ymm8  /* LCPI35_4(%rip) */
+	QUAD $0xffffff290d6f7dc5                   // vmovdqa      $-215(%rip), %ymm9  /* LCPI35_5(%rip) */
+	QUAD $0xffffff41156f7dc5                   // vmovdqa      $-191(%rip), %ymm10  /* LCPI35_7(%rip) */
+	WORD $0x894c; BYTE $0xc8                   // movq         %r9, %rax
+	LONG $0xc0eff9c5                           // vpxor        %xmm0, %xmm0, %xmm0
+	LONG $0xd2efe9c5                           // vpxor        %xmm2, %xmm2, %xmm2
+	LONG $0xc9eff1c5                           // vpxor        %xmm1, %xmm1, %xmm1
+	WORD $0x9090                               // .p2align 4, 0x90
+
+LBB35_3:
+	LONG $0x386f7ec5               // vmovdqu      (%rax), %ymm15
+	LONG $0x686f7ec5; BYTE $0x20   // vmovdqu      $32(%rax), %ymm13
+	LONG $0x606f7ec5; BYTE $0x40   // vmovdqu      $64(%rax), %ymm12
+	LONG $0x586f7ec5; BYTE $0x60   // vmovdqu      $96(%rax), %ymm11
+	LONG $0xeb15c1c4; BYTE $0xdf   // vpor         %ymm15, %ymm13, %ymm3
+	LONG $0xeb2541c4; BYTE $0xf4   // vpor         %ymm12, %ymm11, %ymm14
+	LONG $0xebeb8dc5               // vpor         %ymm3, %ymm14, %ymm5
+	LONG $0xcdd7fdc5               // vpmovmskb    %ymm5, %ecx
+	WORD $0xc985                   // testl        %ecx, %ecx
+	LONG $0x0016850f; WORD $0x0000 // jne          LBB35_6, $22(%rip)
+	LONG $0xc0ebf5c5               // vpor         %ymm0, %ymm1, %ymm0
+
+LBB35_5:
+	LONG $0x80e88348               // subq         $-128, %rax
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0xffc2820f; WORD $0xffff // jb           LBB35_3, $-62(%rip)
+	LONG $0x0002e2e9; BYTE $0x00   // jmp          LBB35_12, $738(%rip)
+
+LBB35_6:
+	LONG $0xcbd7fdc5                     // vpmovmskb    %ymm3, %ecx
+	WORD $0xc985                         // testl        %ecx, %ecx
+	LONG $0x00f0850f; WORD $0x0000       // jne          LBB35_9, $240(%rip)
+	LONG $0xc0ebf5c5                     // vpor         %ymm0, %ymm1, %ymm0
+	LONG $0x466dc3c4; WORD $0x21cc       // vperm2i128   $33, %ymm12, %ymm2, %ymm1
+	LONG $0x0f1de3c4; WORD $0x0fd1       // vpalignr     $15, %ymm1, %ymm12, %ymm2
+	LONG $0xd271e5c5; BYTE $0x04         // vpsrlw       $4, %ymm2, %ymm3
+	LONG $0xdcdbe5c5                     // vpand        %ymm4, %ymm3, %ymm3
+	QUAD $0xfffffe20356f7dc5             // vmovdqa      $-480(%rip), %ymm14  /* LCPI35_1(%rip) */
+	LONG $0x000de2c4; BYTE $0xdb         // vpshufb      %ymm3, %ymm14, %ymm3
+	LONG $0xd4dbedc5                     // vpand        %ymm4, %ymm2, %ymm2
+	LONG $0x004de2c4; BYTE $0xd2         // vpshufb      %ymm2, %ymm6, %ymm2
+	LONG $0x7155c1c4; WORD $0x04d4       // vpsrlw       $4, %ymm12, %ymm5
+	LONG $0xecdbd5c5                     // vpand        %ymm4, %ymm5, %ymm5
+	LONG $0x0045e2c4; BYTE $0xed         // vpshufb      %ymm5, %ymm7, %ymm5
+	LONG $0xd5dbedc5                     // vpand        %ymm5, %ymm2, %ymm2
+	LONG $0xd2dbe5c5                     // vpand        %ymm2, %ymm3, %ymm2
+	LONG $0x0f1de3c4; WORD $0x0ed9       // vpalignr     $14, %ymm1, %ymm12, %ymm3
+	LONG $0x0f1de3c4; WORD $0x0dc9       // vpalignr     $13, %ymm1, %ymm12, %ymm1
+	LONG $0xd865c1c4; BYTE $0xd8         // vpsubusb     %ymm8, %ymm3, %ymm3
+	LONG $0xd875c1c4; BYTE $0xc9         // vpsubusb     %ymm9, %ymm1, %ymm1
+	LONG $0xcbebf5c5                     // vpor         %ymm3, %ymm1, %ymm1
+	LONG $0xef1141c4; BYTE $0xed         // vpxor        %xmm13, %xmm13, %xmm13
+	LONG $0xc97495c5                     // vpcmpeqb     %ymm1, %ymm13, %ymm1
+	QUAD $0xfffeaf1d597de2c4; BYTE $0xff // vpbroadcastq $-337(%rip), %ymm3  /* LCPI35_6(%rip) */
+	LONG $0xcbdff5c5                     // vpandn       %ymm3, %ymm1, %ymm1
+	LONG $0xcaeff5c5                     // vpxor        %ymm2, %ymm1, %ymm1
+	LONG $0xc1ebfdc5                     // vpor         %ymm1, %ymm0, %ymm0
+	LONG $0x461dc3c4; WORD $0x21cb       // vperm2i128   $33, %ymm11, %ymm12, %ymm1
+	LONG $0x0f25e3c4; WORD $0x0fd1       // vpalignr     $15, %ymm1, %ymm11, %ymm2
+	LONG $0xd271d5c5; BYTE $0x04         // vpsrlw       $4, %ymm2, %ymm5
+	LONG $0xecdbd5c5                     // vpand        %ymm4, %ymm5, %ymm5
+	LONG $0x000de2c4; BYTE $0xed         // vpshufb      %ymm5, %ymm14, %ymm5
+	LONG $0xd4dbedc5                     // vpand        %ymm4, %ymm2, %ymm2
+	LONG $0x004de2c4; BYTE $0xd2         // vpshufb      %ymm2, %ymm6, %ymm2
+	LONG $0x711dc1c4; WORD $0x04d3       // vpsrlw       $4, %ymm11, %ymm12
+	LONG $0xe4db1dc5                     // vpand        %ymm4, %ymm12, %ymm12
+	LONG $0x004542c4; BYTE $0xe4         // vpshufb      %ymm12, %ymm7, %ymm12
+	LONG $0xd2db9dc5                     // vpand        %ymm2, %ymm12, %ymm2
+	LONG $0xd2dbd5c5                     // vpand        %ymm2, %ymm5, %ymm2
+	LONG $0x0f25e3c4; WORD $0x0ee9       // vpalignr     $14, %ymm1, %ymm11, %ymm5
+	LONG $0x0f25e3c4; WORD $0x0dc9       // vpalignr     $13, %ymm1, %ymm11, %ymm1
+	LONG $0xd855c1c4; BYTE $0xe8         // vpsubusb     %ymm8, %ymm5, %ymm5
+	LONG $0xd875c1c4; BYTE $0xc9         // vpsubusb     %ymm9, %ymm1, %ymm1
+	LONG $0xcdebf5c5                     // vpor         %ymm5, %ymm1, %ymm1
+	LONG $0xc97495c5                     // vpcmpeqb     %ymm1, %ymm13, %ymm1
+	LONG $0xcbdff5c5                     // vpandn       %ymm3, %ymm1, %ymm1
+	LONG $0xcaeff5c5                     // vpxor        %ymm2, %ymm1, %ymm1
+
+LBB35_8:
+	LONG $0xc1ebfdc5             // vpor         %ymm1, %ymm0, %ymm0
+	LONG $0xd825c1c4; BYTE $0xca // vpsubusb     %ymm10, %ymm11, %ymm1
+	LONG $0xda7f7dc5             // vmovdqa      %ymm11, %ymm2
+	LONG $0xfffef2e9; BYTE $0xff // jmp          LBB35_5, $-270(%rip)
+
+LBB35_9:
+	LONG $0x466dc3c4; WORD $0x21cf       // vperm2i128   $33, %ymm15, %ymm2, %ymm1
+	LONG $0x0f05e3c4; WORD $0x0fd1       // vpalignr     $15, %ymm1, %ymm15, %ymm2
+	LONG $0xd271e5c5; BYTE $0x04         // vpsrlw       $4, %ymm2, %ymm3
+	LONG $0xdcdbe5c5                     // vpand        %ymm4, %ymm3, %ymm3
+	QUAD $0xfffffd342d6ffdc5             // vmovdqa      $-716(%rip), %ymm5  /* LCPI35_1(%rip) */
+	LONG $0x0055e2c4; BYTE $0xdb         // vpshufb      %ymm3, %ymm5, %ymm3
+	LONG $0xd4dbedc5                     // vpand        %ymm4, %ymm2, %ymm2
+	LONG $0x004de2c4; BYTE $0xd2         // vpshufb      %ymm2, %ymm6, %ymm2
+	LONG $0x7155c1c4; WORD $0x04d7       // vpsrlw       $4, %ymm15, %ymm5
+	LONG $0xecdbd5c5                     // vpand        %ymm4, %ymm5, %ymm5
+	LONG $0x0045e2c4; BYTE $0xed         // vpshufb      %ymm5, %ymm7, %ymm5
+	LONG $0xd5dbedc5                     // vpand        %ymm5, %ymm2, %ymm2
+	LONG $0xd2dbe5c5                     // vpand        %ymm2, %ymm3, %ymm2
+	LONG $0x0f05e3c4; WORD $0x0ed9       // vpalignr     $14, %ymm1, %ymm15, %ymm3
+	LONG $0x0f05e3c4; WORD $0x0dc9       // vpalignr     $13, %ymm1, %ymm15, %ymm1
+	LONG $0xd865c1c4; BYTE $0xd8         // vpsubusb     %ymm8, %ymm3, %ymm3
+	LONG $0xd875c1c4; BYTE $0xc9         // vpsubusb     %ymm9, %ymm1, %ymm1
+	LONG $0xcbebf5c5                     // vpor         %ymm3, %ymm1, %ymm1
+	LONG $0xdbefe1c5                     // vpxor        %xmm3, %xmm3, %xmm3
+	LONG $0xdb74f5c5                     // vpcmpeqb     %ymm3, %ymm1, %ymm3
+	QUAD $0xfffdc40d597de2c4; BYTE $0xff // vpbroadcastq $-572(%rip), %ymm1  /* LCPI35_6(%rip) */
+	LONG $0xd9dfe5c5                     // vpandn       %ymm1, %ymm3, %ymm3
+	LONG $0xd2efe5c5                     // vpxor        %ymm2, %ymm3, %ymm2
+	LONG $0x547ffdc5; WORD $0x6024       // vmovdqa      %ymm2, $96(%rsp)
+	LONG $0x4605c3c4; WORD $0x21dd       // vperm2i128   $33, %ymm13, %ymm15, %ymm3
+	LONG $0x0f15e3c4; WORD $0x0feb       // vpalignr     $15, %ymm3, %ymm13, %ymm5
+	LONG $0xd57185c5; BYTE $0x04         // vpsrlw       $4, %ymm5, %ymm15
+	LONG $0xfcdb05c5                     // vpand        %ymm4, %ymm15, %ymm15
+	QUAD $0xfffffcb9156ffdc5             // vmovdqa      $-839(%rip), %ymm2  /* LCPI35_1(%rip) */
+	LONG $0x006d42c4; BYTE $0xff         // vpshufb      %ymm15, %ymm2, %ymm15
+	LONG $0xecdbd5c5                     // vpand        %ymm4, %ymm5, %ymm5
+	LONG $0x004de2c4; BYTE $0xed         // vpshufb      %ymm5, %ymm6, %ymm5
+	LONG $0x716dc1c4; WORD $0x04d5       // vpsrlw       $4, %ymm13, %ymm2
+	LONG $0xd4dbedc5                     // vpand        %ymm4, %ymm2, %ymm2
+	LONG $0x0045e2c4; BYTE $0xd2         // vpshufb      %ymm2, %ymm7, %ymm2
+	LONG $0xd2dbd5c5                     // vpand        %ymm2, %ymm5, %ymm2
+	LONG $0xd2db85c5                     // vpand        %ymm2, %ymm15, %ymm2
+	LONG $0x0f15e3c4; WORD $0x0eeb       // vpalignr     $14, %ymm3, %ymm13, %ymm5
+	LONG $0x0f15e3c4; WORD $0x0ddb       // vpalignr     $13, %ymm3, %ymm13, %ymm3
+	LONG $0xd855c1c4; BYTE $0xe8         // vpsubusb     %ymm8, %ymm5, %ymm5
+	LONG $0xd865c1c4; BYTE $0xd9         // vpsubusb     %ymm9, %ymm3, %ymm3
+	LONG $0xddebe5c5                     // vpor         %ymm5, %ymm3, %ymm3
+	QUAD $0xfffffd321d74e5c5             // vpcmpeqb     $-718(%rip), %ymm3, %ymm3  /* LCPI35_8(%rip) */
+	LONG $0xd9dfe5c5                     // vpandn       %ymm1, %ymm3, %ymm3
+	LONG $0xd2efe5c5                     // vpxor        %ymm2, %ymm3, %ymm2
+	LONG $0x44ebfdc5; WORD $0x6024       // vpor         $96(%rsp), %ymm0, %ymm0
+	LONG $0xc2ebfdc5                     // vpor         %ymm2, %ymm0, %ymm0
+	LONG $0xd77dc1c4; BYTE $0xce         // vpmovmskb    %ymm14, %ecx
+	WORD $0xc985                         // testl        %ecx, %ecx
+	LONG $0x00d6840f; WORD $0x0000       // je           LBB35_11, $214(%rip)
+	LONG $0x4615c3c4; WORD $0x21d4       // vperm2i128   $33, %ymm12, %ymm13, %ymm2
+	LONG $0x0f1de3c4; WORD $0x0fda       // vpalignr     $15, %ymm2, %ymm12, %ymm3
+	LONG $0xd371d5c5; BYTE $0x04         // vpsrlw       $4, %ymm3, %ymm5
+	LONG $0xecdbd5c5                     // vpand        %ymm4, %ymm5, %ymm5
+	QUAD $0xfffffc363d6f7dc5             // vmovdqa      $-970(%rip), %ymm15  /* LCPI35_1(%rip) */
+	LONG $0x0005e2c4; BYTE $0xed         // vpshufb      %ymm5, %ymm15, %ymm5
+	LONG $0xdcdbe5c5                     // vpand        %ymm4, %ymm3, %ymm3
+	LONG $0x004de2c4; BYTE $0xdb         // vpshufb      %ymm3, %ymm6, %ymm3
+	LONG $0x7115c1c4; WORD $0x04d4       // vpsrlw       $4, %ymm12, %ymm13
+	LONG $0xecdb15c5                     // vpand        %ymm4, %ymm13, %ymm13
+	LONG $0x004542c4; BYTE $0xed         // vpshufb      %ymm13, %ymm7, %ymm13
+	LONG $0xdbdb95c5                     // vpand        %ymm3, %ymm13, %ymm3
+	LONG $0xdbdbd5c5                     // vpand        %ymm3, %ymm5, %ymm3
+	LONG $0x0f1de3c4; WORD $0x0eea       // vpalignr     $14, %ymm2, %ymm12, %ymm5
+	LONG $0x0f1de3c4; WORD $0x0dd2       // vpalignr     $13, %ymm2, %ymm12, %ymm2
+	LONG $0xd855c1c4; BYTE $0xe8         // vpsubusb     %ymm8, %ymm5, %ymm5
+	LONG $0xd86dc1c4; BYTE $0xd1         // vpsubusb     %ymm9, %ymm2, %ymm2
+	LONG $0xd5ebedc5                     // vpor         %ymm5, %ymm2, %ymm2
+	LONG $0xef0941c4; BYTE $0xf6         // vpxor        %xmm14, %xmm14, %xmm14
+	LONG $0xd2748dc5                     // vpcmpeqb     %ymm2, %ymm14, %ymm2
+	LONG $0xd1dfedc5                     // vpandn       %ymm1, %ymm2, %ymm2
+	LONG $0xd3efedc5                     // vpxor        %ymm3, %ymm2, %ymm2
+	LONG $0x461dc3c4; WORD $0x21db       // vperm2i128   $33, %ymm11, %ymm12, %ymm3
+	LONG $0x0f25e3c4; WORD $0x0feb       // vpalignr     $15, %ymm3, %ymm11, %ymm5
+	LONG $0xd5719dc5; BYTE $0x04         // vpsrlw       $4, %ymm5, %ymm12
+	LONG $0xe4db1dc5                     // vpand        %ymm4, %ymm12, %ymm12
+	LONG $0x000542c4; BYTE $0xe4         // vpshufb      %ymm12, %ymm15, %ymm12
+	LONG $0xecdbd5c5                     // vpand        %ymm4, %ymm5, %ymm5
+	LONG $0x004de2c4; BYTE $0xed         // vpshufb      %ymm5, %ymm6, %ymm5
+	LONG $0x7115c1c4; WORD $0x04d3       // vpsrlw       $4, %ymm11, %ymm13
+	LONG $0xecdb15c5                     // vpand        %ymm4, %ymm13, %ymm13
+	LONG $0x004542c4; BYTE $0xed         // vpshufb      %ymm13, %ymm7, %ymm13
+	LONG $0xeddb95c5                     // vpand        %ymm5, %ymm13, %ymm5
+	LONG $0xeddb9dc5                     // vpand        %ymm5, %ymm12, %ymm5
+	LONG $0x0f2563c4; WORD $0x0ee3       // vpalignr     $14, %ymm3, %ymm11, %ymm12
+	LONG $0x0f25e3c4; WORD $0x0ddb       // vpalignr     $13, %ymm3, %ymm11, %ymm3
+	LONG $0xd81d41c4; BYTE $0xe0         // vpsubusb     %ymm8, %ymm12, %ymm12
+	LONG $0xd865c1c4; BYTE $0xd9         // vpsubusb     %ymm9, %ymm3, %ymm3
+	LONG $0xdbeb9dc5                     // vpor         %ymm3, %ymm12, %ymm3
+	LONG $0xdb748dc5                     // vpcmpeqb     %ymm3, %ymm14, %ymm3
+	LONG $0xc9dfe5c5                     // vpandn       %ymm1, %ymm3, %ymm1
+	LONG $0xcdeff5c5                     // vpxor        %ymm5, %ymm1, %ymm1
+	LONG $0xc0ebedc5                     // vpor         %ymm0, %ymm2, %ymm0
+	LONG $0xfffe1ae9; BYTE $0xff         // jmp          LBB35_8, $-486(%rip)
+
+LBB35_11:
+	LONG $0xd815c1c4; BYTE $0xca // vpsubusb     %ymm10, %ymm13, %ymm1
+	LONG $0xc1ebfdc5             // vpor         %ymm1, %ymm0, %ymm0
+	LONG $0xea7f7dc5             // vmovdqa      %ymm13, %ymm2
+	LONG $0xfffd0ce9; BYTE $0xff // jmp          LBB35_5, $-756(%rip)
+
+LBB35_12:
+	LONG $0xc0728d49               // leaq         $-64(%r10), %rsi
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0x0159830f; WORD $0x0000 // jae          LBB35_17, $345(%rip)
+	QUAD $0xfffffb361d6ffdc5       // vmovdqa      $-1226(%rip), %ymm3  /* LCPI35_0(%rip) */
+	QUAD $0xfffffb4e256ffdc5       // vmovdqa      $-1202(%rip), %ymm4  /* LCPI35_1(%rip) */
+	QUAD $0xfffffb662d6ffdc5       // vmovdqa      $-1178(%rip), %ymm5  /* LCPI35_2(%rip) */
+	QUAD $0xfffffb7e356ffdc5       // vmovdqa      $-1154(%rip), %ymm6  /* LCPI35_3(%rip) */
+	QUAD $0xfffffb963d6ffdc5       // vmovdqa      $-1130(%rip), %ymm7  /* LCPI35_4(%rip) */
+	QUAD $0xfffffbae056f7dc5       // vmovdqa      $-1106(%rip), %ymm8  /* LCPI35_5(%rip) */
+	LONG $0xef3141c4; BYTE $0xc9   // vpxor        %xmm9, %xmm9, %xmm9
+	QUAD $0xfffffbc1156f7dc5       // vmovdqa      $-1087(%rip), %ymm10  /* LCPI35_7(%rip) */
+	BYTE $0x90                     // .p2align 4, 0x90
+
+LBB35_14:
+	LONG $0x206f7ec5               // vmovdqu      (%rax), %ymm12
+	LONG $0x586f7ec5; BYTE $0x20   // vmovdqu      $32(%rax), %ymm11
+	LONG $0xeb2541c4; BYTE $0xec   // vpor         %ymm12, %ymm11, %ymm13
+	LONG $0xd77dc1c4; BYTE $0xcd   // vpmovmskb    %ymm13, %ecx
+	WORD $0xc985                   // testl        %ecx, %ecx
+	LONG $0x0016850f; WORD $0x0000 // jne          LBB35_16, $22(%rip)
+	LONG $0xc0ebf5c5               // vpor         %ymm0, %ymm1, %ymm0
+	LONG $0x40c08348               // addq         $64, %rax
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0xffd4820f; WORD $0xffff // jb           LBB35_14, $-44(%rip)
+	LONG $0x0000eae9; BYTE $0x00   // jmp          LBB35_17, $234(%rip)
+
+LBB35_16:
+	LONG $0x466dc3c4; WORD $0x21cc       // vperm2i128   $33, %ymm12, %ymm2, %ymm1
+	LONG $0x0f1de3c4; WORD $0x0fd1       // vpalignr     $15, %ymm1, %ymm12, %ymm2
+	LONG $0xd27195c5; BYTE $0x04         // vpsrlw       $4, %ymm2, %ymm13
+	LONG $0xebdb15c5                     // vpand        %ymm3, %ymm13, %ymm13
+	LONG $0x005d42c4; BYTE $0xed         // vpshufb      %ymm13, %ymm4, %ymm13
+	LONG $0xd3dbedc5                     // vpand        %ymm3, %ymm2, %ymm2
+	LONG $0x0055e2c4; BYTE $0xd2         // vpshufb      %ymm2, %ymm5, %ymm2
+	LONG $0x710dc1c4; WORD $0x04d4       // vpsrlw       $4, %ymm12, %ymm14
+	LONG $0xf3db0dc5                     // vpand        %ymm3, %ymm14, %ymm14
+	LONG $0x004d42c4; BYTE $0xf6         // vpshufb      %ymm14, %ymm6, %ymm14
+	LONG $0xd2db8dc5                     // vpand        %ymm2, %ymm14, %ymm2
+	LONG $0xd2db95c5                     // vpand        %ymm2, %ymm13, %ymm2
+	LONG $0x0f1d63c4; WORD $0x0ee9       // vpalignr     $14, %ymm1, %ymm12, %ymm13
+	LONG $0x0f1de3c4; WORD $0x0dc9       // vpalignr     $13, %ymm1, %ymm12, %ymm1
+	LONG $0xefd815c5                     // vpsubusb     %ymm7, %ymm13, %ymm13
+	LONG $0xd875c1c4; BYTE $0xc8         // vpsubusb     %ymm8, %ymm1, %ymm1
+	LONG $0xc9eb95c5                     // vpor         %ymm1, %ymm13, %ymm1
+	LONG $0xc974b5c5                     // vpcmpeqb     %ymm1, %ymm9, %ymm1
+	QUAD $0xfffb6f2d597d62c4; BYTE $0xff // vpbroadcastq $-1169(%rip), %ymm13  /* LCPI35_6(%rip) */
+	LONG $0xdf75c1c4; BYTE $0xcd         // vpandn       %ymm13, %ymm1, %ymm1
+	LONG $0xcaeff5c5                     // vpxor        %ymm2, %ymm1, %ymm1
+	LONG $0x461dc3c4; WORD $0x21d3       // vperm2i128   $33, %ymm11, %ymm12, %ymm2
+	LONG $0x0f2563c4; WORD $0x0fe2       // vpalignr     $15, %ymm2, %ymm11, %ymm12
+	LONG $0x710dc1c4; WORD $0x04d4       // vpsrlw       $4, %ymm12, %ymm14
+	LONG $0xf3db0dc5                     // vpand        %ymm3, %ymm14, %ymm14
+	LONG $0x005d42c4; BYTE $0xf6         // vpshufb      %ymm14, %ymm4, %ymm14
+	LONG $0xe3db1dc5                     // vpand        %ymm3, %ymm12, %ymm12
+	LONG $0x005542c4; BYTE $0xe4         // vpshufb      %ymm12, %ymm5, %ymm12
+	LONG $0x7105c1c4; WORD $0x04d3       // vpsrlw       $4, %ymm11, %ymm15
+	LONG $0xfbdb05c5                     // vpand        %ymm3, %ymm15, %ymm15
+	LONG $0x004d42c4; BYTE $0xff         // vpshufb      %ymm15, %ymm6, %ymm15
+	LONG $0xdb1d41c4; BYTE $0xe7         // vpand        %ymm15, %ymm12, %ymm12
+	LONG $0xdb0d41c4; BYTE $0xe4         // vpand        %ymm12, %ymm14, %ymm12
+	LONG $0x0f2563c4; WORD $0x0ef2       // vpalignr     $14, %ymm2, %ymm11, %ymm14
+	LONG $0x0f25e3c4; WORD $0x0dd2       // vpalignr     $13, %ymm2, %ymm11, %ymm2
+	LONG $0xf7d80dc5                     // vpsubusb     %ymm7, %ymm14, %ymm14
+	LONG $0xd86dc1c4; BYTE $0xd0         // vpsubusb     %ymm8, %ymm2, %ymm2
+	LONG $0xd2eb8dc5                     // vpor         %ymm2, %ymm14, %ymm2
+	LONG $0xd274b5c5                     // vpcmpeqb     %ymm2, %ymm9, %ymm2
+	LONG $0xdf6dc1c4; BYTE $0xd5         // vpandn       %ymm13, %ymm2, %ymm2
+	LONG $0xd2ef9dc5                     // vpxor        %ymm2, %ymm12, %ymm2
+	LONG $0xc0ebf5c5                     // vpor         %ymm0, %ymm1, %ymm0
+	LONG $0xc2ebfdc5                     // vpor         %ymm2, %ymm0, %ymm0
+	LONG $0xd825c1c4; BYTE $0xca         // vpsubusb     %ymm10, %ymm11, %ymm1
+	LONG $0xda7f7dc5                     // vmovdqa      %ymm11, %ymm2
+	LONG $0x40c08348                     // addq         $64, %rax
+	WORD $0x3948; BYTE $0xf0             // cmpq         %rsi, %rax
+	LONG $0xfee5820f; WORD $0xffff       // jb           LBB35_14, $-283(%rip)
+
+LBB35_17:
+	LONG $0xdbefe1c5                           // vpxor        %xmm3, %xmm3, %xmm3
+	LONG $0x5c7ffdc5; WORD $0x4024             // vmovdqa      %ymm3, $64(%rsp)
+	LONG $0x5c7ffdc5; WORD $0x2024             // vmovdqa      %ymm3, $32(%rsp)
+	LONG $0xe4efd9c5                           // vpxor        %xmm4, %xmm4, %xmm4
+	WORD $0x394c; BYTE $0xd0                   // cmpq         %r10, %rax
+	LONG $0x01d7830f; WORD $0x0000             // jae          LBB35_39, $471(%rip)
+	WORD $0x894c; BYTE $0xd7                   // movq         %r10, %rdi
+	WORD $0x2948; BYTE $0xc7                   // subq         %rax, %rdi
+	WORD $0xf631                               // xorl         %esi, %esi
+	LONG $0x10ff8348                           // cmpq         $16, %rdi
+	LONG $0x002c820f; WORD $0x0000             // jb           LBB35_23, $44(%rip)
+	LONG $0x24548d48; BYTE $0x20               // leaq         $32(%rsp), %rdx
+	WORD $0x2948; BYTE $0xc2                   // subq         %rax, %rdx
+	WORD $0x8948; BYTE $0xc1                   // movq         %rax, %rcx
+	LONG $0x80fa8148; WORD $0x0000; BYTE $0x00 // cmpq         $128, %rdx
+	LONG $0x0179820f; WORD $0x0000             // jb           LBB35_36, $377(%rip)
+	LONG $0x80ff8148; WORD $0x0000; BYTE $0x00 // cmpq         $128, %rdi
+	LONG $0x000f830f; WORD $0x0000             // jae          LBB35_24, $15(%rip)
+	WORD $0xf631                               // xorl         %esi, %esi
+	LONG $0x000114e9; BYTE $0x00               // jmp          LBB35_31, $276(%rip)
+
+LBB35_23:
+	WORD $0x8948; BYTE $0xc1     // movq         %rax, %rcx
+	LONG $0x00015de9; BYTE $0x00 // jmp          LBB35_36, $349(%rip)
+
+LBB35_24:
+	WORD $0x8948; BYTE $0xfe                           // movq         %rdi, %rsi
+	LONG $0x80e68348                                   // andq         $-128, %rsi
+	LONG $0x804e8d48                                   // leaq         $-128(%rsi), %rcx
+	WORD $0x8949; BYTE $0xc8                           // movq         %rcx, %r8
+	LONG $0x07e8c149                                   // shrq         $7, %r8
+	WORD $0xff49; BYTE $0xc0                           // incq         %r8
+	WORD $0x8548; BYTE $0xc9                           // testq        %rcx, %rcx
+	LONG $0x012a840f; WORD $0x0000                     // je           LBB35_34, $298(%rip)
+	WORD $0x894c; BYTE $0xc2                           // movq         %r8, %rdx
+	LONG $0xfee28348                                   // andq         $-2, %rdx
+	WORD $0xc931                                       // xorl         %ecx, %ecx
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB35_26:
+	LONG $0x1c10fcc5; BYTE $0x08               // vmovups      (%rax,%rcx), %ymm3
+	LONG $0x6410fcc5; WORD $0x2008             // vmovups      $32(%rax,%rcx), %ymm4
+	LONG $0x6c10fcc5; WORD $0x4008             // vmovups      $64(%rax,%rcx), %ymm5
+	LONG $0x7410fcc5; WORD $0x6008             // vmovups      $96(%rax,%rcx), %ymm6
+	LONG $0x5c11fcc5; WORD $0x200c             // vmovups      %ymm3, $32(%rsp,%rcx)
+	LONG $0x6411fcc5; WORD $0x400c             // vmovups      %ymm4, $64(%rsp,%rcx)
+	LONG $0x6c11fcc5; WORD $0x600c             // vmovups      %ymm5, $96(%rsp,%rcx)
+	QUAD $0x0000800cb411fcc5; BYTE $0x00       // vmovups      %ymm6, $128(%rsp,%rcx)
+	QUAD $0x000080089c6ffec5; BYTE $0x00       // vmovdqu      $128(%rax,%rcx), %ymm3
+	QUAD $0x0000a008a46ffec5; BYTE $0x00       // vmovdqu      $160(%rax,%rcx), %ymm4
+	QUAD $0x0000c008ac6ffec5; BYTE $0x00       // vmovdqu      $192(%rax,%rcx), %ymm5
+	QUAD $0x0000e008b46ffec5; BYTE $0x00       // vmovdqu      $224(%rax,%rcx), %ymm6
+	QUAD $0x0000a00c9c7ffec5; BYTE $0x00       // vmovdqu      %ymm3, $160(%rsp,%rcx)
+	QUAD $0x0000c00ca47ffec5; BYTE $0x00       // vmovdqu      %ymm4, $192(%rsp,%rcx)
+	QUAD $0x0000e00cac7ffec5; BYTE $0x00       // vmovdqu      %ymm5, $224(%rsp,%rcx)
+	QUAD $0x0001000cb47ffec5; BYTE $0x00       // vmovdqu      %ymm6, $256(%rsp,%rcx)
+	LONG $0x00c18148; WORD $0x0001; BYTE $0x00 // addq         $256, %rcx
+	LONG $0xfec28348                           // addq         $-2, %rdx
+	LONG $0xff75850f; WORD $0xffff             // jne          LBB35_26, $-139(%rip)
+	LONG $0x01c0f641                           // testb        $1, %r8b
+	LONG $0x0032840f; WORD $0x0000             // je           LBB35_29, $50(%rip)
+
+LBB35_28:
+	LONG $0x1c6ffec5; BYTE $0x08         // vmovdqu      (%rax,%rcx), %ymm3
+	LONG $0x646ffec5; WORD $0x2008       // vmovdqu      $32(%rax,%rcx), %ymm4
+	LONG $0x6c6ffec5; WORD $0x4008       // vmovdqu      $64(%rax,%rcx), %ymm5
+	LONG $0x746ffec5; WORD $0x6008       // vmovdqu      $96(%rax,%rcx), %ymm6
+	LONG $0x5c7ffec5; WORD $0x200c       // vmovdqu      %ymm3, $32(%rsp,%rcx)
+	LONG $0x647ffec5; WORD $0x400c       // vmovdqu      %ymm4, $64(%rsp,%rcx)
+	LONG $0x6c7ffec5; WORD $0x600c       // vmovdqu      %ymm5, $96(%rsp,%rcx)
+	QUAD $0x0000800cb47ffec5; BYTE $0x00 // vmovdqu      %ymm6, $128(%rsp,%rcx)
+
+LBB35_29:
+	WORD $0x3948; BYTE $0xf7       // cmpq         %rsi, %rdi
+	LONG $0x0083840f; WORD $0x0000 // je           LBB35_38, $131(%rip)
+	LONG $0x70c7f640               // testb        $112, %dil
+	LONG $0x004d840f; WORD $0x0000 // je           LBB35_35, $77(%rip)
+
+LBB35_31:
+	WORD $0x8948; BYTE $0xf2 // movq         %rsi, %rdx
+	WORD $0x8948; BYTE $0xfe // movq         %rdi, %rsi
+	LONG $0xf0e68348         // andq         $-16, %rsi
+	LONG $0x300c8d48         // leaq         (%rax,%rsi), %rcx
+	QUAD $0x9090909090909090 // .p2align 4, 0x90
+
+LBB35_32:
+	LONG $0x1c6ffac5; BYTE $0x10   // vmovdqu      (%rax,%rdx), %xmm3
+	LONG $0x5c7ff9c5; WORD $0x2014 // vmovdqa      %xmm3, $32(%rsp,%rdx)
+	LONG $0x10c28348               // addq         $16, %rdx
+	WORD $0x3948; BYTE $0xd6       // cmpq         %rdx, %rsi
+	LONG $0xffe8850f; WORD $0xffff // jne          LBB35_32, $-24(%rip)
+	WORD $0x3948; BYTE $0xf7       // cmpq         %rsi, %rdi
+	LONG $0x001a850f; WORD $0x0000 // jne          LBB35_36, $26(%rip)
+	LONG $0x00003de9; BYTE $0x00   // jmp          LBB35_38, $61(%rip)
+
+LBB35_34:
+	WORD $0xc931                   // xorl         %ecx, %ecx
+	LONG $0x01c0f641               // testb        $1, %r8b
+	LONG $0xff73850f; WORD $0xffff // jne          LBB35_28, $-141(%rip)
+	LONG $0xffffa0e9; BYTE $0xff   // jmp          LBB35_29, $-96(%rip)
+
+LBB35_35:
+	LONG $0x300c8d48 // leaq         (%rax,%rsi), %rcx
+
+LBB35_36:
+	LONG $0x34148d48         // leaq         (%rsp,%rsi), %rdx
+	LONG $0x20c28348         // addq         $32, %rdx
+	WORD $0x894c; BYTE $0xd7 // movq         %r10, %rdi
+	WORD $0x2948; BYTE $0xf7 // subq         %rsi, %rdi
+	WORD $0x2948; BYTE $0xc7 // subq         %rax, %rdi
+	WORD $0xc031             // xorl         %eax, %eax
+	WORD $0x9090             // .p2align 4, 0x90
+
+LBB35_37:
+	LONG $0x011cb60f               // movzbl       (%rcx,%rax), %ebx
+	WORD $0x1c88; BYTE $0x02       // movb         %bl, (%rdx,%rax)
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3948; BYTE $0xc7       // cmpq         %rax, %rdi
+	LONG $0xffed850f; WORD $0xffff // jne          LBB35_37, $-19(%rip)
+
+LBB35_38:
+	LONG $0x646ffdc5; WORD $0x2024 // vmovdqa      $32(%rsp), %ymm4
+	LONG $0x5c6ffdc5; WORD $0x4024 // vmovdqa      $64(%rsp), %ymm3
+
+LBB35_39:
+	LONG $0xebebddc5               // vpor         %ymm3, %ymm4, %ymm5
+	LONG $0xc5d7fdc5               // vpmovmskb    %ymm5, %eax
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x022a850f; WORD $0x0000 // jne          LBB35_42, $554(%rip)
+	LONG $0xc1ebfdc5               // vpor         %ymm1, %ymm0, %ymm0
+	LONG $0xc1ebfdc5               // vpor         %ymm1, %ymm0, %ymm0
+	LONG $0x177de2c4; BYTE $0xc0   // vptest       %ymm0, %ymm0
+	LONG $0x020b840f; WORD $0x0000 // je           LBB35_22, $523(%rip)
+
+LBB35_43:
+	LONG $0xfd728d49               // leaq         $-3(%r10), %rsi
+	WORD $0x894c; BYTE $0xc8       // movq         %r9, %rax
+	WORD $0x394c; BYTE $0xce       // cmpq         %r9, %rsi
+	LONG $0x00de860f; WORD $0x0000 // jbe          LBB35_57, $222(%rip)
+	WORD $0x894c; BYTE $0xc8       // movq         %r9, %rax
+	LONG $0x000012e9; BYTE $0x00   // jmp          LBB35_46, $18(%rip)
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB35_45:
+	WORD $0x0148; BYTE $0xd0       // addq         %rdx, %rax
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0x00c4830f; WORD $0x0000 // jae          LBB35_57, $196(%rip)
+
+LBB35_46:
+	LONG $0x000001ba; BYTE $0x00                                         // movl         $1, %edx
+	WORD $0x3880; BYTE $0x00                                             // cmpb         $0, (%rax)
+	LONG $0xffe6890f; WORD $0xffff                                       // jns          LBB35_45, $-26(%rip)
+	WORD $0x088b                                                         // movl         (%rax), %ecx
+	WORD $0xca89                                                         // movl         %ecx, %edx
+	LONG $0xc0f0e281; WORD $0x00c0                                       // andl         $12632304, %edx
+	LONG $0x80e0fa81; WORD $0x0080                                       // cmpl         $8421600, %edx
+	LONG $0x0030850f; WORD $0x0000                                       // jne          LBB35_50, $48(%rip)
+	WORD $0xcf89                                                         // movl         %ecx, %edi
+	LONG $0x200fe781; WORD $0x0000                                       // andl         $8207, %edi
+	LONG $0x200dff81; WORD $0x0000                                       // cmpl         $8205, %edi
+	LONG $0x001c840f; WORD $0x0000                                       // je           LBB35_50, $28(%rip)
+	LONG $0x000003ba; BYTE $0x00                                         // movl         $3, %edx
+	WORD $0xff85                                                         // testl        %edi, %edi
+	LONG $0xffaf850f; WORD $0xffff                                       // jne          LBB35_45, $-81(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB35_50:
+	WORD $0xca89                   // movl         %ecx, %edx
+	LONG $0xc0e0e281; WORD $0x0000 // andl         $49376, %edx
+	LONG $0x80c0fa81; WORD $0x0000 // cmpl         $32960, %edx
+	LONG $0x0010850f; WORD $0x0000 // jne          LBB35_52, $16(%rip)
+	WORD $0xcf89                   // movl         %ecx, %edi
+	LONG $0x000002ba; BYTE $0x00   // movl         $2, %edx
+	WORD $0xe783; BYTE $0x1e       // andl         $30, %edi
+	LONG $0xff7c850f; WORD $0xffff // jne          LBB35_45, $-132(%rip)
+
+LBB35_52:
+	WORD $0xca89                   // movl         %ecx, %edx
+	LONG $0xc0f8e281; WORD $0xc0c0 // andl         $-1061109512, %edx
+	LONG $0x80f0fa81; WORD $0x8080 // cmpl         $-2139062032, %edx
+	LONG $0x0028850f; WORD $0x0000 // jne          LBB35_56, $40(%rip)
+	WORD $0xca89                   // movl         %ecx, %edx
+	LONG $0x3007e281; WORD $0x0000 // andl         $12295, %edx
+	LONG $0x001a840f; WORD $0x0000 // je           LBB35_56, $26(%rip)
+	LONG $0x000004ba; BYTE $0x00   // movl         $4, %edx
+	WORD $0xc1f6; BYTE $0x04       // testb        $4, %cl
+	LONG $0xff4c840f; WORD $0xffff // je           LBB35_45, $-180(%rip)
+	LONG $0x3003e181; WORD $0x0000 // andl         $12291, %ecx
+	LONG $0xff40840f; WORD $0xffff // je           LBB35_45, $-192(%rip)
+
+LBB35_56:
+	WORD $0xf748; BYTE $0xd0 // notq         %rax
+	WORD $0x014c; BYTE $0xc8 // addq         %r9, %rax
+	LONG $0xf8658d48         // leaq         $-8(%rbp), %rsp
+	BYTE $0x5b               // popq         %rbx
+	BYTE $0x5d               // popq         %rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	BYTE $0xc3               // retq
+
+LBB35_57:
+	WORD $0x394c; BYTE $0xd0       // cmpq         %r10, %rax
+	LONG $0x0114830f; WORD $0x0000 // jae          LBB35_22, $276(%rip)
+	LONG $0x24448d4c; BYTE $0x20   // leaq         $32(%rsp), %r8
+	LONG $0x245c8d4c; BYTE $0x1e   // leaq         $30(%rsp), %r11
+	LONG $0x000014e9; BYTE $0x00   // jmp          LBB35_60, $20(%rip)
+	QUAD $0x9090909090909090       // .p2align 4, 0x90
+
+LBB35_59:
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x394c; BYTE $0xd0       // cmpq         %r10, %rax
+	LONG $0x00f1830f; WORD $0x0000 // jae          LBB35_22, $241(%rip)
+
+LBB35_60:
+	WORD $0x3880; BYTE $0x00       // cmpb         $0, (%rax)
+	LONG $0xffeb890f; WORD $0xffff // jns          LBB35_59, $-21(%rip)
+	LONG $0x202444c6; BYTE $0x00   // movb         $0, $32(%rsp)
+	LONG $0x1e2444c6; BYTE $0x00   // movb         $0, $30(%rsp)
+	WORD $0x894c; BYTE $0xd2       // movq         %r10, %rdx
+	WORD $0x2948; BYTE $0xc2       // subq         %rax, %rdx
+	LONG $0x02fa8348               // cmpq         $2, %rdx
+	LONG $0x0034820f; WORD $0x0000 // jb           LBB35_64, $52(%rip)
+	WORD $0xb60f; BYTE $0x30       // movzbl       (%rax), %esi
+	LONG $0x0148b60f               // movzbl       $1(%rax), %ecx
+	LONG $0x24748840; BYTE $0x20   // movb         %sil, $32(%rsp)
+	LONG $0x02788d48               // leaq         $2(%rax), %rdi
+	LONG $0xfec28348               // addq         $-2, %rdx
+	WORD $0x894c; BYTE $0xdb       // movq         %r11, %rbx
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0x0027840f; WORD $0x0000 // je           LBB35_65, $39(%rip)
+
+LBB35_63:
+	WORD $0xb60f; BYTE $0x17     // movzbl       (%rdi), %edx
+	WORD $0x1388                 // movb         %dl, (%rbx)
+	LONG $0x2474b60f; BYTE $0x20 // movzbl       $32(%rsp), %esi
+	LONG $0x2454b60f; BYTE $0x1e // movzbl       $30(%rsp), %edx
+	LONG $0x000015e9; BYTE $0x00 // jmp          LBB35_66, $21(%rip)
+
+LBB35_64:
+	WORD $0xf631                   // xorl         %esi, %esi
+	WORD $0xc931                   // xorl         %ecx, %ecx
+	WORD $0x894c; BYTE $0xc3       // movq         %r8, %rbx
+	WORD $0x8948; BYTE $0xc7       // movq         %rax, %rdi
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0xffd9850f; WORD $0xffff // jne          LBB35_63, $-39(%rip)
+
+LBB35_65:
+	WORD $0xd231 // xorl         %edx, %edx
+
+LBB35_66:
+	WORD $0xb60f; BYTE $0xd2                                             // movzbl       %dl, %edx
+	WORD $0xe2c1; BYTE $0x10                                             // shll         $16, %edx
+	WORD $0xb60f; BYTE $0xf9                                             // movzbl       %cl, %edi
+	WORD $0xe7c1; BYTE $0x08                                             // shll         $8, %edi
+	WORD $0xd709                                                         // orl          %edx, %edi
+	LONG $0xceb60f40                                                     // movzbl       %sil, %ecx
+	WORD $0xf909                                                         // orl          %edi, %ecx
+	WORD $0xca89                                                         // movl         %ecx, %edx
+	LONG $0xc0f0e281; WORD $0x00c0                                       // andl         $12632304, %edx
+	LONG $0x80e0fa81; WORD $0x0080                                       // cmpl         $8421600, %edx
+	LONG $0x0030850f; WORD $0x0000                                       // jne          LBB35_69, $48(%rip)
+	WORD $0xcf89                                                         // movl         %ecx, %edi
+	LONG $0x200fe781; WORD $0x0000                                       // andl         $8207, %edi
+	LONG $0x200dff81; WORD $0x0000                                       // cmpl         $8205, %edi
+	LONG $0x001c840f; WORD $0x0000                                       // je           LBB35_69, $28(%rip)
+	LONG $0x000003ba; BYTE $0x00                                         // movl         $3, %edx
+	WORD $0xff85                                                         // testl        %edi, %edi
+	LONG $0x0030850f; WORD $0x0000                                       // jne          LBB35_71, $48(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB35_69:
+	LONG $0x1ec6f640               // testb        $30, %sil
+	LONG $0xfef6840f; WORD $0xffff // je           LBB35_56, $-266(%rip)
+	LONG $0xc0e0e181; WORD $0x0000 // andl         $49376, %ecx
+	LONG $0x000002ba; BYTE $0x00   // movl         $2, %edx
+	LONG $0x80c0f981; WORD $0x0000 // cmpl         $32960, %ecx
+	LONG $0xfedf850f; WORD $0xffff // jne          LBB35_56, $-289(%rip)
+
+LBB35_71:
+	WORD $0x0148; BYTE $0xd0       // addq         %rdx, %rax
+	WORD $0x394c; BYTE $0xd0       // cmpq         %r10, %rax
+	LONG $0xff0f820f; WORD $0xffff // jb           LBB35_60, $-241(%rip)
+
+LBB35_22:
+	WORD $0xc031             // xorl         %eax, %eax
+	LONG $0xf8658d48         // leaq         $-8(%rbp), %rsp
+	BYTE $0x5b               // popq         %rbx
+	BYTE $0x5d               // popq         %rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	BYTE $0xc3               // retq
+
+LBB35_42:
+	LONG $0x466de3c4; WORD $0x21d4                                                     // vperm2i128   $33, %ymm4, %ymm2, %ymm2
+	LONG $0x0f5de3c4; WORD $0x0fea                                                     // vpalignr     $15, %ymm2, %ymm4, %ymm5
+	LONG $0xd571cdc5; BYTE $0x04                                                       // vpsrlw       $4, %ymm5, %ymm6
+	QUAD $0xfffff59e0d6ffdc5                                                           // vmovdqa      $-2658(%rip), %ymm1  /* LCPI35_0(%rip) */
+	LONG $0xf1dbcdc5                                                                   // vpand        %ymm1, %ymm6, %ymm6
+	QUAD $0xfffff5b23d6ffdc5                                                           // vmovdqa      $-2638(%rip), %ymm7  /* LCPI35_1(%rip) */
+	LONG $0x0045e2c4; BYTE $0xf6                                                       // vpshufb      %ymm6, %ymm7, %ymm6
+	LONG $0xe9dbd5c5                                                                   // vpand        %ymm1, %ymm5, %ymm5
+	QUAD $0xfffff5c1056f7dc5                                                           // vmovdqa      $-2623(%rip), %ymm8  /* LCPI35_2(%rip) */
+	LONG $0x003de2c4; BYTE $0xed                                                       // vpshufb      %ymm5, %ymm8, %ymm5
+	LONG $0xd471b5c5; BYTE $0x04                                                       // vpsrlw       $4, %ymm4, %ymm9
+	LONG $0xc9db35c5                                                                   // vpand        %ymm1, %ymm9, %ymm9
+	QUAD $0xfffff5cb156f7dc5                                                           // vmovdqa      $-2613(%rip), %ymm10  /* LCPI35_3(%rip) */
+	LONG $0x002d42c4; BYTE $0xc9                                                       // vpshufb      %ymm9, %ymm10, %ymm9
+	LONG $0xeddbb5c5                                                                   // vpand        %ymm5, %ymm9, %ymm5
+	LONG $0xeddbcdc5                                                                   // vpand        %ymm5, %ymm6, %ymm5
+	LONG $0x0f5de3c4; WORD $0x0ef2                                                     // vpalignr     $14, %ymm2, %ymm4, %ymm6
+	LONG $0x0f5de3c4; WORD $0x0dd2                                                     // vpalignr     $13, %ymm2, %ymm4, %ymm2
+	QUAD $0xfffff5ca0d6f7dc5                                                           // vmovdqa      $-2614(%rip), %ymm9  /* LCPI35_4(%rip) */
+	LONG $0xd84dc1c4; BYTE $0xf1                                                       // vpsubusb     %ymm9, %ymm6, %ymm6
+	QUAD $0xfffff5dd1d6f7dc5                                                           // vmovdqa      $-2595(%rip), %ymm11  /* LCPI35_5(%rip) */
+	LONG $0xd86dc1c4; BYTE $0xd3                                                       // vpsubusb     %ymm11, %ymm2, %ymm2
+	LONG $0xd6ebedc5                                                                   // vpor         %ymm6, %ymm2, %ymm2
+	LONG $0xf6efc9c5                                                                   // vpxor        %xmm6, %xmm6, %xmm6
+	LONG $0xd674edc5                                                                   // vpcmpeqb     %ymm6, %ymm2, %ymm2
+	QUAD $0xfff62325597d62c4; BYTE $0xff                                               // vpbroadcastq $-2525(%rip), %ymm12  /* LCPI35_6(%rip) */
+	LONG $0xdf6dc1c4; BYTE $0xd4                                                       // vpandn       %ymm12, %ymm2, %ymm2
+	LONG $0xd5efedc5                                                                   // vpxor        %ymm5, %ymm2, %ymm2
+	LONG $0x465de3c4; WORD $0x21e3                                                     // vperm2i128   $33, %ymm3, %ymm4, %ymm4
+	LONG $0x0f65e3c4; WORD $0x0fec                                                     // vpalignr     $15, %ymm4, %ymm3, %ymm5
+	LONG $0xd57195c5; BYTE $0x04                                                       // vpsrlw       $4, %ymm5, %ymm13
+	LONG $0xe9db15c5                                                                   // vpand        %ymm1, %ymm13, %ymm13
+	LONG $0x0045c2c4; BYTE $0xfd                                                       // vpshufb      %ymm13, %ymm7, %ymm7
+	LONG $0xe9dbd5c5                                                                   // vpand        %ymm1, %ymm5, %ymm5
+	LONG $0x003de2c4; BYTE $0xed                                                       // vpshufb      %ymm5, %ymm8, %ymm5
+	LONG $0xd371bdc5; BYTE $0x04                                                       // vpsrlw       $4, %ymm3, %ymm8
+	LONG $0xc9dbbdc5                                                                   // vpand        %ymm1, %ymm8, %ymm1
+	LONG $0x002de2c4; BYTE $0xc9                                                       // vpshufb      %ymm1, %ymm10, %ymm1
+	LONG $0xc9dbd5c5                                                                   // vpand        %ymm1, %ymm5, %ymm1
+	LONG $0xc9dbc5c5                                                                   // vpand        %ymm1, %ymm7, %ymm1
+	LONG $0x0f65e3c4; WORD $0x0eec                                                     // vpalignr     $14, %ymm4, %ymm3, %ymm5
+	LONG $0x0f65e3c4; WORD $0x0de4                                                     // vpalignr     $13, %ymm4, %ymm3, %ymm4
+	LONG $0xd855c1c4; BYTE $0xe9                                                       // vpsubusb     %ymm9, %ymm5, %ymm5
+	LONG $0xd85dc1c4; BYTE $0xe3                                                       // vpsubusb     %ymm11, %ymm4, %ymm4
+	LONG $0xe5ebddc5                                                                   // vpor         %ymm5, %ymm4, %ymm4
+	LONG $0xe674ddc5                                                                   // vpcmpeqb     %ymm6, %ymm4, %ymm4
+	LONG $0xdf5dc1c4; BYTE $0xe4                                                       // vpandn       %ymm12, %ymm4, %ymm4
+	LONG $0xc9efddc5                                                                   // vpxor        %ymm1, %ymm4, %ymm1
+	LONG $0xc0ebedc5                                                                   // vpor         %ymm0, %ymm2, %ymm0
+	LONG $0xc1ebfdc5                                                                   // vpor         %ymm1, %ymm0, %ymm0
+	QUAD $0xfffff56a0dd8e5c5                                                           // vpsubusb     $-2710(%rip), %ymm3, %ymm1  /* LCPI35_7(%rip) */
+	LONG $0xc1ebfdc5                                                                   // vpor         %ymm1, %ymm0, %ymm0
+	LONG $0x177de2c4; BYTE $0xc0                                                       // vptest       %ymm0, %ymm0
+	LONG $0xfed8840f; WORD $0xffff                                                     // je           LBB35_22, $-296(%rip)
+	LONG $0xfffcc8e9; BYTE $0xff                                                       // jmp          LBB35_43, $-824(%rip)
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 5, 0x00
+
+LCPI36_0:
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+
+	// .p2align 4, 0x00
+LCPI36_1:
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+
+	// .p2align 4, 0x90
+_f32toa:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	BYTE $0x50                                 // pushq        %rax
+	LONG $0xc07ef9c5                           // vmovd        %xmm0, %eax
+	WORD $0xc189                               // movl         %eax, %ecx
+	WORD $0xe9c1; BYTE $0x17                   // shrl         $23, %ecx
+	WORD $0xb60f; BYTE $0xd1                   // movzbl       %cl, %edx
+	LONG $0x00fffa81; WORD $0x0000             // cmpl         $255, %edx
+	LONG $0x0df0840f; WORD $0x0000             // je           LBB36_141, $3568(%rip)
+	WORD $0x07c6; BYTE $0x2d                   // movb         $45, (%rdi)
+	WORD $0x8941; BYTE $0xc1                   // movl         %eax, %r9d
+	LONG $0x1fe9c141                           // shrl         $31, %r9d
+	LONG $0x0f2c8d4e                           // leaq         (%rdi,%r9), %r13
+	LONG $0xffffffa9; BYTE $0x7f               // testl        $2147483647, %eax
+	LONG $0x01cd840f; WORD $0x0000             // je           LBB36_6, $461(%rip)
+	LONG $0x7fffff25; BYTE $0x00               // andl         $8388607, %eax
+	WORD $0xd285                               // testl        %edx, %edx
+	LONG $0x0dd1840f; WORD $0x0000             // je           LBB36_142, $3537(%rip)
+	LONG $0x00b88d44; WORD $0x8000; BYTE $0x00 // leal         $8388608(%rax), %r15d
+	LONG $0x6a828d44; WORD $0xffff; BYTE $0xff // leal         $-150(%rdx), %r8d
+	WORD $0x4a8d; BYTE $0x81                   // leal         $-127(%rdx), %ecx
+	WORD $0xf983; BYTE $0x17                   // cmpl         $23, %ecx
+	LONG $0x001c870f; WORD $0x0000             // ja           LBB36_7, $28(%rip)
+	LONG $0x000096b9; BYTE $0x00               // movl         $150, %ecx
+	WORD $0xd129                               // subl         %edx, %ecx
+	LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rbx
+	WORD $0xd348; BYTE $0xe3                   // shlq         %cl, %rbx
+	WORD $0xd3f7                               // notl         %ebx
+	WORD $0x8544; BYTE $0xfb                   // testl        %r15d, %ebx
+	LONG $0x043c840f; WORD $0x0000             // je           LBB36_33, $1084(%rip)
+
+LBB36_7:
+	LONG $0xd07d8948 // movq         %rdi, $-48(%rbp)
+
+LBB36_8:
+	WORD $0x8945; BYTE $0xfe                   // movl         %r15d, %r14d
+	LONG $0x01e68341                           // andl         $1, %r14d
+	WORD $0xc085                               // testl        %eax, %eax
+	WORD $0x940f; BYTE $0xc0                   // sete         %al
+	WORD $0xfa83; BYTE $0x02                   // cmpl         $2, %edx
+	WORD $0x930f; BYTE $0xc1                   // setae        %cl
+	WORD $0xc120                               // andb         %al, %cl
+	WORD $0xb60f; BYTE $0xc9                   // movzbl       %cl, %ecx
+	WORD $0x8945; BYTE $0xfa                   // movl         %r15d, %r10d
+	LONG $0x02e2c141                           // shll         $2, %r10d
+	LONG $0xb9048d42                           // leal         (%rcx,%r15,4), %eax
+	WORD $0xc083; BYTE $0xfe                   // addl         $-2, %eax
+	LONG $0x13d06941; WORD $0x1344; BYTE $0x00 // imull        $1262611, %r8d, %edx
+	LONG $0x019a8d44; WORD $0xf801; BYTE $0xff // leal         $-524031(%rdx), %r11d
+	WORD $0xc984                               // testb        %cl, %cl
+	LONG $0xda440f44                           // cmovel       %edx, %r11d
+	LONG $0x16fbc141                           // sarl         $22, %r11d
+	LONG $0xb1cb6941; WORD $0xe56c; BYTE $0xff // imull        $-1741647, %r11d, %ecx
+	WORD $0xe9c1; BYTE $0x13                   // shrl         $19, %ecx
+	WORD $0x0144; BYTE $0xc1                   // addl         %r8d, %ecx
+	LONG $0x00001fba; BYTE $0x00               // movl         $31, %edx
+	WORD $0x2944; BYTE $0xda                   // subl         %r11d, %edx
+	LONG $0x713d8d48; WORD $0x00b8; BYTE $0x00 // leaq         $47217(%rip), %rdi  /* _pow10_ceil_sig_f32.g(%rip) */
+	WORD $0xc1fe                               // incb         %cl
+	WORD $0xe0d3                               // shll         %cl, %eax
+	LONG $0xd7248b4c                           // movq         (%rdi,%rdx,8), %r12
+	WORD $0xf749; BYTE $0xe4                   // mulq         %r12
+	QUAD $0x00000002bd048d46                   // leal         $2(,%r15,4), %r8d
+	WORD $0xf631                               // xorl         %esi, %esi
+	LONG $0x21e8c148                           // shrq         $33, %rax
+	LONG $0xc6950f40                           // setne        %sil
+	WORD $0xd609                               // orl          %edx, %esi
+	WORD $0xd341; BYTE $0xe2                   // shll         %cl, %r10d
+	WORD $0x894c; BYTE $0xd0                   // movq         %r10, %rax
+	WORD $0xf749; BYTE $0xe4                   // mulq         %r12
+	WORD $0x8949; BYTE $0xd2                   // movq         %rdx, %r10
+	WORD $0x3145; BYTE $0xff                   // xorl         %r15d, %r15d
+	LONG $0x21e8c148                           // shrq         $33, %rax
+	LONG $0xc7950f41                           // setne        %r15b
+	WORD $0x0945; BYTE $0xd7                   // orl          %r10d, %r15d
+	WORD $0xd341; BYTE $0xe0                   // shll         %cl, %r8d
+	WORD $0x894c; BYTE $0xc0                   // movq         %r8, %rax
+	WORD $0xf749; BYTE $0xe4                   // mulq         %r12
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0x21e8c148                           // shrq         $33, %rax
+	WORD $0x950f; BYTE $0xc1                   // setne        %cl
+	WORD $0xd109                               // orl          %edx, %ecx
+	WORD $0x0144; BYTE $0xf6                   // addl         %r14d, %esi
+	WORD $0x2944; BYTE $0xf1                   // subl         %r14d, %ecx
+	LONG $0x28ff8341                           // cmpl         $40, %r15d
+	LONG $0x0041820f; WORD $0x0000             // jb           LBB36_10, $65(%rip)
+	WORD $0x8944; BYTE $0xd0                   // movl         %r10d, %eax
+	LONG $0xcccccdba; BYTE $0xcc               // movl         $3435973837, %edx
+	LONG $0xd0af0f48                           // imulq        %rax, %rdx
+	LONG $0x25eac148                           // shrq         $37, %rdx
+	WORD $0xf089                               // movl         %esi, %eax
+	QUAD $0x00000000d53c8d48                   // leaq         (,%rdx,8), %rdi
+	LONG $0xbf1c8d48                           // leaq         (%rdi,%rdi,4), %rbx
+	WORD $0x3948; BYTE $0xc3                   // cmpq         %rax, %rbx
+	LONG $0xc6920f41                           // setb         %r14b
+	LONG $0xbf3c8d48                           // leaq         (%rdi,%rdi,4), %rdi
+	LONG $0x28c78348                           // addq         $40, %rdi
+	WORD $0xcb89                               // movl         %ecx, %ebx
+	WORD $0xc031                               // xorl         %eax, %eax
+	WORD $0x3948; BYTE $0xdf                   // cmpq         %rbx, %rdi
+	LONG $0xc0960f41                           // setbe        %r8b
+	WORD $0x3845; BYTE $0xc6                   // cmpb         %r8b, %r14b
+	LONG $0x01f9840f; WORD $0x0000             // je           LBB36_18, $505(%rip)
+
+LBB36_10:
+	WORD $0x8945; BYTE $0xd0       // movl         %r10d, %r8d
+	LONG $0x02e8c141               // shrl         $2, %r8d
+	WORD $0x8944; BYTE $0xd2       // movl         %r10d, %edx
+	WORD $0xe283; BYTE $0xfc       // andl         $-4, %edx
+	WORD $0xd639                   // cmpl         %edx, %esi
+	LONG $0xc6970f40               // seta         %sil
+	WORD $0x428d; BYTE $0x04       // leal         $4(%rdx), %eax
+	WORD $0xc839                   // cmpl         %ecx, %eax
+	WORD $0x960f; BYTE $0xc3       // setbe        %bl
+	WORD $0x3040; BYTE $0xf3       // xorb         %sil, %bl
+	LONG $0x007e840f; WORD $0x0000 // je           LBB36_14, $126(%rip)
+	WORD $0xca83; BYTE $0x02       // orl          $2, %edx
+	LONG $0x000001b8; BYTE $0x00   // movl         $1, %eax
+	WORD $0x3941; BYTE $0xd7       // cmpl         %edx, %r15d
+	LONG $0x000e870f; WORD $0x0000 // ja           LBB36_13, $14(%rip)
+	WORD $0x940f; BYTE $0xc0       // sete         %al
+	LONG $0x02eac041               // shrb         $2, %r10b
+	WORD $0x2041; BYTE $0xc2       // andb         %al, %r10b
+	LONG $0xc2b60f41               // movzbl       %r10b, %eax
+
+LBB36_13:
+	WORD $0x0144; BYTE $0xc0       // addl         %r8d, %eax
+	WORD $0x894d; BYTE $0xef       // movq         %r13, %r15
+	LONG $0x0186a03d; BYTE $0x00   // cmpl         $100000, %eax
+	LONG $0xd06d8b4c               // movq         $-48(%rbp), %r13
+	LONG $0x0065820f; WORD $0x0000 // jb           LBB36_19, $101(%rip)
+
+LBB36_15:
+	LONG $0x0006bc41; WORD $0x0000 // movl         $6, %r12d
+	LONG $0x0f42403d; BYTE $0x00   // cmpl         $1000000, %eax
+	LONG $0x0093820f; WORD $0x0000 // jb           LBB36_23, $147(%rip)
+	LONG $0x0007bc41; WORD $0x0000 // movl         $7, %r12d
+	LONG $0x9896803d; BYTE $0x00   // cmpl         $10000000, %eax
+	LONG $0x0082820f; WORD $0x0000 // jb           LBB36_23, $130(%rip)
+	WORD $0x3145; BYTE $0xe4       // xorl         %r12d, %r12d
+	LONG $0xf5e1003d; BYTE $0x05   // cmpl         $100000000, %eax
+	LONG $0xc4920f41               // setb         %r12b
+	LONG $0x09f48341               // xorl         $9, %r12d
+	LONG $0x00006de9; BYTE $0x00   // jmp          LBB36_23, $109(%rip)
+
+LBB36_6:
+	LONG $0x0045c641; BYTE $0x30 // movb         $48, (%r13)
+	WORD $0x2941; BYTE $0xfd     // subl         %edi, %r13d
+	WORD $0xff41; BYTE $0xc5     // incl         %r13d
+	WORD $0x8944; BYTE $0xe8     // movl         %r13d, %eax
+	LONG $0x000be5e9; BYTE $0x00 // jmp          LBB36_93, $3045(%rip)
+
+LBB36_14:
+	WORD $0xc139                   // cmpl         %eax, %ecx
+	LONG $0xffd88341               // sbbl         $-1, %r8d
+	WORD $0x8944; BYTE $0xc0       // movl         %r8d, %eax
+	WORD $0x894d; BYTE $0xef       // movq         %r13, %r15
+	LONG $0x0186a03d; BYTE $0x00   // cmpl         $100000, %eax
+	LONG $0xd06d8b4c               // movq         $-48(%rbp), %r13
+	LONG $0xff9b830f; WORD $0xffff // jae          LBB36_15, $-101(%rip)
+
+LBB36_19:
+	LONG $0x0001bc41; WORD $0x0000 // movl         $1, %r12d
+	WORD $0xf883; BYTE $0x0a       // cmpl         $10, %eax
+	LONG $0x0030820f; WORD $0x0000 // jb           LBB36_23, $48(%rip)
+	LONG $0x0002bc41; WORD $0x0000 // movl         $2, %r12d
+	WORD $0xf883; BYTE $0x64       // cmpl         $100, %eax
+	LONG $0x0021820f; WORD $0x0000 // jb           LBB36_23, $33(%rip)
+	LONG $0x0003bc41; WORD $0x0000 // movl         $3, %r12d
+	LONG $0x0003e83d; BYTE $0x00   // cmpl         $1000, %eax
+	LONG $0x0010820f; WORD $0x0000 // jb           LBB36_23, $16(%rip)
+	WORD $0x3145; BYTE $0xe4       // xorl         %r12d, %r12d
+	LONG $0x0027103d; BYTE $0x00   // cmpl         $10000, %eax
+	LONG $0xc4920f41               // setb         %r12b
+	LONG $0x05f48341               // xorl         $5, %r12d
+
+LBB36_23:
+	LONG $0x1c148d47                           // leal         (%r12,%r11), %r10d
+	LONG $0x1c0c8d43                           // leal         (%r12,%r11), %ecx
+	WORD $0xc183; BYTE $0xea                   // addl         $-22, %ecx
+	WORD $0xf983; BYTE $0xe4                   // cmpl         $-28, %ecx
+	LONG $0x0077870f; WORD $0x0000             // ja           LBB36_27, $119(%rip)
+	WORD $0x8944; BYTE $0xe1                   // movl         %r12d, %ecx
+	LONG $0x0f148d49                           // leaq         (%r15,%rcx), %rdx
+	WORD $0xff48; BYTE $0xc2                   // incq         %rdx
+	LONG $0x0027103d; BYTE $0x00               // cmpl         $10000, %eax
+	LONG $0x00f3820f; WORD $0x0000             // jb           LBB36_31, $243(%rip)
+	WORD $0xc789                               // movl         %eax, %edi
+	LONG $0xb71759be; BYTE $0xd1               // movl         $3518437209, %esi
+	LONG $0xf7af0f48                           // imulq        %rdi, %rsi
+	LONG $0x2deec148                           // shrq         $45, %rsi
+	LONG $0xf0c66944; WORD $0xffd8; BYTE $0xff // imull        $-10000, %esi, %r8d
+	WORD $0x0141; BYTE $0xc0                   // addl         %eax, %r8d
+	LONG $0x0464840f; WORD $0x0000             // je           LBB36_59, $1124(%rip)
+	WORD $0x8944; BYTE $0xc0                   // movl         %r8d, %eax
+	LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xf86b; BYTE $0x64                   // imull        $100, %eax, %edi
+	WORD $0x2941; BYTE $0xf8                   // subl         %edi, %r8d
+	LONG $0xf43d8d48; WORD $0x0042; BYTE $0x00 // leaq         $17140(%rip), %rdi  /* _Digits(%rip) */
+	LONG $0x1cb70f42; BYTE $0x47               // movzwl       (%rdi,%r8,2), %ebx
+	LONG $0xfe5a8966                           // movw         %bx, $-2(%rdx)
+	LONG $0x4704b70f                           // movzwl       (%rdi,%rax,2), %eax
+	LONG $0xfc428966                           // movw         %ax, $-4(%rdx)
+	WORD $0x3145; BYTE $0xc0                   // xorl         %r8d, %r8d
+	LONG $0xfcc28348                           // addq         $-4, %rdx
+	WORD $0xfe83; BYTE $0x64                   // cmpl         $100, %esi
+	LONG $0x00a6830f; WORD $0x0000             // jae          LBB36_61, $166(%rip)
+
+LBB36_32:
+	WORD $0xf089                 // movl         %esi, %eax
+	LONG $0x0000dbe9; BYTE $0x00 // jmp          LBB36_63, $219(%rip)
+
+LBB36_27:
+	WORD $0x8945; BYTE $0xe0                   // movl         %r12d, %r8d
+	WORD $0x8545; BYTE $0xdb                   // testl        %r11d, %r11d
+	LONG $0x023a880f; WORD $0x0000             // js           LBB36_36, $570(%rip)
+	LONG $0x070c8d4b                           // leaq         (%r15,%r8), %rcx
+	LONG $0x0027103d; BYTE $0x00               // cmpl         $10000, %eax
+	LONG $0x0295820f; WORD $0x0000             // jb           LBB36_41, $661(%rip)
+	WORD $0xc289                               // movl         %eax, %edx
+	LONG $0xb71759be; BYTE $0xd1               // movl         $3518437209, %esi
+	LONG $0xf2af0f48                           // imulq        %rdx, %rsi
+	LONG $0x2deec148                           // shrq         $45, %rsi
+	LONG $0xd8f0d669; WORD $0xffff             // imull        $-10000, %esi, %edx
+	WORD $0xc201                               // addl         %eax, %edx
+	LONG $0x1fc26948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rdx, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xf86b; BYTE $0x64                   // imull        $100, %eax, %edi
+	WORD $0xfa29                               // subl         %edi, %edx
+	LONG $0x833d8d48; WORD $0x0042; BYTE $0x00 // leaq         $17027(%rip), %rdi  /* _Digits(%rip) */
+	LONG $0x5714b70f                           // movzwl       (%rdi,%rdx,2), %edx
+	LONG $0xfe518966                           // movw         %dx, $-2(%rcx)
+	LONG $0xfc518d48                           // leaq         $-4(%rcx), %rdx
+	LONG $0x4704b70f                           // movzwl       (%rdi,%rax,2), %eax
+	LONG $0xfc418966                           // movw         %ax, $-4(%rcx)
+	WORD $0xf089                               // movl         %esi, %eax
+	WORD $0x8945; BYTE $0xd3                   // movl         %r10d, %r11d
+	WORD $0xf883; BYTE $0x64                   // cmpl         $100, %eax
+	LONG $0x0254830f; WORD $0x0000             // jae          LBB36_42, $596(%rip)
+
+LBB36_30:
+	WORD $0xc689                 // movl         %eax, %esi
+	LONG $0x000288e9; BYTE $0x00 // jmp          LBB36_44, $648(%rip)
+
+LBB36_18:
+	WORD $0x8844; BYTE $0xc0       // movb         %r8b, %al
+	WORD $0xd001                   // addl         %edx, %eax
+	WORD $0xff41; BYTE $0xc3       // incl         %r11d
+	WORD $0x894d; BYTE $0xef       // movq         %r13, %r15
+	LONG $0x0186a03d; BYTE $0x00   // cmpl         $100000, %eax
+	LONG $0xd06d8b4c               // movq         $-48(%rbp), %r13
+	LONG $0xfe45830f; WORD $0xffff // jae          LBB36_15, $-443(%rip)
+	LONG $0xfffea5e9; BYTE $0xff   // jmp          LBB36_19, $-347(%rip)
+
+LBB36_31:
+	WORD $0x3145; BYTE $0xc0       // xorl         %r8d, %r8d
+	WORD $0xc689                   // movl         %eax, %esi
+	WORD $0xfe83; BYTE $0x64       // cmpl         $100, %esi
+	LONG $0xff5a820f; WORD $0xffff // jb           LBB36_32, $-166(%rip)
+
+LBB36_61:
+	WORD $0xff48; BYTE $0xca                   // decq         %rdx
+	LONG $0x231d8d4c; WORD $0x0042; BYTE $0x00 // leaq         $16931(%rip), %r11  /* _Digits(%rip) */
+	WORD $0x9090; BYTE $0x90                   // .p2align 4, 0x90
+
+LBB36_62:
+	WORD $0xf089                               // movl         %esi, %eax
+	LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xf86b; BYTE $0x64                   // imull        $100, %eax, %edi
+	WORD $0xf389                               // movl         %esi, %ebx
+	WORD $0xfb29                               // subl         %edi, %ebx
+	LONG $0x3cb70f41; BYTE $0x5b               // movzwl       (%r11,%rbx,2), %edi
+	LONG $0xff7a8966                           // movw         %di, $-1(%rdx)
+	LONG $0xfec28348                           // addq         $-2, %rdx
+	LONG $0x270ffe81; WORD $0x0000             // cmpl         $9999, %esi
+	WORD $0xc689                               // movl         %eax, %esi
+	LONG $0xffd1870f; WORD $0xffff             // ja           LBB36_62, $-47(%rip)
+
+LBB36_63:
+	LONG $0x01578d49                           // leaq         $1(%r15), %rdx
+	WORD $0xf883; BYTE $0x0a                   // cmpl         $10, %eax
+	LONG $0x001f820f; WORD $0x0000             // jb           LBB36_65, $31(%rip)
+	WORD $0xc689                               // movl         %eax, %esi
+	LONG $0xdb3d8d48; WORD $0x0041; BYTE $0x00 // leaq         $16859(%rip), %rdi  /* _Digits(%rip) */
+	LONG $0x7704b60f                           // movzbl       (%rdi,%rsi,2), %eax
+	LONG $0x775cb60f; BYTE $0x01               // movzbl       $1(%rdi,%rsi,2), %ebx
+	LONG $0x01478841                           // movb         %al, $1(%r15)
+	LONG $0x025f8841                           // movb         %bl, $2(%r15)
+	LONG $0x000004e9; BYTE $0x00               // jmp          LBB36_66, $4(%rip)
+
+LBB36_65:
+	WORD $0x3004 // addb         $48, %al
+	WORD $0x0288 // movb         %al, (%rdx)
+
+LBB36_66:
+	WORD $0x294d; BYTE $0xc1     // subq         %r8, %r9
+	WORD $0x014d; BYTE $0xe9     // addq         %r13, %r9
+	LONG $0x000001be; BYTE $0x00 // movl         $1, %esi
+	WORD $0x294c; BYTE $0xc6     // subq         %r8, %rsi
+	WORD $0x9090; BYTE $0x90     // .p2align 4, 0x90
+
+LBB36_67:
+	WORD $0xff48; BYTE $0xce       // decq         %rsi
+	LONG $0x093c8041; BYTE $0x30   // cmpb         $48, (%r9,%rcx)
+	LONG $0xff498d4d               // leaq         $-1(%r9), %r9
+	LONG $0xffee840f; WORD $0xffff // je           LBB36_67, $-18(%rip)
+	WORD $0x8841; BYTE $0x07       // movb         %al, (%r15)
+	WORD $0x0148; BYTE $0xce       // addq         %rcx, %rsi
+	LONG $0x02fe8348               // cmpq         $2, %rsi
+	LONG $0x00458c0f; WORD $0x0000 // jl           LBB36_72, $69(%rip)
+	LONG $0x09048d49               // leaq         (%r9,%rcx), %rax
+	LONG $0x02c08348               // addq         $2, %rax
+	WORD $0x02c6; BYTE $0x2e       // movb         $46, (%rdx)
+	WORD $0x00c6; BYTE $0x65       // movb         $101, (%rax)
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0x00418e0f; WORD $0x0000 // jle          LBB36_73, $65(%rip)
+
+LBB36_70:
+	WORD $0xff41; BYTE $0xca       // decl         %r10d
+	LONG $0x2b0140c6               // movb         $43, $1(%rax)
+	WORD $0x8944; BYTE $0xd1       // movl         %r10d, %ecx
+	WORD $0xf983; BYTE $0x0a       // cmpl         $10, %ecx
+	LONG $0x0043820f; WORD $0x0000 // jb           LBB36_74, $67(%rip)
+
+LBB36_71:
+	WORD $0x6348; BYTE $0xc9                   // movslq       %ecx, %rcx
+	LONG $0x5a158d48; WORD $0x0041; BYTE $0x00 // leaq         $16730(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x4a0cb70f                           // movzwl       (%rdx,%rcx,2), %ecx
+	LONG $0x02488966                           // movw         %cx, $2(%rax)
+	LONG $0x04c08348                           // addq         $4, %rax
+	LONG $0x00097ae9; BYTE $0x00               // jmp          LBB36_92, $2426(%rip)
+
+LBB36_72:
+	LONG $0x09048d49               // leaq         (%r9,%rcx), %rax
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x00c6; BYTE $0x65       // movb         $101, (%rax)
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0xffbf8f0f; WORD $0xffff // jg           LBB36_70, $-65(%rip)
+
+LBB36_73:
+	LONG $0x2d0140c6               // movb         $45, $1(%rax)
+	LONG $0x000001b9; BYTE $0x00   // movl         $1, %ecx
+	WORD $0x2944; BYTE $0xd1       // subl         %r10d, %ecx
+	WORD $0xf983; BYTE $0x0a       // cmpl         $10, %ecx
+	LONG $0xffbd830f; WORD $0xffff // jae          LBB36_71, $-67(%rip)
+
+LBB36_74:
+	WORD $0xc180; BYTE $0x30     // addb         $48, %cl
+	WORD $0x4888; BYTE $0x02     // movb         %cl, $2(%rax)
+	LONG $0x03c08348             // addq         $3, %rax
+	LONG $0x000943e9; BYTE $0x00 // jmp          LBB36_92, $2371(%rip)
+
+LBB36_33:
+	WORD $0xd341; BYTE $0xef                   // shrl         %cl, %r15d
+	LONG $0xa0ff8141; WORD $0x0186; BYTE $0x00 // cmpl         $100000, %r15d
+	LONG $0x01a8820f; WORD $0x0000             // jb           LBB36_50, $424(%rip)
+	LONG $0x80ff8141; WORD $0x9896; BYTE $0x00 // cmpl         $10000000, %r15d
+	LONG $0x000008b8; BYTE $0x00               // movl         $8, %eax
+	LONG $0x00d88348                           // sbbq         $0, %rax
+	LONG $0x40ff8141; WORD $0x0f42; BYTE $0x00 // cmpl         $1000000, %r15d
+	LONG $0x000006b9; BYTE $0x00               // movl         $6, %ecx
+	LONG $0xc8430f48                           // cmovaeq      %rax, %rcx
+	WORD $0x014c; BYTE $0xe9                   // addq         %r13, %rcx
+
+LBB36_35:
+	WORD $0x8944; BYTE $0xf8                   // movl         %r15d, %eax
+	LONG $0xb71759ba; BYTE $0xd1               // movl         $3518437209, %edx
+	LONG $0xd0af0f48                           // imulq        %rax, %rdx
+	LONG $0x2deac148                           // shrq         $45, %rdx
+	LONG $0xd8f0c269; WORD $0xffff             // imull        $-10000, %edx, %eax
+	WORD $0x0144; BYTE $0xf8                   // addl         %r15d, %eax
+	LONG $0x1ff06948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rsi
+	LONG $0x25eec148                           // shrq         $37, %rsi
+	WORD $0xde6b; BYTE $0x64                   // imull        $100, %esi, %ebx
+	WORD $0xd829                               // subl         %ebx, %eax
+	LONG $0xaf1d8d48; WORD $0x0040; BYTE $0x00 // leaq         $16559(%rip), %rbx  /* _Digits(%rip) */
+	LONG $0x4304b70f                           // movzwl       (%rbx,%rax,2), %eax
+	LONG $0xfe418966                           // movw         %ax, $-2(%rcx)
+	LONG $0x7304b70f                           // movzwl       (%rbx,%rsi,2), %eax
+	LONG $0xfc418966                           // movw         %ax, $-4(%rcx)
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	LONG $0xfcc18348                           // addq         $-4, %rcx
+	WORD $0x8941; BYTE $0xd7                   // movl         %edx, %r15d
+	LONG $0x64ff8341                           // cmpl         $100, %r15d
+	LONG $0x0171830f; WORD $0x0000             // jae          LBB36_54, $369(%rip)
+	LONG $0x0001a8e9; BYTE $0x00               // jmp          LBB36_56, $424(%rip)
+
+LBB36_36:
+	WORD $0x8545; BYTE $0xd2                   // testl        %r10d, %r10d
+	LONG $0x04dc8f0f; WORD $0x0000             // jg           LBB36_102, $1244(%rip)
+	LONG $0x07c74166; WORD $0x2e30             // movw         $11824, (%r15)
+	LONG $0x02c78349                           // addq         $2, %r15
+	WORD $0x8545; BYTE $0xd2                   // testl        %r10d, %r10d
+	LONG $0x04c9890f; WORD $0x0000             // jns          LBB36_102, $1225(%rip)
+	WORD $0x8945; BYTE $0xe6                   // movl         %r12d, %r14d
+	WORD $0xf741; BYTE $0xd6                   // notl         %r14d
+	WORD $0x2945; BYTE $0xde                   // subl         %r11d, %r14d
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0x7ffe8341                           // cmpl         $127, %r14d
+	LONG $0x049d820f; WORD $0x0000             // jb           LBB36_100, $1181(%rip)
+	WORD $0x894c; BYTE $0xfb                   // movq         %r15, %rbx
+	WORD $0x894c; BYTE $0xef                   // movq         %r13, %rdi
+	WORD $0xff49; BYTE $0xc6                   // incq         %r14
+	WORD $0x894c; BYTE $0xf1                   // movq         %r14, %rcx
+	LONG $0x80e18348                           // andq         $-128, %rcx
+	LONG $0x80518d48                           // leaq         $-128(%rcx), %rdx
+	WORD $0x8949; BYTE $0xd5                   // movq         %rdx, %r13
+	LONG $0x07edc149                           // shrq         $7, %r13
+	WORD $0xff49; BYTE $0xc5                   // incq         %r13
+	WORD $0x8945; BYTE $0xef                   // movl         %r13d, %r15d
+	LONG $0x03e78341                           // andl         $3, %r15d
+	LONG $0x80fa8148; WORD $0x0001; BYTE $0x00 // cmpq         $384, %rdx
+	LONG $0x036a830f; WORD $0x0000             // jae          LBB36_94, $874(%rip)
+	WORD $0xd231                               // xorl         %edx, %edx
+	LONG $0x00040de9; BYTE $0x00               // jmp          LBB36_96, $1037(%rip)
+
+LBB36_41:
+	WORD $0x8948; BYTE $0xca       // movq         %rcx, %rdx
+	WORD $0x8945; BYTE $0xd3       // movl         %r10d, %r11d
+	WORD $0xf883; BYTE $0x64       // cmpl         $100, %eax
+	LONG $0xfdac820f; WORD $0xffff // jb           LBB36_30, $-596(%rip)
+
+LBB36_42:
+	WORD $0xff48; BYTE $0xca                   // decq         %rdx
+	LONG $0x03358d4c; WORD $0x0040; BYTE $0x00 // leaq         $16387(%rip), %r14  /* _Digits(%rip) */
+	WORD $0x9090; BYTE $0x90                   // .p2align 4, 0x90
+
+LBB36_43:
+	WORD $0xc689                               // movl         %eax, %esi
+	LONG $0x1ff66948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rsi, %rsi
+	LONG $0x25eec148                           // shrq         $37, %rsi
+	WORD $0xfe6b; BYTE $0x64                   // imull        $100, %esi, %edi
+	WORD $0xc389                               // movl         %eax, %ebx
+	WORD $0xfb29                               // subl         %edi, %ebx
+	LONG $0x3cb70f41; BYTE $0x5e               // movzwl       (%r14,%rbx,2), %edi
+	LONG $0xff7a8966                           // movw         %di, $-1(%rdx)
+	LONG $0xfec28348                           // addq         $-2, %rdx
+	LONG $0x00270f3d; BYTE $0x00               // cmpl         $9999, %eax
+	WORD $0xf089                               // movl         %esi, %eax
+	LONG $0xffd2870f; WORD $0xffff             // ja           LBB36_43, $-46(%rip)
+
+LBB36_44:
+	WORD $0xfe83; BYTE $0x0a                   // cmpl         $10, %esi
+	LONG $0x0022820f; WORD $0x0000             // jb           LBB36_46, $34(%rip)
+	WORD $0xf089                               // movl         %esi, %eax
+	LONG $0xc0158d48; WORD $0x003f; BYTE $0x00 // leaq         $16320(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x4204b70f                           // movzwl       (%rdx,%rax,2), %eax
+	LONG $0x07894166                           // movw         %ax, (%r15)
+	WORD $0x014d; BYTE $0xdf                   // addq         %r11, %r15
+	WORD $0x3945; BYTE $0xd4                   // cmpl         %r10d, %r12d
+	LONG $0x0018820f; WORD $0x0000             // jb           LBB36_47, $24(%rip)
+	LONG $0x0002e6e9; BYTE $0x00               // jmp          LBB36_91, $742(%rip)
+
+LBB36_46:
+	LONG $0x30c68040               // addb         $48, %sil
+	WORD $0x8841; BYTE $0x37       // movb         %sil, (%r15)
+	WORD $0x014d; BYTE $0xdf       // addq         %r11, %r15
+	WORD $0x3945; BYTE $0xd4       // cmpl         %r10d, %r12d
+	LONG $0x02d3830f; WORD $0x0000 // jae          LBB36_91, $723(%rip)
+
+LBB36_47:
+	LONG $0x29048d4b                           // leaq         (%r9,%r13), %rax
+	LONG $0x00148d49                           // leaq         (%r8,%rax), %rdx
+	WORD $0xff48; BYTE $0xc2                   // incq         %rdx
+	WORD $0x0149; BYTE $0xc3                   // addq         %rax, %r11
+	WORD $0x394c; BYTE $0xda                   // cmpq         %r11, %rdx
+	LONG $0xda470f4c                           // cmovaq       %rdx, %r11
+	WORD $0x014c; BYTE $0xc0                   // addq         %r8, %rax
+	WORD $0x2949; BYTE $0xc3                   // subq         %rax, %r11
+	LONG $0x10fb8349                           // cmpq         $16, %r11
+	LONG $0x029f820f; WORD $0x0000             // jb           LBB36_90, $671(%rip)
+	LONG $0x80fb8149; WORD $0x0000; BYTE $0x00 // cmpq         $128, %r11
+	LONG $0x00cf830f; WORD $0x0000             // jae          LBB36_75, $207(%rip)
+	WORD $0x3145; BYTE $0xd2                   // xorl         %r10d, %r10d
+	LONG $0x000211e9; BYTE $0x00               // jmp          LBB36_84, $529(%rip)
+
+LBB36_50:
+	LONG $0x000001b8; BYTE $0x00               // movl         $1, %eax
+	LONG $0x0aff8341                           // cmpl         $10, %r15d
+	LONG $0x0021820f; WORD $0x0000             // jb           LBB36_53, $33(%rip)
+	LONG $0x000002b8; BYTE $0x00               // movl         $2, %eax
+	LONG $0x64ff8341                           // cmpl         $100, %r15d
+	LONG $0x0012820f; WORD $0x0000             // jb           LBB36_53, $18(%rip)
+	LONG $0x000003b8; BYTE $0x00               // movl         $3, %eax
+	LONG $0xe7ff8141; WORD $0x0003; BYTE $0x00 // cmpl         $999, %r15d
+	LONG $0x022b870f; WORD $0x0000             // ja           LBB36_87, $555(%rip)
+
+LBB36_53:
+	WORD $0x014c; BYTE $0xe8       // addq         %r13, %rax
+	WORD $0x8948; BYTE $0xc1       // movq         %rax, %rcx
+	LONG $0x64ff8341               // cmpl         $100, %r15d
+	LONG $0x003c820f; WORD $0x0000 // jb           LBB36_56, $60(%rip)
+
+LBB36_54:
+	WORD $0xff48; BYTE $0xc9                   // decq         %rcx
+	LONG $0x10058d4c; WORD $0x003f; BYTE $0x00 // leaq         $16144(%rip), %r8  /* _Digits(%rip) */
+
+	// .p2align 4, 0x90
+LBB36_55:
+	WORD $0x8944; BYTE $0xfb                   // movl         %r15d, %ebx
+	WORD $0x8944; BYTE $0xfe                   // movl         %r15d, %esi
+	LONG $0x1ffe694c; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rsi, %r15
+	LONG $0x25efc149                           // shrq         $37, %r15
+	LONG $0x64f76b41                           // imull        $100, %r15d, %esi
+	WORD $0xda89                               // movl         %ebx, %edx
+	WORD $0xf229                               // subl         %esi, %edx
+	LONG $0x14b70f41; BYTE $0x50               // movzwl       (%r8,%rdx,2), %edx
+	LONG $0xff518966                           // movw         %dx, $-1(%rcx)
+	LONG $0xfec18348                           // addq         $-2, %rcx
+	LONG $0x270ffb81; WORD $0x0000             // cmpl         $9999, %ebx
+	LONG $0xffce870f; WORD $0xffff             // ja           LBB36_55, $-50(%rip)
+
+LBB36_56:
+	LONG $0x0aff8341                           // cmpl         $10, %r15d
+	LONG $0x001a820f; WORD $0x0000             // jb           LBB36_58, $26(%rip)
+	WORD $0x8944; BYTE $0xf9                   // movl         %r15d, %ecx
+	LONG $0xca158d48; WORD $0x003e; BYTE $0x00 // leaq         $16074(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x4a0cb70f                           // movzwl       (%rdx,%rcx,2), %ecx
+	LONG $0x4d894166; BYTE $0x00               // movw         %cx, (%r13)
+	WORD $0xf829                               // subl         %edi, %eax
+	LONG $0x0006eee9; BYTE $0x00               // jmp          LBB36_93, $1774(%rip)
+
+LBB36_58:
+	LONG $0x30c78041             // addb         $48, %r15b
+	LONG $0x007d8845             // movb         %r15b, (%r13)
+	WORD $0xf829                 // subl         %edi, %eax
+	LONG $0x0006dfe9; BYTE $0x00 // jmp          LBB36_93, $1759(%rip)
+
+LBB36_59:
+	LONG $0x0004b841; WORD $0x0000 // movl         $4, %r8d
+	LONG $0xfcc28348               // addq         $-4, %rdx
+	WORD $0xfe83; BYTE $0x64       // cmpl         $100, %esi
+	LONG $0xfbc5820f; WORD $0xffff // jb           LBB36_32, $-1083(%rip)
+	LONG $0xfffc66e9; BYTE $0xff   // jmp          LBB36_61, $-922(%rip)
+
+LBB36_75:
+	WORD $0x894d; BYTE $0xda       // movq         %r11, %r10
+	LONG $0x80e28349               // andq         $-128, %r10
+	LONG $0x80428d49               // leaq         $-128(%r10), %rax
+	WORD $0x8948; BYTE $0xc2       // movq         %rax, %rdx
+	LONG $0x07eac148               // shrq         $7, %rdx
+	WORD $0xff48; BYTE $0xc2       // incq         %rdx
+	WORD $0x8941; BYTE $0xd6       // movl         %edx, %r14d
+	LONG $0x03e68341               // andl         $3, %r14d
+	LONG $0x01803d48; WORD $0x0000 // cmpq         $384, %rax
+	LONG $0x0007830f; WORD $0x0000 // jae          LBB36_77, $7(%rip)
+	WORD $0xf631                   // xorl         %esi, %esi
+	LONG $0x0000b5e9; BYTE $0x00   // jmp          LBB36_79, $181(%rip)
+
+LBB36_77:
+	LONG $0xfce28348                     // andq         $-4, %rdx
+	LONG $0x01048d4b                     // leaq         (%r9,%r8), %rax
+	WORD $0x014c; BYTE $0xe8             // addq         %r13, %rax
+	LONG $0x01e00548; WORD $0x0000       // addq         $480, %rax
+	WORD $0xf631                         // xorl         %esi, %esi
+	QUAD $0xfffff849056ffdc5             // vmovdqa      $-1975(%rip), %ymm0  /* LCPI36_0(%rip) */
+	QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB36_78:
+	QUAD $0xfffe2030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-480(%rax,%rsi)
+	QUAD $0xfffe4030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-448(%rax,%rsi)
+	QUAD $0xfffe6030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-416(%rax,%rsi)
+	QUAD $0xfffe8030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-384(%rax,%rsi)
+	QUAD $0xfffea030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-352(%rax,%rsi)
+	QUAD $0xfffec030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-320(%rax,%rsi)
+	QUAD $0xfffee030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-288(%rax,%rsi)
+	QUAD $0xffff0030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-256(%rax,%rsi)
+	QUAD $0xffff2030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-224(%rax,%rsi)
+	QUAD $0xffff4030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-192(%rax,%rsi)
+	QUAD $0xffff6030847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-160(%rax,%rsi)
+	LONG $0x447ffec5; WORD $0x8030             // vmovdqu      %ymm0, $-128(%rax,%rsi)
+	LONG $0x447ffec5; WORD $0xa030             // vmovdqu      %ymm0, $-96(%rax,%rsi)
+	LONG $0x447ffec5; WORD $0xc030             // vmovdqu      %ymm0, $-64(%rax,%rsi)
+	LONG $0x447ffec5; WORD $0xe030             // vmovdqu      %ymm0, $-32(%rax,%rsi)
+	LONG $0x047ffec5; BYTE $0x30               // vmovdqu      %ymm0, (%rax,%rsi)
+	LONG $0x00c68148; WORD $0x0002; BYTE $0x00 // addq         $512, %rsi
+	LONG $0xfcc28348                           // addq         $-4, %rdx
+	LONG $0xff6f850f; WORD $0xffff             // jne          LBB36_78, $-145(%rip)
+
+LBB36_79:
+	WORD $0x854d; BYTE $0xf6               // testq        %r14, %r14
+	LONG $0x004a840f; WORD $0x0000         // je           LBB36_82, $74(%rip)
+	WORD $0x014c; BYTE $0xce               // addq         %r9, %rsi
+	WORD $0x014c; BYTE $0xc6               // addq         %r8, %rsi
+	LONG $0x2e048d4a                       // leaq         (%rsi,%r13), %rax
+	LONG $0x60c08348                       // addq         $96, %rax
+	LONG $0x07e6c149                       // shlq         $7, %r14
+	WORD $0xd231                           // xorl         %edx, %edx
+	QUAD $0xfffff78a056ffdc5               // vmovdqa      $-2166(%rip), %ymm0  /* LCPI36_0(%rip) */
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB36_81:
+	LONG $0x447ffec5; WORD $0xa010 // vmovdqu      %ymm0, $-96(%rax,%rdx)
+	LONG $0x447ffec5; WORD $0xc010 // vmovdqu      %ymm0, $-64(%rax,%rdx)
+	LONG $0x447ffec5; WORD $0xe010 // vmovdqu      %ymm0, $-32(%rax,%rdx)
+	LONG $0x047ffec5; BYTE $0x10   // vmovdqu      %ymm0, (%rax,%rdx)
+	LONG $0x80ea8348               // subq         $-128, %rdx
+	WORD $0x3949; BYTE $0xd6       // cmpq         %rdx, %r14
+	LONG $0xffdc850f; WORD $0xffff // jne          LBB36_81, $-36(%rip)
+
+LBB36_82:
+	WORD $0x394d; BYTE $0xd3       // cmpq         %r10, %r11
+	LONG $0x0092840f; WORD $0x0000 // je           LBB36_91, $146(%rip)
+	LONG $0x70c3f641               // testb        $112, %r11b
+	LONG $0x0071840f; WORD $0x0000 // je           LBB36_89, $113(%rip)
+
+LBB36_84:
+	WORD $0x894c; BYTE $0xd8       // movq         %r11, %rax
+	LONG $0xf0e08348               // andq         $-16, %rax
+	WORD $0x0148; BYTE $0xc1       // addq         %rax, %rcx
+	WORD $0x014d; BYTE $0xd1       // addq         %r10, %r9
+	WORD $0x014d; BYTE $0xc1       // addq         %r8, %r9
+	WORD $0x014d; BYTE $0xe9       // addq         %r13, %r9
+	WORD $0x8948; BYTE $0xc2       // movq         %rax, %rdx
+	WORD $0x294c; BYTE $0xd2       // subq         %r10, %rdx
+	WORD $0xf631                   // xorl         %esi, %esi
+	QUAD $0xfffff746056ff9c5       // vmovdqa      $-2234(%rip), %xmm0  /* LCPI36_1(%rip) */
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB36_85:
+	LONG $0x7f7ac1c4; WORD $0x3104 // vmovdqu      %xmm0, (%r9,%rsi)
+	LONG $0x10c68348               // addq         $16, %rsi
+	WORD $0x3948; BYTE $0xf2       // cmpq         %rsi, %rdx
+	LONG $0xffed850f; WORD $0xffff // jne          LBB36_85, $-19(%rip)
+	WORD $0x3949; BYTE $0xc3       // cmpq         %rax, %r11
+	LONG $0x0034850f; WORD $0x0000 // jne          LBB36_90, $52(%rip)
+	LONG $0x00003ee9; BYTE $0x00   // jmp          LBB36_91, $62(%rip)
+
+LBB36_87:
+	LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl         $10000, %r15d
+	WORD $0x894c; BYTE $0xe9                   // movq         %r13, %rcx
+	LONG $0x00d98348                           // sbbq         $0, %rcx
+	LONG $0x05c18348                           // addq         $5, %rcx
+	LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl         $10000, %r15d
+	LONG $0xfc01830f; WORD $0xffff             // jae          LBB36_35, $-1023(%rip)
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	LONG $0xfffdbee9; BYTE $0xff               // jmp          LBB36_54, $-578(%rip)
+
+LBB36_89:
+	WORD $0x014c; BYTE $0xd1     // addq         %r10, %rcx
+	LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB36_90:
+	WORD $0x01c6; BYTE $0x30       // movb         $48, (%rcx)
+	WORD $0xff48; BYTE $0xc1       // incq         %rcx
+	WORD $0x394c; BYTE $0xf9       // cmpq         %r15, %rcx
+	LONG $0xfff1820f; WORD $0xffff // jb           LBB36_90, $-15(%rip)
+
+LBB36_91:
+	WORD $0x894c; BYTE $0xf8     // movq         %r15, %rax
+	LONG $0x0004eae9; BYTE $0x00 // jmp          LBB36_92, $1258(%rip)
+
+LBB36_94:
+	LONG $0xfce58349                           // andq         $-4, %r13
+	LONG $0x39348d49                           // leaq         (%r9,%rdi), %rsi
+	LONG $0xe2c68148; WORD $0x0001; BYTE $0x00 // addq         $482, %rsi
+	WORD $0xd231                               // xorl         %edx, %edx
+	QUAD $0xfffff6a0056ffdc5                   // vmovdqa      $-2400(%rip), %ymm0  /* LCPI36_0(%rip) */
+
+LBB36_95:
+	QUAD $0xfffe2016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-480(%rsi,%rdx)
+	QUAD $0xfffe4016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-448(%rsi,%rdx)
+	QUAD $0xfffe6016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-416(%rsi,%rdx)
+	QUAD $0xfffe8016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-384(%rsi,%rdx)
+	QUAD $0xfffea016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-352(%rsi,%rdx)
+	QUAD $0xfffec016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-320(%rsi,%rdx)
+	QUAD $0xfffee016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-288(%rsi,%rdx)
+	QUAD $0xffff0016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-256(%rsi,%rdx)
+	QUAD $0xffff2016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-224(%rsi,%rdx)
+	QUAD $0xffff4016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-192(%rsi,%rdx)
+	QUAD $0xffff6016847ffec5; BYTE $0xff       // vmovdqu      %ymm0, $-160(%rsi,%rdx)
+	LONG $0x447ffec5; WORD $0x8016             // vmovdqu      %ymm0, $-128(%rsi,%rdx)
+	LONG $0x447ffec5; WORD $0xa016             // vmovdqu      %ymm0, $-96(%rsi,%rdx)
+	LONG $0x447ffec5; WORD $0xc016             // vmovdqu      %ymm0, $-64(%rsi,%rdx)
+	LONG $0x447ffec5; WORD $0xe016             // vmovdqu      %ymm0, $-32(%rsi,%rdx)
+	LONG $0x047ffec5; BYTE $0x16               // vmovdqu      %ymm0, (%rsi,%rdx)
+	LONG $0x00c28148; WORD $0x0002; BYTE $0x00 // addq         $512, %rdx
+	LONG $0xfcc58349                           // addq         $-4, %r13
+	LONG $0xff6f850f; WORD $0xffff             // jne          LBB36_95, $-145(%rip)
+
+LBB36_96:
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	WORD $0x8949; BYTE $0xfd       // movq         %rdi, %r13
+	LONG $0x003c840f; WORD $0x0000 // je           LBB36_99, $60(%rip)
+	WORD $0x014c; BYTE $0xca       // addq         %r9, %rdx
+	WORD $0x014c; BYTE $0xea       // addq         %r13, %rdx
+	LONG $0x62c28348               // addq         $98, %rdx
+	LONG $0x07e7c149               // shlq         $7, %r15
+	WORD $0xf631                   // xorl         %esi, %esi
+	QUAD $0xfffff5eb056ffdc5       // vmovdqa      $-2581(%rip), %ymm0  /* LCPI36_0(%rip) */
+
+LBB36_98:
+	LONG $0x447ffec5; WORD $0xa032 // vmovdqu      %ymm0, $-96(%rdx,%rsi)
+	LONG $0x447ffec5; WORD $0xc032 // vmovdqu      %ymm0, $-64(%rdx,%rsi)
+	LONG $0x447ffec5; WORD $0xe032 // vmovdqu      %ymm0, $-32(%rdx,%rsi)
+	LONG $0x047ffec5; BYTE $0x32   // vmovdqu      %ymm0, (%rdx,%rsi)
+	LONG $0x80ee8348               // subq         $-128, %rsi
+	WORD $0x3949; BYTE $0xf7       // cmpq         %rsi, %r15
+	LONG $0xffdc850f; WORD $0xffff // jne          LBB36_98, $-36(%rip)
+
+LBB36_99:
+	WORD $0x8949; BYTE $0xdf       // movq         %rbx, %r15
+	WORD $0x0149; BYTE $0xcf       // addq         %rcx, %r15
+	WORD $0x3949; BYTE $0xce       // cmpq         %rcx, %r14
+	LONG $0x0017840f; WORD $0x0000 // je           LBB36_102, $23(%rip)
+
+LBB36_100:
+	WORD $0x0144; BYTE $0xd1 // addl         %r10d, %ecx
+	WORD $0xd9f7             // negl         %ecx
+	WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB36_101:
+	LONG $0x3007c641               // movb         $48, (%r15)
+	WORD $0xff49; BYTE $0xc7       // incq         %r15
+	WORD $0xc9ff                   // decl         %ecx
+	LONG $0xfff1850f; WORD $0xffff // jne          LBB36_101, $-15(%rip)
+
+LBB36_102:
+	LONG $0xd07d894c                           // movq         %r15, $-48(%rbp)
+	WORD $0x014d; BYTE $0xc7                   // addq         %r8, %r15
+	LONG $0x0027103d; BYTE $0x00               // cmpl         $10000, %eax
+	LONG $0x005f820f; WORD $0x0000             // jb           LBB36_105, $95(%rip)
+	WORD $0xc289                               // movl         %eax, %edx
+	LONG $0xb71759bb; BYTE $0xd1               // movl         $3518437209, %ebx
+	LONG $0xdaaf0f48                           // imulq        %rdx, %rbx
+	LONG $0x2debc148                           // shrq         $45, %rbx
+	LONG $0xd8f0d369; WORD $0xffff             // imull        $-10000, %ebx, %edx
+	WORD $0xc201                               // addl         %eax, %edx
+	LONG $0x01c3840f; WORD $0x0000             // je           LBB36_107, $451(%rip)
+	WORD $0xd089                               // movl         %edx, %eax
+	LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xf06b; BYTE $0x64                   // imull        $100, %eax, %esi
+	WORD $0xf229                               // subl         %esi, %edx
+	LONG $0x59358d48; WORD $0x003b; BYTE $0x00 // leaq         $15193(%rip), %rsi  /* _Digits(%rip) */
+	LONG $0x5614b70f                           // movzwl       (%rsi,%rdx,2), %edx
+	LONG $0x57894166; BYTE $0xfe               // movw         %dx, $-2(%r15)
+	LONG $0x4604b70f                           // movzwl       (%rsi,%rax,2), %eax
+	LONG $0x47894166; BYTE $0xfc               // movw         %ax, $-4(%r15)
+	WORD $0x3145; BYTE $0xf6                   // xorl         %r14d, %r14d
+	LONG $0xfc578d49                           // leaq         $-4(%r15), %rdx
+	WORD $0xfb83; BYTE $0x64                   // cmpl         $100, %ebx
+	LONG $0x0018830f; WORD $0x0000             // jae          LBB36_109, $24(%rip)
+
+LBB36_106:
+	WORD $0xd889                 // movl         %ebx, %eax
+	LONG $0x00004ee9; BYTE $0x00 // jmp          LBB36_111, $78(%rip)
+
+LBB36_105:
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	WORD $0x894c; BYTE $0xfa       // movq         %r15, %rdx
+	WORD $0xc389                   // movl         %eax, %ebx
+	WORD $0xfb83; BYTE $0x64       // cmpl         $100, %ebx
+	LONG $0xffe8820f; WORD $0xffff // jb           LBB36_106, $-24(%rip)
+
+LBB36_109:
+	WORD $0xff48; BYTE $0xca                   // decq         %rdx
+	LONG $0x15358d48; WORD $0x003b; BYTE $0x00 // leaq         $15125(%rip), %rsi  /* _Digits(%rip) */
+	LONG $0x90909090; BYTE $0x90               // .p2align 4, 0x90
+
+LBB36_110:
+	WORD $0xd889                               // movl         %ebx, %eax
+	LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xf86b; BYTE $0x64                   // imull        $100, %eax, %edi
+	WORD $0xd989                               // movl         %ebx, %ecx
+	WORD $0xf929                               // subl         %edi, %ecx
+	LONG $0x4e0cb70f                           // movzwl       (%rsi,%rcx,2), %ecx
+	LONG $0xff4a8966                           // movw         %cx, $-1(%rdx)
+	LONG $0xfec28348                           // addq         $-2, %rdx
+	LONG $0x270ffb81; WORD $0x0000             // cmpl         $9999, %ebx
+	WORD $0xc389                               // movl         %eax, %ebx
+	LONG $0xffd2870f; WORD $0xffff             // ja           LBB36_110, $-46(%rip)
+
+LBB36_111:
+	WORD $0x894d; BYTE $0xe9                   // movq         %r13, %r9
+	WORD $0xf883; BYTE $0x0a                   // cmpl         $10, %eax
+	LONG $0x0019820f; WORD $0x0000             // jb           LBB36_113, $25(%rip)
+	WORD $0xc089                               // movl         %eax, %eax
+	LONG $0xcd0d8d48; WORD $0x003a; BYTE $0x00 // leaq         $15053(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	LONG $0xd04d8b48                           // movq         $-48(%rbp), %rcx
+	WORD $0x8966; BYTE $0x01                   // movw         %ax, (%rcx)
+	LONG $0x000008e9; BYTE $0x00               // jmp          LBB36_114, $8(%rip)
+
+LBB36_113:
+	WORD $0x3004     // addb         $48, %al
+	LONG $0xd04d8b48 // movq         $-48(%rbp), %rcx
+	WORD $0x0188     // movb         %al, (%rcx)
+
+LBB36_114:
+	WORD $0x294d; BYTE $0xf7 // subq         %r14, %r15
+	WORD $0x294d; BYTE $0xf0 // subq         %r14, %r8
+	WORD $0xff49; BYTE $0xc0 // incq         %r8
+	LONG $0x1e048d43         // leal         (%r14,%r11), %eax
+	WORD $0xd8f6             // negb         %al
+	LONG $0x33148d43         // leal         (%r11,%r14), %edx
+	WORD $0xdaf7             // negl         %edx
+	LONG $0x332c8d47         // leal         (%r11,%r14), %r13d
+	WORD $0xff41; BYTE $0xcd // decl         %r13d
+	LONG $0x33348d43         // leal         (%r11,%r14), %esi
+	WORD $0xc683; BYTE $0xfe // addl         $-2, %esi
+	WORD $0xc931             // xorl         %ecx, %ecx
+
+	// .p2align 4, 0x90
+LBB36_115:
+	WORD $0xc389                   // movl         %eax, %ebx
+	WORD $0x438d; BYTE $0x03       // leal         $3(%rbx), %eax
+	WORD $0xc6ff                   // incl         %esi
+	LONG $0x0f7c8041; WORD $0x30ff // cmpb         $48, $-1(%r15,%rcx)
+	LONG $0xff498d48               // leaq         $-1(%rcx), %rcx
+	LONG $0xffe9840f; WORD $0xffff // je           LBB36_115, $-23(%rip)
+	LONG $0x0f048d49               // leaq         (%r15,%rcx), %rax
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0x00b28e0f; WORD $0x0000 // jle          LBB36_121, $178(%rip)
+	WORD $0x2945; BYTE $0xf4       // subl         %r14d, %r12d
+	LONG $0x0c3c8d41               // leal         (%r12,%rcx), %edi
+	WORD $0xc7ff                   // incl         %edi
+	WORD $0x3941; BYTE $0xfa       // cmpl         %edi, %r10d
+	LONG $0x002d8d0f; WORD $0x0000 // jge          LBB36_122, $45(%rip)
+	WORD $0x6348; BYTE $0xc2       // movslq       %edx, %rax
+	LONG $0x08348d48               // leaq         (%rax,%rcx), %rsi
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0xf685                   // testl        %esi, %esi
+	WORD $0x894d; BYTE $0xcd       // movq         %r9, %r13
+	LONG $0x011a8e0f; WORD $0x0000 // jle          LBB36_133, $282(%rip)
+	WORD $0x8941; BYTE $0xf0       // movl         %esi, %r8d
+	LONG $0xff508d49               // leaq         $-1(%r8), %rdx
+	LONG $0x03fa8348               // cmpq         $3, %rdx
+	LONG $0x009a830f; WORD $0x0000 // jae          LBB36_127, $154(%rip)
+	WORD $0xd231                   // xorl         %edx, %edx
+	LONG $0x0000c6e9; BYTE $0x00   // jmp          LBB36_130, $198(%rip)
+
+LBB36_122:
+	WORD $0x8945; BYTE $0xea                   // movl         %r13d, %r10d
+	WORD $0x2949; BYTE $0xca                   // subq         %rcx, %r10
+	WORD $0x8545; BYTE $0xd2                   // testl        %r10d, %r10d
+	LONG $0x00648e0f; WORD $0x0000             // jle          LBB36_121, $100(%rip)
+	LONG $0x331c8d43                           // leal         (%r11,%r14), %ebx
+	WORD $0xc383; BYTE $0xfe                   // addl         $-2, %ebx
+	WORD $0x2948; BYTE $0xcb                   // subq         %rcx, %rbx
+	WORD $0xd231                               // xorl         %edx, %edx
+	WORD $0xfb83; BYTE $0x7f                   // cmpl         $127, %ebx
+	WORD $0x894d; BYTE $0xcd                   // movq         %r9, %r13
+	LONG $0x0223820f; WORD $0x0000             // jb           LBB36_140, $547(%rip)
+	WORD $0x0145; BYTE $0xde                   // addl         %r11d, %r14d
+	LONG $0xfec68341                           // addl         $-2, %r14d
+	WORD $0x2949; BYTE $0xce                   // subq         %rcx, %r14
+	WORD $0x8941; BYTE $0xdb                   // movl         %ebx, %r11d
+	WORD $0xff49; BYTE $0xc3                   // incq         %r11
+	WORD $0x894c; BYTE $0xda                   // movq         %r11, %rdx
+	LONG $0x80e28348                           // andq         $-128, %rdx
+	LONG $0xd07d8b48                           // movq         $-48(%rbp), %rdi
+	WORD $0x014c; BYTE $0xc7                   // addq         %r8, %rdi
+	WORD $0xf089                               // movl         %esi, %eax
+	WORD $0xff48; BYTE $0xc0                   // incq         %rax
+	LONG $0x80e08348                           // andq         $-128, %rax
+	WORD $0x0148; BYTE $0xf8                   // addq         %rdi, %rax
+	LONG $0x80728d48                           // leaq         $-128(%rdx), %rsi
+	WORD $0x8949; BYTE $0xf0                   // movq         %rsi, %r8
+	LONG $0x07e8c149                           // shrq         $7, %r8
+	WORD $0xff49; BYTE $0xc0                   // incq         %r8
+	LONG $0x80fe8148; WORD $0x0001; BYTE $0x00 // cmpq         $384, %rsi
+	LONG $0x00ae830f; WORD $0x0000             // jae          LBB36_134, $174(%rip)
+	WORD $0xf631                               // xorl         %esi, %esi
+	LONG $0x000163e9; BYTE $0x00               // jmp          LBB36_136, $355(%rip)
+
+LBB36_121:
+	WORD $0x894d; BYTE $0xcd     // movq         %r9, %r13
+	LONG $0x0001e0e9; BYTE $0x00 // jmp          LBB36_92, $480(%rip)
+
+LBB36_107:
+	LONG $0x0004be41; WORD $0x0000 // movl         $4, %r14d
+	LONG $0xfc578d49               // leaq         $-4(%r15), %rdx
+	WORD $0xfb83; BYTE $0x64       // cmpl         $100, %ebx
+	LONG $0xfe65820f; WORD $0xffff // jb           LBB36_106, $-411(%rip)
+	LONG $0xfffe78e9; BYTE $0xff   // jmp          LBB36_109, $-392(%rip)
+
+LBB36_127:
+	WORD $0xe683; BYTE $0xfc                                             // andl         $-4, %esi
+	WORD $0xf748; BYTE $0xde                                             // negq         %rsi
+	WORD $0xd231                                                         // xorl         %edx, %edx
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB36_128:
+	LONG $0x173c8d49               // leaq         (%r15,%rdx), %rdi
+	LONG $0xfd39448b               // movl         $-3(%rcx,%rdi), %eax
+	LONG $0xfe394489               // movl         %eax, $-2(%rcx,%rdi)
+	LONG $0xfcc28348               // addq         $-4, %rdx
+	WORD $0x3948; BYTE $0xd6       // cmpq         %rdx, %rsi
+	LONG $0xffe7850f; WORD $0xffff // jne          LBB36_128, $-25(%rip)
+	WORD $0xf748; BYTE $0xda       // negq         %rdx
+
+LBB36_130:
+	LONG $0x03c0f641                     // testb        $3, %r8b
+	LONG $0x0032840f; WORD $0x0000       // je           LBB36_133, $50(%rip)
+	WORD $0xb60f; BYTE $0xc3             // movzbl       %bl, %eax
+	WORD $0xe083; BYTE $0x03             // andl         $3, %eax
+	WORD $0xf748; BYTE $0xd8             // negq         %rax
+	WORD $0x894c; BYTE $0xfe             // movq         %r15, %rsi
+	WORD $0x2948; BYTE $0xd6             // subq         %rdx, %rsi
+	WORD $0xd231                         // xorl         %edx, %edx
+	QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB36_132:
+	LONG $0x163c8d48               // leaq         (%rsi,%rdx), %rdi
+	LONG $0x391cb60f               // movzbl       (%rcx,%rdi), %ebx
+	LONG $0x01395c88               // movb         %bl, $1(%rcx,%rdi)
+	WORD $0xff48; BYTE $0xca       // decq         %rdx
+	WORD $0x3948; BYTE $0xd0       // cmpq         %rdx, %rax
+	LONG $0xffe8850f; WORD $0xffff // jne          LBB36_132, $-24(%rip)
+
+LBB36_133:
+	WORD $0x8944; BYTE $0xd0     // movl         %r10d, %eax
+	LONG $0xd0558b48             // movq         $-48(%rbp), %rdx
+	LONG $0x2e0204c6             // movb         $46, (%rdx,%rax)
+	LONG $0x0f048d49             // leaq         (%r15,%rcx), %rax
+	LONG $0x02c08348             // addq         $2, %rax
+	LONG $0x000141e9; BYTE $0x00 // jmp          LBB36_92, $321(%rip)
+
+LBB36_134:
+	WORD $0x8944; BYTE $0xf3 // movl         %r14d, %ebx
+	WORD $0xff48; BYTE $0xc3 // incq         %rbx
+	LONG $0x80e38348         // andq         $-128, %rbx
+	LONG $0x80c38348         // addq         $-128, %rbx
+	LONG $0x07ebc148         // shrq         $7, %rbx
+	WORD $0xff48; BYTE $0xc3 // incq         %rbx
+	LONG $0xfce38348         // andq         $-4, %rbx
+	WORD $0xf631             // xorl         %esi, %esi
+	QUAD $0xfffff2ed056ffdc5 // vmovdqa      $-3347(%rip), %ymm0  /* LCPI36_0(%rip) */
+
+LBB36_135:
+	LONG $0x373c8d49                           // leaq         (%r15,%rsi), %rdi
+	LONG $0x447ffec5; WORD $0x0139             // vmovdqu      %ymm0, $1(%rcx,%rdi)
+	LONG $0x447ffec5; WORD $0x2139             // vmovdqu      %ymm0, $33(%rcx,%rdi)
+	LONG $0x447ffec5; WORD $0x4139             // vmovdqu      %ymm0, $65(%rcx,%rdi)
+	LONG $0x447ffec5; WORD $0x6139             // vmovdqu      %ymm0, $97(%rcx,%rdi)
+	QUAD $0x00008139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $129(%rcx,%rdi)
+	QUAD $0x0000a139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $161(%rcx,%rdi)
+	QUAD $0x0000c139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $193(%rcx,%rdi)
+	QUAD $0x0000e139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $225(%rcx,%rdi)
+	QUAD $0x00010139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $257(%rcx,%rdi)
+	QUAD $0x00012139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $289(%rcx,%rdi)
+	QUAD $0x00014139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $321(%rcx,%rdi)
+	QUAD $0x00016139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $353(%rcx,%rdi)
+	QUAD $0x00018139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $385(%rcx,%rdi)
+	QUAD $0x0001a139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $417(%rcx,%rdi)
+	QUAD $0x0001c139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $449(%rcx,%rdi)
+	QUAD $0x0001e139847ffec5; BYTE $0x00       // vmovdqu      %ymm0, $481(%rcx,%rdi)
+	LONG $0x00c68148; WORD $0x0002; BYTE $0x00 // addq         $512, %rsi
+	LONG $0xfcc38348                           // addq         $-4, %rbx
+	LONG $0xff67850f; WORD $0xffff             // jne          LBB36_135, $-153(%rip)
+
+LBB36_136:
+	WORD $0x0148; BYTE $0xc8                   // addq         %rcx, %rax
+	LONG $0x03c0f641                           // testb        $3, %r8b
+	LONG $0x005a840f; WORD $0x0000             // je           LBB36_139, $90(%rip)
+	WORD $0xff41; BYTE $0xc6                   // incl         %r14d
+	LONG $0x80e68141; WORD $0x0001; BYTE $0x00 // andl         $384, %r14d
+	LONG $0x80c68341                           // addl         $-128, %r14d
+	LONG $0x07eec141                           // shrl         $7, %r14d
+	WORD $0xfe41; BYTE $0xc6                   // incb         %r14b
+	LONG $0xc6b60f45                           // movzbl       %r14b, %r8d
+	LONG $0x03e08341                           // andl         $3, %r8d
+	LONG $0x07e0c149                           // shlq         $7, %r8
+	WORD $0x014c; BYTE $0xfe                   // addq         %r15, %rsi
+	LONG $0x61c68348                           // addq         $97, %rsi
+	WORD $0xdb31                               // xorl         %ebx, %ebx
+	QUAD $0xfffff215056ffdc5                   // vmovdqa      $-3563(%rip), %ymm0  /* LCPI36_0(%rip) */
+
+LBB36_138:
+	LONG $0x1e3c8d48               // leaq         (%rsi,%rbx), %rdi
+	LONG $0x447ffec5; WORD $0xa039 // vmovdqu      %ymm0, $-96(%rcx,%rdi)
+	LONG $0x447ffec5; WORD $0xc039 // vmovdqu      %ymm0, $-64(%rcx,%rdi)
+	LONG $0x447ffec5; WORD $0xe039 // vmovdqu      %ymm0, $-32(%rcx,%rdi)
+	LONG $0x047ffec5; BYTE $0x39   // vmovdqu      %ymm0, (%rcx,%rdi)
+	LONG $0x80eb8348               // subq         $-128, %rbx
+	WORD $0x3949; BYTE $0xd8       // cmpq         %rbx, %r8
+	LONG $0xffd8850f; WORD $0xffff // jne          LBB36_138, $-40(%rip)
+
+LBB36_139:
+	WORD $0x3949; BYTE $0xd3       // cmpq         %rdx, %r11
+	LONG $0x0015840f; WORD $0x0000 // je           LBB36_92, $21(%rip)
+	LONG $0x90909090               // .p2align 4, 0x90
+
+LBB36_140:
+	WORD $0x00c6; BYTE $0x30       // movb         $48, (%rax)
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0xc2ff                   // incl         %edx
+	WORD $0x3944; BYTE $0xd2       // cmpl         %r10d, %edx
+	LONG $0xffef8c0f; WORD $0xffff // jl           LBB36_140, $-17(%rip)
+
+LBB36_92:
+	WORD $0x2944; BYTE $0xe8 // subl         %r13d, %eax
+
+LBB36_93:
+	LONG $0x08c48348         // addq         $8, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	BYTE $0xc3               // retq
+
+LBB36_141:
+	WORD $0xc031                 // xorl         %eax, %eax
+	LONG $0xffffe7e9; BYTE $0xff // jmp          LBB36_93, $-25(%rip)
+
+LBB36_142:
+	LONG $0xd07d8948               // movq         %rdi, $-48(%rbp)
+	LONG $0xff6bb841; WORD $0xffff // movl         $-149, %r8d
+	WORD $0x8941; BYTE $0xc7       // movl         %eax, %r15d
+	LONG $0xfff257e9; BYTE $0xff   // jmp          LBB36_8, $-3497(%rip)
+	BYTE $0x90                     // .p2align 4, 0x90
+
+_format_significand:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5641                   // pushq        %r14
+	BYTE $0x53                     // pushq        %rbx
+	WORD $0x8941; BYTE $0xd0       // movl         %edx, %r8d
+	WORD $0x0149; BYTE $0xf0       // addq         %rsi, %r8
+	WORD $0x8948; BYTE $0xf8       // movq         %rdi, %rax
+	LONG $0x20e8c148               // shrq         $32, %rax
+	LONG $0x001c850f; WORD $0x0000 // jne          LBB37_2, $28(%rip)
+	WORD $0x3145; BYTE $0xc9       // xorl         %r9d, %r9d
+	WORD $0x894d; BYTE $0xc6       // movq         %r8, %r14
+	WORD $0x8948; BYTE $0xfa       // movq         %rdi, %rdx
+	LONG $0x2710fa81; WORD $0x0000 // cmpl         $10000, %edx
+	LONG $0x00e3830f; WORD $0x0000 // jae          LBB37_8, $227(%rip)
+
+LBB37_7:
+	WORD $0xd789                 // movl         %edx, %edi
+	LONG $0x000132e9; BYTE $0x00 // jmp          LBB37_10, $306(%rip)
+
+LBB37_2:
+	QUAD $0x77118461cefdb948; WORD $0xabcc     // movabsq      $-6067343680855748867, %rcx
+	WORD $0x8948; BYTE $0xf8                   // movq         %rdi, %rax
+	WORD $0xf748; BYTE $0xe1                   // mulq         %rcx
+	LONG $0x1aeac148                           // shrq         $26, %rdx
+	LONG $0x1f00ca69; WORD $0xfa0a             // imull        $-100000000, %edx, %ecx
+	WORD $0xf901                               // addl         %edi, %ecx
+	LONG $0x00a4840f; WORD $0x0000             // je           LBB37_3, $164(%rip)
+	WORD $0xc889                               // movl         %ecx, %eax
+	LONG $0x1759b941; WORD $0xd1b7             // movl         $3518437209, %r9d
+	LONG $0xc1af0f49                           // imulq        %r9, %rax
+	LONG $0x2de8c148                           // shrq         $45, %rax
+	LONG $0x2710f869; WORD $0x0000             // imull        $10000, %eax, %edi
+	WORD $0xf929                               // subl         %edi, %ecx
+	WORD $0x8948; BYTE $0xc7                   // movq         %rax, %rdi
+	LONG $0xf9af0f49                           // imulq        %r9, %rdi
+	LONG $0x2defc148                           // shrq         $45, %rdi
+	LONG $0x2710ff69; WORD $0x0000             // imull        $10000, %edi, %edi
+	WORD $0xf829                               // subl         %edi, %eax
+	WORD $0xb70f; BYTE $0xf9                   // movzwl       %cx, %edi
+	WORD $0xefc1; BYTE $0x02                   // shrl         $2, %edi
+	LONG $0x7bcf6944; WORD $0x0014; BYTE $0x00 // imull        $5243, %edi, %r9d
+	LONG $0x11e9c141                           // shrl         $17, %r9d
+	LONG $0x64f96b41                           // imull        $100, %r9d, %edi
+	WORD $0xf929                               // subl         %edi, %ecx
+	LONG $0xd1b70f44                           // movzwl       %cx, %r10d
+	WORD $0xb70f; BYTE $0xf8                   // movzwl       %ax, %edi
+	WORD $0xefc1; BYTE $0x02                   // shrl         $2, %edi
+	LONG $0x147bff69; WORD $0x0000             // imull        $5243, %edi, %edi
+	WORD $0xefc1; BYTE $0x11                   // shrl         $17, %edi
+	WORD $0xcf6b; BYTE $0x64                   // imull        $100, %edi, %ecx
+	WORD $0xc829                               // subl         %ecx, %eax
+	LONG $0xd8b70f44                           // movzwl       %ax, %r11d
+	LONG $0xe30d8d48; WORD $0x0036; BYTE $0x00 // leaq         $14051(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x04b70f42; BYTE $0x51               // movzwl       (%rcx,%r10,2), %eax
+	LONG $0x40894166; BYTE $0xfe               // movw         %ax, $-2(%r8)
+	LONG $0x04b70f42; BYTE $0x49               // movzwl       (%rcx,%r9,2), %eax
+	LONG $0x40894166; BYTE $0xfc               // movw         %ax, $-4(%r8)
+	LONG $0x04b70f42; BYTE $0x59               // movzwl       (%rcx,%r11,2), %eax
+	LONG $0x40894166; BYTE $0xfa               // movw         %ax, $-6(%r8)
+	LONG $0x7904b70f                           // movzwl       (%rcx,%rdi,2), %eax
+	LONG $0x40894166; BYTE $0xf8               // movw         %ax, $-8(%r8)
+	WORD $0x3145; BYTE $0xc9                   // xorl         %r9d, %r9d
+	LONG $0xf8708d4d                           // leaq         $-8(%r8), %r14
+	LONG $0x2710fa81; WORD $0x0000             // cmpl         $10000, %edx
+	LONG $0xff38820f; WORD $0xffff             // jb           LBB37_7, $-200(%rip)
+	LONG $0x000016e9; BYTE $0x00               // jmp          LBB37_8, $22(%rip)
+
+LBB37_3:
+	LONG $0x0008b941; WORD $0x0000 // movl         $8, %r9d
+	LONG $0xf8708d4d               // leaq         $-8(%r8), %r14
+	LONG $0x2710fa81; WORD $0x0000 // cmpl         $10000, %edx
+	LONG $0xff1d820f; WORD $0xffff // jb           LBB37_7, $-227(%rip)
+
+LBB37_8:
+	LONG $0x1759ba41; WORD $0xd1b7             // movl         $3518437209, %r10d
+	LONG $0x811d8d4c; WORD $0x0036; BYTE $0x00 // leaq         $13953(%rip), %r11  /* _Digits(%rip) */
+	BYTE $0x90                                 // .p2align 4, 0x90
+
+LBB37_9:
+	WORD $0xd789                               // movl         %edx, %edi
+	LONG $0xfaaf0f49                           // imulq        %r10, %rdi
+	LONG $0x2defc148                           // shrq         $45, %rdi
+	LONG $0xd8f0c769; WORD $0xffff             // imull        $-10000, %edi, %eax
+	WORD $0xd001                               // addl         %edx, %eax
+	LONG $0x1fd86948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rbx
+	LONG $0x25ebc148                           // shrq         $37, %rbx
+	WORD $0xcb6b; BYTE $0x64                   // imull        $100, %ebx, %ecx
+	WORD $0xc829                               // subl         %ecx, %eax
+	LONG $0x04b70f41; BYTE $0x43               // movzwl       (%r11,%rax,2), %eax
+	LONG $0x46894166; BYTE $0xfe               // movw         %ax, $-2(%r14)
+	LONG $0x04b70f41; BYTE $0x5b               // movzwl       (%r11,%rbx,2), %eax
+	LONG $0x46894166; BYTE $0xfc               // movw         %ax, $-4(%r14)
+	LONG $0xfcc68349                           // addq         $-4, %r14
+	LONG $0xe0fffa81; WORD $0x05f5             // cmpl         $99999999, %edx
+	WORD $0xfa89                               // movl         %edi, %edx
+	LONG $0xffb8870f; WORD $0xffff             // ja           LBB37_9, $-72(%rip)
+
+LBB37_10:
+	WORD $0xff83; BYTE $0x64       // cmpl         $100, %edi
+	LONG $0x0020830f; WORD $0x0000 // jae          LBB37_11, $32(%rip)
+	WORD $0xff83; BYTE $0x0a       // cmpl         $10, %edi
+	LONG $0x004d820f; WORD $0x0000 // jb           LBB37_14, $77(%rip)
+
+LBB37_13:
+	WORD $0xf889                               // movl         %edi, %eax
+	LONG $0x1d0d8d48; WORD $0x0036; BYTE $0x00 // leaq         $13853(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	LONG $0x46894166; BYTE $0xfe               // movw         %ax, $-2(%r14)
+	LONG $0x00003de9; BYTE $0x00               // jmp          LBB37_15, $61(%rip)
+
+LBB37_11:
+	WORD $0xb70f; BYTE $0xc7                   // movzwl       %di, %eax
+	WORD $0xe8c1; BYTE $0x02                   // shrl         $2, %eax
+	LONG $0x147bc069; WORD $0x0000             // imull        $5243, %eax, %eax
+	WORD $0xe8c1; BYTE $0x11                   // shrl         $17, %eax
+	WORD $0xc86b; BYTE $0x64                   // imull        $100, %eax, %ecx
+	WORD $0xcf29                               // subl         %ecx, %edi
+	WORD $0xb70f; BYTE $0xcf                   // movzwl       %di, %ecx
+	LONG $0xf1158d48; WORD $0x0035; BYTE $0x00 // leaq         $13809(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x4a0cb70f                           // movzwl       (%rdx,%rcx,2), %ecx
+	LONG $0x4e894166; BYTE $0xfe               // movw         %cx, $-2(%r14)
+	LONG $0xfec68349                           // addq         $-2, %r14
+	WORD $0xc789                               // movl         %eax, %edi
+	WORD $0xff83; BYTE $0x0a                   // cmpl         $10, %edi
+	LONG $0xffb3830f; WORD $0xffff             // jae          LBB37_13, $-77(%rip)
+
+LBB37_14:
+	LONG $0x30c78040         // addb         $48, %dil
+	WORD $0x8840; BYTE $0x3e // movb         %dil, (%rsi)
+
+LBB37_15:
+	WORD $0x294d; BYTE $0xc8                   // subq         %r9, %r8
+	WORD $0x894c; BYTE $0xc0                   // movq         %r8, %rax
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5e41                               // popq         %r14
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+_left_shift:
+	BYTE $0x55                                             // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                               // movq         %rsp, %rbp
+	WORD $0x5741                                           // pushq        %r15
+	WORD $0x5641                                           // pushq        %r14
+	BYTE $0x53                                             // pushq        %rbx
+	WORD $0xf189                                           // movl         %esi, %ecx
+	LONG $0x68c16b48                                       // imulq        $104, %rcx, %rax
+	LONG $0x9a158d48; WORD $0x008f; BYTE $0x00             // leaq         $36762(%rip), %rdx  /* _LSHIFT_TAB(%rip) */
+	LONG $0x10048b44                                       // movl         (%rax,%rdx), %r8d
+	WORD $0x8b4c; BYTE $0x0f                               // movq         (%rdi), %r9
+	WORD $0x0148; BYTE $0xc2                               // addq         %rax, %rdx
+	LONG $0x04c28348                                       // addq         $4, %rdx
+	LONG $0x10476348                                       // movslq       $16(%rdi), %rax
+	WORD $0xf631                                           // xorl         %esi, %esi
+	WORD $0x8548; BYTE $0xc0                               // testq        %rax, %rax
+	LONG $0x0031840f; WORD $0x0000                         // je           LBB38_6, $49(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB38_1:
+	LONG $0x321cb60f               // movzbl       (%rdx,%rsi), %ebx
+	WORD $0xdb84                   // testb        %bl, %bl
+	LONG $0x0025840f; WORD $0x0000 // je           LBB38_8, $37(%rip)
+	LONG $0x311c3841               // cmpb         %bl, (%r9,%rsi)
+	LONG $0x0189850f; WORD $0x0000 // jne          LBB38_3, $393(%rip)
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0xffde850f; WORD $0xffff // jne          LBB38_1, $-34(%rip)
+	WORD $0xc689                   // movl         %eax, %esi
+
+LBB38_6:
+	LONG $0x00323c80               // cmpb         $0, (%rdx,%rsi)
+	LONG $0x0003840f; WORD $0x0000 // je           LBB38_8, $3(%rip)
+
+LBB38_7:
+	WORD $0xff41; BYTE $0xc8 // decl         %r8d
+
+LBB38_8:
+	WORD $0xc085                               // testl        %eax, %eax
+	LONG $0x00968e0f; WORD $0x0000             // jle          LBB38_22, $150(%rip)
+	LONG $0x001c8d45                           // leal         (%r8,%rax), %r11d
+	WORD $0xc389                               // movl         %eax, %ebx
+	WORD $0x634d; BYTE $0xf3                   // movslq       %r11d, %r14
+	WORD $0xff49; BYTE $0xce                   // decq         %r14
+	WORD $0xff48; BYTE $0xc3                   // incq         %rbx
+	WORD $0xd231                               // xorl         %edx, %edx
+	QUAD $0xcccccccccccdba49; WORD $0xcccc     // movabsq      $-3689348814741910323, %r10
+	LONG $0x000023e9; BYTE $0x00               // jmp          LBB38_10, $35(%rip)
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB38_11:
+	WORD $0x3004             // addb         $48, %al
+	LONG $0x31048843         // movb         %al, (%r9,%r14)
+	WORD $0x8b4c; BYTE $0x0f // movq         (%rdi), %r9
+
+LBB38_18:
+	WORD $0xff41; BYTE $0xcb       // decl         %r11d
+	WORD $0xff49; BYTE $0xce       // decq         %r14
+	WORD $0xff48; BYTE $0xcb       // decq         %rbx
+	LONG $0x01fb8348               // cmpq         $1, %rbx
+	LONG $0x0049860f; WORD $0x0000 // jbe          LBB38_12, $73(%rip)
+
+LBB38_10:
+	WORD $0x438d; BYTE $0xfe                   // leal         $-2(%rbx), %eax
+	LONG $0x34be0f49; BYTE $0x01               // movsbq       (%r9,%rax), %rsi
+	LONG $0xd0c68348                           // addq         $-48, %rsi
+	WORD $0xd348; BYTE $0xe6                   // shlq         %cl, %rsi
+	WORD $0x0148; BYTE $0xd6                   // addq         %rdx, %rsi
+	WORD $0x8948; BYTE $0xf0                   // movq         %rsi, %rax
+	WORD $0xf749; BYTE $0xe2                   // mulq         %r10
+	LONG $0x03eac148                           // shrq         $3, %rdx
+	LONG $0x12048d48                           // leaq         (%rdx,%rdx), %rax
+	LONG $0x803c8d4c                           // leaq         (%rax,%rax,4), %r15
+	WORD $0x8948; BYTE $0xf0                   // movq         %rsi, %rax
+	WORD $0x294c; BYTE $0xf8                   // subq         %r15, %rax
+	LONG $0x0877394c                           // cmpq         %r14, $8(%rdi)
+	LONG $0xffb0870f; WORD $0xffff             // ja           LBB38_11, $-80(%rip)
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0xffb0840f; WORD $0xffff             // je           LBB38_18, $-80(%rip)
+	LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl         $1, $28(%rdi)
+	LONG $0xffffa4e9; BYTE $0xff               // jmp          LBB38_18, $-92(%rip)
+
+LBB38_12:
+	LONG $0x0afe8348               // cmpq         $10, %rsi
+	LONG $0x0070830f; WORD $0x0000 // jae          LBB38_13, $112(%rip)
+
+LBB38_22:
+	LONG $0x10476348               // movslq       $16(%rdi), %rax
+	WORD $0x6349; BYTE $0xc8       // movslq       %r8d, %rcx
+	WORD $0x0148; BYTE $0xc1       // addq         %rax, %rcx
+	WORD $0x4f89; BYTE $0x10       // movl         %ecx, $16(%rdi)
+	LONG $0x08478b48               // movq         $8(%rdi), %rax
+	WORD $0x3948; BYTE $0xc8       // cmpq         %rcx, %rax
+	LONG $0x0005870f; WORD $0x0000 // ja           LBB38_24, $5(%rip)
+	WORD $0x4789; BYTE $0x10       // movl         %eax, $16(%rdi)
+	WORD $0xc189                   // movl         %eax, %ecx
+
+LBB38_24:
+	LONG $0x14470144               // addl         %r8d, $20(%rdi)
+	WORD $0xc985                   // testl        %ecx, %ecx
+	LONG $0x00318e0f; WORD $0x0000 // jle          LBB38_28, $49(%rip)
+	WORD $0x8b48; BYTE $0x07       // movq         (%rdi), %rax
+	WORD $0xc989                   // movl         %ecx, %ecx
+	BYTE $0x90                     // .p2align 4, 0x90
+
+LBB38_26:
+	LONG $0xff518d48               // leaq         $-1(%rcx), %rdx
+	WORD $0xd689                   // movl         %edx, %esi
+	LONG $0x30303c80               // cmpb         $48, (%rax,%rsi)
+	LONG $0x0028850f; WORD $0x0000 // jne          LBB38_30, $40(%rip)
+	WORD $0xc9ff                   // decl         %ecx
+	WORD $0x4f89; BYTE $0x10       // movl         %ecx, $16(%rdi)
+	LONG $0x01728d48               // leaq         $1(%rdx), %rsi
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	LONG $0x01fe8348               // cmpq         $1, %rsi
+	LONG $0xffda870f; WORD $0xffff // ja           LBB38_26, $-38(%rip)
+	LONG $0x000006e9; BYTE $0x00   // jmp          LBB38_29, $6(%rip)
+
+LBB38_28:
+	LONG $0x0007850f; WORD $0x0000 // jne          LBB38_30, $7(%rip)
+
+LBB38_29:
+	LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl         $0, $20(%rdi)
+
+LBB38_30:
+	BYTE $0x5b   // popq         %rbx
+	WORD $0x5e41 // popq         %r14
+	WORD $0x5f41 // popq         %r15
+	BYTE $0x5d   // popq         %rbp
+	BYTE $0xc3   // retq
+
+LBB38_13:
+	WORD $0x6349; BYTE $0xf3       // movslq       %r11d, %rsi
+	WORD $0xff48; BYTE $0xce       // decq         %rsi
+	LONG $0x00001be9; BYTE $0x00   // jmp          LBB38_14, $27(%rip)
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB38_15:
+	WORD $0x3004             // addb         $48, %al
+	WORD $0x8b48; BYTE $0x1f // movq         (%rdi), %rbx
+	WORD $0x0488; BYTE $0x33 // movb         %al, (%rbx,%rsi)
+
+LBB38_21:
+	WORD $0xff48; BYTE $0xce       // decq         %rsi
+	LONG $0x09f98348               // cmpq         $9, %rcx
+	LONG $0xff6a860f; WORD $0xffff // jbe          LBB38_22, $-150(%rip)
+
+LBB38_14:
+	WORD $0x8948; BYTE $0xd1                   // movq         %rdx, %rcx
+	WORD $0x8948; BYTE $0xd0                   // movq         %rdx, %rax
+	WORD $0xf749; BYTE $0xe2                   // mulq         %r10
+	LONG $0x03eac148                           // shrq         $3, %rdx
+	LONG $0x12048d48                           // leaq         (%rdx,%rdx), %rax
+	LONG $0x801c8d48                           // leaq         (%rax,%rax,4), %rbx
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	WORD $0x2948; BYTE $0xd8                   // subq         %rbx, %rax
+	LONG $0x08773948                           // cmpq         %rsi, $8(%rdi)
+	LONG $0xffc6870f; WORD $0xffff             // ja           LBB38_15, $-58(%rip)
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0xffc5840f; WORD $0xffff             // je           LBB38_21, $-59(%rip)
+	LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl         $1, $28(%rdi)
+	LONG $0xffffb9e9; BYTE $0xff               // jmp          LBB38_21, $-71(%rip)
+
+LBB38_3:
+	LONG $0xfe898c0f; WORD $0xffff // jl           LBB38_7, $-375(%rip)
+	LONG $0xfffe87e9; BYTE $0xff   // jmp          LBB38_8, $-377(%rip)
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+_right_shift:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	BYTE $0x53                     // pushq        %rbx
+	WORD $0xf189                   // movl         %esi, %ecx
+	LONG $0x10478b44               // movl         $16(%rdi), %r8d
+	WORD $0xd231                   // xorl         %edx, %edx
+	WORD $0x8545; BYTE $0xc0       // testl        %r8d, %r8d
+	LONG $0x0000bb41; WORD $0x0000 // movl         $0, %r11d
+	LONG $0xd84f0f45               // cmovgl       %r8d, %r11d
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x90909090               // .p2align 4, 0x90
+
+LBB39_1:
+	WORD $0x3949; BYTE $0xd3       // cmpq         %rdx, %r11
+	LONG $0x0132840f; WORD $0x0000 // je           LBB39_2, $306(%rip)
+	LONG $0x80048d48               // leaq         (%rax,%rax,4), %rax
+	WORD $0x8b48; BYTE $0x37       // movq         (%rdi), %rsi
+	LONG $0x34be0f48; BYTE $0x16   // movsbq       (%rsi,%rdx), %rsi
+	LONG $0x46048d48               // leaq         (%rsi,%rax,2), %rax
+	LONG $0xd0c08348               // addq         $-48, %rax
+	WORD $0xff48; BYTE $0xc2       // incq         %rdx
+	WORD $0x8948; BYTE $0xc6       // movq         %rax, %rsi
+	WORD $0xd348; BYTE $0xee       // shrq         %cl, %rsi
+	WORD $0x8548; BYTE $0xf6       // testq        %rsi, %rsi
+	LONG $0xffd1840f; WORD $0xffff // je           LBB39_1, $-47(%rip)
+	WORD $0x8941; BYTE $0xd3       // movl         %edx, %r11d
+
+LBB39_7:
+	WORD $0x578b; BYTE $0x14                   // movl         $20(%rdi), %edx
+	WORD $0x2944; BYTE $0xda                   // subl         %r11d, %edx
+	WORD $0xc2ff                               // incl         %edx
+	LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r9
+	WORD $0xd349; BYTE $0xe1                   // shlq         %cl, %r9
+	WORD $0x5789; BYTE $0x14                   // movl         %edx, $20(%rdi)
+	WORD $0xf749; BYTE $0xd1                   // notq         %r9
+	WORD $0x3145; BYTE $0xd2                   // xorl         %r10d, %r10d
+	WORD $0x3945; BYTE $0xc3                   // cmpl         %r8d, %r11d
+	LONG $0x00718d0f; WORD $0x0000             // jge          LBB39_10, $113(%rip)
+	WORD $0x634d; BYTE $0xc3                   // movslq       %r11d, %r8
+	WORD $0x8b48; BYTE $0x37                   // movq         (%rdi), %rsi
+	WORD $0x3145; BYTE $0xd2                   // xorl         %r10d, %r10d
+	BYTE $0x90                                 // .p2align 4, 0x90
+
+LBB39_9:
+	WORD $0x8948; BYTE $0xc2                                 // movq         %rax, %rdx
+	WORD $0xd348; BYTE $0xea                                 // shrq         %cl, %rdx
+	WORD $0x214c; BYTE $0xc8                                 // andq         %r9, %rax
+	WORD $0xc280; BYTE $0x30                                 // addb         $48, %dl
+	LONG $0x16148842                                         // movb         %dl, (%rsi,%r10)
+	WORD $0x8b48; BYTE $0x37                                 // movq         (%rdi), %rsi
+	LONG $0x06148d4a                                         // leaq         (%rsi,%r8), %rdx
+	LONG $0x1cbe0f4d; BYTE $0x12                             // movsbq       (%r10,%rdx), %r11
+	LONG $0x105c8d4b; BYTE $0x01                             // leaq         $1(%r8,%r10), %rbx
+	WORD $0xff49; BYTE $0xc2                                 // incq         %r10
+	LONG $0x80048d48                                         // leaq         (%rax,%rax,4), %rax
+	LONG $0x43048d49                                         // leaq         (%r11,%rax,2), %rax
+	LONG $0xd0c08348                                         // addq         $-48, %rax
+	LONG $0x10576348                                         // movslq       $16(%rdi), %rdx
+	WORD $0x3948; BYTE $0xd3                                 // cmpq         %rdx, %rbx
+	LONG $0xffc38c0f; WORD $0xffff                           // jl           LBB39_9, $-61(%rip)
+	LONG $0x000025e9; BYTE $0x00                             // jmp          LBB39_10, $37(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB39_12:
+	LONG $0x30c68040         // addb         $48, %sil
+	WORD $0x8b48; BYTE $0x1f // movq         (%rdi), %rbx
+	LONG $0x13348840         // movb         %sil, (%rbx,%rdx)
+	WORD $0xc2ff             // incl         %edx
+	WORD $0x8941; BYTE $0xd2 // movl         %edx, %r10d
+
+LBB39_15:
+	WORD $0x0148; BYTE $0xc0 // addq         %rax, %rax
+	LONG $0x80048d48         // leaq         (%rax,%rax,4), %rax
+
+LBB39_10:
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0x002b840f; WORD $0x0000             // je           LBB39_16, $43(%rip)
+	WORD $0x8948; BYTE $0xc6                   // movq         %rax, %rsi
+	WORD $0xd348; BYTE $0xee                   // shrq         %cl, %rsi
+	WORD $0x214c; BYTE $0xc8                   // andq         %r9, %rax
+	WORD $0x6349; BYTE $0xd2                   // movslq       %r10d, %rdx
+	LONG $0x08573948                           // cmpq         %rdx, $8(%rdi)
+	LONG $0xffca870f; WORD $0xffff             // ja           LBB39_12, $-54(%rip)
+	WORD $0x8548; BYTE $0xf6                   // testq        %rsi, %rsi
+	LONG $0xffd1840f; WORD $0xffff             // je           LBB39_15, $-47(%rip)
+	LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl         $1, $28(%rdi)
+	LONG $0xffffc5e9; BYTE $0xff               // jmp          LBB39_15, $-59(%rip)
+
+LBB39_16:
+	LONG $0x10578944               // movl         %r10d, $16(%rdi)
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0x00758e0f; WORD $0x0000 // jle          LBB39_20, $117(%rip)
+	WORD $0x8b48; BYTE $0x07       // movq         (%rdi), %rax
+	WORD $0x8944; BYTE $0xd1       // movl         %r10d, %ecx
+	WORD $0x9090                   // .p2align 4, 0x90
+
+LBB39_18:
+	LONG $0xff518d48               // leaq         $-1(%rcx), %rdx
+	WORD $0xd689                   // movl         %edx, %esi
+	LONG $0x30303c80               // cmpb         $48, (%rax,%rsi)
+	LONG $0x0063850f; WORD $0x0000 // jne          LBB39_22, $99(%rip)
+	WORD $0xc9ff                   // decl         %ecx
+	WORD $0x4f89; BYTE $0x10       // movl         %ecx, $16(%rdi)
+	LONG $0x01728d48               // leaq         $1(%rdx), %rsi
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	LONG $0x01fe8348               // cmpq         $1, %rsi
+	LONG $0xffda870f; WORD $0xffff // ja           LBB39_18, $-38(%rip)
+	LONG $0x00004be9; BYTE $0x00   // jmp          LBB39_21, $75(%rip)
+
+LBB39_2:
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0x004c840f; WORD $0x0000             // je           LBB39_23, $76(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+	WORD $0x8948; BYTE $0xc2                   // movq         %rax, %rdx
+	WORD $0xd348; BYTE $0xea                   // shrq         %cl, %rdx
+	WORD $0x8548; BYTE $0xd2                   // testq        %rdx, %rdx
+	LONG $0xfed3850f; WORD $0xffff             // jne          LBB39_7, $-301(%rip)
+
+LBB39_4:
+	WORD $0x0148; BYTE $0xc0       // addq         %rax, %rax
+	LONG $0x80048d48               // leaq         (%rax,%rax,4), %rax
+	WORD $0xff41; BYTE $0xc3       // incl         %r11d
+	WORD $0x8948; BYTE $0xc2       // movq         %rax, %rdx
+	WORD $0xd348; BYTE $0xea       // shrq         %cl, %rdx
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0xffe7840f; WORD $0xffff // je           LBB39_4, $-25(%rip)
+	LONG $0xfffeb5e9; BYTE $0xff   // jmp          LBB39_7, $-331(%rip)
+
+LBB39_20:
+	LONG $0x0003840f; WORD $0x0000 // je           LBB39_21, $3(%rip)
+
+LBB39_22:
+	BYTE $0x5b // popq         %rbx
+	BYTE $0x5d // popq         %rbp
+	BYTE $0xc3 // retq
+
+LBB39_21:
+	LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl         $0, $20(%rdi)
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB39_23:
+	LONG $0x001047c7; WORD $0x0000; BYTE $0x00                                         // movl         $0, $16(%rdi)
+	BYTE $0x5b                                                                         // popq         %rbx
+	BYTE $0x5d                                                                         // popq         %rbp
+	BYTE $0xc3                                                                         // retq
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000 // .p2align 5, 0x00
+
+LCPI40_0:
+	QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
+	QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
+
+LCPI40_1:
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+
+	// .p2align 4, 0x90
+_advance_string_default:
+	BYTE $0x55                                               // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                                 // movq         %rsp, %rbp
+	WORD $0x5741                                             // pushq        %r15
+	WORD $0x5641                                             // pushq        %r14
+	WORD $0x5541                                             // pushq        %r13
+	WORD $0x5441                                             // pushq        %r12
+	BYTE $0x53                                               // pushq        %rbx
+	LONG $0x087f8b4c                                         // movq         $8(%rdi), %r15
+	WORD $0x2949; BYTE $0xf7                                 // subq         %rsi, %r15
+	LONG $0x02e9840f; WORD $0x0000                           // je           LBB40_17, $745(%rip)
+	WORD $0x8b4c; BYTE $0x0f                                 // movq         (%rdi), %r9
+	LONG $0xff02c748; WORD $0xffff; BYTE $0xff               // movq         $-1, (%rdx)
+	LONG $0x40ff8349                                         // cmpq         $64, %r15
+	LONG $0x0172820f; WORD $0x0000                           // jb           LBB40_18, $370(%rip)
+	WORD $0x8948; BYTE $0xf7                                 // movq         %rsi, %rdi
+	WORD $0xf748; BYTE $0xd7                                 // notq         %rdi
+	LONG $0xffc0c749; WORD $0xffff; BYTE $0xff               // movq         $-1, %r8
+	WORD $0x3145; BYTE $0xf6                                 // xorl         %r14d, %r14d
+	QUAD $0xffffff7a056ffdc5                                 // vmovdqa      $-134(%rip), %ymm0  /* LCPI40_0(%rip) */
+	QUAD $0xffffff920d6ffdc5                                 // vmovdqa      $-110(%rip), %ymm1  /* LCPI40_1(%rip) */
+	QUAD $0xaaaaaaaaaaaaba49; WORD $0xaaaa                   // movabsq      $-6148914691236517206, %r10
+	QUAD $0x555555555555bb49; WORD $0x5555                   // movabsq      $6148914691236517205, %r11
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB40_3:
+	LONG $0x6f7ec1c4; WORD $0x3114             // vmovdqu      (%r9,%rsi), %ymm2
+	LONG $0x6f7ec1c4; WORD $0x315c; BYTE $0x20 // vmovdqu      $32(%r9,%rsi), %ymm3
+	LONG $0xe074edc5                           // vpcmpeqb     %ymm0, %ymm2, %ymm4
+	LONG $0xe4d77dc5                           // vpmovmskb    %ymm4, %r12d
+	LONG $0xe074e5c5                           // vpcmpeqb     %ymm0, %ymm3, %ymm4
+	LONG $0xccd7fdc5                           // vpmovmskb    %ymm4, %ecx
+	LONG $0xd174edc5                           // vpcmpeqb     %ymm1, %ymm2, %ymm2
+	LONG $0xc2d7fdc5                           // vpmovmskb    %ymm2, %eax
+	LONG $0xd174e5c5                           // vpcmpeqb     %ymm1, %ymm3, %ymm2
+	LONG $0xdad7fdc5                           // vpmovmskb    %ymm2, %ebx
+	LONG $0x20e1c148                           // shlq         $32, %rcx
+	WORD $0x0949; BYTE $0xcc                   // orq          %rcx, %r12
+	LONG $0x20e3c148                           // shlq         $32, %rbx
+	WORD $0x0948; BYTE $0xd8                   // orq          %rbx, %rax
+	LONG $0x0030850f; WORD $0x0000             // jne          LBB40_7, $48(%rip)
+	WORD $0x854d; BYTE $0xf6                   // testq        %r14, %r14
+	LONG $0x003b850f; WORD $0x0000             // jne          LBB40_9, $59(%rip)
+	WORD $0x3145; BYTE $0xf6                   // xorl         %r14d, %r14d
+	WORD $0x854d; BYTE $0xe4                   // testq        %r12, %r12
+	LONG $0x006d850f; WORD $0x0000             // jne          LBB40_10, $109(%rip)
+
+LBB40_6:
+	LONG $0xc0c78349               // addq         $-64, %r15
+	LONG $0xc0c78348               // addq         $-64, %rdi
+	LONG $0x40c68348               // addq         $64, %rsi
+	LONG $0x3fff8349               // cmpq         $63, %r15
+	LONG $0xff94870f; WORD $0xffff // ja           LBB40_3, $-108(%rip)
+	LONG $0x000067e9; BYTE $0x00   // jmp          LBB40_12, $103(%rip)
+
+LBB40_7:
+	LONG $0xfff88349               // cmpq         $-1, %r8
+	LONG $0x000a850f; WORD $0x0000 // jne          LBB40_9, $10(%rip)
+	LONG $0xc0bc0f4c               // bsfq         %rax, %r8
+	WORD $0x0149; BYTE $0xf0       // addq         %rsi, %r8
+	WORD $0x894c; BYTE $0x02       // movq         %r8, (%rdx)
+
+LBB40_9:
+	WORD $0x894c; BYTE $0xf1       // movq         %r14, %rcx
+	WORD $0xf748; BYTE $0xd1       // notq         %rcx
+	WORD $0x2148; BYTE $0xc1       // andq         %rax, %rcx
+	LONG $0x092c8d4c               // leaq         (%rcx,%rcx), %r13
+	WORD $0x094d; BYTE $0xf5       // orq          %r14, %r13
+	WORD $0x894c; BYTE $0xeb       // movq         %r13, %rbx
+	WORD $0xf748; BYTE $0xd3       // notq         %rbx
+	WORD $0x2148; BYTE $0xc3       // andq         %rax, %rbx
+	WORD $0x214c; BYTE $0xd3       // andq         %r10, %rbx
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	WORD $0x0148; BYTE $0xcb       // addq         %rcx, %rbx
+	LONG $0xc6920f41               // setb         %r14b
+	WORD $0x0148; BYTE $0xdb       // addq         %rbx, %rbx
+	WORD $0x314c; BYTE $0xdb       // xorq         %r11, %rbx
+	WORD $0x214c; BYTE $0xeb       // andq         %r13, %rbx
+	WORD $0xf748; BYTE $0xd3       // notq         %rbx
+	WORD $0x2149; BYTE $0xdc       // andq         %rbx, %r12
+	WORD $0x854d; BYTE $0xe4       // testq        %r12, %r12
+	LONG $0xff93840f; WORD $0xffff // je           LBB40_6, $-109(%rip)
+
+LBB40_10:
+	LONG $0xc4bc0f49         // bsfq         %r12, %rax
+	WORD $0x2948; BYTE $0xf8 // subq         %rdi, %rax
+
+LBB40_11:
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	BYTE $0xc3               // retq
+
+LBB40_12:
+	WORD $0x014c; BYTE $0xce       // addq         %r9, %rsi
+	LONG $0x20ff8349               // cmpq         $32, %r15
+	LONG $0x00c2820f; WORD $0x0000 // jb           LBB40_23, $194(%rip)
+
+LBB40_13:
+	LONG $0x066ffec5               // vmovdqu      (%rsi), %ymm0
+	QUAD $0xfffffe5f0d74fdc5       // vpcmpeqb     $-417(%rip), %ymm0, %ymm1  /* LCPI40_0(%rip) */
+	LONG $0xf9d7fdc5               // vpmovmskb    %ymm1, %edi
+	QUAD $0xfffffe730574fdc5       // vpcmpeqb     $-397(%rip), %ymm0, %ymm0  /* LCPI40_1(%rip) */
+	LONG $0xc0d7fdc5               // vpmovmskb    %ymm0, %eax
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x0043850f; WORD $0x0000 // jne          LBB40_19, $67(%rip)
+	WORD $0x854d; BYTE $0xf6       // testq        %r14, %r14
+	LONG $0x0054850f; WORD $0x0000 // jne          LBB40_21, $84(%rip)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0x0081840f; WORD $0x0000 // je           LBB40_22, $129(%rip)
+
+LBB40_16:
+	LONG $0xc7bc0f48             // bsfq         %rdi, %rax
+	WORD $0x294c; BYTE $0xce     // subq         %r9, %rsi
+	WORD $0x0148; BYTE $0xf0     // addq         %rsi, %rax
+	WORD $0xff48; BYTE $0xc0     // incq         %rax
+	LONG $0xffff9ae9; BYTE $0xff // jmp          LBB40_11, $-102(%rip)
+
+LBB40_18:
+	WORD $0x014c; BYTE $0xce                   // addq         %r9, %rsi
+	LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r8
+	WORD $0x3145; BYTE $0xf6                   // xorl         %r14d, %r14d
+	LONG $0x20ff8349                           // cmpq         $32, %r15
+	LONG $0xff9e830f; WORD $0xffff             // jae          LBB40_13, $-98(%rip)
+	LONG $0x00005be9; BYTE $0x00               // jmp          LBB40_23, $91(%rip)
+
+LBB40_19:
+	LONG $0xfff88349               // cmpq         $-1, %r8
+	LONG $0x0010850f; WORD $0x0000 // jne          LBB40_21, $16(%rip)
+	WORD $0x8948; BYTE $0xf1       // movq         %rsi, %rcx
+	WORD $0x294c; BYTE $0xc9       // subq         %r9, %rcx
+	LONG $0xc0bc0f4c               // bsfq         %rax, %r8
+	WORD $0x0149; BYTE $0xc8       // addq         %rcx, %r8
+	WORD $0x894c; BYTE $0x02       // movq         %r8, (%rdx)
+
+LBB40_21:
+	WORD $0x8944; BYTE $0xf1       // movl         %r14d, %ecx
+	WORD $0xd1f7                   // notl         %ecx
+	WORD $0xc121                   // andl         %eax, %ecx
+	WORD $0x1c8d; BYTE $0x09       // leal         (%rcx,%rcx), %ebx
+	LONG $0x4e148d45               // leal         (%r14,%rcx,2), %r10d
+	WORD $0xd3f7                   // notl         %ebx
+	WORD $0xc321                   // andl         %eax, %ebx
+	LONG $0xaaaae381; WORD $0xaaaa // andl         $-1431655766, %ebx
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	WORD $0xcb01                   // addl         %ecx, %ebx
+	LONG $0xc6920f41               // setb         %r14b
+	WORD $0xdb01                   // addl         %ebx, %ebx
+	LONG $0x5555f381; WORD $0x5555 // xorl         $1431655765, %ebx
+	WORD $0x2144; BYTE $0xd3       // andl         %r10d, %ebx
+	WORD $0xd3f7                   // notl         %ebx
+	WORD $0xdf21                   // andl         %ebx, %edi
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0xff7f850f; WORD $0xffff // jne          LBB40_16, $-129(%rip)
+
+LBB40_22:
+	LONG $0x20c68348 // addq         $32, %rsi
+	LONG $0xe0c78349 // addq         $-32, %r15
+
+LBB40_23:
+	WORD $0x854d; BYTE $0xf6       // testq        %r14, %r14
+	LONG $0x00b0850f; WORD $0x0000 // jne          LBB40_38, $176(%rip)
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x0083840f; WORD $0x0000 // je           LBB40_35, $131(%rip)
+
+LBB40_25:
+	WORD $0x894d; BYTE $0xca                   // movq         %r9, %r10
+	WORD $0xf749; BYTE $0xda                   // negq         %r10
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+
+LBB40_26:
+	WORD $0xdb31 // xorl         %ebx, %ebx
+
+LBB40_27:
+	LONG $0x1e3cb60f               // movzbl       (%rsi,%rbx), %edi
+	WORD $0xff83; BYTE $0x22       // cmpl         $34, %edi
+	LONG $0x0061840f; WORD $0x0000 // je           LBB40_34, $97(%rip)
+	WORD $0xff83; BYTE $0x5c       // cmpl         $92, %edi
+	LONG $0x0011840f; WORD $0x0000 // je           LBB40_30, $17(%rip)
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	WORD $0x3949; BYTE $0xdf       // cmpq         %rbx, %r15
+	LONG $0xffde850f; WORD $0xffff // jne          LBB40_27, $-34(%rip)
+	LONG $0x000058e9; BYTE $0x00   // jmp          LBB40_36, $88(%rip)
+
+LBB40_30:
+	LONG $0xff4f8d49               // leaq         $-1(%r15), %rcx
+	WORD $0x3948; BYTE $0xd9       // cmpq         %rbx, %rcx
+	LONG $0xfece840f; WORD $0xffff // je           LBB40_11, $-306(%rip)
+	LONG $0xfff88349               // cmpq         $-1, %r8
+	LONG $0x000a850f; WORD $0x0000 // jne          LBB40_33, $10(%rip)
+	LONG $0x32048d4d               // leaq         (%r10,%rsi), %r8
+	WORD $0x0149; BYTE $0xd8       // addq         %rbx, %r8
+	WORD $0x894c; BYTE $0x02       // movq         %r8, (%rdx)
+
+LBB40_33:
+	WORD $0x0148; BYTE $0xde       // addq         %rbx, %rsi
+	LONG $0x02c68348               // addq         $2, %rsi
+	WORD $0x894c; BYTE $0xf9       // movq         %r15, %rcx
+	WORD $0x2948; BYTE $0xd9       // subq         %rbx, %rcx
+	LONG $0xfec18348               // addq         $-2, %rcx
+	LONG $0xfec78349               // addq         $-2, %r15
+	WORD $0x3949; BYTE $0xdf       // cmpq         %rbx, %r15
+	WORD $0x8949; BYTE $0xcf       // movq         %rcx, %r15
+	LONG $0xff95850f; WORD $0xffff // jne          LBB40_26, $-107(%rip)
+	LONG $0xfffe94e9; BYTE $0xff   // jmp          LBB40_11, $-364(%rip)
+
+LBB40_34:
+	WORD $0x0148; BYTE $0xde // addq         %rbx, %rsi
+	WORD $0xff48; BYTE $0xc6 // incq         %rsi
+
+LBB40_35:
+	WORD $0x294c; BYTE $0xce     // subq         %r9, %rsi
+	WORD $0x8948; BYTE $0xf0     // movq         %rsi, %rax
+	LONG $0xfffe83e9; BYTE $0xff // jmp          LBB40_11, $-381(%rip)
+
+LBB40_36:
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0x22ff8040                           // cmpb         $34, %dil
+	LONG $0xfe72850f; WORD $0xffff             // jne          LBB40_11, $-398(%rip)
+	WORD $0x0148; BYTE $0xde                   // addq         %rbx, %rsi
+	LONG $0xffffdce9; BYTE $0xff               // jmp          LBB40_35, $-36(%rip)
+
+LBB40_38:
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x002a840f; WORD $0x0000 // je           LBB40_17, $42(%rip)
+	LONG $0xfff88349               // cmpq         $-1, %r8
+	LONG $0x000c850f; WORD $0x0000 // jne          LBB40_41, $12(%rip)
+	WORD $0x894d; BYTE $0xc8       // movq         %r9, %r8
+	WORD $0xf749; BYTE $0xd0       // notq         %r8
+	WORD $0x0149; BYTE $0xf0       // addq         %rsi, %r8
+	WORD $0x894c; BYTE $0x02       // movq         %r8, (%rdx)
+
+LBB40_41:
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0xff49; BYTE $0xcf       // decq         %r15
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0xff2b850f; WORD $0xffff // jne          LBB40_25, $-213(%rip)
+	LONG $0xffffa9e9; BYTE $0xff   // jmp          LBB40_35, $-87(%rip)
+
+LBB40_17:
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xfffe2be9; BYTE $0xff               // jmp          LBB40_11, $-469(%rip)
+	BYTE $0x00                                 // .p2align 4, 0x00
+
+LCPI41_0:
+	BYTE $0xf0 // .byte 240
+	BYTE $0x80 // .byte 128
+	BYTE $0x80 // .byte 128
+	BYTE $0x80 // .byte 128
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+
+	// .p2align 4, 0x90
+_unescape:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x18ec8348                           // subq         $24, %rsp
+	WORD $0x8b4c; BYTE $0x2f                   // movq         (%rdi), %r13
+	WORD $0x294c; BYTE $0xee                   // subq         %r13, %rsi
+	LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rbx
+	WORD $0x8548; BYTE $0xf6                   // testq        %rsi, %rsi
+	LONG $0x00d38e0f; WORD $0x0000             // jle          LBB41_13, $211(%rip)
+	WORD $0x8949; BYTE $0xd6                   // movq         %rdx, %r14
+	WORD $0x8949; BYTE $0xff                   // movq         %rdi, %r15
+	LONG $0x01458d49                           // leaq         $1(%r13), %rax
+	LONG $0x4db60f41; BYTE $0x01               // movzbl       $1(%r13), %ecx
+	LONG $0x53158d48; WORD $0x0077; BYTE $0x00 // leaq         $30547(%rip), %rdx  /* __UnquoteTab(%rip) */
+	LONG $0x110cb60f                           // movzbl       (%rcx,%rdx), %ecx
+	LONG $0x00fff981; WORD $0x0000             // cmpl         $255, %ecx
+	LONG $0x0017840f; WORD $0x0000             // je           LBB41_4, $23(%rip)
+	WORD $0xc985                               // testl        %ecx, %ecx
+	LONG $0x0021850f; WORD $0x0000             // jne          LBB41_6, $33(%rip)
+	WORD $0x8949; BYTE $0x07                   // movq         %rax, (%r15)
+	LONG $0xfdc3c748; WORD $0xffff; BYTE $0xff // movq         $-3, %rbx
+	LONG $0x000096e9; BYTE $0x00               // jmp          LBB41_13, $150(%rip)
+
+LBB41_4:
+	LONG $0x03fe8348               // cmpq         $3, %rsi
+	LONG $0x0019870f; WORD $0x0000 // ja           LBB41_7, $25(%rip)
+	WORD $0x8949; BYTE $0x07       // movq         %rax, (%r15)
+	LONG $0x000084e9; BYTE $0x00   // jmp          LBB41_13, $132(%rip)
+
+LBB41_6:
+	WORD $0x8841; BYTE $0x0e     // movb         %cl, (%r14)
+	LONG $0x02078349             // addq         $2, (%r15)
+	LONG $0x000001bb; BYTE $0x00 // movl         $1, %ebx
+	LONG $0x000073e9; BYTE $0x00 // jmp          LBB41_13, $115(%rip)
+
+LBB41_7:
+	LONG $0x024d8b41               // movl         $2(%r13), %ecx
+	WORD $0xc889                   // movl         %ecx, %eax
+	WORD $0xd0f7                   // notl         %eax
+	LONG $0xcfd0918d; WORD $0xcfcf // leal         $-808464432(%rcx), %edx
+	LONG $0x80808025; BYTE $0x80   // andl         $-2139062144, %eax
+	WORD $0xd085                   // testl        %edx, %eax
+	LONG $0x004a850f; WORD $0x0000 // jne          LBB41_11, $74(%rip)
+	LONG $0x1919918d; WORD $0x1919 // leal         $421075225(%rcx), %edx
+	WORD $0xca09                   // orl          %ecx, %edx
+	LONG $0x8080c2f7; WORD $0x8080 // testl        $-2139062144, %edx
+	LONG $0x0036850f; WORD $0x0000 // jne          LBB41_11, $54(%rip)
+	WORD $0xca89                   // movl         %ecx, %edx
+	LONG $0x7f7fe281; WORD $0x7f7f // andl         $2139062143, %edx
+	LONG $0xc0c0c0bf; BYTE $0xc0   // movl         $-1061109568, %edi
+	WORD $0xd729                   // subl         %edx, %edi
+	LONG $0x46469a8d; WORD $0x4646 // leal         $1179010630(%rdx), %ebx
+	WORD $0xc721                   // andl         %eax, %edi
+	WORD $0xdf85                   // testl        %ebx, %edi
+	LONG $0x0017850f; WORD $0x0000 // jne          LBB41_11, $23(%rip)
+	LONG $0xe0e0e0bf; BYTE $0xe0   // movl         $-522133280, %edi
+	WORD $0xd729                   // subl         %edx, %edi
+	LONG $0x3939c281; WORD $0x3939 // addl         $960051513, %edx
+	WORD $0xf821                   // andl         %edi, %eax
+	WORD $0xd085                   // testl        %edx, %eax
+	LONG $0x0020840f; WORD $0x0000 // je           LBB41_14, $32(%rip)
+
+LBB41_11:
+	LONG $0x02c58349         // addq         $2, %r13
+	WORD $0x894d; BYTE $0x2f // movq         %r13, (%r15)
+
+LBB41_12:
+	LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rbx
+
+LBB41_13:
+	WORD $0x8948; BYTE $0xd8 // movq         %rbx, %rax
+	LONG $0x18c48348         // addq         $24, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB41_14:
+	WORD $0xc90f                               // bswapl       %ecx
+	WORD $0xc889                               // movl         %ecx, %eax
+	WORD $0xd0f7                               // notl         %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	LONG $0x01010125; BYTE $0x01               // andl         $16843009, %eax
+	WORD $0x048d; BYTE $0xc0                   // leal         (%rax,%rax,8), %eax
+	LONG $0x0f0fe181; WORD $0x0f0f             // andl         $252645135, %ecx
+	WORD $0xc101                               // addl         %eax, %ecx
+	WORD $0xc889                               // movl         %ecx, %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	WORD $0xc809                               // orl          %ecx, %eax
+	WORD $0xc189                               // movl         %eax, %ecx
+	WORD $0xe9c1; BYTE $0x08                   // shrl         $8, %ecx
+	LONG $0xff00e181; WORD $0x0000             // andl         $65280, %ecx
+	LONG $0xe0b60f44                           // movzbl       %al, %r12d
+	WORD $0x0941; BYTE $0xcc                   // orl          %ecx, %r12d
+	LONG $0x06558d49                           // leaq         $6(%r13), %rdx
+	WORD $0x8949; BYTE $0x17                   // movq         %rdx, (%r15)
+	LONG $0x7ffc8341                           // cmpl         $127, %r12d
+	LONG $0x004c860f; WORD $0x0000             // jbe          LBB41_18, $76(%rip)
+	LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl         $2047, %r12d
+	LONG $0x004c860f; WORD $0x0000             // jbe          LBB41_19, $76(%rip)
+	QUAD $0xffff200024bc8d41                   // leal         $-57344(%r12), %edi
+	LONG $0xf7ffff81; WORD $0xffff             // cmpl         $-2049, %edi
+	LONG $0x0055870f; WORD $0x0000             // ja           LBB41_20, $85(%rip)
+	WORD $0xe9c1; BYTE $0x0c                   // shrl         $12, %ecx
+	WORD $0xc980; BYTE $0xe0                   // orb          $-32, %cl
+	WORD $0x8841; BYTE $0x0e                   // movb         %cl, (%r14)
+	LONG $0x06ecc141                           // shrl         $6, %r12d
+	LONG $0x3fe48041                           // andb         $63, %r12b
+	LONG $0x80cc8041                           // orb          $-128, %r12b
+	LONG $0x01668845                           // movb         %r12b, $1(%r14)
+	WORD $0x3f24                               // andb         $63, %al
+	WORD $0x800c                               // orb          $-128, %al
+	LONG $0x02468841                           // movb         %al, $2(%r14)
+	LONG $0x000003bb; BYTE $0x00               // movl         $3, %ebx
+	LONG $0xffff5fe9; BYTE $0xff               // jmp          LBB41_13, $-161(%rip)
+
+LBB41_18:
+	WORD $0x8841; BYTE $0x06     // movb         %al, (%r14)
+	LONG $0x000001bb; BYTE $0x00 // movl         $1, %ebx
+	LONG $0xffff52e9; BYTE $0xff // jmp          LBB41_13, $-174(%rip)
+
+LBB41_19:
+	LONG $0x06ecc141             // shrl         $6, %r12d
+	LONG $0xc0cc8041             // orb          $-64, %r12b
+	WORD $0x8845; BYTE $0x26     // movb         %r12b, (%r14)
+	WORD $0x3f24                 // andb         $63, %al
+	WORD $0x800c                 // orb          $-128, %al
+	LONG $0x01468841             // movb         %al, $1(%r14)
+	LONG $0x000002bb; BYTE $0x00 // movl         $2, %ebx
+	LONG $0xffff35e9; BYTE $0xff // jmp          LBB41_13, $-203(%rip)
+
+LBB41_20:
+	LONG $0xfcc3c748; WORD $0xffff; BYTE $0xff // movq         $-4, %rbx
+	LONG $0x06fe8348                           // cmpq         $6, %rsi
+	LONG $0xff24820f; WORD $0xffff             // jb           LBB41_13, $-220(%rip)
+	LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl         $56319, %r12d
+	LONG $0xff17870f; WORD $0xffff             // ja           LBB41_13, $-233(%rip)
+	WORD $0x3a80; BYTE $0x5c                   // cmpb         $92, (%rdx)
+	LONG $0xff0e850f; WORD $0xffff             // jne          LBB41_13, $-242(%rip)
+	LONG $0x077d8041; BYTE $0x75               // cmpb         $117, $7(%r13)
+	LONG $0xff03850f; WORD $0xffff             // jne          LBB41_13, $-253(%rip)
+	LONG $0x08458d49                           // leaq         $8(%r13), %rax
+	LONG $0xc8458948                           // movq         %rax, $-56(%rbp)
+	LONG $0x087d8b41                           // movl         $8(%r13), %edi
+	WORD $0x7d89; BYTE $0xd4                   // movl         %edi, $-44(%rbp)
+	LONG $0xff89b5e8; BYTE $0xff               // callq        _unhex16_is, $-30283(%rip)
+	WORD $0xc084                               // testb        %al, %al
+	LONG $0x004f840f; WORD $0x0000             // je           LBB41_27, $79(%rip)
+	WORD $0x4d8b; BYTE $0xd4                   // movl         $-44(%rbp), %ecx
+	WORD $0xc90f                               // bswapl       %ecx
+	WORD $0xc889                               // movl         %ecx, %eax
+	WORD $0xd0f7                               // notl         %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	LONG $0x01010125; BYTE $0x01               // andl         $16843009, %eax
+	WORD $0x048d; BYTE $0xc0                   // leal         (%rax,%rax,8), %eax
+	LONG $0x0f0fe181; WORD $0x0f0f             // andl         $252645135, %ecx
+	WORD $0xc101                               // addl         %eax, %ecx
+	WORD $0xc889                               // movl         %ecx, %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	WORD $0xc809                               // orl          %ecx, %eax
+	WORD $0xb60f; BYTE $0xc8                   // movzbl       %al, %ecx
+	WORD $0xe8c1; BYTE $0x08                   // shrl         $8, %eax
+	LONG $0x00ff0025; BYTE $0x00               // andl         $65280, %eax
+	WORD $0x148d; BYTE $0x08                   // leal         (%rax,%rcx), %edx
+	LONG $0x2000c281; WORD $0xffff             // addl         $-57344, %edx
+	LONG $0xfbfffa81; WORD $0xffff             // cmpl         $-1025, %edx
+	LONG $0x0018870f; WORD $0x0000             // ja           LBB41_28, $24(%rip)
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	WORD $0x8949; BYTE $0x07                   // movq         %rax, (%r15)
+	LONG $0xfffe98e9; BYTE $0xff               // jmp          LBB41_13, $-360(%rip)
+
+LBB41_27:
+	LONG $0xc8458b48             // movq         $-56(%rbp), %rax
+	WORD $0x8949; BYTE $0x07     // movq         %rax, (%r15)
+	LONG $0xfffe85e9; BYTE $0xff // jmp          LBB41_12, $-379(%rip)
+
+LBB41_28:
+	WORD $0xc809                                       // orl          %ecx, %eax
+	LONG $0x0ae4c141                                   // shll         $10, %r12d
+	WORD $0xc189                                       // movl         %eax, %ecx
+	WORD $0x0144; BYTE $0xe1                           // addl         %r12d, %ecx
+	WORD $0x0144; BYTE $0xe0                           // addl         %r12d, %eax
+	LONG $0xa0240005; BYTE $0xfc                       // addl         $-56613888, %eax
+	WORD $0xc289                                       // movl         %eax, %edx
+	WORD $0xeac1; BYTE $0x12                           // shrl         $18, %edx
+	WORD $0xc689                                       // movl         %eax, %esi
+	WORD $0xeec1; BYTE $0x0c                           // shrl         $12, %esi
+	LONG $0x3fe68040                                   // andb         $63, %sil
+	WORD $0xe8c1; BYTE $0x06                           // shrl         $6, %eax
+	WORD $0x3f24                                       // andb         $63, %al
+	WORD $0xe180; BYTE $0x3f                           // andb         $63, %cl
+	LONG $0xc26ef9c5                                   // vmovd        %edx, %xmm0
+	LONG $0xd6b60f40                                   // movzbl       %sil, %edx
+	LONG $0x2079e3c4; WORD $0x01c2                     // vpinsrb      $1, %edx, %xmm0, %xmm0
+	WORD $0xb60f; BYTE $0xc0                           // movzbl       %al, %eax
+	LONG $0x2079e3c4; WORD $0x02c0                     // vpinsrb      $2, %eax, %xmm0, %xmm0
+	WORD $0xb60f; BYTE $0xc1                           // movzbl       %cl, %eax
+	LONG $0x2079e3c4; WORD $0x03c0                     // vpinsrb      $3, %eax, %xmm0, %xmm0
+	QUAD $0xfffffd3105ebf9c5                           // vpor         $-719(%rip), %xmm0, %xmm0  /* LCPI41_0(%rip) */
+	LONG $0x7e79c1c4; BYTE $0x06                       // vmovd        %xmm0, (%r14)
+	LONG $0x0cc58349                                   // addq         $12, %r13
+	WORD $0x894d; BYTE $0x2f                           // movq         %r13, (%r15)
+	LONG $0x000004bb; BYTE $0x00                       // movl         $4, %ebx
+	LONG $0xfffe25e9; BYTE $0xff                       // jmp          LBB41_13, $-475(%rip)
+	QUAD $0x0000000000000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00
+
+_POW10_M128_TAB:
+	QUAD $0x1732c869cd60e453                           // .quad 1671618768450675795
+	QUAD $0xfa8fd5a0081c0288                           // .quad -391859759250406776
+	QUAD $0x0e7fbd42205c8eb4                           // .quad 1044761730281672372
+	QUAD $0x9c99e58405118195                           // .quad -7162441377172586091
+	QUAD $0x521fac92a873b261                           // .quad 5917638181279478369
+	QUAD $0xc3c05ee50655e1fa                           // .quad -4341365703038344710
+	QUAD $0xe6a797b752909ef9                           // .quad -1826324310255427847
+	QUAD $0xf4b0769e47eb5a78                           // .quad -815021110370542984
+	QUAD $0x9028bed2939a635c                           // .quad -8058981721550724260
+	QUAD $0x98ee4a22ecf3188b                           // .quad -7426917221622671221
+	QUAD $0x7432ee873880fc33                           // .quad 8373016921771146291
+	QUAD $0xbf29dcaba82fdeae                           // .quad -4671960508600951122
+	QUAD $0x113faa2906a13b3f                           // .quad 1242899115359157055
+	QUAD $0xeef453d6923bd65a                           // .quad -1228264617323800998
+	QUAD $0x4ac7ca59a424c507                           // .quad 5388497965526861063
+	QUAD $0x9558b4661b6565f8                           // .quad -7685194413468457480
+	QUAD $0x5d79bcf00d2df649                           // .quad 6735622456908576329
+	QUAD $0xbaaee17fa23ebf76                           // .quad -4994806998408183946
+	QUAD $0xf4d82c2c107973dc                           // .quad -803843965719055396
+	QUAD $0xe95a99df8ace6f53                           // .quad -1631822729582842029
+	QUAD $0x79071b9b8a4be869                           // .quad 8720969558280366185
+	QUAD $0x91d8a02bb6c10594                           // .quad -7937418233630358124
+	QUAD $0x9748e2826cdee284                           // .quad -7545532125859093884
+	QUAD $0xb64ec836a47146f9                           // .quad -5310086773610559751
+	QUAD $0xfd1b1b2308169b25                           // .quad -208543120469091547
+	QUAD $0xe3e27a444d8d98b7                           // .quad -2025922448585811785
+	QUAD $0xfe30f0f5e50e20f7                           // .quad -130339450293182217
+	QUAD $0x8e6d8c6ab0787f72                           // .quad -8183730558007214222
+	QUAD $0xbdbd2d335e51a935                           // .quad -4774610331293865675
+	QUAD $0xb208ef855c969f4f                           // .quad -5617977179081629873
+	QUAD $0xad2c788035e61382                           // .quad -5968262914117332094
+	QUAD $0xde8b2b66b3bc4723                           // .quad -2410785455424649437
+	QUAD $0x4c3bcb5021afcc31                           // .quad 5493207715531443249
+	QUAD $0x8b16fb203055ac76                           // .quad -8424269937281487754
+	QUAD $0xdf4abe242a1bbf3d                           // .quad -2356862392440471747
+	QUAD $0xaddcb9e83c6b1793                           // .quad -5918651403174471789
+	QUAD $0xd71d6dad34a2af0d                           // .quad -2946077990550589683
+	QUAD $0xd953e8624b85dd78                           // .quad -2786628235540701832
+	QUAD $0x8672648c40e5ad68                           // .quad -8758827771735200408
+	QUAD $0x87d4713d6f33aa6b                           // .quad -8659171674854020501
+	QUAD $0x680efdaf511f18c2                           // .quad 7498209359040551106
+	QUAD $0xa9c98d8ccb009506                           // .quad -6212278575140137722
+	QUAD $0x0212bd1b2566def2                           // .quad 149389661945913074
+	QUAD $0xd43bf0effdc0ba48                           // .quad -3153662200497784248
+	QUAD $0x014bb630f7604b57                           // .quad 93368538716195671
+	QUAD $0x84a57695fe98746d                           // .quad -8888567902952197011
+	QUAD $0x419ea3bd35385e2d                           // .quad 4728396691822632493
+	QUAD $0xa5ced43b7e3e9188                           // .quad -6499023860262858360
+	QUAD $0x52064cac828675b9                           // .quad 5910495864778290617
+	QUAD $0xcf42894a5dce35ea                           // .quad -3512093806901185046
+	QUAD $0x7343efebd1940993                           // .quad 8305745933913819539
+	QUAD $0x818995ce7aa0e1b2                           // .quad -9112587656954322510
+	QUAD $0x1014ebe6c5f90bf8                           // .quad 1158810380537498616
+	QUAD $0xa1ebfb4219491a1f                           // .quad -6779048552765515233
+	QUAD $0xd41a26e077774ef6                           // .quad -3163173042755514634
+	QUAD $0xca66fa129f9b60a6                           // .quad -3862124672529506138
+	QUAD $0x8920b098955522b4                           // .quad -8565652321871781196
+	QUAD $0xfd00b897478238d0                           // .quad -215969822234494768
+	QUAD $0x55b46e5f5d5535b0                           // .quad 6175682344898606512
+	QUAD $0x9e20735e8cb16382                           // .quad -7052510166537641086
+	QUAD $0xeb2189f734aa831d                           // .quad -1503769105731517667
+	QUAD $0xc5a890362fddbc62                           // .quad -4203951689744663454
+	QUAD $0xa5e9ec7501d523e4                           // .quad -6491397400591784988
+	QUAD $0xf712b443bbd52b7b                           // .quad -643253593753441413
+	QUAD $0x47b233c92125366e                           // .quad 5166248661484910190
+	QUAD $0x9a6bb0aa55653b2d                           // .quad -7319562523736982739
+	QUAD $0x999ec0bb696e840a                           // .quad -7377247228426025974
+	QUAD $0xc1069cd4eabe89f8                           // .quad -4537767136243840520
+	QUAD $0xc00670ea43ca250d                           // .quad -4609873017105144563
+	QUAD $0xf148440a256e2c76                           // .quad -1060522901877412746
+	QUAD $0x380406926a5e5728                           // .quad 4036358391950366504
+	QUAD $0x96cd2a865764dbca                           // .quad -7580355841314464822
+	QUAD $0xc605083704f5ecf2                           // .quad -4177924046916817678
+	QUAD $0xbc807527ed3e12bc                           // .quad -4863758783215693124
+	QUAD $0xf7864a44c633682e                           // .quad -610719040218634194
+	QUAD $0xeba09271e88d976b                           // .quad -1468012460592228501
+	QUAD $0x7ab3ee6afbe0211d                           // .quad 8841672636718129437
+	QUAD $0x93445b8731587ea3                           // .quad -7835036815511224669
+	QUAD $0x5960ea05bad82964                           // .quad 6440404777470273892
+	QUAD $0xb8157268fdae9e4c                           // .quad -5182110000961642932
+	QUAD $0x6fb92487298e33bd                           // .quad 8050505971837842365
+	QUAD $0xe61acf033d1a45df                           // .quad -1865951482774665761
+	QUAD $0xa5d3b6d479f8e056                           // .quad -6497648813669818282
+	QUAD $0x8fd0c16206306bab                           // .quad -8083748704375247957
+	QUAD $0x8f48a4899877186c                           // .quad -8122061017087272852
+	QUAD $0xb3c4f1ba87bc8696                           // .quad -5492999862041672042
+	QUAD $0x331acdabfe94de87                           // .quad 3682481783923072647
+	QUAD $0xe0b62e2929aba83c                           // .quad -2254563809124702148
+	QUAD $0x9ff0c08b7f1d0b14                           // .quad -6921820921902855404
+	QUAD $0x8c71dcd9ba0b4925                           // .quad -8326631408344020699
+	QUAD $0x07ecf0ae5ee44dd9                           // .quad 571095884476206553
+	QUAD $0xaf8e5410288e1b6f                           // .quad -5796603242002637969
+	QUAD $0xc9e82cd9f69d6150                           // .quad -3897816162832129712
+	QUAD $0xdb71e91432b1a24a                           // .quad -2634068034075909558
+	QUAD $0xbe311c083a225cd2                           // .quad -4741978110983775022
+	QUAD $0x892731ac9faf056e                           // .quad -8563821548938525330
+	QUAD $0x6dbd630a48aaf406                           // .quad 7907585416552444934
+	QUAD $0xab70fe17c79ac6ca                           // .quad -6093090917745768758
+	QUAD $0x092cbbccdad5b108                           // .quad 661109733835780360
+	QUAD $0xd64d3d9db981787d                           // .quad -3004677628754823043
+	QUAD $0x25bbf56008c58ea5                           // .quad 2719036592861056677
+	QUAD $0x85f0468293f0eb4e                           // .quad -8795452545612846258
+	QUAD $0xaf2af2b80af6f24e                           // .quad -5824576295778454962
+	QUAD $0xa76c582338ed2621                           // .quad -6382629663588669919
+	QUAD $0x1af5af660db4aee1                           // .quad 1942651667131707105
+	QUAD $0xd1476e2c07286faa                           // .quad -3366601061058449494
+	QUAD $0x50d98d9fc890ed4d                           // .quad 5825843310384704845
+	QUAD $0x82cca4db847945ca                           // .quad -9021654690802612790
+	QUAD $0xe50ff107bab528a0                           // .quad -1941067898873894752
+	QUAD $0xa37fce126597973c                           // .quad -6665382345075878084
+	QUAD $0x1e53ed49a96272c8                           // .quad 2185351144835019464
+	QUAD $0xcc5fc196fefd7d0c                           // .quad -3720041912917459700
+	QUAD $0x25e8e89c13bb0f7a                           // .quad 2731688931043774330
+	QUAD $0xff77b1fcbebcdc4f                           // .quad -38366372719436721
+	QUAD $0x77b191618c54e9ac                           // .quad 8624834609543440812
+	QUAD $0x9faacf3df73609b1                           // .quad -6941508010590729807
+	QUAD $0xd59df5b9ef6a2417                           // .quad -3054014793352862697
+	QUAD $0xc795830d75038c1d                           // .quad -4065198994811024355
+	QUAD $0x4b0573286b44ad1d                           // .quad 5405853545163697437
+	QUAD $0xf97ae3d0d2446f25                           // .quad -469812725086392539
+	QUAD $0x4ee367f9430aec32                           // .quad 5684501474941004850
+	QUAD $0x9becce62836ac577                           // .quad -7211161980820077193
+	QUAD $0x229c41f793cda73f                           // .quad 2493940825248868159
+	QUAD $0xc2e801fb244576d5                           // .quad -4402266457597708587
+	QUAD $0x6b43527578c1110f                           // .quad 7729112049988473103
+	QUAD $0xf3a20279ed56d48a                           // .quad -891147053569747830
+	QUAD $0x830a13896b78aaa9                           // .quad -9004363024039368023
+	QUAD $0x9845418c345644d6                           // .quad -7474495936122174250
+	QUAD $0x23cc986bc656d553                           // .quad 2579604275232953683
+	QUAD $0xbe5691ef416bd60c                           // .quad -4731433901725329908
+	QUAD $0x2cbfbe86b7ec8aa8                           // .quad 3224505344041192104
+	QUAD $0xedec366b11c6cb8f                           // .quad -1302606358729274481
+	QUAD $0x7bf7d71432f3d6a9                           // .quad 8932844867666826921
+	QUAD $0x94b3a202eb1c3f39                           // .quad -7731658001846878407
+	QUAD $0xdaf5ccd93fb0cc53                           // .quad -2669001970698630061
+	QUAD $0xb9e08a83a5e34f07                           // .quad -5052886483881210105
+	QUAD $0xd1b3400f8f9cff68                           // .quad -3336252463373287576
+	QUAD $0xe858ad248f5c22c9                           // .quad -1704422086424124727
+	QUAD $0x23100809b9c21fa1                           // .quad 2526528228819083169
+	QUAD $0x91376c36d99995be                           // .quad -7982792831656159810
+	QUAD $0xabd40a0c2832a78a                           // .quad -6065211750830921846
+	QUAD $0xb58547448ffffb2d                           // .quad -5366805021142811859
+	QUAD $0x16c90c8f323f516c                           // .quad 1641857348316123500
+	QUAD $0xe2e69915b3fff9f9                           // .quad -2096820258001126919
+	QUAD $0xae3da7d97f6792e3                           // .quad -5891368184943504669
+	QUAD $0x8dd01fad907ffc3b                           // .quad -8228041688891786181
+	QUAD $0x99cd11cfdf41779c                           // .quad -7364210231179380836
+	QUAD $0xb1442798f49ffb4a                           // .quad -5673366092687344822
+	QUAD $0x40405643d711d583                           // .quad 4629795266307937667
+	QUAD $0xdd95317f31c7fa1d                           // .quad -2480021597431793123
+	QUAD $0x482835ea666b2572                           // .quad 5199465050656154994
+	QUAD $0x8a7d3eef7f1cfc52                           // .quad -8467542526035952558
+	QUAD $0xda3243650005eecf                           // .quad -2724040723534582065
+	QUAD $0xad1c8eab5ee43b66                           // .quad -5972742139117552794
+	QUAD $0x90bed43e40076a82                           // .quad -8016736922845615486
+	QUAD $0xd863b256369d4a40                           // .quad -2854241655469553088
+	QUAD $0x5a7744a6e804a291                           // .quad 6518754469289960081
+	QUAD $0x873e4f75e2224e68                           // .quad -8701430062309552536
+	QUAD $0x711515d0a205cb36                           // .quad 8148443086612450102
+	QUAD $0xa90de3535aaae202                           // .quad -6265101559459552766
+	QUAD $0x0d5a5b44ca873e03                           // .quad 962181821410786819
+	QUAD $0xd3515c2831559a83                           // .quad -3219690930897053053
+	QUAD $0xe858790afe9486c2                           // .quad -1704479370831952190
+	QUAD $0x8412d9991ed58091                           // .quad -8929835859451740015
+	QUAD $0x626e974dbe39a872                           // .quad 7092772823314835570
+	QUAD $0xa5178fff668ae0b6                           // .quad -6550608805887287114
+	QUAD $0xfb0a3d212dc8128f                           // .quad -357406007711231345
+	QUAD $0xce5d73ff402d98e3                           // .quad -3576574988931720989
+	QUAD $0x7ce66634bc9d0b99                           // .quad 8999993282035256217
+	QUAD $0x80fa687f881c7f8e                           // .quad -9152888395723407474
+	QUAD $0x1c1fffc1ebc44e80                           // .quad 2026619565689294464
+	QUAD $0xa139029f6a239f72                           // .quad -6829424476226871438
+	QUAD $0xa327ffb266b56220                           // .quad -6690097579743157728
+	QUAD $0xc987434744ac874e                           // .quad -3925094576856201394
+	QUAD $0x4bf1ff9f0062baa8                           // .quad 5472436080603216552
+	QUAD $0xfbe9141915d7a922                           // .quad -294682202642863838
+	QUAD $0x6f773fc3603db4a9                           // .quad 8031958568804398249
+	QUAD $0x9d71ac8fada6c9b5                           // .quad -7101705404292871755
+	QUAD $0xcb550fb4384d21d3                           // .quad -3795109844276665901
+	QUAD $0xc4ce17b399107c22                           // .quad -4265445736938701790
+	QUAD $0x7e2a53a146606a48                           // .quad 9091170749936331336
+	QUAD $0xf6019da07f549b2b                           // .quad -720121152745989333
+	QUAD $0x2eda7444cbfc426d                           // .quad 3376138709496513133
+	QUAD $0x99c102844f94e0fb                           // .quad -7367604748107325189
+	QUAD $0xfa911155fefb5308                           // .quad -391512631556746488
+	QUAD $0xc0314325637a1939                           // .quad -4597819916706768583
+	QUAD $0x793555ab7eba27ca                           // .quad 8733981247408842698
+	QUAD $0xf03d93eebc589f88                           // .quad -1135588877456072824
+	QUAD $0x4bc1558b2f3458de                           // .quad 5458738279630526686
+	QUAD $0x96267c7535b763b5                           // .quad -7627272076051127371
+	QUAD $0x9eb1aaedfb016f16                           // .quad -7011635205744005354
+	QUAD $0xbbb01b9283253ca2                           // .quad -4922404076636521310
+	QUAD $0x465e15a979c1cadc                           // .quad 5070514048102157020
+	QUAD $0xea9c227723ee8bcb                           // .quad -1541319077368263733
+	QUAD $0x0bfacd89ec191ec9                           // .quad 863228270850154185
+	QUAD $0x92a1958a7675175f                           // .quad -7880853450996246689
+	QUAD $0xcef980ec671f667b                           // .quad -3532650679864695173
+	QUAD $0xb749faed14125d36                           // .quad -5239380795317920458
+	QUAD $0x82b7e12780e7401a                           // .quad -9027499368258256870
+	QUAD $0xe51c79a85916f484                           // .quad -1937539975720012668
+	QUAD $0xd1b2ecb8b0908810                           // .quad -3336344095947716592
+	QUAD $0x8f31cc0937ae58d2                           // .quad -8128491512466089774
+	QUAD $0x861fa7e6dcb4aa15                           // .quad -8782116138362033643
+	QUAD $0xb2fe3f0b8599ef07                           // .quad -5548928372155224313
+	QUAD $0x67a791e093e1d49a                           // .quad 7469098900757009562
+	QUAD $0xdfbdcece67006ac9                           // .quad -2324474446766642487
+	QUAD $0xe0c8bb2c5c6d24e0                           // .quad -2249342214667950880
+	QUAD $0x8bd6a141006042bd                           // .quad -8370325556870233411
+	QUAD $0x58fae9f773886e18                           // .quad 6411694268519837208
+	QUAD $0xaecc49914078536d                           // .quad -5851220927660403859
+	QUAD $0xaf39a475506a899e                           // .quad -5820440219632367202
+	QUAD $0xda7f5bf590966848                           // .quad -2702340141148116920
+	QUAD $0x6d8406c952429603                           // .quad 7891439908798240259
+	QUAD $0x888f99797a5e012d                           // .quad -8606491615858654931
+	QUAD $0xc8e5087ba6d33b83                           // .quad -3970758169284363389
+	QUAD $0xaab37fd7d8f58178                           // .quad -6146428501395930760
+	QUAD $0xfb1e4a9a90880a64                           // .quad -351761693178066332
+	QUAD $0xd5605fcdcf32e1d6                           // .quad -3071349608317525546
+	QUAD $0x5cf2eea09a55067f                           // .quad 6697677969404790399
+	QUAD $0x855c3be0a17fcd26                           // .quad -8837122532839535322
+	QUAD $0xf42faa48c0ea481e                           // .quad -851274575098787810
+	QUAD $0xa6b34ad8c9dfc06f                           // .quad -6434717147622031249
+	QUAD $0xf13b94daf124da26                           // .quad -1064093218873484762
+	QUAD $0xd0601d8efc57b08b                           // .quad -3431710416100151157
+	QUAD $0x76c53d08d6b70858                           // .quad 8558313775058847832
+	QUAD $0x823c12795db6ce57                           // .quad -9062348037703676329
+	QUAD $0x54768c4b0c64ca6e                           // .quad 6086206200396171886
+	QUAD $0xa2cb1717b52481ed                           // .quad -6716249028702207507
+	QUAD $0xa9942f5dcf7dfd09                           // .quad -6227300304786948855
+	QUAD $0xcb7ddcdda26da268                           // .quad -3783625267450371480
+	QUAD $0xd3f93b35435d7c4c                           // .quad -3172439362556298164
+	QUAD $0xfe5d54150b090b02                           // .quad -117845565885576446
+	QUAD $0xc47bc5014a1a6daf                           // .quad -4288617610811380305
+	QUAD $0x9efa548d26e5a6e1                           // .quad -6991182506319567135
+	QUAD $0x359ab6419ca1091b                           // .quad 3862600023340550427
+	QUAD $0xc6b8e9b0709f109a                           // .quad -4127292114472071014
+	QUAD $0xc30163d203c94b62                           // .quad -4395122007679087774
+	QUAD $0xf867241c8cc6d4c0                           // .quad -547429124662700864
+	QUAD $0x79e0de63425dcf1d                           // .quad 8782263791269039901
+	QUAD $0x9b407691d7fc44f8                           // .quad -7259672230555269896
+	QUAD $0x985915fc12f542e4                           // .quad -7468914334623251740
+	QUAD $0xc21094364dfb5636                           // .quad -4462904269766699466
+	QUAD $0x3e6f5b7b17b2939d                           // .quad 4498915137003099037
+	QUAD $0xf294b943e17a2bc4                           // .quad -966944318780986428
+	QUAD $0xa705992ceecf9c42                           // .quad -6411550076227838910
+	QUAD $0x979cf3ca6cec5b5a                           // .quad -7521869226879198374
+	QUAD $0x50c6ff782a838353                           // .quad 5820620459997365075
+	QUAD $0xbd8430bd08277231                           // .quad -4790650515171610063
+	QUAD $0xa4f8bf5635246428                           // .quad -6559282480285457368
+	QUAD $0xece53cec4a314ebd                           // .quad -1376627125537124675
+	QUAD $0x871b7795e136be99                           // .quad -8711237568605798759
+	QUAD $0x940f4613ae5ed136                           // .quad -7777920981101784778
+	QUAD $0x28e2557b59846e3f                           // .quad 2946011094524915263
+	QUAD $0xb913179899f68584                           // .quad -5110715207949843068
+	QUAD $0x331aeada2fe589cf                           // .quad 3682513868156144079
+	QUAD $0xe757dd7ec07426e5                           // .quad -1776707991509915931
+	QUAD $0x3ff0d2c85def7621                           // .quad 4607414176811284001
+	QUAD $0x9096ea6f3848984f                           // .quad -8027971522334779313
+	QUAD $0x0fed077a756b53a9                           // .quad 1147581702586717097
+	QUAD $0xb4bca50b065abe63                           // .quad -5423278384491086237
+	QUAD $0xd3e8495912c62894                           // .quad -3177208890193991532
+	QUAD $0xe1ebce4dc7f16dfb                           // .quad -2167411962186469893
+	QUAD $0x64712dd7abbbd95c                           // .quad 7237616480483531100
+	QUAD $0x8d3360f09cf6e4bd                           // .quad -8272161504007625539
+	QUAD $0xbd8d794d96aacfb3                           // .quad -4788037454677749837
+	QUAD $0xb080392cc4349dec                           // .quad -5728515861582144020
+	QUAD $0xecf0d7a0fc5583a0                           // .quad -1373360799919799392
+	QUAD $0xdca04777f541c567                           // .quad -2548958808550292121
+	QUAD $0xf41686c49db57244                           // .quad -858350499949874620
+	QUAD $0x89e42caaf9491b60                           // .quad -8510628282985014432
+	QUAD $0x311c2875c522ced5                           // .quad 3538747893490044629
+	QUAD $0xac5d37d5b79b6239                           // .quad -6026599335303880135
+	QUAD $0x7d633293366b828b                           // .quad 9035120885289943691
+	QUAD $0xd77485cb25823ac7                           // .quad -2921563150702462265
+	QUAD $0xae5dff9c02033197                           // .quad -5882264492762254953
+	QUAD $0x86a8d39ef77164bc                           // .quad -8743505996830120772
+	QUAD $0xd9f57f830283fdfc                           // .quad -2741144597525430788
+	QUAD $0xa8530886b54dbdeb                           // .quad -6317696477610263061
+	QUAD $0xd072df63c324fd7b                           // .quad -3426430746906788485
+	QUAD $0xd267caa862a12d66                           // .quad -3285434578585440922
+	QUAD $0x4247cb9e59f71e6d                           // .quad 4776009810824339053
+	QUAD $0x8380dea93da4bc60                           // .quad -8970925639256982432
+	QUAD $0x52d9be85f074e608                           // .quad 5970012263530423816
+	QUAD $0xa46116538d0deb78                           // .quad -6601971030643840136
+	QUAD $0x67902e276c921f8b                           // .quad 7462515329413029771
+	QUAD $0xcd795be870516656                           // .quad -3640777769877412266
+	QUAD $0x00ba1cd8a3db53b6                           // .quad 52386062455755702
+	QUAD $0x806bd9714632dff6                           // .quad -9193015133814464522
+	QUAD $0x80e8a40eccd228a4                           // .quad -9157889458785081180
+	QUAD $0xa086cfcd97bf97f3                           // .quad -6879582898840692749
+	QUAD $0x6122cd128006b2cd                           // .quad 6999382250228200141
+	QUAD $0xc8a883c0fdaf7df0                           // .quad -3987792605123478032
+	QUAD $0x796b805720085f81                           // .quad 8749227812785250177
+	QUAD $0xfad2a4b13d1b5d6c                           // .quad -373054737976959636
+	QUAD $0xcbe3303674053bb0                           // .quad -3755104653863994448
+	QUAD $0x9cc3a6eec6311a63                           // .quad -7150688238876681629
+	QUAD $0xbedbfc4411068a9c                           // .quad -4693880817329993060
+	QUAD $0xc3f490aa77bd60fc                           // .quad -4326674280168464132
+	QUAD $0xee92fb5515482d44                           // .quad -1255665003235103420
+	QUAD $0xf4f1b4d515acb93b                           // .quad -796656831783192261
+	QUAD $0x751bdd152d4d1c4a                           // .quad 8438581409832836170
+	QUAD $0x991711052d8bf3c5                           // .quad -7415439547505577019
+	QUAD $0xd262d45a78a0635d                           // .quad -3286831292991118499
+	QUAD $0xbf5cd54678eef0b6                           // .quad -4657613415954583370
+	QUAD $0x86fb897116c87c34                           // .quad -8720225134666286028
+	QUAD $0xef340a98172aace4                           // .quad -1210330751515841308
+	QUAD $0xd45d35e6ae3d4da0                           // .quad -3144297699952734816
+	QUAD $0x9580869f0e7aac0e                           // .quad -7673985747338482674
+	QUAD $0x8974836059cca109                           // .quad -8542058143368306423
+	QUAD $0xbae0a846d2195712                           // .quad -4980796165745715438
+	QUAD $0x2bd1a438703fc94b                           // .quad 3157485376071780683
+	QUAD $0xe998d258869facd7                           // .quad -1614309188754756393
+	QUAD $0x7b6306a34627ddcf                           // .quad 8890957387685944783
+	QUAD $0x91ff83775423cc06                           // .quad -7926472270612804602
+	QUAD $0x1a3bc84c17b1d542                           // .quad 1890324697752655170
+	QUAD $0xb67f6455292cbf08                           // .quad -5296404319838617848
+	QUAD $0x20caba5f1d9e4a93                           // .quad 2362905872190818963
+	QUAD $0xe41f3d6a7377eeca                           // .quad -2008819381370884406
+	QUAD $0x547eb47b7282ee9c                           // .quad 6088502188546649756
+	QUAD $0x8e938662882af53e                           // .quad -8173041140997884610
+	QUAD $0xe99e619a4f23aa43                           // .quad -1612744301171463613
+	QUAD $0xb23867fb2a35b28d                           // .quad -5604615407819967859
+	QUAD $0x6405fa00e2ec94d4                           // .quad 7207441660390446292
+	QUAD $0xdec681f9f4c31f31                           // .quad -2394083241347571919
+	QUAD $0xde83bc408dd3dd04                           // .quad -2412877989897052924
+	QUAD $0x8b3c113c38f9f37e                           // .quad -8413831053483314306
+	QUAD $0x9624ab50b148d445                           // .quad -7627783505798704059
+	QUAD $0xae0b158b4738705e                           // .quad -5905602798426754978
+	QUAD $0x3badd624dd9b0957                           // .quad 4300328673033783639
+	QUAD $0xd98ddaee19068c76                           // .quad -2770317479606055818
+	QUAD $0xe54ca5d70a80e5d6                           // .quad -1923980597781273130
+	QUAD $0x87f8a8d4cfa417c9                           // .quad -8648977452394866743
+	QUAD $0x5e9fcf4ccd211f4c                           // .quad 6818396289628184396
+	QUAD $0xa9f6d30a038d1dbc                           // .quad -6199535797066195524
+	QUAD $0x7647c3200069671f                           // .quad 8522995362035230495
+	QUAD $0xd47487cc8470652b                           // .quad -3137733727905356501
+	QUAD $0x29ecd9f40041e073                           // .quad 3021029092058325107
+	QUAD $0x84c8d4dfd2c63f3b                           // .quad -8878612607581929669
+	QUAD $0xf468107100525890                           // .quad -835399653354481520
+	QUAD $0xa5fb0a17c777cf09                           // .quad -6486579741050024183
+	QUAD $0x7182148d4066eeb4                           // .quad 8179122470161673908
+	QUAD $0xcf79cc9db955c2cc                           // .quad -3496538657885142324
+	QUAD $0xc6f14cd848405530                           // .quad -4111420493003729616
+	QUAD $0x81ac1fe293d599bf                           // .quad -9102865688819295809
+	QUAD $0xb8ada00e5a506a7c                           // .quad -5139275616254662020
+	QUAD $0xa21727db38cb002f                           // .quad -6766896092596731857
+	QUAD $0xa6d90811f0e4851c                           // .quad -6424094520318327524
+	QUAD $0xca9cf1d206fdc03b                           // .quad -3846934097318526917
+	QUAD $0x908f4a166d1da663                           // .quad -8030118150397909405
+	QUAD $0xfd442e4688bd304a                           // .quad -196981603220770742
+	QUAD $0x9a598e4e043287fe                           // .quad -7324666853212387330
+	QUAD $0x9e4a9cec15763e2e                           // .quad -7040642529654063570
+	QUAD $0x40eff1e1853f29fd                           // .quad 4679224488766679549
+	QUAD $0xc5dd44271ad3cdba                           // .quad -4189117143640191558
+	QUAD $0xd12bee59e68ef47c                           // .quad -3374341425896426372
+	QUAD $0xf7549530e188c128                           // .quad -624710411122851544
+	QUAD $0x82bb74f8301958ce                           // .quad -9026492418826348338
+	QUAD $0x9a94dd3e8cf578b9                           // .quad -7307973034592864071
+	QUAD $0xe36a52363c1faf01                           // .quad -2059743486678159615
+	QUAD $0xc13a148e3032d6e7                           // .quad -4523280274813692185
+	QUAD $0xdc44e6c3cb279ac1                           // .quad -2574679358347699519
+	QUAD $0xf18899b1bc3f8ca1                           // .quad -1042414325089727327
+	QUAD $0x29ab103a5ef8c0b9                           // .quad 3002511419460075705
+	QUAD $0x96f5600f15a7b7e5                           // .quad -7569037980822161435
+	QUAD $0x7415d448f6b6f0e7                           // .quad 8364825292752482535
+	QUAD $0xbcb2b812db11a5de                           // .quad -4849611457600313890
+	QUAD $0x111b495b3464ad21                           // .quad 1232659579085827361
+	QUAD $0xebdf661791d60f56                           // .quad -1450328303573004458
+	QUAD $0xcab10dd900beec34                           // .quad -3841273781498745804
+	QUAD $0x936b9fcebb25c995                           // .quad -7823984217374209643
+	QUAD $0x3d5d514f40eea742                           // .quad 4421779809981343554
+	QUAD $0xb84687c269ef3bfb                           // .quad -5168294253290374149
+	QUAD $0x0cb4a5a3112a5112                           // .quad 915538744049291538
+	QUAD $0xe65829b3046b0afa                           // .quad -1848681798185579782
+	QUAD $0x47f0e785eaba72ab                           // .quad 5183897733458195115
+	QUAD $0x8ff71a0fe2c2e6dc                           // .quad -8072955151507069220
+	QUAD $0x59ed216765690f56                           // .quad 6479872166822743894
+	QUAD $0xb3f4e093db73a093                           // .quad -5479507920956448621
+	QUAD $0x306869c13ec3532c                           // .quad 3488154190101041964
+	QUAD $0xe0f218b8d25088b8                           // .quad -2237698882768172872
+	QUAD $0x1e414218c73a13fb                           // .quad 2180096368813151227
+	QUAD $0x8c974f7383725573                           // .quad -8316090829371189901
+	QUAD $0xe5d1929ef90898fa                           // .quad -1886565557410948870
+	QUAD $0xafbd2350644eeacf                           // .quad -5783427518286599473
+	QUAD $0xdf45f746b74abf39                           // .quad -2358206946763686087
+	QUAD $0xdbac6c247d62a583                           // .quad -2617598379430861437
+	QUAD $0x6b8bba8c328eb783                           // .quad 7749492695127472003
+	QUAD $0x894bc396ce5da772                           // .quad -8553528014785370254
+	QUAD $0x066ea92f3f326564                           // .quad 463493832054564196
+	QUAD $0xab9eb47c81f5114f                           // .quad -6080224000054324913
+	QUAD $0xc80a537b0efefebd                           // .quad -4032318728359182659
+	QUAD $0xd686619ba27255a2                           // .quad -2988593981640518238
+	QUAD $0xbd06742ce95f5f36                           // .quad -4826042214438183114
+	QUAD $0x8613fd0145877585                           // .quad -8785400266166405755
+	QUAD $0x2c48113823b73704                           // .quad 3190819268807046916
+	QUAD $0xa798fc4196e952e7                           // .quad -6370064314280619289
+	QUAD $0xf75a15862ca504c5                           // .quad -623161932418579259
+	QUAD $0xd17f3b51fca3a7a0                           // .quad -3350894374423386208
+	QUAD $0x9a984d73dbe722fb                           // .quad -7307005235402693893
+	QUAD $0x82ef85133de648c4                           // .quad -9011838011655698236
+	QUAD $0xc13e60d0d2e0ebba                           // .quad -4522070525825979462
+	QUAD $0xa3ab66580d5fdaf5                           // .quad -6653111496142234891
+	QUAD $0x318df905079926a8                           // .quad 3570783879572301480
+	QUAD $0xcc963fee10b7d1b3                           // .quad -3704703351750405709
+	QUAD $0xfdf17746497f7052                           // .quad -148206168962011054
+	QUAD $0xffbbcfe994e5c61f                           // .quad -19193171260619233
+	QUAD $0xfeb6ea8bedefa633                           // .quad -92628855601256909
+	QUAD $0x9fd561f1fd0f9bd3                           // .quad -6929524759678968877
+	QUAD $0xfe64a52ee96b8fc0                           // .quad -115786069501571136
+	QUAD $0xc7caba6e7c5382c8                           // .quad -4050219931171323192
+	QUAD $0x3dfdce7aa3c673b0                           // .quad 4466953431550423984
+	QUAD $0xf9bd690a1b68637b                           // .quad -451088895536766085
+	QUAD $0x06bea10ca65c084e                           // .quad 486002885505321038
+	QUAD $0x9c1661a651213e2d                           // .quad -7199459587351560659
+	QUAD $0x486e494fcff30a62                           // .quad 5219189625309039202
+	QUAD $0xc31bfa0fe5698db8                           // .quad -4387638465762062920
+	QUAD $0x5a89dba3c3efccfa                           // .quad 6523987031636299002
+	QUAD $0xf3e2f893dec3f126                           // .quad -872862063775190746
+	QUAD $0xf89629465a75e01c                           // .quad -534194123654701028
+	QUAD $0x986ddb5c6b3a76b7                           // .quad -7463067817500576073
+	QUAD $0xf6bbb397f1135823                           // .quad -667742654568376285
+	QUAD $0xbe89523386091465                           // .quad -4717148753448332187
+	QUAD $0x746aa07ded582e2c                           // .quad 8388693718644305452
+	QUAD $0xee2ba6c0678b597f                           // .quad -1284749923383027329
+	QUAD $0xa8c2a44eb4571cdc                           // .quad -6286281471915778852
+	QUAD $0x94db483840b717ef                           // .quad -7720497729755473937
+	QUAD $0x92f34d62616ce413                           // .quad -7857851839894723565
+	QUAD $0xba121a4650e4ddeb                           // .quad -5038936143766954517
+	QUAD $0x77b020baf9c81d17                           // .quad 8624429273841147159
+	QUAD $0xe896a0d7e51e1566                           // .quad -1686984161281305242
+	QUAD $0x0ace1474dc1d122e                           // .quad 778582277723329070
+	QUAD $0x915e2486ef32cd60                           // .quad -7971894128441897632
+	QUAD $0x0d819992132456ba                           // .quad 973227847154161338
+	QUAD $0xb5b5ada8aaff80b8                           // .quad -5353181642124984136
+	QUAD $0x10e1fff697ed6c69                           // .quad 1216534808942701673
+	QUAD $0xe3231912d5bf60e6                           // .quad -2079791034228842266
+	QUAD $0xca8d3ffa1ef463c1                           // .quad -3851351762838199359
+	QUAD $0x8df5efabc5979c8f                           // .quad -8217398424034108273
+	QUAD $0xbd308ff8a6b17cb2                           // .quad -4814189703547749198
+	QUAD $0xb1736b96b6fd83b3                           // .quad -5660062011615247437
+	QUAD $0xac7cb3f6d05ddbde                           // .quad -6017737129434686498
+	QUAD $0xddd0467c64bce4a0                           // .quad -2463391496091671392
+	QUAD $0x6bcdf07a423aa96b                           // .quad 7768129340171790699
+	QUAD $0x8aa22c0dbef60ee4                           // .quad -8457148712698376476
+	QUAD $0x86c16c98d2c953c6                           // .quad -8736582398494813242
+	QUAD $0xad4ab7112eb3929d                           // .quad -5959749872445582691
+	QUAD $0xe871c7bf077ba8b7                           // .quad -1697355961263740745
+	QUAD $0xd89d64d57a607744                           // .quad -2838001322129590460
+	QUAD $0x11471cd764ad4972                           // .quad 1244995533423855986
+	QUAD $0x87625f056c7c4a8b                           // .quad -8691279853972075893
+	QUAD $0xd598e40d3dd89bcf                           // .quad -3055441601647567921
+	QUAD $0xa93af6c6c79b5d2d                           // .quad -6252413799037706963
+	QUAD $0x4aff1d108d4ec2c3                           // .quad 5404070034795315907
+	QUAD $0xd389b47879823479                           // .quad -3203831230369745799
+	QUAD $0xcedf722a585139ba                           // .quad -3539985255894009414
+	QUAD $0x843610cb4bf160cb                           // .quad -8919923546622172981
+	QUAD $0xc2974eb4ee658828                           // .quad -4424981569867511768
+	QUAD $0xa54394fe1eedb8fe                           // .quad -6538218414850328322
+	QUAD $0x733d226229feea32                           // .quad 8303831092947774002
+	QUAD $0xce947a3da6a9273e                           // .quad -3561087000135522498
+	QUAD $0x0806357d5a3f525f                           // .quad 578208414664970847
+	QUAD $0x811ccc668829b887                           // .quad -9143208402725783417
+	QUAD $0xca07c2dcb0cf26f7                           // .quad -3888925500096174345
+	QUAD $0xa163ff802a3426a8                           // .quad -6817324484979841368
+	QUAD $0xfc89b393dd02f0b5                           // .quad -249470856692830027
+	QUAD $0xc9bcff6034c13052                           // .quad -3909969587797413806
+	QUAD $0xbbac2078d443ace2                           // .quad -4923524589293425438
+	QUAD $0xfc2c3f3841f17c67                           // .quad -275775966319379353
+	QUAD $0xd54b944b84aa4c0d                           // .quad -3077202868308390899
+	QUAD $0x9d9ba7832936edc0                           // .quad -7089889006590693952
+	QUAD $0x0a9e795e65d4df11                           // .quad 765182433041899281
+	QUAD $0xc5029163f384a931                           // .quad -4250675239810979535
+	QUAD $0x4d4617b5ff4a16d5                           // .quad 5568164059729762005
+	QUAD $0xf64335bcf065d37d                           // .quad -701658031336336515
+	QUAD $0x504bced1bf8e4e45                           // .quad 5785945546544795205
+	QUAD $0x99ea0196163fa42e                           // .quad -7356065297226292178
+	QUAD $0xe45ec2862f71e1d6                           // .quad -1990940103673781802
+	QUAD $0xc06481fb9bcf8d39                           // .quad -4583395603105477319
+	QUAD $0x5d767327bb4e5a4c                           // .quad 6734696907262548556
+	QUAD $0xf07da27a82c37088                           // .quad -1117558485454458744
+	QUAD $0x3a6a07f8d510f86f                           // .quad 4209185567039092847
+	QUAD $0x964e858c91ba2655                           // .quad -7616003081050118571
+	QUAD $0x890489f70a55368b                           // .quad -8573576096483297653
+	QUAD $0xbbe226efb628afea                           // .quad -4908317832885260310
+	QUAD $0x2b45ac74ccea842e                           // .quad 3118087934678041646
+	QUAD $0xeadab0aba3b2dbe5                           // .quad -1523711272679187483
+	QUAD $0x3b0b8bc90012929d                           // .quad 4254647968387469981
+	QUAD $0x92c8ae6b464fc96f                           // .quad -7869848573065574033
+	QUAD $0x09ce6ebb40173744                           // .quad 706623942056949572
+	QUAD $0xb77ada0617e3bbcb                           // .quad -5225624697904579637
+	QUAD $0xcc420a6a101d0515                           // .quad -3728406090856200939
+	QUAD $0xe55990879ddcaabd                           // .quad -1920344853953336643
+	QUAD $0x9fa946824a12232d                           // .quad -6941939825212513491
+	QUAD $0x8f57fa54c2a9eab6                           // .quad -8117744561361917258
+	QUAD $0x47939822dc96abf9                           // .quad 5157633273766521849
+	QUAD $0xb32df8e9f3546564                           // .quad -5535494683275008668
+	QUAD $0x59787e2b93bc56f7                           // .quad 6447041592208152311
+	QUAD $0xdff9772470297ebd                           // .quad -2307682335666372931
+	QUAD $0x57eb4edb3c55b65a                           // .quad 6335244004343789146
+	QUAD $0x8bfbea76c619ef36                           // .quad -8359830487432564938
+	QUAD $0xede622920b6b23f1                           // .quad -1304317031425039375
+	QUAD $0xaefae51477a06b03                           // .quad -5838102090863318269
+	QUAD $0xe95fab368e45eced                           // .quad -1630396289281299219
+	QUAD $0xdab99e59958885c4                           // .quad -2685941595151759932
+	QUAD $0x11dbcb0218ebb414                           // .quad 1286845328412881940
+	QUAD $0x88b402f7fd75539b                           // .quad -8596242524610931813
+	QUAD $0xd652bdc29f26a119                           // .quad -3003129357911285479
+	QUAD $0xaae103b5fcd2a881                           // .quad -6133617137336276863
+	QUAD $0x4be76d3346f0495f                           // .quad 5469460339465668959
+	QUAD $0xd59944a37c0752a2                           // .quad -3055335403242958174
+	QUAD $0x6f70a4400c562ddb                           // .quad 8030098730593431003
+	QUAD $0x857fcae62d8493a5                           // .quad -8827113654667930715
+	QUAD $0xcb4ccd500f6bb952                           // .quad -3797434642040374958
+	QUAD $0xa6dfbd9fb8e5b88e                           // .quad -6422206049907525490
+	QUAD $0x7e2000a41346a7a7                           // .quad 9088264752731695015
+	QUAD $0xd097ad07a71f26b2                           // .quad -3416071543957018958
+	QUAD $0x8ed400668c0c28c8                           // .quad -8154892584824854328
+	QUAD $0x825ecc24c873782f                           // .quad -9052573742614218705
+	QUAD $0x728900802f0f32fa                           // .quad 8253128342678483706
+	QUAD $0xa2f67f2dfa90563b                           // .quad -6704031159840385477
+	QUAD $0x4f2b40a03ad2ffb9                           // .quad 5704724409920716729
+	QUAD $0xcbb41ef979346bca                           // .quad -3768352931373093942
+	QUAD $0xe2f610c84987bfa8                           // .quad -2092466524453879896
+	QUAD $0xfea126b7d78186bc                           // .quad -98755145788979524
+	QUAD $0x0dd9ca7d2df4d7c9                           // .quad 998051431430019017
+	QUAD $0x9f24b832e6b0f436                           // .quad -6979250993759194058
+	QUAD $0x91503d1c79720dbb                           // .quad -7975807747567252037
+	QUAD $0xc6ede63fa05d3143                           // .quad -4112377723771604669
+	QUAD $0x75a44c6397ce912a                           // .quad 8476984389250486570
+	QUAD $0xf8a95fcf88747d94                           // .quad -528786136287117932
+	QUAD $0xc986afbe3ee11aba                           // .quad -3925256793573221702
+	QUAD $0x9b69dbe1b548ce7c                           // .quad -7248020362820530564
+	QUAD $0xfbe85badce996168                           // .quad -294884973539139224
+	QUAD $0xc24452da229b021b                           // .quad -4448339435098275301
+	QUAD $0xfae27299423fb9c3                           // .quad -368606216923924029
+	QUAD $0xf2d56790ab41c2a2                           // .quad -948738275445456222
+	QUAD $0xdccd879fc967d41a                           // .quad -2536221894791146470
+	QUAD $0x97c560ba6b0919a5                           // .quad -7510490449794491995
+	QUAD $0x5400e987bbc1c920                           // .quad 6053094668365842720
+	QUAD $0xbdb6b8e905cb600f                           // .quad -4776427043815727089
+	QUAD $0x290123e9aab23b68                           // .quad 2954682317029915496
+	QUAD $0xed246723473e3813                           // .quad -1358847786342270957
+	QUAD $0xf9a0b6720aaf6521                           // .quad -459166561069996767
+	QUAD $0x9436c0760c86e30b                           // .quad -7766808894105001205
+	QUAD $0xf808e40e8d5b3e69                           // .quad -573958201337495959
+	QUAD $0xb94470938fa89bce                           // .quad -5096825099203863602
+	QUAD $0xb60b1d1230b20e04                           // .quad -5329133770099257852
+	QUAD $0xe7958cb87392c2c2                           // .quad -1759345355577441598
+	QUAD $0xb1c6f22b5e6f48c2                           // .quad -5636551615525730110
+	QUAD $0x90bd77f3483bb9b9                           // .quad -8017119874876982855
+	QUAD $0x1e38aeb6360b1af3                           // .quad 2177682517447613171
+	QUAD $0xb4ecd5f01a4aa828                           // .quad -5409713825168840664
+	QUAD $0x25c6da63c38de1b0                           // .quad 2722103146809516464
+	QUAD $0xe2280b6c20dd5232                           // .quad -2150456263033662926
+	QUAD $0x579c487e5a38ad0e                           // .quad 6313000485183335694
+	QUAD $0x8d590723948a535f                           // .quad -8261564192037121185
+	QUAD $0x2d835a9df0c6d851                           // .quad 3279564588051781713
+	QUAD $0xb0af48ec79ace837                           // .quad -5715269221619013577
+	QUAD $0xf8e431456cf88e65                           // .quad -512230283362660763
+	QUAD $0xdcdb1b2798182244                           // .quad -2532400508596379068
+	QUAD $0x1b8e9ecb641b58ff                           // .quad 1985699082112030975
+	QUAD $0x8a08f0f8bf0f156b                           // .quad -8500279345513818773
+	QUAD $0xe272467e3d222f3f                           // .quad -2129562165787349185
+	QUAD $0xac8b2d36eed2dac5                           // .quad -6013663163464885563
+	QUAD $0x5b0ed81dcc6abb0f                           // .quad 6561419329620589327
+	QUAD $0xd7adf884aa879177                           // .quad -2905392935903719049
+	QUAD $0x98e947129fc2b4e9                           // .quad -7428327965055601431
+	QUAD $0x86ccbb52ea94baea                           // .quad -8733399612580906262
+	QUAD $0x3f2398d747b36224                           // .quad 4549648098962661924
+	QUAD $0xa87fea27a539e9a5                           // .quad -6305063497298744923
+	QUAD $0x8eec7f0d19a03aad                           // .quad -8147997931578836307
+	QUAD $0xd29fe4b18e88640e                           // .quad -3269643353196043250
+	QUAD $0x1953cf68300424ac                           // .quad 1825030320404309164
+	QUAD $0x83a3eeeef9153e89                           // .quad -8961056123388608887
+	QUAD $0x5fa8c3423c052dd7                           // .quad 6892973918932774359
+	QUAD $0xa48ceaaab75a8e2b                           // .quad -6589634135808373205
+	QUAD $0x3792f412cb06794d                           // .quad 4004531380238580045
+	QUAD $0xcdb02555653131b6                           // .quad -3625356651333078602
+	QUAD $0xe2bbd88bbee40bd0                           // .quad -2108853905778275376
+	QUAD $0x808e17555f3ebf11                           // .quad -9183376934724255983
+	QUAD $0x5b6aceaeae9d0ec4                           // .quad 6587304654631931588
+	QUAD $0xa0b19d2ab70e6ed6                           // .quad -6867535149977932074
+	QUAD $0xf245825a5a445275                           // .quad -989241218564861323
+	QUAD $0xc8de047564d20a8b                           // .quad -3972732919045027189
+	QUAD $0xeed6e2f0f0d56712                           // .quad -1236551523206076654
+	QUAD $0xfb158592be068d2e                           // .quad -354230130378896082
+	QUAD $0x55464dd69685606b                           // .quad 6144684325637283947
+	QUAD $0x9ced737bb6c4183d                           // .quad -7138922859127891907
+	QUAD $0xaa97e14c3c26b886                           // .quad -6154202648235558778
+	QUAD $0xc428d05aa4751e4c                           // .quad -4311967555482476980
+	QUAD $0xd53dd99f4b3066a8                           // .quad -3081067291867060568
+	QUAD $0xf53304714d9265df                           // .quad -778273425925708321
+	QUAD $0xe546a8038efe4029                           // .quad -1925667057416912855
+	QUAD $0x993fe2c6d07b7fab                           // .quad -7403949918844649557
+	QUAD $0xde98520472bdd033                           // .quad -2407083821771141069
+	QUAD $0xbf8fdb78849a5f96                           // .quad -4643251380128424042
+	QUAD $0x963e66858f6d4440                           // .quad -7620540795641314240
+	QUAD $0xef73d256a5c0f77c                           // .quad -1192378206733142148
+	QUAD $0xdde7001379a44aa8                           // .quad -2456994988062127448
+	QUAD $0x95a8637627989aad                           // .quad -7662765406849295699
+	QUAD $0x5560c018580d5d52                           // .quad 6152128301777116498
+	QUAD $0xbb127c53b17ec159                           // .quad -4966770740134231719
+	QUAD $0xaab8f01e6e10b4a6                           // .quad -6144897678060768090
+	QUAD $0xe9d71b689dde71af                           // .quad -1596777406740401745
+	QUAD $0xcab3961304ca70e8                           // .quad -3840561048787980056
+	QUAD $0x9226712162ab070d                           // .quad -7915514906853832947
+	QUAD $0x3d607b97c5fd0d22                           // .quad 4422670725869800738
+	QUAD $0xb6b00d69bb55c8d1                           // .quad -5282707615139903279
+	QUAD $0x8cb89a7db77c506a                           // .quad -8306719647944912790
+	QUAD $0xe45c10c42a2b3b05                           // .quad -1991698500497491195
+	QUAD $0x77f3608e92adb242                           // .quad 8643358275316593218
+	QUAD $0x8eb98a7a9a5b04e3                           // .quad -8162340590452013853
+	QUAD $0x55f038b237591ed3                           // .quad 6192511825718353619
+	QUAD $0xb267ed1940f1c61c                           // .quad -5591239719637629412
+	QUAD $0x6b6c46dec52f6688                           // .quad 7740639782147942024
+	QUAD $0xdf01e85f912e37a3                           // .quad -2377363631119648861
+	QUAD $0x2323ac4b3b3da015                           // .quad 2532056854628769813
+	QUAD $0x8b61313bbabce2c6                           // .quad -8403381297090862394
+	QUAD $0xabec975e0a0d081a                           // .quad -6058300968568813542
+	QUAD $0xae397d8aa96c1b77                           // .quad -5892540602936190089
+	QUAD $0x96e7bd358c904a21                           // .quad -7572876210711016927
+	QUAD $0xd9c7dced53c72255                           // .quad -2753989735242849707
+	QUAD $0x7e50d64177da2e54                           // .quad 9102010423587778132
+	QUAD $0x881cea14545c7575                           // .quad -8638772612167862923
+	QUAD $0xdde50bd1d5d0b9e9                           // .quad -2457545025797441047
+	QUAD $0xaa242499697392d2                           // .quad -6186779746782440750
+	QUAD $0x955e4ec64b44e864                           // .quad -7683617300674189212
+	QUAD $0xd4ad2dbfc3d07787                           // .quad -3121788665050663033
+	QUAD $0xbd5af13bef0b113e                           // .quad -4802260812921368258
+	QUAD $0x84ec3c97da624ab4                           // .quad -8868646943297746252
+	QUAD $0xecb1ad8aeacdd58e                           // .quad -1391139997724322418
+	QUAD $0xa6274bbdd0fadd61                           // .quad -6474122660694794911
+	QUAD $0x67de18eda5814af2                           // .quad 7484447039699372786
+	QUAD $0xcfb11ead453994ba                           // .quad -3480967307441105734
+	QUAD $0x80eacf948770ced7                           // .quad -9157278655470055721
+	QUAD $0x81ceb32c4b43fcf4                           // .quad -9093133594791772940
+	QUAD $0xa1258379a94d028d                           // .quad -6834912300910181747
+	QUAD $0xa2425ff75e14fc31                           // .quad -6754730975062328271
+	QUAD $0x096ee45813a04330                           // .quad 679731660717048624
+	QUAD $0xcad2f7f5359a3b3e                           // .quad -3831727700400522434
+	QUAD $0x8bca9d6e188853fc                           // .quad -8373707460958465028
+	QUAD $0xfd87b5f28300ca0d                           // .quad -177973607073265139
+	QUAD $0x775ea264cf55347d                           // .quad 8601490892183123069
+	QUAD $0x9e74d1b791e07e48                           // .quad -7028762532061872568
+	QUAD $0x95364afe032a819d                           // .quad -7694880458480647779
+	QUAD $0xc612062576589dda                           // .quad -4174267146649952806
+	QUAD $0x3a83ddbd83f52204                           // .quad 4216457482181353988
+	QUAD $0xf79687aed3eec551                           // .quad -606147914885053103
+	QUAD $0xc4926a9672793542                           // .quad -4282243101277735614
+	QUAD $0x9abe14cd44753b52                           // .quad -7296371474444240046
+	QUAD $0x75b7053c0f178293                           // .quad 8482254178684994195
+	QUAD $0xc16d9a0095928a27                           // .quad -4508778324627912153
+	QUAD $0x5324c68b12dd6338                           // .quad 5991131704928854840
+	QUAD $0xf1c90080baf72cb1                           // .quad -1024286887357502287
+	QUAD $0xd3f6fc16ebca5e03                           // .quad -3173071712060547581
+	QUAD $0x971da05074da7bee                           // .quad -7557708332239520786
+	QUAD $0x88f4bb1ca6bcf584                           // .quad -8578025658503072380
+	QUAD $0xbce5086492111aea                           // .quad -4835449396872013078
+	QUAD $0x2b31e9e3d06c32e5                           // .quad 3112525982153323237
+	QUAD $0xec1e4a7db69561a5                           // .quad -1432625727662628443
+	QUAD $0x3aff322e62439fcf                           // .quad 4251171748059520975
+	QUAD $0x9392ee8e921d5d07                           // .quad -7812920107430224633
+	QUAD $0x09befeb9fad487c2                           // .quad 702278666647013314
+	QUAD $0xb877aa3236a4b449                           // .quad -5154464115860392887
+	QUAD $0x4c2ebe687989a9b3                           // .quad 5489534351736154547
+	QUAD $0xe69594bec44de15b                           // .quad -1831394126398103205
+	QUAD $0x0f9d37014bf60a10                           // .quad 1125115960621402640
+	QUAD $0x901d7cf73ab0acd9                           // .quad -8062150356639896359
+	QUAD $0x538484c19ef38c94                           // .quad 6018080969204141204
+	QUAD $0xb424dc35095cd80f                           // .quad -5466001927372482545
+	QUAD $0x2865a5f206b06fb9                           // .quad 2910915193077788601
+	QUAD $0xe12e13424bb40e13                           // .quad -2220816390788215277
+	QUAD $0xf93f87b7442e45d3                           // .quad -486521013540076077
+	QUAD $0x8cbccc096f5088cb                           // .quad -8305539271883716405
+	QUAD $0xf78f69a51539d748                           // .quad -608151266925095096
+	QUAD $0xafebff0bcb24aafe                           // .quad -5770238071427257602
+	QUAD $0xb573440e5a884d1b                           // .quad -5371875102083756773
+	QUAD $0xdbe6fecebdedd5be                           // .quad -2601111570856684098
+	QUAD $0x31680a88f8953030                           // .quad 3560107088838733872
+	QUAD $0x89705f4136b4a597                           // .quad -8543223759426509417
+	QUAD $0xfdc20d2b36ba7c3d                           // .quad -161552157378970563
+	QUAD $0xabcc77118461cefc                           // .quad -6067343680855748868
+	QUAD $0x3d32907604691b4c                           // .quad 4409745821703674700
+	QUAD $0xd6bf94d5e57a42bc                           // .quad -2972493582642298180
+	QUAD $0xa63f9a49c2c1b10f                           // .quad -6467280898289979121
+	QUAD $0x8637bd05af6c69b5                           // .quad -8775337516792518219
+	QUAD $0x0fcf80dc33721d53                           // .quad 1139270913992301907
+	QUAD $0xa7c5ac471b478423                           // .quad -6357485877563259869
+	QUAD $0xd3c36113404ea4a8                           // .quad -3187597375937010520
+	QUAD $0xd1b71758e219652b                           // .quad -3335171328526686933
+	QUAD $0x645a1cac083126e9                           // .quad 7231123676894144233
+	QUAD $0x83126e978d4fdf3b                           // .quad -9002011107970261189
+	QUAD $0x3d70a3d70a3d70a3                           // .quad 4427218577690292387
+	QUAD $0xa3d70a3d70a3d70a                           // .quad -6640827866535438582
+	QUAD $0xcccccccccccccccc; QUAD $0xcccccccccccccccc // .space 16, '\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc'
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x8000000000000000                           // .quad -9223372036854775808
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xa000000000000000                           // .quad -6917529027641081856
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xc800000000000000                           // .quad -4035225266123964416
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xfa00000000000000                           // .quad -432345564227567616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x9c40000000000000                           // .quad -7187745005283311616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xc350000000000000                           // .quad -4372995238176751616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xf424000000000000                           // .quad -854558029293551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x9896800000000000                           // .quad -7451627795949551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xbebc200000000000                           // .quad -4702848726509551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xee6b280000000000                           // .quad -1266874889709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x9502f90000000000                           // .quad -7709325833709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xba43b74000000000                           // .quad -5024971273709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xe8d4a51000000000                           // .quad -1669528073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x9184e72a00000000                           // .quad -7960984073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xb5e620f480000000                           // .quad -5339544073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xe35fa931a0000000                           // .quad -2062744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x8e1bc9bf04000000                           // .quad -8206744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xb1a2bc2ec5000000                           // .quad -5646744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xde0b6b3a76400000                           // .quad -2446744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x8ac7230489e80000                           // .quad -8446744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xad78ebc5ac620000                           // .quad -5946744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xd8d726b7177a8000                           // .quad -2821744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x878678326eac9000                           // .quad -8681119073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xa968163f0a57b400                           // .quad -6239712823709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xd3c21bcecceda100                           // .quad -3187955011209551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x84595161401484a0                           // .quad -8910000909647051616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xa56fa5b99019a5c8                           // .quad -6525815118631426616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xcecb8f27f4200f3a                           // .quad -3545582879861895366
+	QUAD $0x4000000000000000                           // .quad 4611686018427387904
+	QUAD $0x813f3978f8940984                           // .quad -9133518327554766460
+	QUAD $0x5000000000000000                           // .quad 5764607523034234880
+	QUAD $0xa18f07d736b90be5                           // .quad -6805211891016070171
+	QUAD $0xa400000000000000                           // .quad -6629298651489370112
+	QUAD $0xc9f2c9cd04674ede                           // .quad -3894828845342699810
+	QUAD $0x4d00000000000000                           // .quad 5548434740920451072
+	QUAD $0xfc6f7c4045812296                           // .quad -256850038250986858
+	QUAD $0xf020000000000000                           // .quad -1143914305352105984
+	QUAD $0x9dc5ada82b70b59d                           // .quad -7078060301547948643
+	QUAD $0x6c28000000000000                           // .quad 7793479155164643328
+	QUAD $0xc5371912364ce305                           // .quad -4235889358507547899
+	QUAD $0xc732000000000000                           // .quad -4093209111326359552
+	QUAD $0xf684df56c3e01bc6                           // .quad -683175679707046970
+	QUAD $0x3c7f400000000000                           // .quad 4359273333062107136
+	QUAD $0x9a130b963a6c115c                           // .quad -7344513827457986212
+	QUAD $0x4b9f100000000000                           // .quad 5449091666327633920
+	QUAD $0xc097ce7bc90715b3                           // .quad -4568956265895094861
+	QUAD $0x1e86d40000000000                           // .quad 2199678564482154496
+	QUAD $0xf0bdc21abb48db20                           // .quad -1099509313941480672
+	QUAD $0x1314448000000000                           // .quad 1374799102801346560
+	QUAD $0x96769950b50d88f4                           // .quad -7604722348854507276
+	QUAD $0x17d955a000000000                           // .quad 1718498878501683200
+	QUAD $0xbc143fa4e250eb31                           // .quad -4894216917640746191
+	QUAD $0x5dcfab0800000000                           // .quad 6759809616554491904
+	QUAD $0xeb194f8e1ae525fd                           // .quad -1506085128623544835
+	QUAD $0x5aa1cae500000000                           // .quad 6530724019560251392
+	QUAD $0x92efd1b8d0cf37be                           // .quad -7858832233030797378
+	QUAD $0xf14a3d9e40000000                           // .quad -1059967012404461568
+	QUAD $0xb7abc627050305ad                           // .quad -5211854272861108819
+	QUAD $0x6d9ccd05d0000000                           // .quad 7898413271349198848
+	QUAD $0xe596b7b0c643c719                           // .quad -1903131822648998119
+	QUAD $0xe4820023a2000000                           // .quad -1981020733047832576
+	QUAD $0x8f7e32ce7bea5c6f                           // .quad -8106986416796705681
+	QUAD $0xdda2802c8a800000                           // .quad -2476275916309790720
+	QUAD $0xb35dbf821ae4f38b                           // .quad -5522047002568494197
+	QUAD $0xd50b2037ad200000                           // .quad -3095344895387238400
+	QUAD $0xe0352f62a19e306e                           // .quad -2290872734783229842
+	QUAD $0x4526f422cc340000                           // .quad 4982938468024057856
+	QUAD $0x8c213d9da502de45                           // .quad -8349324486880600507
+	QUAD $0x9670b12b7f410000                           // .quad -7606384970252091392
+	QUAD $0xaf298d050e4395d6                           // .quad -5824969590173362730
+	QUAD $0x3c0cdd765f114000                           // .quad 4327076842467049472
+	QUAD $0xdaf3f04651d47b4c                           // .quad -2669525969289315508
+	QUAD $0xa5880a69fb6ac800                           // .quad -6518949010312869888
+	QUAD $0x88d8762bf324cd0f                           // .quad -8585982758446904049
+	QUAD $0x8eea0d047a457a00                           // .quad -8148686262891087360
+	QUAD $0xab0e93b6efee0053                           // .quad -6120792429631242157
+	QUAD $0x72a4904598d6d880                           // .quad 8260886245095692416
+	QUAD $0xd5d238a4abe98068                           // .quad -3039304518611664792
+	QUAD $0x47a6da2b7f864750                           // .quad 5163053903184807760
+	QUAD $0x85a36366eb71f041                           // .quad -8817094351773372351
+	QUAD $0x999090b65f67d924                           // .quad -7381240676301154012
+	QUAD $0xa70c3c40a64e6c51                           // .quad -6409681921289327535
+	QUAD $0xfff4b4e3f741cf6d                           // .quad -3178808521666707
+	QUAD $0xd0cf4b50cfe20765                           // .quad -3400416383184271515
+	QUAD $0xbff8f10e7a8921a4                           // .quad -4613672773753429596
+	QUAD $0x82818f1281ed449f                           // .quad -9042789267131251553
+	QUAD $0xaff72d52192b6a0d                           // .quad -5767090967191786995
+	QUAD $0xa321f2d7226895c7                           // .quad -6691800565486676537
+	QUAD $0x9bf4f8a69f764490                           // .quad -7208863708989733744
+	QUAD $0xcbea6f8ceb02bb39                           // .quad -3753064688430957767
+	QUAD $0x02f236d04753d5b4                           // .quad 212292400617608628
+	QUAD $0xfee50b7025c36a08                           // .quad -79644842111309304
+	QUAD $0x01d762422c946590                           // .quad 132682750386005392
+	QUAD $0x9f4f2726179a2245                           // .quad -6967307053960650171
+	QUAD $0x424d3ad2b7b97ef5                           // .quad 4777539456409894645
+	QUAD $0xc722f0ef9d80aad6                           // .quad -4097447799023424810
+	QUAD $0xd2e0898765a7deb2                           // .quad -3251447716342407502
+	QUAD $0xf8ebad2b84e0d58b                           // .quad -510123730351893109
+	QUAD $0x63cc55f49f88eb2f                           // .quad 7191217214140771119
+	QUAD $0x9b934c3b330c8577                           // .quad -7236356359111015049
+	QUAD $0x3cbf6b71c76b25fb                           // .quad 4377335499248575995
+	QUAD $0xc2781f49ffcfa6d5                           // .quad -4433759430461380907
+	QUAD $0x8bef464e3945ef7a                           // .quad -8363388681221443718
+	QUAD $0xf316271c7fc3908a                           // .quad -930513269649338230
+	QUAD $0x97758bf0e3cbb5ac                           // .quad -7532960934977096276
+	QUAD $0x97edd871cfda3a56                           // .quad -7499099821171918250
+	QUAD $0x3d52eeed1cbea317                           // .quad 4418856886560793367
+	QUAD $0xbde94e8e43d0c8ec                           // .quad -4762188758037509908
+	QUAD $0x4ca7aaa863ee4bdd                           // .quad 5523571108200991709
+	QUAD $0xed63a231d4c4fb27                           // .quad -1341049929119499481
+	QUAD $0x8fe8caa93e74ef6a                           // .quad -8076983103442849942
+	QUAD $0x945e455f24fb1cf8                           // .quad -7755685233340769032
+	QUAD $0xb3e2fd538e122b44                           // .quad -5484542860876174524
+	QUAD $0xb975d6b6ee39e436                           // .quad -5082920523248573386
+	QUAD $0x60dbbca87196b616                           // .quad 6979379479186945558
+	QUAD $0xe7d34c64a9c85d44                           // .quad -1741964635633328828
+	QUAD $0xbc8955e946fe31cd                           // .quad -4861259862362934835
+	QUAD $0x90e40fbeea1d3a4a                           // .quad -8006256924911912374
+	QUAD $0x6babab6398bdbe41                           // .quad 7758483227328495169
+	QUAD $0xb51d13aea4a488dd                           // .quad -5396135137712502563
+	QUAD $0xc696963c7eed2dd1                           // .quad -4136954021121544751
+	QUAD $0xe264589a4dcdab14                           // .quad -2133482903713240300
+	QUAD $0xfc1e1de5cf543ca2                           // .quad -279753253987271518
+	QUAD $0x8d7eb76070a08aec                           // .quad -8250955842461857044
+	QUAD $0x3b25a55f43294bcb                           // .quad 4261994450943298507
+	QUAD $0xb0de65388cc8ada8                           // .quad -5702008784649933400
+	QUAD $0x49ef0eb713f39ebe                           // .quad 5327493063679123134
+	QUAD $0xdd15fe86affad912                           // .quad -2515824962385028846
+	QUAD $0x6e3569326c784337                           // .quad 7941369183226839863
+	QUAD $0x8a2dbf142dfcc7ab                           // .quad -8489919629131724885
+	QUAD $0x49c2c37f07965404                           // .quad 5315025460606161924
+	QUAD $0xacb92ed9397bf996                           // .quad -6000713517987268202
+	QUAD $0xdc33745ec97be906                           // .quad -2579590211097073402
+	QUAD $0xd7e77a8f87daf7fb                           // .quad -2889205879056697349
+	QUAD $0x69a028bb3ded71a3                           // .quad 7611128154919104931
+	QUAD $0x86f0ac99b4e8dafd                           // .quad -8723282702051517699
+	QUAD $0xc40832ea0d68ce0c                           // .quad -4321147861633282548
+	QUAD $0xa8acd7c0222311bc                           // .quad -6292417359137009220
+	QUAD $0xf50a3fa490c30190                           // .quad -789748808614215280
+	QUAD $0xd2d80db02aabd62b                           // .quad -3253835680493873621
+	QUAD $0x792667c6da79e0fa                           // .quad 8729779031470891258
+	QUAD $0x83c7088e1aab65db                           // .quad -8951176327949752869
+	QUAD $0x577001b891185938                           // .quad 6300537770911226168
+	QUAD $0xa4b8cab1a1563f52                           // .quad -6577284391509803182
+	QUAD $0xed4c0226b55e6f86                           // .quad -1347699823215743098
+	QUAD $0xcde6fd5e09abcf26                           // .quad -3609919470959866074
+	QUAD $0x544f8158315b05b4                           // .quad 6075216638131242420
+	QUAD $0x80b05e5ac60b6178                           // .quad -9173728696990998152
+	QUAD $0x696361ae3db1c721                           // .quad 7594020797664053025
+	QUAD $0xa0dc75f1778e39d6                           // .quad -6855474852811359786
+	QUAD $0x03bc3a19cd1e38e9                           // .quad 269153960225290473
+	QUAD $0xc913936dd571c84c                           // .quad -3957657547586811828
+	QUAD $0x04ab48a04065c723                           // .quad 336442450281613091
+	QUAD $0xfb5878494ace3a5f                           // .quad -335385916056126881
+	QUAD $0x62eb0d64283f9c76                           // .quad 7127805559067090038
+	QUAD $0x9d174b2dcec0e47b                           // .quad -7127145225176161157
+	QUAD $0x3ba5d0bd324f8394                           // .quad 4298070930406474644
+	QUAD $0xc45d1df942711d9a                           // .quad -4297245513042813542
+	QUAD $0xca8f44ec7ee36479                           // .quad -3850783373846682503
+	QUAD $0xf5746577930d6500                           // .quad -759870872876129024
+	QUAD $0x7e998b13cf4e1ecb                           // .quad 9122475437414293195
+	QUAD $0x9968bf6abbe85f20                           // .quad -7392448323188662496
+	QUAD $0x9e3fedd8c321a67e                           // .quad -7043649776941685122
+	QUAD $0xbfc2ef456ae276e8                           // .quad -4628874385558440216
+	QUAD $0xc5cfe94ef3ea101e                           // .quad -4192876202749718498
+	QUAD $0xefb3ab16c59b14a2                           // .quad -1174406963520662366
+	QUAD $0xbba1f1d158724a12                           // .quad -4926390635932268014
+	QUAD $0x95d04aee3b80ece5                           // .quad -7651533379841495835
+	QUAD $0x2a8a6e45ae8edc97                           // .quad 3065383741939440791
+	QUAD $0xbb445da9ca61281f                           // .quad -4952730706374481889
+	QUAD $0xf52d09d71a3293bd                           // .quad -779956341003086915
+	QUAD $0xea1575143cf97226                           // .quad -1579227364540714458
+	QUAD $0x593c2626705f9c56                           // .quad 6430056314514152534
+	QUAD $0x924d692ca61be758                           // .quad -7904546130479028392
+	QUAD $0x6f8b2fb00c77836c                           // .quad 8037570393142690668
+	QUAD $0xb6e0c377cfa2e12e                           // .quad -5268996644671397586
+	QUAD $0x0b6dfb9c0f956447                           // .quad 823590954573587527
+	QUAD $0xe498f455c38b997a                           // .quad -1974559787411859078
+	QUAD $0x4724bd4189bd5eac                           // .quad 5126430365035880108
+	QUAD $0x8edf98b59a373fec                           // .quad -8151628894773493780
+	QUAD $0x58edec91ec2cb657                           // .quad 6408037956294850135
+	QUAD $0xb2977ee300c50fe7                           // .quad -5577850100039479321
+	QUAD $0x2f2967b66737e3ed                           // .quad 3398361426941174765
+	QUAD $0xdf3d5e9bc0f653e1                           // .quad -2360626606621961247
+	QUAD $0xbd79e0d20082ee74                           // .quad -4793553135802847628
+	QUAD $0x8b865b215899f46c                           // .quad -8392920656779807636
+	QUAD $0xecd8590680a3aa11                           // .quad -1380255401326171631
+	QUAD $0xae67f1e9aec07187                           // .quad -5879464802547371641
+	QUAD $0xe80e6f4820cc9495                           // .quad -1725319251657714539
+	QUAD $0xda01ee641a708de9                           // .quad -2737644984756826647
+	QUAD $0x3109058d147fdcdd                           // .quad 3533361486141316317
+	QUAD $0x884134fe908658b2                           // .quad -8628557143114098510
+	QUAD $0xbd4b46f0599fd415                           // .quad -4806670179178130411
+	QUAD $0xaa51823e34a7eede                           // .quad -6174010410465235234
+	QUAD $0x6c9e18ac7007c91a                           // .quad 7826720331309500698
+	QUAD $0xd4e5e2cdc1d1ea96                           // .quad -3105826994654156138
+	QUAD $0x03e2cf6bc604ddb0                           // .quad 280014188641050032
+	QUAD $0x850fadc09923329e                           // .quad -8858670899299929442
+	QUAD $0x84db8346b786151c                           // .quad -8873354301053463268
+	QUAD $0xa6539930bf6bff45                           // .quad -6461652605697523899
+	QUAD $0xe612641865679a63                           // .quad -1868320839462053277
+	QUAD $0xcfe87f7cef46ff16                           // .quad -3465379738694516970
+	QUAD $0x4fcb7e8f3f60c07e                           // .quad 5749828502977298558
+	QUAD $0x81f14fae158c5f6e                           // .quad -9083391364325154962
+	QUAD $0xe3be5e330f38f09d                           // .quad -2036086408133152611
+	QUAD $0xa26da3999aef7749                           // .quad -6742553186979055799
+	QUAD $0x5cadf5bfd3072cc5                           // .quad 6678264026688335045
+	QUAD $0xcb090c8001ab551c                           // .quad -3816505465296431844
+	QUAD $0x73d9732fc7c8f7f6                           // .quad 8347830033360418806
+	QUAD $0xfdcb4fa002162a63                           // .quad -158945813193151901
+	QUAD $0x2867e7fddcdd9afa                           // .quad 2911550761636567802
+	QUAD $0x9e9f11c4014dda7e                           // .quad -7016870160886801794
+	QUAD $0xb281e1fd541501b8                           // .quad -5583933584809066056
+	QUAD $0xc646d63501a1511d                           // .quad -4159401682681114339
+	QUAD $0x1f225a7ca91a4226                           // .quad 2243455055843443238
+	QUAD $0xf7d88bc24209a565                           // .quad -587566084924005019
+	QUAD $0x3375788de9b06958                           // .quad 3708002419115845976
+	QUAD $0x9ae757596946075f                           // .quad -7284757830718584993
+	QUAD $0x0052d6b1641c83ae                           // .quad 23317005467419566
+	QUAD $0xc1a12d2fc3978937                           // .quad -4494261269970843337
+	QUAD $0xc0678c5dbd23a49a                           // .quad -4582539761593113446
+	QUAD $0xf209787bb47d6b84                           // .quad -1006140569036166268
+	QUAD $0xf840b7ba963646e0                           // .quad -558244341782001952
+	QUAD $0x9745eb4d50ce6332                           // .quad -7546366883288685774
+	QUAD $0xb650e5a93bc3d898                           // .quad -5309491445654890344
+	QUAD $0xbd176620a501fbff                           // .quad -4821272585683469313
+	QUAD $0xa3e51f138ab4cebe                           // .quad -6636864307068612930
+	QUAD $0xec5d3fa8ce427aff                           // .quad -1414904713676948737
+	QUAD $0xc66f336c36b10137                           // .quad -4148040191917883081
+	QUAD $0x93ba47c980e98cdf                           // .quad -7801844473689174817
+	QUAD $0xb80b0047445d4184                           // .quad -5185050239897353852
+	QUAD $0xb8a8d9bbe123f017                           // .quad -5140619573684080617
+	QUAD $0xa60dc059157491e5                           // .quad -6481312799871692315
+	QUAD $0xe6d3102ad96cec1d                           // .quad -1814088448677712867
+	QUAD $0x87c89837ad68db2f                           // .quad -8662506518347195601
+	QUAD $0x9043ea1ac7e41392                           // .quad -8051334308064652398
+	QUAD $0x29babe4598c311fb                           // .quad 3006924907348169211
+	QUAD $0xb454e4a179dd1877                           // .quad -5452481866653427593
+	QUAD $0xf4296dd6fef3d67a                           // .quad -853029884242176390
+	QUAD $0xe16a1dc9d8545e94                           // .quad -2203916314889396588
+	QUAD $0x1899e4a65f58660c                           // .quad 1772699331562333708
+	QUAD $0x8ce2529e2734bb1d                           // .quad -8294976724446954723
+	QUAD $0x5ec05dcff72e7f8f                           // .quad 6827560182880305039
+	QUAD $0xb01ae745b101e9e4                           // .quad -5757034887131305500
+	QUAD $0x76707543f4fa1f73                           // .quad 8534450228600381299
+	QUAD $0xdc21a1171d42645d                           // .quad -2584607590486743971
+	QUAD $0x6a06494a791c53a8                           // .quad 7639874402088932264
+	QUAD $0x899504ae72497eba                           // .quad -8532908771695296838
+	QUAD $0x0487db9d17636892                           // .quad 326470965756389522
+	QUAD $0xabfa45da0edbde69                           // .quad -6054449946191733143
+	QUAD $0x45a9d2845d3c42b6                           // .quad 5019774725622874806
+	QUAD $0xd6f8d7509292d603                           // .quad -2956376414312278525
+	QUAD $0x0b8a2392ba45a9b2                           // .quad 831516194300602802
+	QUAD $0x865b86925b9bc5c2                           // .quad -8765264286586255934
+	QUAD $0x8e6cac7768d7141e                           // .quad -8183976793979022306
+	QUAD $0xa7f26836f282b732                           // .quad -6344894339805432014
+	QUAD $0x3207d795430cd926                           // .quad 3605087062808385830
+	QUAD $0xd1ef0244af2364ff                           // .quad -3319431906329402113
+	QUAD $0x7f44e6bd49e807b8                           // .quad 9170708441896323000
+	QUAD $0x8335616aed761f1f                           // .quad -8992173969096958177
+	QUAD $0x5f16206c9c6209a6                           // .quad 6851699533943015846
+	QUAD $0xa402b9c5a8d3a6e7                           // .quad -6628531442943809817
+	QUAD $0x36dba887c37a8c0f                           // .quad 3952938399001381903
+	QUAD $0xcd036837130890a1                           // .quad -3673978285252374367
+	QUAD $0xc2494954da2c9789                           // .quad -4446942528265218167
+	QUAD $0x802221226be55a64                           // .quad -9213765455923815836
+	QUAD $0xf2db9baa10b7bd6c                           // .quad -946992141904134804
+	QUAD $0xa02aa96b06deb0fd                           // .quad -6905520801477381891
+	QUAD $0x6f92829494e5acc7                           // .quad 8039631859474607303
+	QUAD $0xc83553c5c8965d3d                           // .quad -4020214983419339459
+	QUAD $0xcb772339ba1f17f9                           // .quad -3785518230938904583
+	QUAD $0xfa42a8b73abbf48c                           // .quad -413582710846786420
+	QUAD $0xff2a760414536efb                           // .quad -60105885123121413
+	QUAD $0x9c69a97284b578d7                           // .quad -7176018221920323369
+	QUAD $0xfef5138519684aba                           // .quad -75132356403901766
+	QUAD $0xc38413cf25e2d70d                           // .quad -4358336758973016307
+	QUAD $0x7eb258665fc25d69                           // .quad 9129456591349898601
+	QUAD $0xf46518c2ef5b8cd1                           // .quad -836234930288882479
+	QUAD $0xef2f773ffbd97a61                           // .quad -1211618658047395231
+	QUAD $0x98bf2f79d5993802                           // .quad -7440175859071633406
+	QUAD $0xaafb550ffacfd8fa                           // .quad -6126209340986631942
+	QUAD $0xbeeefb584aff8603                           // .quad -4688533805412153853
+	QUAD $0x95ba2a53f983cf38                           // .quad -7657761676233289928
+	QUAD $0xeeaaba2e5dbf6784                           // .quad -1248981238337804412
+	QUAD $0xdd945a747bf26183                           // .quad -2480258038432112253
+	QUAD $0x952ab45cfa97a0b2                           // .quad -7698142301602209614
+	QUAD $0x94f971119aeef9e4                           // .quad -7712008566467528220
+	QUAD $0xba756174393d88df                           // .quad -5010991858575374113
+	QUAD $0x7a37cd5601aab85d                           // .quad 8806733365625141341
+	QUAD $0xe912b9d1478ceb17                           // .quad -1652053804791829737
+	QUAD $0xac62e055c10ab33a                           // .quad -6025006692552756422
+	QUAD $0x91abb422ccb812ee                           // .quad -7950062655635975442
+	QUAD $0x577b986b314d6009                           // .quad 6303799689591218185
+	QUAD $0xb616a12b7fe617aa                           // .quad -5325892301117581398
+	QUAD $0xed5a7e85fda0b80b                           // .quad -1343622424865753077
+	QUAD $0xe39c49765fdf9d94                           // .quad -2045679357969588844
+	QUAD $0x14588f13be847307                           // .quad 1466078993672598279
+	QUAD $0x8e41ade9fbebc27d                           // .quad -8196078626372074883
+	QUAD $0x596eb2d8ae258fc8                           // .quad 6444284760518135752
+	QUAD $0xb1d219647ae6b31c                           // .quad -5633412264537705700
+	QUAD $0x6fca5f8ed9aef3bb                           // .quad 8055355950647669691
+	QUAD $0xde469fbd99a05fe3                           // .quad -2430079312244744221
+	QUAD $0x25de7bb9480d5854                           // .quad 2728754459941099604
+	QUAD $0x8aec23d680043bee                           // .quad -8436328597794046994
+	QUAD $0xaf561aa79a10ae6a                           // .quad -5812428961928401302
+	QUAD $0xada72ccc20054ae9                           // .quad -5933724728815170839
+	QUAD $0x1b2ba1518094da04                           // .quad 1957835834444274180
+	QUAD $0xd910f7ff28069da4                           // .quad -2805469892591575644
+	QUAD $0x90fb44d2f05d0842                           // .quad -7999724640327104446
+	QUAD $0x87aa9aff79042286                           // .quad -8670947710510816634
+	QUAD $0x353a1607ac744a53                           // .quad 3835402254873283155
+	QUAD $0xa99541bf57452b28                           // .quad -6226998619711132888
+	QUAD $0x42889b8997915ce8                           // .quad 4794252818591603944
+	QUAD $0xd3fa922f2d1675f2                           // .quad -3172062256211528206
+	QUAD $0x69956135febada11                           // .quad 7608094030047140369
+	QUAD $0x847c9b5d7c2e09b7                           // .quad -8900067937773286985
+	QUAD $0x43fab9837e699095                           // .quad 4898431519131537557
+	QUAD $0xa59bc234db398c25                           // .quad -6513398903789220827
+	QUAD $0x94f967e45e03f4bb                           // .quad -7712018656367741765
+	QUAD $0xcf02b2c21207ef2e                           // .quad -3530062611309138130
+	QUAD $0x1d1be0eebac278f5                           // .quad 2097517367411243253
+	QUAD $0x8161afb94b44f57d                           // .quad -9123818159709293187
+	QUAD $0x6462d92a69731732                           // .quad 7233582727691441970
+	QUAD $0xa1ba1ba79e1632dc                           // .quad -6793086681209228580
+	QUAD $0x7d7b8f7503cfdcfe                           // .quad 9041978409614302462
+	QUAD $0xca28a291859bbf93                           // .quad -3879672333084147821
+	QUAD $0x5cda735244c3d43e                           // .quad 6690786993590490174
+	QUAD $0xfcb2cb35e702af78                           // .quad -237904397927796872
+	QUAD $0x3a0888136afa64a7                           // .quad 4181741870994056359
+	QUAD $0x9defbf01b061adab                           // .quad -7066219276345954901
+	QUAD $0x088aaa1845b8fdd0                           // .quad 615491320315182544
+	QUAD $0xc56baec21c7a1916                           // .quad -4221088077005055722
+	QUAD $0x8aad549e57273d45                           // .quad -8454007886460797627
+	QUAD $0xf6c69a72a3989f5b                           // .quad -664674077828931749
+	QUAD $0x36ac54e2f678864b                           // .quad 3939617107816777291
+	QUAD $0x9a3c2087a63f6399                           // .quad -7332950326284164199
+	QUAD $0x84576a1bb416a7dd                           // .quad -8910536670511192099
+	QUAD $0xc0cb28a98fcf3c7f                           // .quad -4554501889427817345
+	QUAD $0x656d44a2a11c51d5                           // .quad 7308573235570561493
+	QUAD $0xf0fdf2d3f3c30b9f                           // .quad -1081441343357383777
+	QUAD $0x9f644ae5a4b1b325                           // .quad -6961356773836868827
+	QUAD $0x969eb7c47859e743                           // .quad -7593429867239446717
+	QUAD $0x873d5d9f0dde1fee                           // .quad -8701695967296086034
+	QUAD $0xbc4665b596706114                           // .quad -4880101315621920492
+	QUAD $0xa90cb506d155a7ea                           // .quad -6265433940692719638
+	QUAD $0xeb57ff22fc0c7959                           // .quad -1488440626100012711
+	QUAD $0x09a7f12442d588f2                           // .quad 695789805494438130
+	QUAD $0x9316ff75dd87cbd8                           // .quad -7847804418953589800
+	QUAD $0x0c11ed6d538aeb2f                           // .quad 869737256868047663
+	QUAD $0xb7dcbf5354e9bece                           // .quad -5198069505264599346
+	QUAD $0x8f1668c8a86da5fa                           // .quad -8136200465769716230
+	QUAD $0xe5d3ef282a242e81                           // .quad -1885900863153361279
+	QUAD $0xf96e017d694487bc                           // .quad -473439272678684740
+	QUAD $0x8fa475791a569d10                           // .quad -8096217067111932656
+	QUAD $0x37c981dcc395a9ac                           // .quad 4019886927579031980
+	QUAD $0xb38d92d760ec4455                           // .quad -5508585315462527915
+	QUAD $0x85bbe253f47b1417                           // .quad -8810199395808373737
+	QUAD $0xe070f78d3927556a                           // .quad -2274045625900771990
+	QUAD $0x93956d7478ccec8e                           // .quad -7812217631593927538
+	QUAD $0x8c469ab843b89562                           // .quad -8338807543829064350
+	QUAD $0x387ac8d1970027b2                           // .quad 4069786015789754290
+	QUAD $0xaf58416654a6babb                           // .quad -5811823411358942533
+	QUAD $0x06997b05fcc0319e                           // .quad 475546501309804958
+	QUAD $0xdb2e51bfe9d0696a                           // .quad -2653093245771290262
+	QUAD $0x441fece3bdf81f03                           // .quad 4908902581746016003
+	QUAD $0x88fcf317f22241e2                           // .quad -8575712306248138270
+	QUAD $0xd527e81cad7626c3                           // .quad -3087243809672255805
+	QUAD $0xab3c2fddeeaad25a                           // .quad -6107954364382784934
+	QUAD $0x8a71e223d8d3b074                           // .quad -8470740780517707660
+	QUAD $0xd60b3bd56a5586f1                           // .quad -3023256937051093263
+	QUAD $0xf6872d5667844e49                           // .quad -682526969396179383
+	QUAD $0x85c7056562757456                           // .quad -8807064613298015146
+	QUAD $0xb428f8ac016561db                           // .quad -5464844730172612133
+	QUAD $0xa738c6bebb12d16c                           // .quad -6397144748195131028
+	QUAD $0xe13336d701beba52                           // .quad -2219369894288377262
+	QUAD $0xd106f86e69d785c7                           // .quad -3384744916816525881
+	QUAD $0xecc0024661173473                           // .quad -1387106183930235789
+	QUAD $0x82a45b450226b39c                           // .quad -9032994600651410532
+	QUAD $0x27f002d7f95d0190                           // .quad 2877803288514593168
+	QUAD $0xa34d721642b06084                           // .quad -6679557232386875260
+	QUAD $0x31ec038df7b441f4                           // .quad 3597254110643241460
+	QUAD $0xcc20ce9bd35c78a5                           // .quad -3737760522056206171
+	QUAD $0x7e67047175a15271                           // .quad 9108253656731439729
+	QUAD $0xff290242c83396ce                           // .quad -60514634142869810
+	QUAD $0x0f0062c6e984d386                           // .quad 1080972517029761926
+	QUAD $0x9f79a169bd203e41                           // .quad -6955350673980375487
+	QUAD $0x52c07b78a3e60868                           // .quad 5962901664714590312
+	QUAD $0xc75809c42c684dd1                           // .quad -4082502324048081455
+	QUAD $0xa7709a56ccdf8a82                           // .quad -6381430974388925822
+	QUAD $0xf92e0c3537826145                           // .quad -491441886632713915
+	QUAD $0x88a66076400bb691                           // .quad -8600080377420466543
+	QUAD $0x9bbcc7a142b17ccb                           // .quad -7224680206786528053
+	QUAD $0x6acff893d00ea435                           // .quad 7696643601933968437
+	QUAD $0xc2abf989935ddbfe                           // .quad -4419164240055772162
+	QUAD $0x0583f6b8c4124d43                           // .quad 397432465562684739
+	QUAD $0xf356f7ebf83552fe                           // .quad -912269281642327298
+	QUAD $0xc3727a337a8b704a                           // .quad -4363290727450709942
+	QUAD $0x98165af37b2153de                           // .quad -7487697328667536418
+	QUAD $0x744f18c0592e4c5c                           // .quad 8380944645968776284
+	QUAD $0xbe1bf1b059e9a8d6                           // .quad -4747935642407032618
+	QUAD $0x1162def06f79df73                           // .quad 1252808770606194547
+	QUAD $0xeda2ee1c7064130c                           // .quad -1323233534581402868
+	QUAD $0x8addcb5645ac2ba8                           // .quad -8440366555225904216
+	QUAD $0x9485d4d1c63e8be7                           // .quad -7744549986754458649
+	QUAD $0x6d953e2bd7173692                           // .quad 7896285879677171346
+	QUAD $0xb9a74a0637ce2ee1                           // .quad -5069001465015685407
+	QUAD $0xc8fa8db6ccdd0437                           // .quad -3964700705685699529
+	QUAD $0xe8111c87c5c1ba99                           // .quad -1724565812842218855
+	QUAD $0x1d9c9892400a22a2                           // .quad 2133748077373825698
+	QUAD $0x910ab1d4db9914a0                           // .quad -7995382660667468640
+	QUAD $0x2503beb6d00cab4b                           // .quad 2667185096717282123
+	QUAD $0xb54d5e4a127f59c8                           // .quad -5382542307406947896
+	QUAD $0x2e44ae64840fd61d                           // .quad 3333981370896602653
+	QUAD $0xe2a0b5dc971f303a                           // .quad -2116491865831296966
+	QUAD $0x5ceaecfed289e5d2                           // .quad 6695424375237764562
+	QUAD $0x8da471a9de737e24                           // .quad -8240336443785642460
+	QUAD $0x7425a83e872c5f47                           // .quad 8369280469047205703
+	QUAD $0xb10d8e1456105dad                           // .quad -5688734536304665171
+	QUAD $0xd12f124e28f77719                           // .quad -3373457468973156583
+	QUAD $0xdd50f1996b947518                           // .quad -2499232151953443560
+	QUAD $0x82bd6b70d99aaa6f                           // .quad -9025939945749304721
+	QUAD $0x8a5296ffe33cc92f                           // .quad -8479549122611984081
+	QUAD $0x636cc64d1001550b                           // .quad 7164319141522920715
+	QUAD $0xace73cbfdc0bfb7b                           // .quad -5987750384837592197
+	QUAD $0x3c47f7e05401aa4e                           // .quad 4343712908476262990
+	QUAD $0xd8210befd30efa5a                           // .quad -2873001962619602342
+	QUAD $0x65acfaec34810a71                           // .quad 7326506586225052273
+	QUAD $0x8714a775e3e95c78                           // .quad -8713155254278333320
+	QUAD $0x7f1839a741a14d0d                           // .quad 9158133232781315341
+	QUAD $0xa8d9d1535ce3b396                           // .quad -6279758049420528746
+	QUAD $0x1ede48111209a050                           // .quad 2224294504121868368
+	QUAD $0xd31045a8341ca07c                           // .quad -3238011543348273028
+	QUAD $0x934aed0aab460432                           // .quad -7833187971778608078
+	QUAD $0x83ea2b892091e44d                           // .quad -8941286242233752499
+	QUAD $0xf81da84d5617853f                           // .quad -568112927868484289
+	QUAD $0xa4e4b66b68b65d60                           // .quad -6564921784364802720
+	QUAD $0x36251260ab9d668e                           // .quad 3901544858591782542
+	QUAD $0xce1de40642e3f4b9                           // .quad -3594466212028615495
+	QUAD $0xc1d72b7c6b426019                           // .quad -4479063491021217767
+	QUAD $0x80d2ae83e9ce78f3                           // .quad -9164070410158966541
+	QUAD $0xb24cf65b8612f81f                           // .quad -5598829363776522209
+	QUAD $0xa1075a24e4421730                           // .quad -6843401994271320272
+	QUAD $0xdee033f26797b627                           // .quad -2386850686293264857
+	QUAD $0xc94930ae1d529cfc                           // .quad -3942566474411762436
+	QUAD $0x169840ef017da3b1                           // .quad 1628122660560806833
+	QUAD $0xfb9b7cd9a4a7443c                           // .quad -316522074587315140
+	QUAD $0x8e1f289560ee864e                           // .quad -8205795374004271538
+	QUAD $0x9d412e0806e88aa5                           // .quad -7115355324258153819
+	QUAD $0xf1a6f2bab92a27e2                           // .quad -1033872180650563614
+	QUAD $0xc491798a08a2ad4e                           // .quad -4282508136895304370
+	QUAD $0xae10af696774b1db                           // .quad -5904026244240592421
+	QUAD $0xf5b5d7ec8acb58a2                           // .quad -741449152691742558
+	QUAD $0xacca6da1e0a8ef29                           // .quad -5995859411864064215
+	QUAD $0x9991a6f3d6bf1765                           // .quad -7380934748073420955
+	QUAD $0x17fd090a58d32af3                           // .quad 1728547772024695539
+	QUAD $0xbff610b0cc6edd3f                           // .quad -4614482416664388289
+	QUAD $0xddfc4b4cef07f5b0                           // .quad -2451001303396518480
+	QUAD $0xeff394dcff8a948e                           // .quad -1156417002403097458
+	QUAD $0x4abdaf101564f98e                           // .quad 5385653213018257806
+	QUAD $0x95f83d0a1fb69cd9                           // .quad -7640289654143017767
+	QUAD $0x9d6d1ad41abe37f1                           // .quad -7102991539009341455
+	QUAD $0xbb764c4ca7a4440f                           // .quad -4938676049251384305
+	QUAD $0x84c86189216dc5ed                           // .quad -8878739423761676819
+	QUAD $0xea53df5fd18d5513                           // .quad -1561659043136842477
+	QUAD $0x32fd3cf5b4e49bb4                           // .quad 3674159897003727796
+	QUAD $0x92746b9be2f8552c                           // .quad -7893565929601608404
+	QUAD $0x3fbc8c33221dc2a1                           // .quad 4592699871254659745
+	QUAD $0xb7118682dbb66a77                           // .quad -5255271393574622601
+	QUAD $0x0fabaf3feaa5334a                           // .quad 1129188820640936778
+	QUAD $0xe4d5e82392a40515                           // .quad -1957403223540890347
+	QUAD $0x29cb4d87f2a7400e                           // .quad 3011586022114279438
+	QUAD $0x8f05b1163ba6832d                           // .quad -8140906042354138323
+	QUAD $0x743e20e9ef511012                           // .quad 8376168546070237202
+	QUAD $0xb2c71d5bca9023f8                           // .quad -5564446534515285000
+	QUAD $0x914da9246b255416                           // .quad -7976533391121755114
+	QUAD $0xdf78e4b2bd342cf6                           // .quad -2343872149716718346
+	QUAD $0x1ad089b6c2f7548e                           // .quad 1932195658189984910
+	QUAD $0x8bab8eefb6409c1a                           // .quad -8382449121214030822
+	QUAD $0xa184ac2473b529b1                           // .quad -6808127464117294671
+	QUAD $0xae9672aba3d0c320                           // .quad -5866375383090150624
+	QUAD $0xc9e5d72d90a2741e                           // .quad -3898473311719230434
+	QUAD $0xda3c0f568cc4f3e8                           // .quad -2721283210435300376
+	QUAD $0x7e2fa67c7a658892                           // .quad 9092669226243950738
+	QUAD $0x8865899617fb1871                           // .quad -8618331034163144591
+	QUAD $0xddbb901b98feeab7                           // .quad -2469221522477225289
+	QUAD $0xaa7eebfb9df9de8d                           // .quad -6161227774276542835
+	QUAD $0x552a74227f3ea565                           // .quad 6136845133758244197
+	QUAD $0xd51ea6fa85785631                           // .quad -3089848699418290639
+	QUAD $0xd53a88958f87275f                           // .quad -3082000819042179233
+	QUAD $0x8533285c936b35de                           // .quad -8848684464777513506
+	QUAD $0x8a892abaf368f137                           // .quad -8464187042230111945
+	QUAD $0xa67ff273b8460356                           // .quad -6449169562544503978
+	QUAD $0x2d2b7569b0432d85                           // .quad 3254824252494523781
+	QUAD $0xd01fef10a657842c                           // .quad -3449775934753242068
+	QUAD $0x9c3b29620e29fc73                           // .quad -7189106879045698445
+	QUAD $0x8213f56a67f6b29b                           // .quad -9073638986861858149
+	QUAD $0x8349f3ba91b47b8f                           // .quad -8986383598807123057
+	QUAD $0xa298f2c501f45f42                           // .quad -6730362715149934782
+	QUAD $0x241c70a936219a73                           // .quad 2602078556773259891
+	QUAD $0xcb3f2f7642717713                           // .quad -3801267375510030573
+	QUAD $0xed238cd383aa0110                           // .quad -1359087822460813040
+	QUAD $0xfe0efb53d30dd4d7                           // .quad -139898200960150313
+	QUAD $0xf4363804324a40aa                           // .quad -849429889038008150
+	QUAD $0x9ec95d1463e8a506                           // .quad -7004965403241175802
+	QUAD $0xb143c6053edcd0d5                           // .quad -5673473379724898091
+	QUAD $0xc67bb4597ce2ce48                           // .quad -4144520735624081848
+	QUAD $0xdd94b7868e94050a                           // .quad -2480155706228734710
+	QUAD $0xf81aa16fdc1b81da                           // .quad -568964901102714406
+	QUAD $0xca7cf2b4191c8326                           // .quad -3855940325606653146
+	QUAD $0x9b10a4e5e9913128                           // .quad -7273132090830278360
+	QUAD $0xfd1c2f611f63a3f0                           // .quad -208239388580928528
+	QUAD $0xc1d4ce1f63f57d72                           // .quad -4479729095110460046
+	QUAD $0xbc633b39673c8cec                           // .quad -4871985254153548564
+	QUAD $0xf24a01a73cf2dccf                           // .quad -987975350460687153
+	QUAD $0xd5be0503e085d813                           // .quad -3044990783845967853
+	QUAD $0x976e41088617ca01                           // .quad -7535013621679011327
+	QUAD $0x4b2d8644d8a74e18                           // .quad 5417133557047315992
+	QUAD $0xbd49d14aa79dbc82                           // .quad -4807081008671376254
+	QUAD $0xddf8e7d60ed1219e                           // .quad -2451955090545630818
+	QUAD $0xec9c459d51852ba2                           // .quad -1397165242411832414
+	QUAD $0xcabb90e5c942b503                           // .quad -3838314940804713213
+	QUAD $0x93e1ab8252f33b45                           // .quad -7790757304148477115
+	QUAD $0x3d6a751f3b936243                           // .quad 4425478360848884291
+	QUAD $0xb8da1662e7b00a17                           // .quad -5126760611758208489
+	QUAD $0x0cc512670a783ad4                           // .quad 920161932633717460
+	QUAD $0xe7109bfba19c0c9d                           // .quad -1796764746270372707
+	QUAD $0x27fb2b80668b24c5                           // .quad 2880944217109767365
+	QUAD $0x906a617d450187e2                           // .quad -8040506994060064798
+	QUAD $0xb1f9f660802dedf6                           // .quad -5622191765467566602
+	QUAD $0xb484f9dc9641e9da                           // .quad -5438947724147693094
+	QUAD $0x5e7873f8a0396973                           // .quad 6807318348447705459
+	QUAD $0xe1a63853bbd26451                           // .quad -2186998636757228463
+	QUAD $0xdb0b487b6423e1e8                           // .quad -2662955059861265944
+	QUAD $0x8d07e33455637eb2                           // .quad -8284403175614349646
+	QUAD $0x91ce1a9a3d2cda62                           // .quad -7940379843253970334
+	QUAD $0xb049dc016abc5e5f                           // .quad -5743817951090549153
+	QUAD $0x7641a140cc7810fb                           // .quad 8521269269642088699
+	QUAD $0xdc5c5301c56b75f7                           // .quad -2568086420435798537
+	QUAD $0xa9e904c87fcb0a9d                           // .quad -6203421752542164323
+	QUAD $0x89b9b3e11b6329ba                           // .quad -8522583040413455942
+	QUAD $0x546345fa9fbdcd44                           // .quad 6080780864604458308
+	QUAD $0xac2820d9623bf429                           // .quad -6041542782089432023
+	QUAD $0xa97c177947ad4095                           // .quad -6234081974526590827
+	QUAD $0xd732290fbacaf133                           // .quad -2940242459184402125
+	QUAD $0x49ed8eabcccc485d                           // .quad 5327070802775656541
+	QUAD $0x867f59a9d4bed6c0                           // .quad -8755180564631333184
+	QUAD $0x5c68f256bfff5a74                           // .quad 6658838503469570676
+	QUAD $0xa81f301449ee8c70                           // .quad -6332289687361778576
+	QUAD $0x73832eec6fff3111                           // .quad 8323548129336963345
+	QUAD $0xd226fc195c6a2f8c                           // .quad -3303676090774835316
+	QUAD $0xc831fd53c5ff7eab                           // .quad -4021154456019173717
+	QUAD $0x83585d8fd9c25db7                           // .quad -8982326584375353929
+	QUAD $0xba3e7ca8b77f5e55                           // .quad -5026443070023967147
+	QUAD $0xa42e74f3d032f525                           // .quad -6616222212041804507
+	QUAD $0x28ce1bd2e55f35eb                           // .quad 2940318199324816875
+	QUAD $0xcd3a1230c43fb26f                           // .quad -3658591746624867729
+	QUAD $0x7980d163cf5b81b3                           // .quad 8755227902219092403
+	QUAD $0x80444b5e7aa7cf85                           // .quad -9204148869281624187
+	QUAD $0xd7e105bcc332621f                           // .quad -2891023177508298209
+	QUAD $0xa0555e361951c366                           // .quad -6893500068174642330
+	QUAD $0x8dd9472bf3fefaa7                           // .quad -8225464990312760665
+	QUAD $0xc86ab5c39fa63440                           // .quad -4005189066790915008
+	QUAD $0xb14f98f6f0feb951                           // .quad -5670145219463562927
+	QUAD $0xfa856334878fc150                           // .quad -394800315061255856
+	QUAD $0x6ed1bf9a569f33d3                           // .quad 7985374283903742931
+	QUAD $0x9c935e00d4b9d8d2                           // .quad -7164279224554366766
+	QUAD $0x0a862f80ec4700c8                           // .quad 758345818024902856
+	QUAD $0xc3b8358109e84f07                           // .quad -4343663012265570553
+	QUAD $0xcd27bb612758c0fa                           // .quad -3663753745896259334
+	QUAD $0xf4a642e14c6262c8                           // .quad -817892746904575288
+	QUAD $0x8038d51cb897789c                           // .quad -9207375118826243940
+	QUAD $0x98e7e9cccfbd7dbd                           // .quad -7428711994456441411
+	QUAD $0xe0470a63e6bd56c3                           // .quad -2285846861678029117
+	QUAD $0xbf21e44003acdd2c                           // .quad -4674203974643163860
+	QUAD $0x1858ccfce06cac74                           // .quad 1754377441329851508
+	QUAD $0xeeea5d5004981478                           // .quad -1231068949876566920
+	QUAD $0x0f37801e0c43ebc8                           // .quad 1096485900831157192
+	QUAD $0x95527a5202df0ccb                           // .quad -7686947121313936181
+	QUAD $0xd30560258f54e6ba                           // .quad -3241078642388441414
+	QUAD $0xbaa718e68396cffd                           // .quad -4996997883215032323
+	QUAD $0x47c6b82ef32a2069                           // .quad 5172023733869224041
+	QUAD $0xe950df20247c83fd                           // .quad -1634561335591402499
+	QUAD $0x4cdc331d57fa5441                           // .quad 5538357842881958977
+	QUAD $0x91d28b7416cdd27e                           // .quad -7939129862385708418
+	QUAD $0xe0133fe4adf8e952                           // .quad -2300424733252327086
+	QUAD $0xb6472e511c81471d                           // .quad -5312226309554747619
+	QUAD $0x58180fddd97723a6                           // .quad 6347841120289366950
+	QUAD $0xe3d8f9e563a198e5                           // .quad -2028596868516046619
+	QUAD $0x570f09eaa7ea7648                           // .quad 6273243709394548296
+	QUAD $0x8e679c2f5e44ff8f                           // .quad -8185402070463610993
+	QUAD $0x2cd2cc6551e513da                           // .quad 3229868618315797466
+	QUAD $0xb201833b35d63f73                           // .quad -5620066569652125837
+	QUAD $0xf8077f7ea65e58d1                           // .quad -574350245532641071
+	QUAD $0xde81e40a034bcf4f                           // .quad -2413397193637769393
+	QUAD $0xfb04afaf27faf782                           // .quad -358968903457900670
+	QUAD $0x8b112e86420f6191                           // .quad -8425902273664687727
+	QUAD $0x79c5db9af1f9b563                           // .quad 8774660907532399971
+	QUAD $0xadd57a27d29339f6                           // .quad -5920691823653471754
+	QUAD $0x18375281ae7822bc                           // .quad 1744954097560724156
+	QUAD $0xd94ad8b1c7380874                           // .quad -2789178761139451788
+	QUAD $0x8f2293910d0b15b5                           // .quad -8132775725879323211
+	QUAD $0x87cec76f1c830548                           // .quad -8660765753353239224
+	QUAD $0xb2eb3875504ddb22                           // .quad -5554283638921766110
+	QUAD $0xa9c2794ae3a3c69a                           // .quad -6214271173264161126
+	QUAD $0x5fa60692a46151eb                           // .quad 6892203506629956075
+	QUAD $0xd433179d9c8cb841                           // .quad -3156152948152813503
+	QUAD $0xdbc7c41ba6bcd333                           // .quad -2609901835997359309
+	QUAD $0x849feec281d7f328                           // .quad -8890124620236590296
+	QUAD $0x12b9b522906c0800                           // .quad 1349308723430688768
+	QUAD $0xa5c7ea73224deff3                           // .quad -6500969756868349965
+	QUAD $0xd768226b34870a00                           // .quad -2925050114139026944
+	QUAD $0xcf39e50feae16bef                           // .quad -3514526177658049553
+	QUAD $0xe6a1158300d46640                           // .quad -1828156321336891840
+	QUAD $0x81842f29f2cce375                           // .quad -9114107888677362827
+	QUAD $0x60495ae3c1097fd0                           // .quad 6938176635183661008
+	QUAD $0xa1e53af46f801c53                           // .quad -6780948842419315629
+	QUAD $0x385bb19cb14bdfc4                           // .quad 4061034775552188356
+	QUAD $0xca5e89b18b602368                           // .quad -3864500034596756632
+	QUAD $0x46729e03dd9ed7b5                           // .quad 5076293469440235445
+	QUAD $0xfcf62c1dee382c42                           // .quad -218939024818557886
+	QUAD $0x6c07a2c26a8346d1                           // .quad 7784369436827535057
+	QUAD $0x9e19db92b4e31ba9                           // .quad -7054365918152680535
+	QUAD $0xc7098b7305241885                           // .quad -4104596259247744891
+	QUAD $0xc5a05277621be293                           // .quad -4206271379263462765
+	QUAD $0xb8cbee4fc66d1ea7                           // .quad -5130745324059681113
+	QUAD $0xf70867153aa2db38                           // .quad -646153205651940552
+	QUAD $0x737f74f1dc043328                           // .quad 8322499218531169064
+	QUAD $0x9a65406d44a5c903                           // .quad -7321374781173544701
+	QUAD $0x505f522e53053ff2                           // .quad 5791438004736573426
+	QUAD $0xc0fe908895cf3b44                           // .quad -4540032458039542972
+	QUAD $0x647726b9e7c68fef                           // .quad 7239297505920716783
+	QUAD $0xf13e34aabb430a15                           // .quad -1063354554122040811
+	QUAD $0x5eca783430dc19f5                           // .quad 6830403950414141941
+	QUAD $0x96c6e0eab509e64d                           // .quad -7582125623967357363
+	QUAD $0xb67d16413d132072                           // .quad -5297053117264486286
+	QUAD $0xbc789925624c5fe0                           // .quad -4865971011531808800
+	QUAD $0xe41c5bd18c57e88f                           // .quad -2009630378153219953
+	QUAD $0xeb96bf6ebadf77d8                           // .quad -1470777745987373096
+	QUAD $0x8e91b962f7b6f159                           // .quad -8173548013986844327
+	QUAD $0x933e37a534cbaae7                           // .quad -7836765118883190041
+	QUAD $0x723627bbb5a4adb0                           // .quad 8229809056225996208
+	QUAD $0xb80dc58e81fe95a1                           // .quad -5184270380176599647
+	QUAD $0xcec3b1aaa30dd91c                           // .quad -3547796734999668452
+	QUAD $0xe61136f2227e3b09                           // .quad -1868651956793361655
+	QUAD $0x213a4f0aa5e8a7b1                           // .quad 2394313059052595121
+	QUAD $0x8fcac257558ee4e6                           // .quad -8085436500636932890
+	QUAD $0xa988e2cd4f62d19d                           // .quad -6230480713039031907
+	QUAD $0xb3bd72ed2af29e1f                           // .quad -5495109607368778209
+	QUAD $0x93eb1b80a33b8605                           // .quad -7788100891298789883
+	QUAD $0xe0accfa875af45a7                           // .quad -2257200990783584857
+	QUAD $0xbc72f130660533c3                           // .quad -4867563057061743677
+	QUAD $0x8c6c01c9498d8b88                           // .quad -8328279646880822392
+	QUAD $0xeb8fad7c7f8680b4                           // .quad -1472767802899791692
+	QUAD $0xaf87023b9bf0ee6a                           // .quad -5798663540173640086
+	QUAD $0xa67398db9f6820e1                           // .quad -6452645772052127519
+	QUAD $0xdb68c2ca82ed2a05                           // .quad -2636643406789662203
+	QUAD $0x88083f8943a1148c                           // .quad -8644589625959967604
+	QUAD $0x892179be91d43a43                           // .quad -8565431156884620733
+	QUAD $0x6a0a4f6b948959b0                           // .quad 7641007041259592112
+	QUAD $0xab69d82e364948d4                           // .quad -6095102927678388012
+	QUAD $0x848ce34679abb01c                           // .quad -8895485272135061476
+	QUAD $0xd6444e39c3db9b09                           // .quad -3007192641170597111
+	QUAD $0xf2d80e0c0c0b4e11                           // .quad -947992276657025519
+	QUAD $0x85eab0e41a6940e5                           // .quad -8797024428372705051
+	QUAD $0x6f8e118f0f0e2195                           // .quad 8038381691033493909
+	QUAD $0xa7655d1d2103911f                           // .quad -6384594517038493409
+	QUAD $0x4b7195f2d2d1a9fb                           // .quad 5436291095364479483
+	QUAD $0xd13eb46469447567                           // .quad -3369057127870728857
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+	// .p2align 4, 0x00
+_POW_TAB:
+	LONG $0x00000001 // .long 1
+	LONG $0x00000003 // .long 3
+	LONG $0x00000006 // .long 6
+	LONG $0x00000009 // .long 9
+	LONG $0x0000000d // .long 13
+	LONG $0x00000010 // .long 16
+	LONG $0x00000013 // .long 19
+	LONG $0x00000017 // .long 23
+	LONG $0x0000001a // .long 26
+
+	// .p2align 2, 0x00
+_MASK_USE_NUMBER:
+	LONG $0x00000002         // .long 2
+	QUAD $0x0000000000000000 // .p2align 4, 0x00
+
+_Digits:
+	QUAD $0x3330323031303030; QUAD $0x3730363035303430 // .ascii 16, '0001020304050607'
+	QUAD $0x3131303139303830; QUAD $0x3531343133313231 // .ascii 16, '0809101112131415'
+	QUAD $0x3931383137313631; QUAD $0x3332323231323032 // .ascii 16, '1617181920212223'
+	QUAD $0x3732363235323432; QUAD $0x3133303339323832 // .ascii 16, '2425262728293031'
+	QUAD $0x3533343333333233; QUAD $0x3933383337333633 // .ascii 16, '3233343536373839'
+	QUAD $0x3334323431343034; QUAD $0x3734363435343434 // .ascii 16, '4041424344454647'
+	QUAD $0x3135303539343834; QUAD $0x3535343533353235 // .ascii 16, '4849505152535455'
+	QUAD $0x3935383537353635; QUAD $0x3336323631363036 // .ascii 16, '5657585960616263'
+	QUAD $0x3736363635363436; QUAD $0x3137303739363836 // .ascii 16, '6465666768697071'
+	QUAD $0x3537343733373237; QUAD $0x3937383737373637 // .ascii 16, '7273747576777879'
+	QUAD $0x3338323831383038; QUAD $0x3738363835383438 // .ascii 16, '8081828384858687'
+	QUAD $0x3139303939383838; QUAD $0x3539343933393239 // .ascii 16, '8889909192939495'
+	QUAD $0x3939383937393639                           // .ascii 8, '96979899'
+	QUAD $0x0000000000000000                           // .p2align 4, 0x00
+
+_LB_5d8b2db8: // _pow10_ceil_sig.g
+	QUAD $0xff77b1fcbebcdc4f // .quad -38366372719436721
+	QUAD $0x25e8e89c13bb0f7b // .quad 2731688931043774331
+	QUAD $0x9faacf3df73609b1 // .quad -6941508010590729807
+	QUAD $0x77b191618c54e9ad // .quad 8624834609543440813
+	QUAD $0xc795830d75038c1d // .quad -4065198994811024355
+	QUAD $0xd59df5b9ef6a2418 // .quad -3054014793352862696
+	QUAD $0xf97ae3d0d2446f25 // .quad -469812725086392539
+	QUAD $0x4b0573286b44ad1e // .quad 5405853545163697438
+	QUAD $0x9becce62836ac577 // .quad -7211161980820077193
+	QUAD $0x4ee367f9430aec33 // .quad 5684501474941004851
+	QUAD $0xc2e801fb244576d5 // .quad -4402266457597708587
+	QUAD $0x229c41f793cda740 // .quad 2493940825248868160
+	QUAD $0xf3a20279ed56d48a // .quad -891147053569747830
+	QUAD $0x6b43527578c11110 // .quad 7729112049988473104
+	QUAD $0x9845418c345644d6 // .quad -7474495936122174250
+	QUAD $0x830a13896b78aaaa // .quad -9004363024039368022
+	QUAD $0xbe5691ef416bd60c // .quad -4731433901725329908
+	QUAD $0x23cc986bc656d554 // .quad 2579604275232953684
+	QUAD $0xedec366b11c6cb8f // .quad -1302606358729274481
+	QUAD $0x2cbfbe86b7ec8aa9 // .quad 3224505344041192105
+	QUAD $0x94b3a202eb1c3f39 // .quad -7731658001846878407
+	QUAD $0x7bf7d71432f3d6aa // .quad 8932844867666826922
+	QUAD $0xb9e08a83a5e34f07 // .quad -5052886483881210105
+	QUAD $0xdaf5ccd93fb0cc54 // .quad -2669001970698630060
+	QUAD $0xe858ad248f5c22c9 // .quad -1704422086424124727
+	QUAD $0xd1b3400f8f9cff69 // .quad -3336252463373287575
+	QUAD $0x91376c36d99995be // .quad -7982792831656159810
+	QUAD $0x23100809b9c21fa2 // .quad 2526528228819083170
+	QUAD $0xb58547448ffffb2d // .quad -5366805021142811859
+	QUAD $0xabd40a0c2832a78b // .quad -6065211750830921845
+	QUAD $0xe2e69915b3fff9f9 // .quad -2096820258001126919
+	QUAD $0x16c90c8f323f516d // .quad 1641857348316123501
+	QUAD $0x8dd01fad907ffc3b // .quad -8228041688891786181
+	QUAD $0xae3da7d97f6792e4 // .quad -5891368184943504668
+	QUAD $0xb1442798f49ffb4a // .quad -5673366092687344822
+	QUAD $0x99cd11cfdf41779d // .quad -7364210231179380835
+	QUAD $0xdd95317f31c7fa1d // .quad -2480021597431793123
+	QUAD $0x40405643d711d584 // .quad 4629795266307937668
+	QUAD $0x8a7d3eef7f1cfc52 // .quad -8467542526035952558
+	QUAD $0x482835ea666b2573 // .quad 5199465050656154995
+	QUAD $0xad1c8eab5ee43b66 // .quad -5972742139117552794
+	QUAD $0xda3243650005eed0 // .quad -2724040723534582064
+	QUAD $0xd863b256369d4a40 // .quad -2854241655469553088
+	QUAD $0x90bed43e40076a83 // .quad -8016736922845615485
+	QUAD $0x873e4f75e2224e68 // .quad -8701430062309552536
+	QUAD $0x5a7744a6e804a292 // .quad 6518754469289960082
+	QUAD $0xa90de3535aaae202 // .quad -6265101559459552766
+	QUAD $0x711515d0a205cb37 // .quad 8148443086612450103
+	QUAD $0xd3515c2831559a83 // .quad -3219690930897053053
+	QUAD $0x0d5a5b44ca873e04 // .quad 962181821410786820
+	QUAD $0x8412d9991ed58091 // .quad -8929835859451740015
+	QUAD $0xe858790afe9486c3 // .quad -1704479370831952189
+	QUAD $0xa5178fff668ae0b6 // .quad -6550608805887287114
+	QUAD $0x626e974dbe39a873 // .quad 7092772823314835571
+	QUAD $0xce5d73ff402d98e3 // .quad -3576574988931720989
+	QUAD $0xfb0a3d212dc81290 // .quad -357406007711231344
+	QUAD $0x80fa687f881c7f8e // .quad -9152888395723407474
+	QUAD $0x7ce66634bc9d0b9a // .quad 8999993282035256218
+	QUAD $0xa139029f6a239f72 // .quad -6829424476226871438
+	QUAD $0x1c1fffc1ebc44e81 // .quad 2026619565689294465
+	QUAD $0xc987434744ac874e // .quad -3925094576856201394
+	QUAD $0xa327ffb266b56221 // .quad -6690097579743157727
+	QUAD $0xfbe9141915d7a922 // .quad -294682202642863838
+	QUAD $0x4bf1ff9f0062baa9 // .quad 5472436080603216553
+	QUAD $0x9d71ac8fada6c9b5 // .quad -7101705404292871755
+	QUAD $0x6f773fc3603db4aa // .quad 8031958568804398250
+	QUAD $0xc4ce17b399107c22 // .quad -4265445736938701790
+	QUAD $0xcb550fb4384d21d4 // .quad -3795109844276665900
+	QUAD $0xf6019da07f549b2b // .quad -720121152745989333
+	QUAD $0x7e2a53a146606a49 // .quad 9091170749936331337
+	QUAD $0x99c102844f94e0fb // .quad -7367604748107325189
+	QUAD $0x2eda7444cbfc426e // .quad 3376138709496513134
+	QUAD $0xc0314325637a1939 // .quad -4597819916706768583
+	QUAD $0xfa911155fefb5309 // .quad -391512631556746487
+	QUAD $0xf03d93eebc589f88 // .quad -1135588877456072824
+	QUAD $0x793555ab7eba27cb // .quad 8733981247408842699
+	QUAD $0x96267c7535b763b5 // .quad -7627272076051127371
+	QUAD $0x4bc1558b2f3458df // .quad 5458738279630526687
+	QUAD $0xbbb01b9283253ca2 // .quad -4922404076636521310
+	QUAD $0x9eb1aaedfb016f17 // .quad -7011635205744005353
+	QUAD $0xea9c227723ee8bcb // .quad -1541319077368263733
+	QUAD $0x465e15a979c1cadd // .quad 5070514048102157021
+	QUAD $0x92a1958a7675175f // .quad -7880853450996246689
+	QUAD $0x0bfacd89ec191eca // .quad 863228270850154186
+	QUAD $0xb749faed14125d36 // .quad -5239380795317920458
+	QUAD $0xcef980ec671f667c // .quad -3532650679864695172
+	QUAD $0xe51c79a85916f484 // .quad -1937539975720012668
+	QUAD $0x82b7e12780e7401b // .quad -9027499368258256869
+	QUAD $0x8f31cc0937ae58d2 // .quad -8128491512466089774
+	QUAD $0xd1b2ecb8b0908811 // .quad -3336344095947716591
+	QUAD $0xb2fe3f0b8599ef07 // .quad -5548928372155224313
+	QUAD $0x861fa7e6dcb4aa16 // .quad -8782116138362033642
+	QUAD $0xdfbdcece67006ac9 // .quad -2324474446766642487
+	QUAD $0x67a791e093e1d49b // .quad 7469098900757009563
+	QUAD $0x8bd6a141006042bd // .quad -8370325556870233411
+	QUAD $0xe0c8bb2c5c6d24e1 // .quad -2249342214667950879
+	QUAD $0xaecc49914078536d // .quad -5851220927660403859
+	QUAD $0x58fae9f773886e19 // .quad 6411694268519837209
+	QUAD $0xda7f5bf590966848 // .quad -2702340141148116920
+	QUAD $0xaf39a475506a899f // .quad -5820440219632367201
+	QUAD $0x888f99797a5e012d // .quad -8606491615858654931
+	QUAD $0x6d8406c952429604 // .quad 7891439908798240260
+	QUAD $0xaab37fd7d8f58178 // .quad -6146428501395930760
+	QUAD $0xc8e5087ba6d33b84 // .quad -3970758169284363388
+	QUAD $0xd5605fcdcf32e1d6 // .quad -3071349608317525546
+	QUAD $0xfb1e4a9a90880a65 // .quad -351761693178066331
+	QUAD $0x855c3be0a17fcd26 // .quad -8837122532839535322
+	QUAD $0x5cf2eea09a550680 // .quad 6697677969404790400
+	QUAD $0xa6b34ad8c9dfc06f // .quad -6434717147622031249
+	QUAD $0xf42faa48c0ea481f // .quad -851274575098787809
+	QUAD $0xd0601d8efc57b08b // .quad -3431710416100151157
+	QUAD $0xf13b94daf124da27 // .quad -1064093218873484761
+	QUAD $0x823c12795db6ce57 // .quad -9062348037703676329
+	QUAD $0x76c53d08d6b70859 // .quad 8558313775058847833
+	QUAD $0xa2cb1717b52481ed // .quad -6716249028702207507
+	QUAD $0x54768c4b0c64ca6f // .quad 6086206200396171887
+	QUAD $0xcb7ddcdda26da268 // .quad -3783625267450371480
+	QUAD $0xa9942f5dcf7dfd0a // .quad -6227300304786948854
+	QUAD $0xfe5d54150b090b02 // .quad -117845565885576446
+	QUAD $0xd3f93b35435d7c4d // .quad -3172439362556298163
+	QUAD $0x9efa548d26e5a6e1 // .quad -6991182506319567135
+	QUAD $0xc47bc5014a1a6db0 // .quad -4288617610811380304
+	QUAD $0xc6b8e9b0709f109a // .quad -4127292114472071014
+	QUAD $0x359ab6419ca1091c // .quad 3862600023340550428
+	QUAD $0xf867241c8cc6d4c0 // .quad -547429124662700864
+	QUAD $0xc30163d203c94b63 // .quad -4395122007679087773
+	QUAD $0x9b407691d7fc44f8 // .quad -7259672230555269896
+	QUAD $0x79e0de63425dcf1e // .quad 8782263791269039902
+	QUAD $0xc21094364dfb5636 // .quad -4462904269766699466
+	QUAD $0x985915fc12f542e5 // .quad -7468914334623251739
+	QUAD $0xf294b943e17a2bc4 // .quad -966944318780986428
+	QUAD $0x3e6f5b7b17b2939e // .quad 4498915137003099038
+	QUAD $0x979cf3ca6cec5b5a // .quad -7521869226879198374
+	QUAD $0xa705992ceecf9c43 // .quad -6411550076227838909
+	QUAD $0xbd8430bd08277231 // .quad -4790650515171610063
+	QUAD $0x50c6ff782a838354 // .quad 5820620459997365076
+	QUAD $0xece53cec4a314ebd // .quad -1376627125537124675
+	QUAD $0xa4f8bf5635246429 // .quad -6559282480285457367
+	QUAD $0x940f4613ae5ed136 // .quad -7777920981101784778
+	QUAD $0x871b7795e136be9a // .quad -8711237568605798758
+	QUAD $0xb913179899f68584 // .quad -5110715207949843068
+	QUAD $0x28e2557b59846e40 // .quad 2946011094524915264
+	QUAD $0xe757dd7ec07426e5 // .quad -1776707991509915931
+	QUAD $0x331aeada2fe589d0 // .quad 3682513868156144080
+	QUAD $0x9096ea6f3848984f // .quad -8027971522334779313
+	QUAD $0x3ff0d2c85def7622 // .quad 4607414176811284002
+	QUAD $0xb4bca50b065abe63 // .quad -5423278384491086237
+	QUAD $0x0fed077a756b53aa // .quad 1147581702586717098
+	QUAD $0xe1ebce4dc7f16dfb // .quad -2167411962186469893
+	QUAD $0xd3e8495912c62895 // .quad -3177208890193991531
+	QUAD $0x8d3360f09cf6e4bd // .quad -8272161504007625539
+	QUAD $0x64712dd7abbbd95d // .quad 7237616480483531101
+	QUAD $0xb080392cc4349dec // .quad -5728515861582144020
+	QUAD $0xbd8d794d96aacfb4 // .quad -4788037454677749836
+	QUAD $0xdca04777f541c567 // .quad -2548958808550292121
+	QUAD $0xecf0d7a0fc5583a1 // .quad -1373360799919799391
+	QUAD $0x89e42caaf9491b60 // .quad -8510628282985014432
+	QUAD $0xf41686c49db57245 // .quad -858350499949874619
+	QUAD $0xac5d37d5b79b6239 // .quad -6026599335303880135
+	QUAD $0x311c2875c522ced6 // .quad 3538747893490044630
+	QUAD $0xd77485cb25823ac7 // .quad -2921563150702462265
+	QUAD $0x7d633293366b828c // .quad 9035120885289943692
+	QUAD $0x86a8d39ef77164bc // .quad -8743505996830120772
+	QUAD $0xae5dff9c02033198 // .quad -5882264492762254952
+	QUAD $0xa8530886b54dbdeb // .quad -6317696477610263061
+	QUAD $0xd9f57f830283fdfd // .quad -2741144597525430787
+	QUAD $0xd267caa862a12d66 // .quad -3285434578585440922
+	QUAD $0xd072df63c324fd7c // .quad -3426430746906788484
+	QUAD $0x8380dea93da4bc60 // .quad -8970925639256982432
+	QUAD $0x4247cb9e59f71e6e // .quad 4776009810824339054
+	QUAD $0xa46116538d0deb78 // .quad -6601971030643840136
+	QUAD $0x52d9be85f074e609 // .quad 5970012263530423817
+	QUAD $0xcd795be870516656 // .quad -3640777769877412266
+	QUAD $0x67902e276c921f8c // .quad 7462515329413029772
+	QUAD $0x806bd9714632dff6 // .quad -9193015133814464522
+	QUAD $0x00ba1cd8a3db53b7 // .quad 52386062455755703
+	QUAD $0xa086cfcd97bf97f3 // .quad -6879582898840692749
+	QUAD $0x80e8a40eccd228a5 // .quad -9157889458785081179
+	QUAD $0xc8a883c0fdaf7df0 // .quad -3987792605123478032
+	QUAD $0x6122cd128006b2ce // .quad 6999382250228200142
+	QUAD $0xfad2a4b13d1b5d6c // .quad -373054737976959636
+	QUAD $0x796b805720085f82 // .quad 8749227812785250178
+	QUAD $0x9cc3a6eec6311a63 // .quad -7150688238876681629
+	QUAD $0xcbe3303674053bb1 // .quad -3755104653863994447
+	QUAD $0xc3f490aa77bd60fc // .quad -4326674280168464132
+	QUAD $0xbedbfc4411068a9d // .quad -4693880817329993059
+	QUAD $0xf4f1b4d515acb93b // .quad -796656831783192261
+	QUAD $0xee92fb5515482d45 // .quad -1255665003235103419
+	QUAD $0x991711052d8bf3c5 // .quad -7415439547505577019
+	QUAD $0x751bdd152d4d1c4b // .quad 8438581409832836171
+	QUAD $0xbf5cd54678eef0b6 // .quad -4657613415954583370
+	QUAD $0xd262d45a78a0635e // .quad -3286831292991118498
+	QUAD $0xef340a98172aace4 // .quad -1210330751515841308
+	QUAD $0x86fb897116c87c35 // .quad -8720225134666286027
+	QUAD $0x9580869f0e7aac0e // .quad -7673985747338482674
+	QUAD $0xd45d35e6ae3d4da1 // .quad -3144297699952734815
+	QUAD $0xbae0a846d2195712 // .quad -4980796165745715438
+	QUAD $0x8974836059cca10a // .quad -8542058143368306422
+	QUAD $0xe998d258869facd7 // .quad -1614309188754756393
+	QUAD $0x2bd1a438703fc94c // .quad 3157485376071780684
+	QUAD $0x91ff83775423cc06 // .quad -7926472270612804602
+	QUAD $0x7b6306a34627ddd0 // .quad 8890957387685944784
+	QUAD $0xb67f6455292cbf08 // .quad -5296404319838617848
+	QUAD $0x1a3bc84c17b1d543 // .quad 1890324697752655171
+	QUAD $0xe41f3d6a7377eeca // .quad -2008819381370884406
+	QUAD $0x20caba5f1d9e4a94 // .quad 2362905872190818964
+	QUAD $0x8e938662882af53e // .quad -8173041140997884610
+	QUAD $0x547eb47b7282ee9d // .quad 6088502188546649757
+	QUAD $0xb23867fb2a35b28d // .quad -5604615407819967859
+	QUAD $0xe99e619a4f23aa44 // .quad -1612744301171463612
+	QUAD $0xdec681f9f4c31f31 // .quad -2394083241347571919
+	QUAD $0x6405fa00e2ec94d5 // .quad 7207441660390446293
+	QUAD $0x8b3c113c38f9f37e // .quad -8413831053483314306
+	QUAD $0xde83bc408dd3dd05 // .quad -2412877989897052923
+	QUAD $0xae0b158b4738705e // .quad -5905602798426754978
+	QUAD $0x9624ab50b148d446 // .quad -7627783505798704058
+	QUAD $0xd98ddaee19068c76 // .quad -2770317479606055818
+	QUAD $0x3badd624dd9b0958 // .quad 4300328673033783640
+	QUAD $0x87f8a8d4cfa417c9 // .quad -8648977452394866743
+	QUAD $0xe54ca5d70a80e5d7 // .quad -1923980597781273129
+	QUAD $0xa9f6d30a038d1dbc // .quad -6199535797066195524
+	QUAD $0x5e9fcf4ccd211f4d // .quad 6818396289628184397
+	QUAD $0xd47487cc8470652b // .quad -3137733727905356501
+	QUAD $0x7647c32000696720 // .quad 8522995362035230496
+	QUAD $0x84c8d4dfd2c63f3b // .quad -8878612607581929669
+	QUAD $0x29ecd9f40041e074 // .quad 3021029092058325108
+	QUAD $0xa5fb0a17c777cf09 // .quad -6486579741050024183
+	QUAD $0xf468107100525891 // .quad -835399653354481519
+	QUAD $0xcf79cc9db955c2cc // .quad -3496538657885142324
+	QUAD $0x7182148d4066eeb5 // .quad 8179122470161673909
+	QUAD $0x81ac1fe293d599bf // .quad -9102865688819295809
+	QUAD $0xc6f14cd848405531 // .quad -4111420493003729615
+	QUAD $0xa21727db38cb002f // .quad -6766896092596731857
+	QUAD $0xb8ada00e5a506a7d // .quad -5139275616254662019
+	QUAD $0xca9cf1d206fdc03b // .quad -3846934097318526917
+	QUAD $0xa6d90811f0e4851d // .quad -6424094520318327523
+	QUAD $0xfd442e4688bd304a // .quad -196981603220770742
+	QUAD $0x908f4a166d1da664 // .quad -8030118150397909404
+	QUAD $0x9e4a9cec15763e2e // .quad -7040642529654063570
+	QUAD $0x9a598e4e043287ff // .quad -7324666853212387329
+	QUAD $0xc5dd44271ad3cdba // .quad -4189117143640191558
+	QUAD $0x40eff1e1853f29fe // .quad 4679224488766679550
+	QUAD $0xf7549530e188c128 // .quad -624710411122851544
+	QUAD $0xd12bee59e68ef47d // .quad -3374341425896426371
+	QUAD $0x9a94dd3e8cf578b9 // .quad -7307973034592864071
+	QUAD $0x82bb74f8301958cf // .quad -9026492418826348337
+	QUAD $0xc13a148e3032d6e7 // .quad -4523280274813692185
+	QUAD $0xe36a52363c1faf02 // .quad -2059743486678159614
+	QUAD $0xf18899b1bc3f8ca1 // .quad -1042414325089727327
+	QUAD $0xdc44e6c3cb279ac2 // .quad -2574679358347699518
+	QUAD $0x96f5600f15a7b7e5 // .quad -7569037980822161435
+	QUAD $0x29ab103a5ef8c0ba // .quad 3002511419460075706
+	QUAD $0xbcb2b812db11a5de // .quad -4849611457600313890
+	QUAD $0x7415d448f6b6f0e8 // .quad 8364825292752482536
+	QUAD $0xebdf661791d60f56 // .quad -1450328303573004458
+	QUAD $0x111b495b3464ad22 // .quad 1232659579085827362
+	QUAD $0x936b9fcebb25c995 // .quad -7823984217374209643
+	QUAD $0xcab10dd900beec35 // .quad -3841273781498745803
+	QUAD $0xb84687c269ef3bfb // .quad -5168294253290374149
+	QUAD $0x3d5d514f40eea743 // .quad 4421779809981343555
+	QUAD $0xe65829b3046b0afa // .quad -1848681798185579782
+	QUAD $0x0cb4a5a3112a5113 // .quad 915538744049291539
+	QUAD $0x8ff71a0fe2c2e6dc // .quad -8072955151507069220
+	QUAD $0x47f0e785eaba72ac // .quad 5183897733458195116
+	QUAD $0xb3f4e093db73a093 // .quad -5479507920956448621
+	QUAD $0x59ed216765690f57 // .quad 6479872166822743895
+	QUAD $0xe0f218b8d25088b8 // .quad -2237698882768172872
+	QUAD $0x306869c13ec3532d // .quad 3488154190101041965
+	QUAD $0x8c974f7383725573 // .quad -8316090829371189901
+	QUAD $0x1e414218c73a13fc // .quad 2180096368813151228
+	QUAD $0xafbd2350644eeacf // .quad -5783427518286599473
+	QUAD $0xe5d1929ef90898fb // .quad -1886565557410948869
+	QUAD $0xdbac6c247d62a583 // .quad -2617598379430861437
+	QUAD $0xdf45f746b74abf3a // .quad -2358206946763686086
+	QUAD $0x894bc396ce5da772 // .quad -8553528014785370254
+	QUAD $0x6b8bba8c328eb784 // .quad 7749492695127472004
+	QUAD $0xab9eb47c81f5114f // .quad -6080224000054324913
+	QUAD $0x066ea92f3f326565 // .quad 463493832054564197
+	QUAD $0xd686619ba27255a2 // .quad -2988593981640518238
+	QUAD $0xc80a537b0efefebe // .quad -4032318728359182658
+	QUAD $0x8613fd0145877585 // .quad -8785400266166405755
+	QUAD $0xbd06742ce95f5f37 // .quad -4826042214438183113
+	QUAD $0xa798fc4196e952e7 // .quad -6370064314280619289
+	QUAD $0x2c48113823b73705 // .quad 3190819268807046917
+	QUAD $0xd17f3b51fca3a7a0 // .quad -3350894374423386208
+	QUAD $0xf75a15862ca504c6 // .quad -623161932418579258
+	QUAD $0x82ef85133de648c4 // .quad -9011838011655698236
+	QUAD $0x9a984d73dbe722fc // .quad -7307005235402693892
+	QUAD $0xa3ab66580d5fdaf5 // .quad -6653111496142234891
+	QUAD $0xc13e60d0d2e0ebbb // .quad -4522070525825979461
+	QUAD $0xcc963fee10b7d1b3 // .quad -3704703351750405709
+	QUAD $0x318df905079926a9 // .quad 3570783879572301481
+	QUAD $0xffbbcfe994e5c61f // .quad -19193171260619233
+	QUAD $0xfdf17746497f7053 // .quad -148206168962011053
+	QUAD $0x9fd561f1fd0f9bd3 // .quad -6929524759678968877
+	QUAD $0xfeb6ea8bedefa634 // .quad -92628855601256908
+	QUAD $0xc7caba6e7c5382c8 // .quad -4050219931171323192
+	QUAD $0xfe64a52ee96b8fc1 // .quad -115786069501571135
+	QUAD $0xf9bd690a1b68637b // .quad -451088895536766085
+	QUAD $0x3dfdce7aa3c673b1 // .quad 4466953431550423985
+	QUAD $0x9c1661a651213e2d // .quad -7199459587351560659
+	QUAD $0x06bea10ca65c084f // .quad 486002885505321039
+	QUAD $0xc31bfa0fe5698db8 // .quad -4387638465762062920
+	QUAD $0x486e494fcff30a63 // .quad 5219189625309039203
+	QUAD $0xf3e2f893dec3f126 // .quad -872862063775190746
+	QUAD $0x5a89dba3c3efccfb // .quad 6523987031636299003
+	QUAD $0x986ddb5c6b3a76b7 // .quad -7463067817500576073
+	QUAD $0xf89629465a75e01d // .quad -534194123654701027
+	QUAD $0xbe89523386091465 // .quad -4717148753448332187
+	QUAD $0xf6bbb397f1135824 // .quad -667742654568376284
+	QUAD $0xee2ba6c0678b597f // .quad -1284749923383027329
+	QUAD $0x746aa07ded582e2d // .quad 8388693718644305453
+	QUAD $0x94db483840b717ef // .quad -7720497729755473937
+	QUAD $0xa8c2a44eb4571cdd // .quad -6286281471915778851
+	QUAD $0xba121a4650e4ddeb // .quad -5038936143766954517
+	QUAD $0x92f34d62616ce414 // .quad -7857851839894723564
+	QUAD $0xe896a0d7e51e1566 // .quad -1686984161281305242
+	QUAD $0x77b020baf9c81d18 // .quad 8624429273841147160
+	QUAD $0x915e2486ef32cd60 // .quad -7971894128441897632
+	QUAD $0x0ace1474dc1d122f // .quad 778582277723329071
+	QUAD $0xb5b5ada8aaff80b8 // .quad -5353181642124984136
+	QUAD $0x0d819992132456bb // .quad 973227847154161339
+	QUAD $0xe3231912d5bf60e6 // .quad -2079791034228842266
+	QUAD $0x10e1fff697ed6c6a // .quad 1216534808942701674
+	QUAD $0x8df5efabc5979c8f // .quad -8217398424034108273
+	QUAD $0xca8d3ffa1ef463c2 // .quad -3851351762838199358
+	QUAD $0xb1736b96b6fd83b3 // .quad -5660062011615247437
+	QUAD $0xbd308ff8a6b17cb3 // .quad -4814189703547749197
+	QUAD $0xddd0467c64bce4a0 // .quad -2463391496091671392
+	QUAD $0xac7cb3f6d05ddbdf // .quad -6017737129434686497
+	QUAD $0x8aa22c0dbef60ee4 // .quad -8457148712698376476
+	QUAD $0x6bcdf07a423aa96c // .quad 7768129340171790700
+	QUAD $0xad4ab7112eb3929d // .quad -5959749872445582691
+	QUAD $0x86c16c98d2c953c7 // .quad -8736582398494813241
+	QUAD $0xd89d64d57a607744 // .quad -2838001322129590460
+	QUAD $0xe871c7bf077ba8b8 // .quad -1697355961263740744
+	QUAD $0x87625f056c7c4a8b // .quad -8691279853972075893
+	QUAD $0x11471cd764ad4973 // .quad 1244995533423855987
+	QUAD $0xa93af6c6c79b5d2d // .quad -6252413799037706963
+	QUAD $0xd598e40d3dd89bd0 // .quad -3055441601647567920
+	QUAD $0xd389b47879823479 // .quad -3203831230369745799
+	QUAD $0x4aff1d108d4ec2c4 // .quad 5404070034795315908
+	QUAD $0x843610cb4bf160cb // .quad -8919923546622172981
+	QUAD $0xcedf722a585139bb // .quad -3539985255894009413
+	QUAD $0xa54394fe1eedb8fe // .quad -6538218414850328322
+	QUAD $0xc2974eb4ee658829 // .quad -4424981569867511767
+	QUAD $0xce947a3da6a9273e // .quad -3561087000135522498
+	QUAD $0x733d226229feea33 // .quad 8303831092947774003
+	QUAD $0x811ccc668829b887 // .quad -9143208402725783417
+	QUAD $0x0806357d5a3f5260 // .quad 578208414664970848
+	QUAD $0xa163ff802a3426a8 // .quad -6817324484979841368
+	QUAD $0xca07c2dcb0cf26f8 // .quad -3888925500096174344
+	QUAD $0xc9bcff6034c13052 // .quad -3909969587797413806
+	QUAD $0xfc89b393dd02f0b6 // .quad -249470856692830026
+	QUAD $0xfc2c3f3841f17c67 // .quad -275775966319379353
+	QUAD $0xbbac2078d443ace3 // .quad -4923524589293425437
+	QUAD $0x9d9ba7832936edc0 // .quad -7089889006590693952
+	QUAD $0xd54b944b84aa4c0e // .quad -3077202868308390898
+	QUAD $0xc5029163f384a931 // .quad -4250675239810979535
+	QUAD $0x0a9e795e65d4df12 // .quad 765182433041899282
+	QUAD $0xf64335bcf065d37d // .quad -701658031336336515
+	QUAD $0x4d4617b5ff4a16d6 // .quad 5568164059729762006
+	QUAD $0x99ea0196163fa42e // .quad -7356065297226292178
+	QUAD $0x504bced1bf8e4e46 // .quad 5785945546544795206
+	QUAD $0xc06481fb9bcf8d39 // .quad -4583395603105477319
+	QUAD $0xe45ec2862f71e1d7 // .quad -1990940103673781801
+	QUAD $0xf07da27a82c37088 // .quad -1117558485454458744
+	QUAD $0x5d767327bb4e5a4d // .quad 6734696907262548557
+	QUAD $0x964e858c91ba2655 // .quad -7616003081050118571
+	QUAD $0x3a6a07f8d510f870 // .quad 4209185567039092848
+	QUAD $0xbbe226efb628afea // .quad -4908317832885260310
+	QUAD $0x890489f70a55368c // .quad -8573576096483297652
+	QUAD $0xeadab0aba3b2dbe5 // .quad -1523711272679187483
+	QUAD $0x2b45ac74ccea842f // .quad 3118087934678041647
+	QUAD $0x92c8ae6b464fc96f // .quad -7869848573065574033
+	QUAD $0x3b0b8bc90012929e // .quad 4254647968387469982
+	QUAD $0xb77ada0617e3bbcb // .quad -5225624697904579637
+	QUAD $0x09ce6ebb40173745 // .quad 706623942056949573
+	QUAD $0xe55990879ddcaabd // .quad -1920344853953336643
+	QUAD $0xcc420a6a101d0516 // .quad -3728406090856200938
+	QUAD $0x8f57fa54c2a9eab6 // .quad -8117744561361917258
+	QUAD $0x9fa946824a12232e // .quad -6941939825212513490
+	QUAD $0xb32df8e9f3546564 // .quad -5535494683275008668
+	QUAD $0x47939822dc96abfa // .quad 5157633273766521850
+	QUAD $0xdff9772470297ebd // .quad -2307682335666372931
+	QUAD $0x59787e2b93bc56f8 // .quad 6447041592208152312
+	QUAD $0x8bfbea76c619ef36 // .quad -8359830487432564938
+	QUAD $0x57eb4edb3c55b65b // .quad 6335244004343789147
+	QUAD $0xaefae51477a06b03 // .quad -5838102090863318269
+	QUAD $0xede622920b6b23f2 // .quad -1304317031425039374
+	QUAD $0xdab99e59958885c4 // .quad -2685941595151759932
+	QUAD $0xe95fab368e45ecee // .quad -1630396289281299218
+	QUAD $0x88b402f7fd75539b // .quad -8596242524610931813
+	QUAD $0x11dbcb0218ebb415 // .quad 1286845328412881941
+	QUAD $0xaae103b5fcd2a881 // .quad -6133617137336276863
+	QUAD $0xd652bdc29f26a11a // .quad -3003129357911285478
+	QUAD $0xd59944a37c0752a2 // .quad -3055335403242958174
+	QUAD $0x4be76d3346f04960 // .quad 5469460339465668960
+	QUAD $0x857fcae62d8493a5 // .quad -8827113654667930715
+	QUAD $0x6f70a4400c562ddc // .quad 8030098730593431004
+	QUAD $0xa6dfbd9fb8e5b88e // .quad -6422206049907525490
+	QUAD $0xcb4ccd500f6bb953 // .quad -3797434642040374957
+	QUAD $0xd097ad07a71f26b2 // .quad -3416071543957018958
+	QUAD $0x7e2000a41346a7a8 // .quad 9088264752731695016
+	QUAD $0x825ecc24c873782f // .quad -9052573742614218705
+	QUAD $0x8ed400668c0c28c9 // .quad -8154892584824854327
+	QUAD $0xa2f67f2dfa90563b // .quad -6704031159840385477
+	QUAD $0x728900802f0f32fb // .quad 8253128342678483707
+	QUAD $0xcbb41ef979346bca // .quad -3768352931373093942
+	QUAD $0x4f2b40a03ad2ffba // .quad 5704724409920716730
+	QUAD $0xfea126b7d78186bc // .quad -98755145788979524
+	QUAD $0xe2f610c84987bfa9 // .quad -2092466524453879895
+	QUAD $0x9f24b832e6b0f436 // .quad -6979250993759194058
+	QUAD $0x0dd9ca7d2df4d7ca // .quad 998051431430019018
+	QUAD $0xc6ede63fa05d3143 // .quad -4112377723771604669
+	QUAD $0x91503d1c79720dbc // .quad -7975807747567252036
+	QUAD $0xf8a95fcf88747d94 // .quad -528786136287117932
+	QUAD $0x75a44c6397ce912b // .quad 8476984389250486571
+	QUAD $0x9b69dbe1b548ce7c // .quad -7248020362820530564
+	QUAD $0xc986afbe3ee11abb // .quad -3925256793573221701
+	QUAD $0xc24452da229b021b // .quad -4448339435098275301
+	QUAD $0xfbe85badce996169 // .quad -294884973539139223
+	QUAD $0xf2d56790ab41c2a2 // .quad -948738275445456222
+	QUAD $0xfae27299423fb9c4 // .quad -368606216923924028
+	QUAD $0x97c560ba6b0919a5 // .quad -7510490449794491995
+	QUAD $0xdccd879fc967d41b // .quad -2536221894791146469
+	QUAD $0xbdb6b8e905cb600f // .quad -4776427043815727089
+	QUAD $0x5400e987bbc1c921 // .quad 6053094668365842721
+	QUAD $0xed246723473e3813 // .quad -1358847786342270957
+	QUAD $0x290123e9aab23b69 // .quad 2954682317029915497
+	QUAD $0x9436c0760c86e30b // .quad -7766808894105001205
+	QUAD $0xf9a0b6720aaf6522 // .quad -459166561069996766
+	QUAD $0xb94470938fa89bce // .quad -5096825099203863602
+	QUAD $0xf808e40e8d5b3e6a // .quad -573958201337495958
+	QUAD $0xe7958cb87392c2c2 // .quad -1759345355577441598
+	QUAD $0xb60b1d1230b20e05 // .quad -5329133770099257851
+	QUAD $0x90bd77f3483bb9b9 // .quad -8017119874876982855
+	QUAD $0xb1c6f22b5e6f48c3 // .quad -5636551615525730109
+	QUAD $0xb4ecd5f01a4aa828 // .quad -5409713825168840664
+	QUAD $0x1e38aeb6360b1af4 // .quad 2177682517447613172
+	QUAD $0xe2280b6c20dd5232 // .quad -2150456263033662926
+	QUAD $0x25c6da63c38de1b1 // .quad 2722103146809516465
+	QUAD $0x8d590723948a535f // .quad -8261564192037121185
+	QUAD $0x579c487e5a38ad0f // .quad 6313000485183335695
+	QUAD $0xb0af48ec79ace837 // .quad -5715269221619013577
+	QUAD $0x2d835a9df0c6d852 // .quad 3279564588051781714
+	QUAD $0xdcdb1b2798182244 // .quad -2532400508596379068
+	QUAD $0xf8e431456cf88e66 // .quad -512230283362660762
+	QUAD $0x8a08f0f8bf0f156b // .quad -8500279345513818773
+	QUAD $0x1b8e9ecb641b5900 // .quad 1985699082112030976
+	QUAD $0xac8b2d36eed2dac5 // .quad -6013663163464885563
+	QUAD $0xe272467e3d222f40 // .quad -2129562165787349184
+	QUAD $0xd7adf884aa879177 // .quad -2905392935903719049
+	QUAD $0x5b0ed81dcc6abb10 // .quad 6561419329620589328
+	QUAD $0x86ccbb52ea94baea // .quad -8733399612580906262
+	QUAD $0x98e947129fc2b4ea // .quad -7428327965055601430
+	QUAD $0xa87fea27a539e9a5 // .quad -6305063497298744923
+	QUAD $0x3f2398d747b36225 // .quad 4549648098962661925
+	QUAD $0xd29fe4b18e88640e // .quad -3269643353196043250
+	QUAD $0x8eec7f0d19a03aae // .quad -8147997931578836306
+	QUAD $0x83a3eeeef9153e89 // .quad -8961056123388608887
+	QUAD $0x1953cf68300424ad // .quad 1825030320404309165
+	QUAD $0xa48ceaaab75a8e2b // .quad -6589634135808373205
+	QUAD $0x5fa8c3423c052dd8 // .quad 6892973918932774360
+	QUAD $0xcdb02555653131b6 // .quad -3625356651333078602
+	QUAD $0x3792f412cb06794e // .quad 4004531380238580046
+	QUAD $0x808e17555f3ebf11 // .quad -9183376934724255983
+	QUAD $0xe2bbd88bbee40bd1 // .quad -2108853905778275375
+	QUAD $0xa0b19d2ab70e6ed6 // .quad -6867535149977932074
+	QUAD $0x5b6aceaeae9d0ec5 // .quad 6587304654631931589
+	QUAD $0xc8de047564d20a8b // .quad -3972732919045027189
+	QUAD $0xf245825a5a445276 // .quad -989241218564861322
+	QUAD $0xfb158592be068d2e // .quad -354230130378896082
+	QUAD $0xeed6e2f0f0d56713 // .quad -1236551523206076653
+	QUAD $0x9ced737bb6c4183d // .quad -7138922859127891907
+	QUAD $0x55464dd69685606c // .quad 6144684325637283948
+	QUAD $0xc428d05aa4751e4c // .quad -4311967555482476980
+	QUAD $0xaa97e14c3c26b887 // .quad -6154202648235558777
+	QUAD $0xf53304714d9265df // .quad -778273425925708321
+	QUAD $0xd53dd99f4b3066a9 // .quad -3081067291867060567
+	QUAD $0x993fe2c6d07b7fab // .quad -7403949918844649557
+	QUAD $0xe546a8038efe402a // .quad -1925667057416912854
+	QUAD $0xbf8fdb78849a5f96 // .quad -4643251380128424042
+	QUAD $0xde98520472bdd034 // .quad -2407083821771141068
+	QUAD $0xef73d256a5c0f77c // .quad -1192378206733142148
+	QUAD $0x963e66858f6d4441 // .quad -7620540795641314239
+	QUAD $0x95a8637627989aad // .quad -7662765406849295699
+	QUAD $0xdde7001379a44aa9 // .quad -2456994988062127447
+	QUAD $0xbb127c53b17ec159 // .quad -4966770740134231719
+	QUAD $0x5560c018580d5d53 // .quad 6152128301777116499
+	QUAD $0xe9d71b689dde71af // .quad -1596777406740401745
+	QUAD $0xaab8f01e6e10b4a7 // .quad -6144897678060768089
+	QUAD $0x9226712162ab070d // .quad -7915514906853832947
+	QUAD $0xcab3961304ca70e9 // .quad -3840561048787980055
+	QUAD $0xb6b00d69bb55c8d1 // .quad -5282707615139903279
+	QUAD $0x3d607b97c5fd0d23 // .quad 4422670725869800739
+	QUAD $0xe45c10c42a2b3b05 // .quad -1991698500497491195
+	QUAD $0x8cb89a7db77c506b // .quad -8306719647944912789
+	QUAD $0x8eb98a7a9a5b04e3 // .quad -8162340590452013853
+	QUAD $0x77f3608e92adb243 // .quad 8643358275316593219
+	QUAD $0xb267ed1940f1c61c // .quad -5591239719637629412
+	QUAD $0x55f038b237591ed4 // .quad 6192511825718353620
+	QUAD $0xdf01e85f912e37a3 // .quad -2377363631119648861
+	QUAD $0x6b6c46dec52f6689 // .quad 7740639782147942025
+	QUAD $0x8b61313bbabce2c6 // .quad -8403381297090862394
+	QUAD $0x2323ac4b3b3da016 // .quad 2532056854628769814
+	QUAD $0xae397d8aa96c1b77 // .quad -5892540602936190089
+	QUAD $0xabec975e0a0d081b // .quad -6058300968568813541
+	QUAD $0xd9c7dced53c72255 // .quad -2753989735242849707
+	QUAD $0x96e7bd358c904a22 // .quad -7572876210711016926
+	QUAD $0x881cea14545c7575 // .quad -8638772612167862923
+	QUAD $0x7e50d64177da2e55 // .quad 9102010423587778133
+	QUAD $0xaa242499697392d2 // .quad -6186779746782440750
+	QUAD $0xdde50bd1d5d0b9ea // .quad -2457545025797441046
+	QUAD $0xd4ad2dbfc3d07787 // .quad -3121788665050663033
+	QUAD $0x955e4ec64b44e865 // .quad -7683617300674189211
+	QUAD $0x84ec3c97da624ab4 // .quad -8868646943297746252
+	QUAD $0xbd5af13bef0b113f // .quad -4802260812921368257
+	QUAD $0xa6274bbdd0fadd61 // .quad -6474122660694794911
+	QUAD $0xecb1ad8aeacdd58f // .quad -1391139997724322417
+	QUAD $0xcfb11ead453994ba // .quad -3480967307441105734
+	QUAD $0x67de18eda5814af3 // .quad 7484447039699372787
+	QUAD $0x81ceb32c4b43fcf4 // .quad -9093133594791772940
+	QUAD $0x80eacf948770ced8 // .quad -9157278655470055720
+	QUAD $0xa2425ff75e14fc31 // .quad -6754730975062328271
+	QUAD $0xa1258379a94d028e // .quad -6834912300910181746
+	QUAD $0xcad2f7f5359a3b3e // .quad -3831727700400522434
+	QUAD $0x096ee45813a04331 // .quad 679731660717048625
+	QUAD $0xfd87b5f28300ca0d // .quad -177973607073265139
+	QUAD $0x8bca9d6e188853fd // .quad -8373707460958465027
+	QUAD $0x9e74d1b791e07e48 // .quad -7028762532061872568
+	QUAD $0x775ea264cf55347e // .quad 8601490892183123070
+	QUAD $0xc612062576589dda // .quad -4174267146649952806
+	QUAD $0x95364afe032a819e // .quad -7694880458480647778
+	QUAD $0xf79687aed3eec551 // .quad -606147914885053103
+	QUAD $0x3a83ddbd83f52205 // .quad 4216457482181353989
+	QUAD $0x9abe14cd44753b52 // .quad -7296371474444240046
+	QUAD $0xc4926a9672793543 // .quad -4282243101277735613
+	QUAD $0xc16d9a0095928a27 // .quad -4508778324627912153
+	QUAD $0x75b7053c0f178294 // .quad 8482254178684994196
+	QUAD $0xf1c90080baf72cb1 // .quad -1024286887357502287
+	QUAD $0x5324c68b12dd6339 // .quad 5991131704928854841
+	QUAD $0x971da05074da7bee // .quad -7557708332239520786
+	QUAD $0xd3f6fc16ebca5e04 // .quad -3173071712060547580
+	QUAD $0xbce5086492111aea // .quad -4835449396872013078
+	QUAD $0x88f4bb1ca6bcf585 // .quad -8578025658503072379
+	QUAD $0xec1e4a7db69561a5 // .quad -1432625727662628443
+	QUAD $0x2b31e9e3d06c32e6 // .quad 3112525982153323238
+	QUAD $0x9392ee8e921d5d07 // .quad -7812920107430224633
+	QUAD $0x3aff322e62439fd0 // .quad 4251171748059520976
+	QUAD $0xb877aa3236a4b449 // .quad -5154464115860392887
+	QUAD $0x09befeb9fad487c3 // .quad 702278666647013315
+	QUAD $0xe69594bec44de15b // .quad -1831394126398103205
+	QUAD $0x4c2ebe687989a9b4 // .quad 5489534351736154548
+	QUAD $0x901d7cf73ab0acd9 // .quad -8062150356639896359
+	QUAD $0x0f9d37014bf60a11 // .quad 1125115960621402641
+	QUAD $0xb424dc35095cd80f // .quad -5466001927372482545
+	QUAD $0x538484c19ef38c95 // .quad 6018080969204141205
+	QUAD $0xe12e13424bb40e13 // .quad -2220816390788215277
+	QUAD $0x2865a5f206b06fba // .quad 2910915193077788602
+	QUAD $0x8cbccc096f5088cb // .quad -8305539271883716405
+	QUAD $0xf93f87b7442e45d4 // .quad -486521013540076076
+	QUAD $0xafebff0bcb24aafe // .quad -5770238071427257602
+	QUAD $0xf78f69a51539d749 // .quad -608151266925095095
+	QUAD $0xdbe6fecebdedd5be // .quad -2601111570856684098
+	QUAD $0xb573440e5a884d1c // .quad -5371875102083756772
+	QUAD $0x89705f4136b4a597 // .quad -8543223759426509417
+	QUAD $0x31680a88f8953031 // .quad 3560107088838733873
+	QUAD $0xabcc77118461cefc // .quad -6067343680855748868
+	QUAD $0xfdc20d2b36ba7c3e // .quad -161552157378970562
+	QUAD $0xd6bf94d5e57a42bc // .quad -2972493582642298180
+	QUAD $0x3d32907604691b4d // .quad 4409745821703674701
+	QUAD $0x8637bd05af6c69b5 // .quad -8775337516792518219
+	QUAD $0xa63f9a49c2c1b110 // .quad -6467280898289979120
+	QUAD $0xa7c5ac471b478423 // .quad -6357485877563259869
+	QUAD $0x0fcf80dc33721d54 // .quad 1139270913992301908
+	QUAD $0xd1b71758e219652b // .quad -3335171328526686933
+	QUAD $0xd3c36113404ea4a9 // .quad -3187597375937010519
+	QUAD $0x83126e978d4fdf3b // .quad -9002011107970261189
+	QUAD $0x645a1cac083126ea // .quad 7231123676894144234
+	QUAD $0xa3d70a3d70a3d70a // .quad -6640827866535438582
+	QUAD $0x3d70a3d70a3d70a4 // .quad 4427218577690292388
+	QUAD $0xcccccccccccccccc // .quad -3689348814741910324
+	QUAD $0xcccccccccccccccd // .quad -3689348814741910323
+	QUAD $0x8000000000000000 // .quad -9223372036854775808
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xa000000000000000 // .quad -6917529027641081856
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xc800000000000000 // .quad -4035225266123964416
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xfa00000000000000 // .quad -432345564227567616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x9c40000000000000 // .quad -7187745005283311616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xc350000000000000 // .quad -4372995238176751616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xf424000000000000 // .quad -854558029293551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x9896800000000000 // .quad -7451627795949551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xbebc200000000000 // .quad -4702848726509551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xee6b280000000000 // .quad -1266874889709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x9502f90000000000 // .quad -7709325833709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xba43b74000000000 // .quad -5024971273709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xe8d4a51000000000 // .quad -1669528073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x9184e72a00000000 // .quad -7960984073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xb5e620f480000000 // .quad -5339544073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xe35fa931a0000000 // .quad -2062744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x8e1bc9bf04000000 // .quad -8206744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xb1a2bc2ec5000000 // .quad -5646744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xde0b6b3a76400000 // .quad -2446744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x8ac7230489e80000 // .quad -8446744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xad78ebc5ac620000 // .quad -5946744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xd8d726b7177a8000 // .quad -2821744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x878678326eac9000 // .quad -8681119073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xa968163f0a57b400 // .quad -6239712823709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xd3c21bcecceda100 // .quad -3187955011209551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x84595161401484a0 // .quad -8910000909647051616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xa56fa5b99019a5c8 // .quad -6525815118631426616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xcecb8f27f4200f3a // .quad -3545582879861895366
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x813f3978f8940984 // .quad -9133518327554766460
+	QUAD $0x4000000000000000 // .quad 4611686018427387904
+	QUAD $0xa18f07d736b90be5 // .quad -6805211891016070171
+	QUAD $0x5000000000000000 // .quad 5764607523034234880
+	QUAD $0xc9f2c9cd04674ede // .quad -3894828845342699810
+	QUAD $0xa400000000000000 // .quad -6629298651489370112
+	QUAD $0xfc6f7c4045812296 // .quad -256850038250986858
+	QUAD $0x4d00000000000000 // .quad 5548434740920451072
+	QUAD $0x9dc5ada82b70b59d // .quad -7078060301547948643
+	QUAD $0xf020000000000000 // .quad -1143914305352105984
+	QUAD $0xc5371912364ce305 // .quad -4235889358507547899
+	QUAD $0x6c28000000000000 // .quad 7793479155164643328
+	QUAD $0xf684df56c3e01bc6 // .quad -683175679707046970
+	QUAD $0xc732000000000000 // .quad -4093209111326359552
+	QUAD $0x9a130b963a6c115c // .quad -7344513827457986212
+	QUAD $0x3c7f400000000000 // .quad 4359273333062107136
+	QUAD $0xc097ce7bc90715b3 // .quad -4568956265895094861
+	QUAD $0x4b9f100000000000 // .quad 5449091666327633920
+	QUAD $0xf0bdc21abb48db20 // .quad -1099509313941480672
+	QUAD $0x1e86d40000000000 // .quad 2199678564482154496
+	QUAD $0x96769950b50d88f4 // .quad -7604722348854507276
+	QUAD $0x1314448000000000 // .quad 1374799102801346560
+	QUAD $0xbc143fa4e250eb31 // .quad -4894216917640746191
+	QUAD $0x17d955a000000000 // .quad 1718498878501683200
+	QUAD $0xeb194f8e1ae525fd // .quad -1506085128623544835
+	QUAD $0x5dcfab0800000000 // .quad 6759809616554491904
+	QUAD $0x92efd1b8d0cf37be // .quad -7858832233030797378
+	QUAD $0x5aa1cae500000000 // .quad 6530724019560251392
+	QUAD $0xb7abc627050305ad // .quad -5211854272861108819
+	QUAD $0xf14a3d9e40000000 // .quad -1059967012404461568
+	QUAD $0xe596b7b0c643c719 // .quad -1903131822648998119
+	QUAD $0x6d9ccd05d0000000 // .quad 7898413271349198848
+	QUAD $0x8f7e32ce7bea5c6f // .quad -8106986416796705681
+	QUAD $0xe4820023a2000000 // .quad -1981020733047832576
+	QUAD $0xb35dbf821ae4f38b // .quad -5522047002568494197
+	QUAD $0xdda2802c8a800000 // .quad -2476275916309790720
+	QUAD $0xe0352f62a19e306e // .quad -2290872734783229842
+	QUAD $0xd50b2037ad200000 // .quad -3095344895387238400
+	QUAD $0x8c213d9da502de45 // .quad -8349324486880600507
+	QUAD $0x4526f422cc340000 // .quad 4982938468024057856
+	QUAD $0xaf298d050e4395d6 // .quad -5824969590173362730
+	QUAD $0x9670b12b7f410000 // .quad -7606384970252091392
+	QUAD $0xdaf3f04651d47b4c // .quad -2669525969289315508
+	QUAD $0x3c0cdd765f114000 // .quad 4327076842467049472
+	QUAD $0x88d8762bf324cd0f // .quad -8585982758446904049
+	QUAD $0xa5880a69fb6ac800 // .quad -6518949010312869888
+	QUAD $0xab0e93b6efee0053 // .quad -6120792429631242157
+	QUAD $0x8eea0d047a457a00 // .quad -8148686262891087360
+	QUAD $0xd5d238a4abe98068 // .quad -3039304518611664792
+	QUAD $0x72a4904598d6d880 // .quad 8260886245095692416
+	QUAD $0x85a36366eb71f041 // .quad -8817094351773372351
+	QUAD $0x47a6da2b7f864750 // .quad 5163053903184807760
+	QUAD $0xa70c3c40a64e6c51 // .quad -6409681921289327535
+	QUAD $0x999090b65f67d924 // .quad -7381240676301154012
+	QUAD $0xd0cf4b50cfe20765 // .quad -3400416383184271515
+	QUAD $0xfff4b4e3f741cf6d // .quad -3178808521666707
+	QUAD $0x82818f1281ed449f // .quad -9042789267131251553
+	QUAD $0xbff8f10e7a8921a5 // .quad -4613672773753429595
+	QUAD $0xa321f2d7226895c7 // .quad -6691800565486676537
+	QUAD $0xaff72d52192b6a0e // .quad -5767090967191786994
+	QUAD $0xcbea6f8ceb02bb39 // .quad -3753064688430957767
+	QUAD $0x9bf4f8a69f764491 // .quad -7208863708989733743
+	QUAD $0xfee50b7025c36a08 // .quad -79644842111309304
+	QUAD $0x02f236d04753d5b5 // .quad 212292400617608629
+	QUAD $0x9f4f2726179a2245 // .quad -6967307053960650171
+	QUAD $0x01d762422c946591 // .quad 132682750386005393
+	QUAD $0xc722f0ef9d80aad6 // .quad -4097447799023424810
+	QUAD $0x424d3ad2b7b97ef6 // .quad 4777539456409894646
+	QUAD $0xf8ebad2b84e0d58b // .quad -510123730351893109
+	QUAD $0xd2e0898765a7deb3 // .quad -3251447716342407501
+	QUAD $0x9b934c3b330c8577 // .quad -7236356359111015049
+	QUAD $0x63cc55f49f88eb30 // .quad 7191217214140771120
+	QUAD $0xc2781f49ffcfa6d5 // .quad -4433759430461380907
+	QUAD $0x3cbf6b71c76b25fc // .quad 4377335499248575996
+	QUAD $0xf316271c7fc3908a // .quad -930513269649338230
+	QUAD $0x8bef464e3945ef7b // .quad -8363388681221443717
+	QUAD $0x97edd871cfda3a56 // .quad -7499099821171918250
+	QUAD $0x97758bf0e3cbb5ad // .quad -7532960934977096275
+	QUAD $0xbde94e8e43d0c8ec // .quad -4762188758037509908
+	QUAD $0x3d52eeed1cbea318 // .quad 4418856886560793368
+	QUAD $0xed63a231d4c4fb27 // .quad -1341049929119499481
+	QUAD $0x4ca7aaa863ee4bde // .quad 5523571108200991710
+	QUAD $0x945e455f24fb1cf8 // .quad -7755685233340769032
+	QUAD $0x8fe8caa93e74ef6b // .quad -8076983103442849941
+	QUAD $0xb975d6b6ee39e436 // .quad -5082920523248573386
+	QUAD $0xb3e2fd538e122b45 // .quad -5484542860876174523
+	QUAD $0xe7d34c64a9c85d44 // .quad -1741964635633328828
+	QUAD $0x60dbbca87196b617 // .quad 6979379479186945559
+	QUAD $0x90e40fbeea1d3a4a // .quad -8006256924911912374
+	QUAD $0xbc8955e946fe31ce // .quad -4861259862362934834
+	QUAD $0xb51d13aea4a488dd // .quad -5396135137712502563
+	QUAD $0x6babab6398bdbe42 // .quad 7758483227328495170
+	QUAD $0xe264589a4dcdab14 // .quad -2133482903713240300
+	QUAD $0xc696963c7eed2dd2 // .quad -4136954021121544750
+	QUAD $0x8d7eb76070a08aec // .quad -8250955842461857044
+	QUAD $0xfc1e1de5cf543ca3 // .quad -279753253987271517
+	QUAD $0xb0de65388cc8ada8 // .quad -5702008784649933400
+	QUAD $0x3b25a55f43294bcc // .quad 4261994450943298508
+	QUAD $0xdd15fe86affad912 // .quad -2515824962385028846
+	QUAD $0x49ef0eb713f39ebf // .quad 5327493063679123135
+	QUAD $0x8a2dbf142dfcc7ab // .quad -8489919629131724885
+	QUAD $0x6e3569326c784338 // .quad 7941369183226839864
+	QUAD $0xacb92ed9397bf996 // .quad -6000713517987268202
+	QUAD $0x49c2c37f07965405 // .quad 5315025460606161925
+	QUAD $0xd7e77a8f87daf7fb // .quad -2889205879056697349
+	QUAD $0xdc33745ec97be907 // .quad -2579590211097073401
+	QUAD $0x86f0ac99b4e8dafd // .quad -8723282702051517699
+	QUAD $0x69a028bb3ded71a4 // .quad 7611128154919104932
+	QUAD $0xa8acd7c0222311bc // .quad -6292417359137009220
+	QUAD $0xc40832ea0d68ce0d // .quad -4321147861633282547
+	QUAD $0xd2d80db02aabd62b // .quad -3253835680493873621
+	QUAD $0xf50a3fa490c30191 // .quad -789748808614215279
+	QUAD $0x83c7088e1aab65db // .quad -8951176327949752869
+	QUAD $0x792667c6da79e0fb // .quad 8729779031470891259
+	QUAD $0xa4b8cab1a1563f52 // .quad -6577284391509803182
+	QUAD $0x577001b891185939 // .quad 6300537770911226169
+	QUAD $0xcde6fd5e09abcf26 // .quad -3609919470959866074
+	QUAD $0xed4c0226b55e6f87 // .quad -1347699823215743097
+	QUAD $0x80b05e5ac60b6178 // .quad -9173728696990998152
+	QUAD $0x544f8158315b05b5 // .quad 6075216638131242421
+	QUAD $0xa0dc75f1778e39d6 // .quad -6855474852811359786
+	QUAD $0x696361ae3db1c722 // .quad 7594020797664053026
+	QUAD $0xc913936dd571c84c // .quad -3957657547586811828
+	QUAD $0x03bc3a19cd1e38ea // .quad 269153960225290474
+	QUAD $0xfb5878494ace3a5f // .quad -335385916056126881
+	QUAD $0x04ab48a04065c724 // .quad 336442450281613092
+	QUAD $0x9d174b2dcec0e47b // .quad -7127145225176161157
+	QUAD $0x62eb0d64283f9c77 // .quad 7127805559067090039
+	QUAD $0xc45d1df942711d9a // .quad -4297245513042813542
+	QUAD $0x3ba5d0bd324f8395 // .quad 4298070930406474645
+	QUAD $0xf5746577930d6500 // .quad -759870872876129024
+	QUAD $0xca8f44ec7ee3647a // .quad -3850783373846682502
+	QUAD $0x9968bf6abbe85f20 // .quad -7392448323188662496
+	QUAD $0x7e998b13cf4e1ecc // .quad 9122475437414293196
+	QUAD $0xbfc2ef456ae276e8 // .quad -4628874385558440216
+	QUAD $0x9e3fedd8c321a67f // .quad -7043649776941685121
+	QUAD $0xefb3ab16c59b14a2 // .quad -1174406963520662366
+	QUAD $0xc5cfe94ef3ea101f // .quad -4192876202749718497
+	QUAD $0x95d04aee3b80ece5 // .quad -7651533379841495835
+	QUAD $0xbba1f1d158724a13 // .quad -4926390635932268013
+	QUAD $0xbb445da9ca61281f // .quad -4952730706374481889
+	QUAD $0x2a8a6e45ae8edc98 // .quad 3065383741939440792
+	QUAD $0xea1575143cf97226 // .quad -1579227364540714458
+	QUAD $0xf52d09d71a3293be // .quad -779956341003086914
+	QUAD $0x924d692ca61be758 // .quad -7904546130479028392
+	QUAD $0x593c2626705f9c57 // .quad 6430056314514152535
+	QUAD $0xb6e0c377cfa2e12e // .quad -5268996644671397586
+	QUAD $0x6f8b2fb00c77836d // .quad 8037570393142690669
+	QUAD $0xe498f455c38b997a // .quad -1974559787411859078
+	QUAD $0x0b6dfb9c0f956448 // .quad 823590954573587528
+	QUAD $0x8edf98b59a373fec // .quad -8151628894773493780
+	QUAD $0x4724bd4189bd5ead // .quad 5126430365035880109
+	QUAD $0xb2977ee300c50fe7 // .quad -5577850100039479321
+	QUAD $0x58edec91ec2cb658 // .quad 6408037956294850136
+	QUAD $0xdf3d5e9bc0f653e1 // .quad -2360626606621961247
+	QUAD $0x2f2967b66737e3ee // .quad 3398361426941174766
+	QUAD $0x8b865b215899f46c // .quad -8392920656779807636
+	QUAD $0xbd79e0d20082ee75 // .quad -4793553135802847627
+	QUAD $0xae67f1e9aec07187 // .quad -5879464802547371641
+	QUAD $0xecd8590680a3aa12 // .quad -1380255401326171630
+	QUAD $0xda01ee641a708de9 // .quad -2737644984756826647
+	QUAD $0xe80e6f4820cc9496 // .quad -1725319251657714538
+	QUAD $0x884134fe908658b2 // .quad -8628557143114098510
+	QUAD $0x3109058d147fdcde // .quad 3533361486141316318
+	QUAD $0xaa51823e34a7eede // .quad -6174010410465235234
+	QUAD $0xbd4b46f0599fd416 // .quad -4806670179178130410
+	QUAD $0xd4e5e2cdc1d1ea96 // .quad -3105826994654156138
+	QUAD $0x6c9e18ac7007c91b // .quad 7826720331309500699
+	QUAD $0x850fadc09923329e // .quad -8858670899299929442
+	QUAD $0x03e2cf6bc604ddb1 // .quad 280014188641050033
+	QUAD $0xa6539930bf6bff45 // .quad -6461652605697523899
+	QUAD $0x84db8346b786151d // .quad -8873354301053463267
+	QUAD $0xcfe87f7cef46ff16 // .quad -3465379738694516970
+	QUAD $0xe612641865679a64 // .quad -1868320839462053276
+	QUAD $0x81f14fae158c5f6e // .quad -9083391364325154962
+	QUAD $0x4fcb7e8f3f60c07f // .quad 5749828502977298559
+	QUAD $0xa26da3999aef7749 // .quad -6742553186979055799
+	QUAD $0xe3be5e330f38f09e // .quad -2036086408133152610
+	QUAD $0xcb090c8001ab551c // .quad -3816505465296431844
+	QUAD $0x5cadf5bfd3072cc6 // .quad 6678264026688335046
+	QUAD $0xfdcb4fa002162a63 // .quad -158945813193151901
+	QUAD $0x73d9732fc7c8f7f7 // .quad 8347830033360418807
+	QUAD $0x9e9f11c4014dda7e // .quad -7016870160886801794
+	QUAD $0x2867e7fddcdd9afb // .quad 2911550761636567803
+	QUAD $0xc646d63501a1511d // .quad -4159401682681114339
+	QUAD $0xb281e1fd541501b9 // .quad -5583933584809066055
+	QUAD $0xf7d88bc24209a565 // .quad -587566084924005019
+	QUAD $0x1f225a7ca91a4227 // .quad 2243455055843443239
+	QUAD $0x9ae757596946075f // .quad -7284757830718584993
+	QUAD $0x3375788de9b06959 // .quad 3708002419115845977
+	QUAD $0xc1a12d2fc3978937 // .quad -4494261269970843337
+	QUAD $0x0052d6b1641c83af // .quad 23317005467419567
+	QUAD $0xf209787bb47d6b84 // .quad -1006140569036166268
+	QUAD $0xc0678c5dbd23a49b // .quad -4582539761593113445
+	QUAD $0x9745eb4d50ce6332 // .quad -7546366883288685774
+	QUAD $0xf840b7ba963646e1 // .quad -558244341782001951
+	QUAD $0xbd176620a501fbff // .quad -4821272585683469313
+	QUAD $0xb650e5a93bc3d899 // .quad -5309491445654890343
+	QUAD $0xec5d3fa8ce427aff // .quad -1414904713676948737
+	QUAD $0xa3e51f138ab4cebf // .quad -6636864307068612929
+	QUAD $0x93ba47c980e98cdf // .quad -7801844473689174817
+	QUAD $0xc66f336c36b10138 // .quad -4148040191917883080
+	QUAD $0xb8a8d9bbe123f017 // .quad -5140619573684080617
+	QUAD $0xb80b0047445d4185 // .quad -5185050239897353851
+	QUAD $0xe6d3102ad96cec1d // .quad -1814088448677712867
+	QUAD $0xa60dc059157491e6 // .quad -6481312799871692314
+	QUAD $0x9043ea1ac7e41392 // .quad -8051334308064652398
+	QUAD $0x87c89837ad68db30 // .quad -8662506518347195600
+	QUAD $0xb454e4a179dd1877 // .quad -5452481866653427593
+	QUAD $0x29babe4598c311fc // .quad 3006924907348169212
+	QUAD $0xe16a1dc9d8545e94 // .quad -2203916314889396588
+	QUAD $0xf4296dd6fef3d67b // .quad -853029884242176389
+	QUAD $0x8ce2529e2734bb1d // .quad -8294976724446954723
+	QUAD $0x1899e4a65f58660d // .quad 1772699331562333709
+	QUAD $0xb01ae745b101e9e4 // .quad -5757034887131305500
+	QUAD $0x5ec05dcff72e7f90 // .quad 6827560182880305040
+	QUAD $0xdc21a1171d42645d // .quad -2584607590486743971
+	QUAD $0x76707543f4fa1f74 // .quad 8534450228600381300
+	QUAD $0x899504ae72497eba // .quad -8532908771695296838
+	QUAD $0x6a06494a791c53a9 // .quad 7639874402088932265
+	QUAD $0xabfa45da0edbde69 // .quad -6054449946191733143
+	QUAD $0x0487db9d17636893 // .quad 326470965756389523
+	QUAD $0xd6f8d7509292d603 // .quad -2956376414312278525
+	QUAD $0x45a9d2845d3c42b7 // .quad 5019774725622874807
+	QUAD $0x865b86925b9bc5c2 // .quad -8765264286586255934
+	QUAD $0x0b8a2392ba45a9b3 // .quad 831516194300602803
+	QUAD $0xa7f26836f282b732 // .quad -6344894339805432014
+	QUAD $0x8e6cac7768d7141f // .quad -8183976793979022305
+	QUAD $0xd1ef0244af2364ff // .quad -3319431906329402113
+	QUAD $0x3207d795430cd927 // .quad 3605087062808385831
+	QUAD $0x8335616aed761f1f // .quad -8992173969096958177
+	QUAD $0x7f44e6bd49e807b9 // .quad 9170708441896323001
+	QUAD $0xa402b9c5a8d3a6e7 // .quad -6628531442943809817
+	QUAD $0x5f16206c9c6209a7 // .quad 6851699533943015847
+	QUAD $0xcd036837130890a1 // .quad -3673978285252374367
+	QUAD $0x36dba887c37a8c10 // .quad 3952938399001381904
+	QUAD $0x802221226be55a64 // .quad -9213765455923815836
+	QUAD $0xc2494954da2c978a // .quad -4446942528265218166
+	QUAD $0xa02aa96b06deb0fd // .quad -6905520801477381891
+	QUAD $0xf2db9baa10b7bd6d // .quad -946992141904134803
+	QUAD $0xc83553c5c8965d3d // .quad -4020214983419339459
+	QUAD $0x6f92829494e5acc8 // .quad 8039631859474607304
+	QUAD $0xfa42a8b73abbf48c // .quad -413582710846786420
+	QUAD $0xcb772339ba1f17fa // .quad -3785518230938904582
+	QUAD $0x9c69a97284b578d7 // .quad -7176018221920323369
+	QUAD $0xff2a760414536efc // .quad -60105885123121412
+	QUAD $0xc38413cf25e2d70d // .quad -4358336758973016307
+	QUAD $0xfef5138519684abb // .quad -75132356403901765
+	QUAD $0xf46518c2ef5b8cd1 // .quad -836234930288882479
+	QUAD $0x7eb258665fc25d6a // .quad 9129456591349898602
+	QUAD $0x98bf2f79d5993802 // .quad -7440175859071633406
+	QUAD $0xef2f773ffbd97a62 // .quad -1211618658047395230
+	QUAD $0xbeeefb584aff8603 // .quad -4688533805412153853
+	QUAD $0xaafb550ffacfd8fb // .quad -6126209340986631941
+	QUAD $0xeeaaba2e5dbf6784 // .quad -1248981238337804412
+	QUAD $0x95ba2a53f983cf39 // .quad -7657761676233289927
+	QUAD $0x952ab45cfa97a0b2 // .quad -7698142301602209614
+	QUAD $0xdd945a747bf26184 // .quad -2480258038432112252
+	QUAD $0xba756174393d88df // .quad -5010991858575374113
+	QUAD $0x94f971119aeef9e5 // .quad -7712008566467528219
+	QUAD $0xe912b9d1478ceb17 // .quad -1652053804791829737
+	QUAD $0x7a37cd5601aab85e // .quad 8806733365625141342
+	QUAD $0x91abb422ccb812ee // .quad -7950062655635975442
+	QUAD $0xac62e055c10ab33b // .quad -6025006692552756421
+	QUAD $0xb616a12b7fe617aa // .quad -5325892301117581398
+	QUAD $0x577b986b314d600a // .quad 6303799689591218186
+	QUAD $0xe39c49765fdf9d94 // .quad -2045679357969588844
+	QUAD $0xed5a7e85fda0b80c // .quad -1343622424865753076
+	QUAD $0x8e41ade9fbebc27d // .quad -8196078626372074883
+	QUAD $0x14588f13be847308 // .quad 1466078993672598280
+	QUAD $0xb1d219647ae6b31c // .quad -5633412264537705700
+	QUAD $0x596eb2d8ae258fc9 // .quad 6444284760518135753
+	QUAD $0xde469fbd99a05fe3 // .quad -2430079312244744221
+	QUAD $0x6fca5f8ed9aef3bc // .quad 8055355950647669692
+	QUAD $0x8aec23d680043bee // .quad -8436328597794046994
+	QUAD $0x25de7bb9480d5855 // .quad 2728754459941099605
+	QUAD $0xada72ccc20054ae9 // .quad -5933724728815170839
+	QUAD $0xaf561aa79a10ae6b // .quad -5812428961928401301
+	QUAD $0xd910f7ff28069da4 // .quad -2805469892591575644
+	QUAD $0x1b2ba1518094da05 // .quad 1957835834444274181
+	QUAD $0x87aa9aff79042286 // .quad -8670947710510816634
+	QUAD $0x90fb44d2f05d0843 // .quad -7999724640327104445
+	QUAD $0xa99541bf57452b28 // .quad -6226998619711132888
+	QUAD $0x353a1607ac744a54 // .quad 3835402254873283156
+	QUAD $0xd3fa922f2d1675f2 // .quad -3172062256211528206
+	QUAD $0x42889b8997915ce9 // .quad 4794252818591603945
+	QUAD $0x847c9b5d7c2e09b7 // .quad -8900067937773286985
+	QUAD $0x69956135febada12 // .quad 7608094030047140370
+	QUAD $0xa59bc234db398c25 // .quad -6513398903789220827
+	QUAD $0x43fab9837e699096 // .quad 4898431519131537558
+	QUAD $0xcf02b2c21207ef2e // .quad -3530062611309138130
+	QUAD $0x94f967e45e03f4bc // .quad -7712018656367741764
+	QUAD $0x8161afb94b44f57d // .quad -9123818159709293187
+	QUAD $0x1d1be0eebac278f6 // .quad 2097517367411243254
+	QUAD $0xa1ba1ba79e1632dc // .quad -6793086681209228580
+	QUAD $0x6462d92a69731733 // .quad 7233582727691441971
+	QUAD $0xca28a291859bbf93 // .quad -3879672333084147821
+	QUAD $0x7d7b8f7503cfdcff // .quad 9041978409614302463
+	QUAD $0xfcb2cb35e702af78 // .quad -237904397927796872
+	QUAD $0x5cda735244c3d43f // .quad 6690786993590490175
+	QUAD $0x9defbf01b061adab // .quad -7066219276345954901
+	QUAD $0x3a0888136afa64a8 // .quad 4181741870994056360
+	QUAD $0xc56baec21c7a1916 // .quad -4221088077005055722
+	QUAD $0x088aaa1845b8fdd1 // .quad 615491320315182545
+	QUAD $0xf6c69a72a3989f5b // .quad -664674077828931749
+	QUAD $0x8aad549e57273d46 // .quad -8454007886460797626
+	QUAD $0x9a3c2087a63f6399 // .quad -7332950326284164199
+	QUAD $0x36ac54e2f678864c // .quad 3939617107816777292
+	QUAD $0xc0cb28a98fcf3c7f // .quad -4554501889427817345
+	QUAD $0x84576a1bb416a7de // .quad -8910536670511192098
+	QUAD $0xf0fdf2d3f3c30b9f // .quad -1081441343357383777
+	QUAD $0x656d44a2a11c51d6 // .quad 7308573235570561494
+	QUAD $0x969eb7c47859e743 // .quad -7593429867239446717
+	QUAD $0x9f644ae5a4b1b326 // .quad -6961356773836868826
+	QUAD $0xbc4665b596706114 // .quad -4880101315621920492
+	QUAD $0x873d5d9f0dde1fef // .quad -8701695967296086033
+	QUAD $0xeb57ff22fc0c7959 // .quad -1488440626100012711
+	QUAD $0xa90cb506d155a7eb // .quad -6265433940692719637
+	QUAD $0x9316ff75dd87cbd8 // .quad -7847804418953589800
+	QUAD $0x09a7f12442d588f3 // .quad 695789805494438131
+	QUAD $0xb7dcbf5354e9bece // .quad -5198069505264599346
+	QUAD $0x0c11ed6d538aeb30 // .quad 869737256868047664
+	QUAD $0xe5d3ef282a242e81 // .quad -1885900863153361279
+	QUAD $0x8f1668c8a86da5fb // .quad -8136200465769716229
+	QUAD $0x8fa475791a569d10 // .quad -8096217067111932656
+	QUAD $0xf96e017d694487bd // .quad -473439272678684739
+	QUAD $0xb38d92d760ec4455 // .quad -5508585315462527915
+	QUAD $0x37c981dcc395a9ad // .quad 4019886927579031981
+	QUAD $0xe070f78d3927556a // .quad -2274045625900771990
+	QUAD $0x85bbe253f47b1418 // .quad -8810199395808373736
+	QUAD $0x8c469ab843b89562 // .quad -8338807543829064350
+	QUAD $0x93956d7478ccec8f // .quad -7812217631593927537
+	QUAD $0xaf58416654a6babb // .quad -5811823411358942533
+	QUAD $0x387ac8d1970027b3 // .quad 4069786015789754291
+	QUAD $0xdb2e51bfe9d0696a // .quad -2653093245771290262
+	QUAD $0x06997b05fcc0319f // .quad 475546501309804959
+	QUAD $0x88fcf317f22241e2 // .quad -8575712306248138270
+	QUAD $0x441fece3bdf81f04 // .quad 4908902581746016004
+	QUAD $0xab3c2fddeeaad25a // .quad -6107954364382784934
+	QUAD $0xd527e81cad7626c4 // .quad -3087243809672255804
+	QUAD $0xd60b3bd56a5586f1 // .quad -3023256937051093263
+	QUAD $0x8a71e223d8d3b075 // .quad -8470740780517707659
+	QUAD $0x85c7056562757456 // .quad -8807064613298015146
+	QUAD $0xf6872d5667844e4a // .quad -682526969396179382
+	QUAD $0xa738c6bebb12d16c // .quad -6397144748195131028
+	QUAD $0xb428f8ac016561dc // .quad -5464844730172612132
+	QUAD $0xd106f86e69d785c7 // .quad -3384744916816525881
+	QUAD $0xe13336d701beba53 // .quad -2219369894288377261
+	QUAD $0x82a45b450226b39c // .quad -9032994600651410532
+	QUAD $0xecc0024661173474 // .quad -1387106183930235788
+	QUAD $0xa34d721642b06084 // .quad -6679557232386875260
+	QUAD $0x27f002d7f95d0191 // .quad 2877803288514593169
+	QUAD $0xcc20ce9bd35c78a5 // .quad -3737760522056206171
+	QUAD $0x31ec038df7b441f5 // .quad 3597254110643241461
+	QUAD $0xff290242c83396ce // .quad -60514634142869810
+	QUAD $0x7e67047175a15272 // .quad 9108253656731439730
+	QUAD $0x9f79a169bd203e41 // .quad -6955350673980375487
+	QUAD $0x0f0062c6e984d387 // .quad 1080972517029761927
+	QUAD $0xc75809c42c684dd1 // .quad -4082502324048081455
+	QUAD $0x52c07b78a3e60869 // .quad 5962901664714590313
+	QUAD $0xf92e0c3537826145 // .quad -491441886632713915
+	QUAD $0xa7709a56ccdf8a83 // .quad -6381430974388925821
+	QUAD $0x9bbcc7a142b17ccb // .quad -7224680206786528053
+	QUAD $0x88a66076400bb692 // .quad -8600080377420466542
+	QUAD $0xc2abf989935ddbfe // .quad -4419164240055772162
+	QUAD $0x6acff893d00ea436 // .quad 7696643601933968438
+	QUAD $0xf356f7ebf83552fe // .quad -912269281642327298
+	QUAD $0x0583f6b8c4124d44 // .quad 397432465562684740
+	QUAD $0x98165af37b2153de // .quad -7487697328667536418
+	QUAD $0xc3727a337a8b704b // .quad -4363290727450709941
+	QUAD $0xbe1bf1b059e9a8d6 // .quad -4747935642407032618
+	QUAD $0x744f18c0592e4c5d // .quad 8380944645968776285
+	QUAD $0xeda2ee1c7064130c // .quad -1323233534581402868
+	QUAD $0x1162def06f79df74 // .quad 1252808770606194548
+	QUAD $0x9485d4d1c63e8be7 // .quad -7744549986754458649
+	QUAD $0x8addcb5645ac2ba9 // .quad -8440366555225904215
+	QUAD $0xb9a74a0637ce2ee1 // .quad -5069001465015685407
+	QUAD $0x6d953e2bd7173693 // .quad 7896285879677171347
+	QUAD $0xe8111c87c5c1ba99 // .quad -1724565812842218855
+	QUAD $0xc8fa8db6ccdd0438 // .quad -3964700705685699528
+	QUAD $0x910ab1d4db9914a0 // .quad -7995382660667468640
+	QUAD $0x1d9c9892400a22a3 // .quad 2133748077373825699
+	QUAD $0xb54d5e4a127f59c8 // .quad -5382542307406947896
+	QUAD $0x2503beb6d00cab4c // .quad 2667185096717282124
+	QUAD $0xe2a0b5dc971f303a // .quad -2116491865831296966
+	QUAD $0x2e44ae64840fd61e // .quad 3333981370896602654
+	QUAD $0x8da471a9de737e24 // .quad -8240336443785642460
+	QUAD $0x5ceaecfed289e5d3 // .quad 6695424375237764563
+	QUAD $0xb10d8e1456105dad // .quad -5688734536304665171
+	QUAD $0x7425a83e872c5f48 // .quad 8369280469047205704
+	QUAD $0xdd50f1996b947518 // .quad -2499232151953443560
+	QUAD $0xd12f124e28f7771a // .quad -3373457468973156582
+	QUAD $0x8a5296ffe33cc92f // .quad -8479549122611984081
+	QUAD $0x82bd6b70d99aaa70 // .quad -9025939945749304720
+	QUAD $0xace73cbfdc0bfb7b // .quad -5987750384837592197
+	QUAD $0x636cc64d1001550c // .quad 7164319141522920716
+	QUAD $0xd8210befd30efa5a // .quad -2873001962619602342
+	QUAD $0x3c47f7e05401aa4f // .quad 4343712908476262991
+	QUAD $0x8714a775e3e95c78 // .quad -8713155254278333320
+	QUAD $0x65acfaec34810a72 // .quad 7326506586225052274
+	QUAD $0xa8d9d1535ce3b396 // .quad -6279758049420528746
+	QUAD $0x7f1839a741a14d0e // .quad 9158133232781315342
+	QUAD $0xd31045a8341ca07c // .quad -3238011543348273028
+	QUAD $0x1ede48111209a051 // .quad 2224294504121868369
+	QUAD $0x83ea2b892091e44d // .quad -8941286242233752499
+	QUAD $0x934aed0aab460433 // .quad -7833187971778608077
+	QUAD $0xa4e4b66b68b65d60 // .quad -6564921784364802720
+	QUAD $0xf81da84d56178540 // .quad -568112927868484288
+	QUAD $0xce1de40642e3f4b9 // .quad -3594466212028615495
+	QUAD $0x36251260ab9d668f // .quad 3901544858591782543
+	QUAD $0x80d2ae83e9ce78f3 // .quad -9164070410158966541
+	QUAD $0xc1d72b7c6b42601a // .quad -4479063491021217766
+	QUAD $0xa1075a24e4421730 // .quad -6843401994271320272
+	QUAD $0xb24cf65b8612f820 // .quad -5598829363776522208
+	QUAD $0xc94930ae1d529cfc // .quad -3942566474411762436
+	QUAD $0xdee033f26797b628 // .quad -2386850686293264856
+	QUAD $0xfb9b7cd9a4a7443c // .quad -316522074587315140
+	QUAD $0x169840ef017da3b2 // .quad 1628122660560806834
+	QUAD $0x9d412e0806e88aa5 // .quad -7115355324258153819
+	QUAD $0x8e1f289560ee864f // .quad -8205795374004271537
+	QUAD $0xc491798a08a2ad4e // .quad -4282508136895304370
+	QUAD $0xf1a6f2bab92a27e3 // .quad -1033872180650563613
+	QUAD $0xf5b5d7ec8acb58a2 // .quad -741449152691742558
+	QUAD $0xae10af696774b1dc // .quad -5904026244240592420
+	QUAD $0x9991a6f3d6bf1765 // .quad -7380934748073420955
+	QUAD $0xacca6da1e0a8ef2a // .quad -5995859411864064214
+	QUAD $0xbff610b0cc6edd3f // .quad -4614482416664388289
+	QUAD $0x17fd090a58d32af4 // .quad 1728547772024695540
+	QUAD $0xeff394dcff8a948e // .quad -1156417002403097458
+	QUAD $0xddfc4b4cef07f5b1 // .quad -2451001303396518479
+	QUAD $0x95f83d0a1fb69cd9 // .quad -7640289654143017767
+	QUAD $0x4abdaf101564f98f // .quad 5385653213018257807
+	QUAD $0xbb764c4ca7a4440f // .quad -4938676049251384305
+	QUAD $0x9d6d1ad41abe37f2 // .quad -7102991539009341454
+	QUAD $0xea53df5fd18d5513 // .quad -1561659043136842477
+	QUAD $0x84c86189216dc5ee // .quad -8878739423761676818
+	QUAD $0x92746b9be2f8552c // .quad -7893565929601608404
+	QUAD $0x32fd3cf5b4e49bb5 // .quad 3674159897003727797
+	QUAD $0xb7118682dbb66a77 // .quad -5255271393574622601
+	QUAD $0x3fbc8c33221dc2a2 // .quad 4592699871254659746
+	QUAD $0xe4d5e82392a40515 // .quad -1957403223540890347
+	QUAD $0x0fabaf3feaa5334b // .quad 1129188820640936779
+	QUAD $0x8f05b1163ba6832d // .quad -8140906042354138323
+	QUAD $0x29cb4d87f2a7400f // .quad 3011586022114279439
+	QUAD $0xb2c71d5bca9023f8 // .quad -5564446534515285000
+	QUAD $0x743e20e9ef511013 // .quad 8376168546070237203
+	QUAD $0xdf78e4b2bd342cf6 // .quad -2343872149716718346
+	QUAD $0x914da9246b255417 // .quad -7976533391121755113
+	QUAD $0x8bab8eefb6409c1a // .quad -8382449121214030822
+	QUAD $0x1ad089b6c2f7548f // .quad 1932195658189984911
+	QUAD $0xae9672aba3d0c320 // .quad -5866375383090150624
+	QUAD $0xa184ac2473b529b2 // .quad -6808127464117294670
+	QUAD $0xda3c0f568cc4f3e8 // .quad -2721283210435300376
+	QUAD $0xc9e5d72d90a2741f // .quad -3898473311719230433
+	QUAD $0x8865899617fb1871 // .quad -8618331034163144591
+	QUAD $0x7e2fa67c7a658893 // .quad 9092669226243950739
+	QUAD $0xaa7eebfb9df9de8d // .quad -6161227774276542835
+	QUAD $0xddbb901b98feeab8 // .quad -2469221522477225288
+	QUAD $0xd51ea6fa85785631 // .quad -3089848699418290639
+	QUAD $0x552a74227f3ea566 // .quad 6136845133758244198
+	QUAD $0x8533285c936b35de // .quad -8848684464777513506
+	QUAD $0xd53a88958f872760 // .quad -3082000819042179232
+	QUAD $0xa67ff273b8460356 // .quad -6449169562544503978
+	QUAD $0x8a892abaf368f138 // .quad -8464187042230111944
+	QUAD $0xd01fef10a657842c // .quad -3449775934753242068
+	QUAD $0x2d2b7569b0432d86 // .quad 3254824252494523782
+	QUAD $0x8213f56a67f6b29b // .quad -9073638986861858149
+	QUAD $0x9c3b29620e29fc74 // .quad -7189106879045698444
+	QUAD $0xa298f2c501f45f42 // .quad -6730362715149934782
+	QUAD $0x8349f3ba91b47b90 // .quad -8986383598807123056
+	QUAD $0xcb3f2f7642717713 // .quad -3801267375510030573
+	QUAD $0x241c70a936219a74 // .quad 2602078556773259892
+	QUAD $0xfe0efb53d30dd4d7 // .quad -139898200960150313
+	QUAD $0xed238cd383aa0111 // .quad -1359087822460813039
+	QUAD $0x9ec95d1463e8a506 // .quad -7004965403241175802
+	QUAD $0xf4363804324a40ab // .quad -849429889038008149
+	QUAD $0xc67bb4597ce2ce48 // .quad -4144520735624081848
+	QUAD $0xb143c6053edcd0d6 // .quad -5673473379724898090
+	QUAD $0xf81aa16fdc1b81da // .quad -568964901102714406
+	QUAD $0xdd94b7868e94050b // .quad -2480155706228734709
+	QUAD $0x9b10a4e5e9913128 // .quad -7273132090830278360
+	QUAD $0xca7cf2b4191c8327 // .quad -3855940325606653145
+	QUAD $0xc1d4ce1f63f57d72 // .quad -4479729095110460046
+	QUAD $0xfd1c2f611f63a3f1 // .quad -208239388580928527
+	QUAD $0xf24a01a73cf2dccf // .quad -987975350460687153
+	QUAD $0xbc633b39673c8ced // .quad -4871985254153548563
+	QUAD $0x976e41088617ca01 // .quad -7535013621679011327
+	QUAD $0xd5be0503e085d814 // .quad -3044990783845967852
+	QUAD $0xbd49d14aa79dbc82 // .quad -4807081008671376254
+	QUAD $0x4b2d8644d8a74e19 // .quad 5417133557047315993
+	QUAD $0xec9c459d51852ba2 // .quad -1397165242411832414
+	QUAD $0xddf8e7d60ed1219f // .quad -2451955090545630817
+	QUAD $0x93e1ab8252f33b45 // .quad -7790757304148477115
+	QUAD $0xcabb90e5c942b504 // .quad -3838314940804713212
+	QUAD $0xb8da1662e7b00a17 // .quad -5126760611758208489
+	QUAD $0x3d6a751f3b936244 // .quad 4425478360848884292
+	QUAD $0xe7109bfba19c0c9d // .quad -1796764746270372707
+	QUAD $0x0cc512670a783ad5 // .quad 920161932633717461
+	QUAD $0x906a617d450187e2 // .quad -8040506994060064798
+	QUAD $0x27fb2b80668b24c6 // .quad 2880944217109767366
+	QUAD $0xb484f9dc9641e9da // .quad -5438947724147693094
+	QUAD $0xb1f9f660802dedf7 // .quad -5622191765467566601
+	QUAD $0xe1a63853bbd26451 // .quad -2186998636757228463
+	QUAD $0x5e7873f8a0396974 // .quad 6807318348447705460
+	QUAD $0x8d07e33455637eb2 // .quad -8284403175614349646
+	QUAD $0xdb0b487b6423e1e9 // .quad -2662955059861265943
+	QUAD $0xb049dc016abc5e5f // .quad -5743817951090549153
+	QUAD $0x91ce1a9a3d2cda63 // .quad -7940379843253970333
+	QUAD $0xdc5c5301c56b75f7 // .quad -2568086420435798537
+	QUAD $0x7641a140cc7810fc // .quad 8521269269642088700
+	QUAD $0x89b9b3e11b6329ba // .quad -8522583040413455942
+	QUAD $0xa9e904c87fcb0a9e // .quad -6203421752542164322
+	QUAD $0xac2820d9623bf429 // .quad -6041542782089432023
+	QUAD $0x546345fa9fbdcd45 // .quad 6080780864604458309
+	QUAD $0xd732290fbacaf133 // .quad -2940242459184402125
+	QUAD $0xa97c177947ad4096 // .quad -6234081974526590826
+	QUAD $0x867f59a9d4bed6c0 // .quad -8755180564631333184
+	QUAD $0x49ed8eabcccc485e // .quad 5327070802775656542
+	QUAD $0xa81f301449ee8c70 // .quad -6332289687361778576
+	QUAD $0x5c68f256bfff5a75 // .quad 6658838503469570677
+	QUAD $0xd226fc195c6a2f8c // .quad -3303676090774835316
+	QUAD $0x73832eec6fff3112 // .quad 8323548129336963346
+	QUAD $0x83585d8fd9c25db7 // .quad -8982326584375353929
+	QUAD $0xc831fd53c5ff7eac // .quad -4021154456019173716
+	QUAD $0xa42e74f3d032f525 // .quad -6616222212041804507
+	QUAD $0xba3e7ca8b77f5e56 // .quad -5026443070023967146
+	QUAD $0xcd3a1230c43fb26f // .quad -3658591746624867729
+	QUAD $0x28ce1bd2e55f35ec // .quad 2940318199324816876
+	QUAD $0x80444b5e7aa7cf85 // .quad -9204148869281624187
+	QUAD $0x7980d163cf5b81b4 // .quad 8755227902219092404
+	QUAD $0xa0555e361951c366 // .quad -6893500068174642330
+	QUAD $0xd7e105bcc3326220 // .quad -2891023177508298208
+	QUAD $0xc86ab5c39fa63440 // .quad -4005189066790915008
+	QUAD $0x8dd9472bf3fefaa8 // .quad -8225464990312760664
+	QUAD $0xfa856334878fc150 // .quad -394800315061255856
+	QUAD $0xb14f98f6f0feb952 // .quad -5670145219463562926
+	QUAD $0x9c935e00d4b9d8d2 // .quad -7164279224554366766
+	QUAD $0x6ed1bf9a569f33d4 // .quad 7985374283903742932
+	QUAD $0xc3b8358109e84f07 // .quad -4343663012265570553
+	QUAD $0x0a862f80ec4700c9 // .quad 758345818024902857
+	QUAD $0xf4a642e14c6262c8 // .quad -817892746904575288
+	QUAD $0xcd27bb612758c0fb // .quad -3663753745896259333
+	QUAD $0x98e7e9cccfbd7dbd // .quad -7428711994456441411
+	QUAD $0x8038d51cb897789d // .quad -9207375118826243939
+	QUAD $0xbf21e44003acdd2c // .quad -4674203974643163860
+	QUAD $0xe0470a63e6bd56c4 // .quad -2285846861678029116
+	QUAD $0xeeea5d5004981478 // .quad -1231068949876566920
+	QUAD $0x1858ccfce06cac75 // .quad 1754377441329851509
+	QUAD $0x95527a5202df0ccb // .quad -7686947121313936181
+	QUAD $0x0f37801e0c43ebc9 // .quad 1096485900831157193
+	QUAD $0xbaa718e68396cffd // .quad -4996997883215032323
+	QUAD $0xd30560258f54e6bb // .quad -3241078642388441413
+	QUAD $0xe950df20247c83fd // .quad -1634561335591402499
+	QUAD $0x47c6b82ef32a206a // .quad 5172023733869224042
+	QUAD $0x91d28b7416cdd27e // .quad -7939129862385708418
+	QUAD $0x4cdc331d57fa5442 // .quad 5538357842881958978
+	QUAD $0xb6472e511c81471d // .quad -5312226309554747619
+	QUAD $0xe0133fe4adf8e953 // .quad -2300424733252327085
+	QUAD $0xe3d8f9e563a198e5 // .quad -2028596868516046619
+	QUAD $0x58180fddd97723a7 // .quad 6347841120289366951
+	QUAD $0x8e679c2f5e44ff8f // .quad -8185402070463610993
+	QUAD $0x570f09eaa7ea7649 // .quad 6273243709394548297
+	QUAD $0xb201833b35d63f73 // .quad -5620066569652125837
+	QUAD $0x2cd2cc6551e513db // .quad 3229868618315797467
+	QUAD $0xde81e40a034bcf4f // .quad -2413397193637769393
+	QUAD $0xf8077f7ea65e58d2 // .quad -574350245532641070
+	QUAD $0x8b112e86420f6191 // .quad -8425902273664687727
+	QUAD $0xfb04afaf27faf783 // .quad -358968903457900669
+	QUAD $0xadd57a27d29339f6 // .quad -5920691823653471754
+	QUAD $0x79c5db9af1f9b564 // .quad 8774660907532399972
+	QUAD $0xd94ad8b1c7380874 // .quad -2789178761139451788
+	QUAD $0x18375281ae7822bd // .quad 1744954097560724157
+	QUAD $0x87cec76f1c830548 // .quad -8660765753353239224
+	QUAD $0x8f2293910d0b15b6 // .quad -8132775725879323210
+	QUAD $0xa9c2794ae3a3c69a // .quad -6214271173264161126
+	QUAD $0xb2eb3875504ddb23 // .quad -5554283638921766109
+	QUAD $0xd433179d9c8cb841 // .quad -3156152948152813503
+	QUAD $0x5fa60692a46151ec // .quad 6892203506629956076
+	QUAD $0x849feec281d7f328 // .quad -8890124620236590296
+	QUAD $0xdbc7c41ba6bcd334 // .quad -2609901835997359308
+	QUAD $0xa5c7ea73224deff3 // .quad -6500969756868349965
+	QUAD $0x12b9b522906c0801 // .quad 1349308723430688769
+	QUAD $0xcf39e50feae16bef // .quad -3514526177658049553
+	QUAD $0xd768226b34870a01 // .quad -2925050114139026943
+	QUAD $0x81842f29f2cce375 // .quad -9114107888677362827
+	QUAD $0xe6a1158300d46641 // .quad -1828156321336891839
+	QUAD $0xa1e53af46f801c53 // .quad -6780948842419315629
+	QUAD $0x60495ae3c1097fd1 // .quad 6938176635183661009
+	QUAD $0xca5e89b18b602368 // .quad -3864500034596756632
+	QUAD $0x385bb19cb14bdfc5 // .quad 4061034775552188357
+	QUAD $0xfcf62c1dee382c42 // .quad -218939024818557886
+	QUAD $0x46729e03dd9ed7b6 // .quad 5076293469440235446
+	QUAD $0x9e19db92b4e31ba9 // .quad -7054365918152680535
+	QUAD $0x6c07a2c26a8346d2 // .quad 7784369436827535058
+
+	// .p2align 4, 0x00
+_VecShiftShuffles:
+	QUAD $0x0706050403020100; QUAD $0x0f0e0d0c0b0a0908 // .ascii 16, '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f'
+	QUAD $0x0807060504030201; QUAD $0xff0f0e0d0c0b0a09 // .ascii 16, '\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff'
+	QUAD $0x0908070605040302; QUAD $0xffff0f0e0d0c0b0a // .ascii 16, '\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff'
+	QUAD $0x0a09080706050403; QUAD $0xffffff0f0e0d0c0b // .ascii 16, '\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff'
+	QUAD $0x0b0a090807060504; QUAD $0xffffffff0f0e0d0c // .ascii 16, '\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff'
+	QUAD $0x0c0b0a0908070605; QUAD $0xffffffffff0f0e0d // .ascii 16, '\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff'
+	QUAD $0x0d0c0b0a09080706; QUAD $0xffffffffffff0f0e // .ascii 16, '\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff'
+	QUAD $0x0e0d0c0b0a090807; QUAD $0xffffffffffffff0f // .ascii 16, '\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0x0f0e0d0c0b0a0908; QUAD $0xffffffffffffffff // .ascii 16, '\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff'
+
+	// .p2align 4, 0x00
+__SingleQuoteTab:
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000030303030755c                           // .asciz 8, '\\u0000\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000031303030755c                           // .asciz 8, '\\u0001\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000032303030755c                           // .asciz 8, '\\u0002\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000033303030755c                           // .asciz 8, '\\u0003\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000034303030755c                           // .asciz 8, '\\u0004\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000035303030755c                           // .asciz 8, '\\u0005\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000036303030755c                           // .asciz 8, '\\u0006\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000037303030755c                           // .asciz 8, '\\u0007\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000038303030755c                           // .asciz 8, '\\u0008\x00\x00'
+	QUAD $0x0000000000000002                           // .quad 2
+	QUAD $0x000000000000745c                           // .asciz 8, '\\t\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000002                           // .quad 2
+	QUAD $0x0000000000006e5c                           // .asciz 8, '\\n\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000062303030755c                           // .asciz 8, '\\u000b\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000063303030755c                           // .asciz 8, '\\u000c\x00\x00'
+	QUAD $0x0000000000000002                           // .quad 2
+	QUAD $0x000000000000725c                           // .asciz 8, '\\r\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000065303030755c                           // .asciz 8, '\\u000e\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000066303030755c                           // .asciz 8, '\\u000f\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000030313030755c                           // .asciz 8, '\\u0010\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000031313030755c                           // .asciz 8, '\\u0011\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000032313030755c                           // .asciz 8, '\\u0012\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000033313030755c                           // .asciz 8, '\\u0013\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000034313030755c                           // .asciz 8, '\\u0014\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000035313030755c                           // .asciz 8, '\\u0015\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000036313030755c                           // .asciz 8, '\\u0016\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000037313030755c                           // .asciz 8, '\\u0017\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000038313030755c                           // .asciz 8, '\\u0018\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000039313030755c                           // .asciz 8, '\\u0019\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000061313030755c                           // .asciz 8, '\\u001a\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000062313030755c                           // .asciz 8, '\\u001b\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000063313030755c                           // .asciz 8, '\\u001c\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000064313030755c                           // .asciz 8, '\\u001d\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000065313030755c                           // .asciz 8, '\\u001e\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000066313030755c                           // .asciz 8, '\\u001f\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000002                           // .quad 2
+	QUAD $0x000000000000225c                           // .asciz 8, '\\"\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000002                           // .quad 2
+	QUAD $0x0000000000005c5c                           // .asciz 8, '\\\\\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+	// .p2align 4, 0x00
+__DoubleQuoteTab:
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0030303030755c5c                           // .asciz 8, '\\\\u0000\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0031303030755c5c                           // .asciz 8, '\\\\u0001\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0032303030755c5c                           // .asciz 8, '\\\\u0002\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0033303030755c5c                           // .asciz 8, '\\\\u0003\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0034303030755c5c                           // .asciz 8, '\\\\u0004\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0035303030755c5c                           // .asciz 8, '\\\\u0005\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0036303030755c5c                           // .asciz 8, '\\\\u0006\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0037303030755c5c                           // .asciz 8, '\\\\u0007\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0038303030755c5c                           // .asciz 8, '\\\\u0008\x00'
+	QUAD $0x0000000000000003                           // .quad 3
+	QUAD $0x0000000000745c5c                           // .asciz 8, '\\\\t\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000003                           // .quad 3
+	QUAD $0x00000000006e5c5c                           // .asciz 8, '\\\\n\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0062303030755c5c                           // .asciz 8, '\\\\u000b\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0063303030755c5c                           // .asciz 8, '\\\\u000c\x00'
+	QUAD $0x0000000000000003                           // .quad 3
+	QUAD $0x0000000000725c5c                           // .asciz 8, '\\\\r\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0065303030755c5c                           // .asciz 8, '\\\\u000e\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0066303030755c5c                           // .asciz 8, '\\\\u000f\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0030313030755c5c                           // .asciz 8, '\\\\u0010\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0031313030755c5c                           // .asciz 8, '\\\\u0011\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0032313030755c5c                           // .asciz 8, '\\\\u0012\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0033313030755c5c                           // .asciz 8, '\\\\u0013\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0034313030755c5c                           // .asciz 8, '\\\\u0014\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0035313030755c5c                           // .asciz 8, '\\\\u0015\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0036313030755c5c                           // .asciz 8, '\\\\u0016\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0037313030755c5c                           // .asciz 8, '\\\\u0017\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0038313030755c5c                           // .asciz 8, '\\\\u0018\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0039313030755c5c                           // .asciz 8, '\\\\u0019\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0061313030755c5c                           // .asciz 8, '\\\\u001a\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0062313030755c5c                           // .asciz 8, '\\\\u001b\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0063313030755c5c                           // .asciz 8, '\\\\u001c\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0064313030755c5c                           // .asciz 8, '\\\\u001d\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0065313030755c5c                           // .asciz 8, '\\\\u001e\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0066313030755c5c                           // .asciz 8, '\\\\u001f\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000004                           // .quad 4
+	QUAD $0x00000000225c5c5c                           // .asciz 8, '\\\\\\"\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000004                           // .quad 4
+	QUAD $0x000000005c5c5c5c                           // .asciz 8, '\\\\\\\\\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+	// .p2align 4, 0x00
+__EscTab:
+	QUAD $0x0101010101010101; QUAD $0x0101010101010101     // .ascii 16, '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01'
+	QUAD $0x0101010101010101; QUAD $0x0101010101010101     // .ascii 16, '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01'
+	QUAD $0x0000000000010000; QUAD $0x0000000000000000     // .ascii 16, '\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; LONG $0x00000000; BYTE $0x01 // .ascii 13, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	WORD $0x0000; BYTE $0x00                               // .space 3, '\x00\x00\x00'
+
+	// .p2align 4, 0x00
+__UnquoteTab:
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000220000; QUAD $0x2f00000000000000 // .ascii 16, '\x00\x00"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00/'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000005c00000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\\\x00\x00\x00'
+	QUAD $0x000c000000080000; QUAD $0x000a000000000000 // .ascii 16, '\x00\x00\x08\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\n\x00'
+	LONG $0x000d0000; WORD $0xff09                     // .ascii 6, '\x00\x00\r\x00\t\xff'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; WORD $0x0000             // .space 10, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+	// .p2align 4, 0x00
+__HtmlQuoteTab:
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000036323030755c                           // .asciz 8, '\\u0026\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000063333030755c                           // .asciz 8, '\\u003c\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000065333030755c                           // .asciz 8, '\\u003e\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000038323032755c                           // .asciz 8, '\\u2028\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000039323032755c                           // .asciz 8, '\\u2029\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+	// .p2align 4, 0x00
+_LSHIFT_TAB:
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000                           // .space 8, '\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000001                                   // .long 1
+	QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000001                                   // .long 1
+	QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000001                                   // .long 1
+	QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000002                                   // .long 2
+	QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000002                                   // .long 2
+	QUAD $0x0000000035323133; QUAD $0x0000000000000000 // .asciz 16, '3125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000002                                   // .long 2
+	QUAD $0x0000003532363531; QUAD $0x0000000000000000 // .asciz 16, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000003                                   // .long 3
+	QUAD $0x0000003532313837; QUAD $0x0000000000000000 // .asciz 16, '78125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000003                                   // .long 3
+	QUAD $0x0000353236303933; QUAD $0x0000000000000000 // .asciz 16, '390625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000003                                   // .long 3
+	QUAD $0x0035323133353931; QUAD $0x0000000000000000 // .asciz 16, '1953125\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000004                                   // .long 4
+	QUAD $0x0035323635363739; QUAD $0x0000000000000000 // .asciz 16, '9765625\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000004                                   // .long 4
+	QUAD $0x3532313832383834; QUAD $0x0000000000000000 // .asciz 16, '48828125\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000004                                   // .long 4
+	QUAD $0x3236303431343432; QUAD $0x0000000000000035 // .asciz 16, '244140625\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000004                                   // .long 4
+	QUAD $0x3133303730323231; QUAD $0x0000000000003532 // .asciz 16, '1220703125\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000005                                   // .long 5
+	QUAD $0x3635313533303136; QUAD $0x0000000000003532 // .asciz 16, '6103515625\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000005                                   // .long 5
+	QUAD $0x3837353731353033; QUAD $0x0000000000353231 // .asciz 16, '30517578125\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000005                                   // .long 5
+	QUAD $0x3938373835323531; QUAD $0x0000000035323630 // .asciz 16, '152587890625\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000006                                   // .long 6
+	QUAD $0x3534393339323637; QUAD $0x0000000035323133 // .asciz 16, '762939453125\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000006                                   // .long 6
+	QUAD $0x3237393634313833; QUAD $0x0000003532363536 // .asciz 16, '3814697265625\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000006                                   // .long 6
+	QUAD $0x3638343337303931; QUAD $0x0000353231383233 // .asciz 16, '19073486328125\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000007                                   // .long 7
+	QUAD $0x3133343736333539; QUAD $0x0000353236303436 // .asciz 16, '95367431640625\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000007                                   // .long 7
+	QUAD $0x3531373338363734; QUAD $0x0035323133303238 // .asciz 16, '476837158203125\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000007                                   // .long 7
+	QUAD $0x3735383134383332; QUAD $0x3532363531303139 // .asciz 16, '2384185791015625'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000007                                   // .long 7
+	QUAD $0x3832393032393131; QUAD $0x3231383730353539 // .asciz 16, '1192092895507812'
+	QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000008                                   // .long 8
+	QUAD $0x3434363430363935; QUAD $0x3236303933353737 // .asciz 16, '5960464477539062'
+	QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000008                                   // .long 8
+	QUAD $0x3232333230383932; QUAD $0x3133353936373833 // .asciz 16, '2980232238769531'
+	QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000008                                   // .long 8
+	QUAD $0x3136313130393431; QUAD $0x3536373438333931 // .asciz 16, '1490116119384765'
+	QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000009                                   // .long 9
+	QUAD $0x3530383530353437; QUAD $0x3832383332393639 // .asciz 16, '7450580596923828'
+	QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000009                                   // .long 9
+	QUAD $0x3230393235323733; QUAD $0x3431393136343839 // .asciz 16, '3725290298461914'
+	QUAD $0x0000000035323630; QUAD $0x0000000000000000 // .asciz 16, '0625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000009                                   // .long 9
+	QUAD $0x3135343632363831; QUAD $0x3735393033323934 // .asciz 16, '1862645149230957'
+	QUAD $0x0000003532313330; QUAD $0x0000000000000000 // .asciz 16, '03125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000a                                   // .long 10
+	QUAD $0x3735323233313339; QUAD $0x3538373435313634 // .asciz 16, '9313225746154785'
+	QUAD $0x0000003532363531; QUAD $0x0000000000000000 // .asciz 16, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000a                                   // .long 10
+	QUAD $0x3832313636353634; QUAD $0x3239333737303337 // .asciz 16, '4656612873077392'
+	QUAD $0x0000353231383735; QUAD $0x0000000000000000 // .asciz 16, '578125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000a                                   // .long 10
+	QUAD $0x3436303338323332; QUAD $0x3639363833353633 // .asciz 16, '2328306436538696'
+	QUAD $0x0035323630393832; QUAD $0x0000000000000000 // .asciz 16, '2890625\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000a                                   // .long 10
+	QUAD $0x3233353134363131; QUAD $0x3834333936323831 // .asciz 16, '1164153218269348'
+	QUAD $0x3532313335343431; QUAD $0x0000000000000000 // .asciz 16, '14453125\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000b                                   // .long 11
+	QUAD $0x3036363730323835; QUAD $0x3034373634333139 // .asciz 16, '5820766091346740'
+	QUAD $0x3532363536323237; QUAD $0x0000000000000000 // .asciz 16, '72265625\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000b                                   // .long 11
+	QUAD $0x3033383330313932; QUAD $0x3037333337363534 // .asciz 16, '2910383045673370'
+	QUAD $0x3231383233313633; QUAD $0x0000000000000035 // .asciz 16, '361328125\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000b                                   // .long 11
+	QUAD $0x3531393135353431; QUAD $0x3538363633383232 // .asciz 16, '1455191522836685'
+	QUAD $0x3630343636303831; QUAD $0x0000000000003532 // .asciz 16, '1806640625\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000c                                   // .long 12
+	QUAD $0x3637353935373237; QUAD $0x3532343338313431 // .asciz 16, '7275957614183425'
+	QUAD $0x3133303233333039; QUAD $0x0000000000003532 // .asciz 16, '9033203125\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000c                                   // .long 12
+	QUAD $0x3838373937333633; QUAD $0x3231373139303730 // .asciz 16, '3637978807091712'
+	QUAD $0x3531303636313539; QUAD $0x0000000000353236 // .asciz 16, '95166015625\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000c                                   // .long 12
+	QUAD $0x3439383938313831; QUAD $0x3635383534353330 // .asciz 16, '1818989403545856'
+	QUAD $0x3730303338353734; QUAD $0x0000000035323138 // .asciz 16, '475830078125\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000d                                   // .long 13
+	QUAD $0x3037343934393039; QUAD $0x3238323932373731 // .asciz 16, '9094947017729282'
+	QUAD $0x3933303531393733; QUAD $0x0000000035323630 // .asciz 16, '379150390625\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000d                                   // .long 13
+	QUAD $0x3533373437343534; QUAD $0x3134363436383830 // .asciz 16, '4547473508864641'
+	QUAD $0x3931353735393831; QUAD $0x0000003532313335 // .asciz 16, '1895751953125\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000d                                   // .long 13
+	QUAD $0x3736333733373232; QUAD $0x3032333233343435 // .asciz 16, '2273736754432320'
+	QUAD $0x3935373837343935; QUAD $0x0000353236353637 // .asciz 16, '59478759765625\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000d                                   // .long 13
+	QUAD $0x3338363836333131; QUAD $0x3036313631323737 // .asciz 16, '1136868377216160'
+	QUAD $0x3937333933373932; QUAD $0x0035323138323838 // .asciz 16, '297393798828125\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000e                                   // .long 14
+	QUAD $0x3831343334383635; QUAD $0x3130383038303638 // .asciz 16, '5684341886080801'
+	QUAD $0x3939383639363834; QUAD $0x0035323630343134 // .asciz 16, '486968994140625\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000e                                   // .long 14
+	QUAD $0x3930373132343832; QUAD $0x3030343034303334 // .asciz 16, '2842170943040400'
+	QUAD $0x3934343834333437; QUAD $0x3532313330373037 // .asciz 16, '7434844970703125'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000e                                   // .long 14
+	QUAD $0x3435383031323431; QUAD $0x3030323032353137 // .asciz 16, '1421085471520200'
+	QUAD $0x3432323437313733; QUAD $0x3236353135333538 // .asciz 16, '3717422485351562'
+	QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000f                                   // .long 15
+	QUAD $0x3337323435303137; QUAD $0x3130303130363735 // .asciz 16, '7105427357601001'
+	QUAD $0x3432313137383538; QUAD $0x3231383735373632 // .asciz 16, '8587112426757812'
+	QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000f                                   // .long 15
+	QUAD $0x3633313732353533; QUAD $0x3030353030383837 // .asciz 16, '3552713678800500'
+	QUAD $0x3236353533393239; QUAD $0x3630393837333331 // .asciz 16, '9293556213378906'
+	QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000f                                   // .long 15
+	QUAD $0x3836353336373731; QUAD $0x3035323030343933 // .asciz 16, '1776356839400250'
+	QUAD $0x3138373736343634; QUAD $0x3335343938363630 // .asciz 16, '4646778106689453'
+	QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000010                                   // .long 16
+	QUAD $0x3134383731383838; QUAD $0x3235323130303739 // .asciz 16, '8881784197001252'
+	QUAD $0x3530393833333233; QUAD $0x3536323734343333 // .asciz 16, '3233890533447265'
+	QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000010                                   // .long 16
+	QUAD $0x3032393830343434; QUAD $0x3632363030353839 // .asciz 16, '4440892098500626'
+	QUAD $0x3235343936313631; QUAD $0x3233363332373636 // .asciz 16, '1616945266723632'
+	QUAD $0x0000000035323138; QUAD $0x0000000000000000 // .asciz 16, '8125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000010                                   // .long 16
+	QUAD $0x3036343430323232; QUAD $0x3331333035323934 // .asciz 16, '2220446049250313'
+	QUAD $0x3632373438303830; QUAD $0x3631383136333333 // .asciz 16, '0808472633361816'
+	QUAD $0x0000003532363034; QUAD $0x0000000000000000 // .asciz 16, '40625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000010                                   // .long 16
+	QUAD $0x3033323230313131; QUAD $0x3635313532363432 // .asciz 16, '1110223024625156'
+	QUAD $0x3336333234303435; QUAD $0x3830393038363631 // .asciz 16, '5404236316680908'
+	QUAD $0x0000353231333032; QUAD $0x0000000000000000 // .asciz 16, '203125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000011                                   // .long 17
+	QUAD $0x3135313131353535; QUAD $0x3238373532313332 // .asciz 16, '5551115123125782'
+	QUAD $0x3531383131323037; QUAD $0x3134353430343338 // .asciz 16, '7021181583404541'
+	QUAD $0x0000353236353130; QUAD $0x0000000000000000 // .asciz 16, '015625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000011                                   // .long 17
+	QUAD $0x3537353535373732; QUAD $0x3139383236353136 // .asciz 16, '2775557561562891'
+	QUAD $0x3730393530313533; QUAD $0x3037323230373139 // .asciz 16, '3510590791702270'
+	QUAD $0x0035323138373035; QUAD $0x0000000000000000 // .asciz 16, '5078125\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000011                                   // .long 17
+	QUAD $0x3738373737383331; QUAD $0x3534343138373038 // .asciz 16, '1387778780781445'
+	QUAD $0x3335393235353736; QUAD $0x3533313135383539 // .asciz 16, '6755295395851135'
+	QUAD $0x3532363039333532; QUAD $0x0000000000000000 // .asciz 16, '25390625\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000012                                   // .long 18
+	QUAD $0x3933393838333936; QUAD $0x3832323730393330 // .asciz 16, '6938893903907228'
+	QUAD $0x3936373436373733; QUAD $0x3637363535323937 // .asciz 16, '3776476979255676'
+	QUAD $0x3532313335393632; QUAD $0x0000000000000000 // .asciz 16, '26953125\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000012                                   // .long 18
+	QUAD $0x3936343439363433; QUAD $0x3431363335393135 // .asciz 16, '3469446951953614'
+	QUAD $0x3438333238383831; QUAD $0x3833383732363938 // .asciz 16, '1888238489627838'
+	QUAD $0x3236353637343331; QUAD $0x0000000000000035 // .asciz 16, '134765625\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000012                                   // .long 18
+	QUAD $0x3433323734333731; QUAD $0x3730383637393537 // .asciz 16, '1734723475976807'
+	QUAD $0x3239313134343930; QUAD $0x3931393331383434 // .asciz 16, '0944119244813919'
+	QUAD $0x3138323833373630; QUAD $0x0000000000003532 // .asciz 16, '0673828125\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000013                                   // .long 19
+	QUAD $0x3337313633373638; QUAD $0x3533303438383937 // .asciz 16, '8673617379884035'
+	QUAD $0x3236393530323734; QUAD $0x3539353936303432 // .asciz 16, '4720596224069595'
+	QUAD $0x3630343139363333; QUAD $0x0000000000003532 // .asciz 16, '3369140625\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	QUAD $0x0000000000000000                           // .p2align 4, 0x00
+
+_P10_TAB:
+	QUAD $0x3ff0000000000000 // .quad 0x3ff0000000000000
+	QUAD $0x4024000000000000 // .quad 0x4024000000000000
+	QUAD $0x4059000000000000 // .quad 0x4059000000000000
+	QUAD $0x408f400000000000 // .quad 0x408f400000000000
+	QUAD $0x40c3880000000000 // .quad 0x40c3880000000000
+	QUAD $0x40f86a0000000000 // .quad 0x40f86a0000000000
+	QUAD $0x412e848000000000 // .quad 0x412e848000000000
+	QUAD $0x416312d000000000 // .quad 0x416312d000000000
+	QUAD $0x4197d78400000000 // .quad 0x4197d78400000000
+	QUAD $0x41cdcd6500000000 // .quad 0x41cdcd6500000000
+	QUAD $0x4202a05f20000000 // .quad 0x4202a05f20000000
+	QUAD $0x42374876e8000000 // .quad 0x42374876e8000000
+	QUAD $0x426d1a94a2000000 // .quad 0x426d1a94a2000000
+	QUAD $0x42a2309ce5400000 // .quad 0x42a2309ce5400000
+	QUAD $0x42d6bcc41e900000 // .quad 0x42d6bcc41e900000
+	QUAD $0x430c6bf526340000 // .quad 0x430c6bf526340000
+	QUAD $0x4341c37937e08000 // .quad 0x4341c37937e08000
+	QUAD $0x4376345785d8a000 // .quad 0x4376345785d8a000
+	QUAD $0x43abc16d674ec800 // .quad 0x43abc16d674ec800
+	QUAD $0x43e158e460913d00 // .quad 0x43e158e460913d00
+	QUAD $0x4415af1d78b58c40 // .quad 0x4415af1d78b58c40
+	QUAD $0x444b1ae4d6e2ef50 // .quad 0x444b1ae4d6e2ef50
+	QUAD $0x4480f0cf064dd592 // .quad 0x4480f0cf064dd592
+	QUAD $0x0000000000000000 // .p2align 4, 0x00
+
+_LB_85cdfac5: // _pow10_ceil_sig_f32.g
+	QUAD $0x81ceb32c4b43fcf5 // .quad -9093133594791772939
+	QUAD $0xa2425ff75e14fc32 // .quad -6754730975062328270
+	QUAD $0xcad2f7f5359a3b3f // .quad -3831727700400522433
+	QUAD $0xfd87b5f28300ca0e // .quad -177973607073265138
+	QUAD $0x9e74d1b791e07e49 // .quad -7028762532061872567
+	QUAD $0xc612062576589ddb // .quad -4174267146649952805
+	QUAD $0xf79687aed3eec552 // .quad -606147914885053102
+	QUAD $0x9abe14cd44753b53 // .quad -7296371474444240045
+	QUAD $0xc16d9a0095928a28 // .quad -4508778324627912152
+	QUAD $0xf1c90080baf72cb2 // .quad -1024286887357502286
+	QUAD $0x971da05074da7bef // .quad -7557708332239520785
+	QUAD $0xbce5086492111aeb // .quad -4835449396872013077
+	QUAD $0xec1e4a7db69561a6 // .quad -1432625727662628442
+	QUAD $0x9392ee8e921d5d08 // .quad -7812920107430224632
+	QUAD $0xb877aa3236a4b44a // .quad -5154464115860392886
+	QUAD $0xe69594bec44de15c // .quad -1831394126398103204
+	QUAD $0x901d7cf73ab0acda // .quad -8062150356639896358
+	QUAD $0xb424dc35095cd810 // .quad -5466001927372482544
+	QUAD $0xe12e13424bb40e14 // .quad -2220816390788215276
+	QUAD $0x8cbccc096f5088cc // .quad -8305539271883716404
+	QUAD $0xafebff0bcb24aaff // .quad -5770238071427257601
+	QUAD $0xdbe6fecebdedd5bf // .quad -2601111570856684097
+	QUAD $0x89705f4136b4a598 // .quad -8543223759426509416
+	QUAD $0xabcc77118461cefd // .quad -6067343680855748867
+	QUAD $0xd6bf94d5e57a42bd // .quad -2972493582642298179
+	QUAD $0x8637bd05af6c69b6 // .quad -8775337516792518218
+	QUAD $0xa7c5ac471b478424 // .quad -6357485877563259868
+	QUAD $0xd1b71758e219652c // .quad -3335171328526686932
+	QUAD $0x83126e978d4fdf3c // .quad -9002011107970261188
+	QUAD $0xa3d70a3d70a3d70b // .quad -6640827866535438581
+	QUAD $0xcccccccccccccccd // .quad -3689348814741910323
+	QUAD $0x8000000000000000 // .quad -9223372036854775808
+	QUAD $0xa000000000000000 // .quad -6917529027641081856
+	QUAD $0xc800000000000000 // .quad -4035225266123964416
+	QUAD $0xfa00000000000000 // .quad -432345564227567616
+	QUAD $0x9c40000000000000 // .quad -7187745005283311616
+	QUAD $0xc350000000000000 // .quad -4372995238176751616
+	QUAD $0xf424000000000000 // .quad -854558029293551616
+	QUAD $0x9896800000000000 // .quad -7451627795949551616
+	QUAD $0xbebc200000000000 // .quad -4702848726509551616
+	QUAD $0xee6b280000000000 // .quad -1266874889709551616
+	QUAD $0x9502f90000000000 // .quad -7709325833709551616
+	QUAD $0xba43b74000000000 // .quad -5024971273709551616
+	QUAD $0xe8d4a51000000000 // .quad -1669528073709551616
+	QUAD $0x9184e72a00000000 // .quad -7960984073709551616
+	QUAD $0xb5e620f480000000 // .quad -5339544073709551616
+	QUAD $0xe35fa931a0000000 // .quad -2062744073709551616
+	QUAD $0x8e1bc9bf04000000 // .quad -8206744073709551616
+	QUAD $0xb1a2bc2ec5000000 // .quad -5646744073709551616
+	QUAD $0xde0b6b3a76400000 // .quad -2446744073709551616
+	QUAD $0x8ac7230489e80000 // .quad -8446744073709551616
+	QUAD $0xad78ebc5ac620000 // .quad -5946744073709551616
+	QUAD $0xd8d726b7177a8000 // .quad -2821744073709551616
+	QUAD $0x878678326eac9000 // .quad -8681119073709551616
+	QUAD $0xa968163f0a57b400 // .quad -6239712823709551616
+	QUAD $0xd3c21bcecceda100 // .quad -3187955011209551616
+	QUAD $0x84595161401484a0 // .quad -8910000909647051616
+	QUAD $0xa56fa5b99019a5c8 // .quad -6525815118631426616
+	QUAD $0xcecb8f27f4200f3a // .quad -3545582879861895366
+	QUAD $0x813f3978f8940985 // .quad -9133518327554766459
+	QUAD $0xa18f07d736b90be6 // .quad -6805211891016070170
+	QUAD $0xc9f2c9cd04674edf // .quad -3894828845342699809
+	QUAD $0xfc6f7c4045812297 // .quad -256850038250986857
+	QUAD $0x9dc5ada82b70b59e // .quad -7078060301547948642
+	QUAD $0xc5371912364ce306 // .quad -4235889358507547898
+	QUAD $0xf684df56c3e01bc7 // .quad -683175679707046969
+	QUAD $0x9a130b963a6c115d // .quad -7344513827457986211
+	QUAD $0xc097ce7bc90715b4 // .quad -4568956265895094860
+	QUAD $0xf0bdc21abb48db21 // .quad -1099509313941480671
+	QUAD $0x96769950b50d88f5 // .quad -7604722348854507275
+	QUAD $0xbc143fa4e250eb32 // .quad -4894216917640746190
+	QUAD $0xeb194f8e1ae525fe // .quad -1506085128623544834
+	QUAD $0x92efd1b8d0cf37bf // .quad -7858832233030797377
+	QUAD $0xb7abc627050305ae // .quad -5211854272861108818
+	QUAD $0xe596b7b0c643c71a // .quad -1903131822648998118
+	QUAD $0x8f7e32ce7bea5c70 // .quad -8106986416796705680
+	QUAD $0xb35dbf821ae4f38c // .quad -5522047002568494196
+
+TEXT ·__f32toa(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -56(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_f32toa:
+	MOVQ  out+0(FP), DI
+	MOVSD val+8(FP), X0
+	CALL  ·__native_entry__+35216(SB) // _f32toa
+	MOVQ  AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__f64toa(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -80(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_f64toa:
+	MOVQ  out+0(FP), DI
+	MOVSD val+8(FP), X0
+	CALL  ·__native_entry__+752(SB) // _f64toa
+	MOVQ  AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__get_by_path(SB), NOSPLIT | NOFRAME, $0 - 32
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -320(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_get_by_path:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ path+16(FP), DX
+	CALL ·__native_entry__+30384(SB) // _get_by_path
+	MOVQ AX, ret+24(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__html_escape(SB), NOSPLIT | NOFRAME, $0 - 40
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -72(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_html_escape:
+	MOVQ sp+0(FP), DI
+	MOVQ nb+8(FP), SI
+	MOVQ dp+16(FP), DX
+	MOVQ dn+24(FP), CX
+	CALL ·__native_entry__+11712(SB) // _html_escape
+	MOVQ AX, ret+32(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__i64toa(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -16(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_i64toa:
+	MOVQ out+0(FP), DI
+	MOVQ val+8(FP), SI
+	CALL ·__native_entry__+4368(SB) // _i64toa
+	MOVQ AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__lspace(SB), NOSPLIT | NOFRAME, $0 - 32
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -8(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_lspace:
+	MOVQ sp+0(FP), DI
+	MOVQ nb+8(FP), SI
+	MOVQ off+16(FP), DX
+	CALL ·__native_entry__+224(SB) // _lspace
+	MOVQ AX, ret+24(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__quote(SB), NOSPLIT | NOFRAME, $0 - 48
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -72(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_quote:
+	MOVQ sp+0(FP), DI
+	MOVQ nb+8(FP), SI
+	MOVQ dp+16(FP), DX
+	MOVQ dn+24(FP), CX
+	MOVQ flags+32(FP), R8
+	CALL ·__native_entry__+6160(SB) // _quote
+	MOVQ AX, ret+40(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__skip_array(SB), NOSPLIT | NOFRAME, $0 - 40
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -120(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_skip_array:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ m+16(FP), DX
+	MOVQ flags+24(FP), CX
+	CALL ·__native_entry__+22864(SB) // _skip_array
+	MOVQ AX, ret+32(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__skip_number(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -80(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_skip_number:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	CALL ·__native_entry__+26928(SB) // _skip_number
+	MOVQ AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__skip_object(SB), NOSPLIT | NOFRAME, $0 - 40
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -120(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_skip_object:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ m+16(FP), DX
+	MOVQ flags+24(FP), CX
+	CALL ·__native_entry__+24864(SB) // _skip_object
+	MOVQ AX, ret+32(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__skip_one(SB), NOSPLIT | NOFRAME, $0 - 40
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -120(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_skip_one:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ m+16(FP), DX
+	MOVQ flags+24(FP), CX
+	CALL ·__native_entry__+27088(SB) // _skip_one
+	MOVQ AX, ret+32(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__skip_one_fast(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -216(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_skip_one_fast:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	CALL ·__native_entry__+27504(SB) // _skip_one_fast
+	MOVQ AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__u64toa(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -8(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_u64toa:
+	MOVQ out+0(FP), DI
+	MOVQ val+8(FP), SI
+	CALL ·__native_entry__+4640(SB) // _u64toa
+	MOVQ AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__unquote(SB), NOSPLIT | NOFRAME, $0 - 48
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -128(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_unquote:
+	MOVQ sp+0(FP), DI
+	MOVQ nb+8(FP), SI
+	MOVQ dp+16(FP), DX
+	MOVQ ep+24(FP), CX
+	MOVQ flags+32(FP), R8
+	CALL ·__native_entry__+8960(SB) // _unquote
+	MOVQ AX, ret+40(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__validate_one(SB), NOSPLIT | NOFRAME, $0 - 32
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -120(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_validate_one:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ m+16(FP), DX
+	CALL ·__native_entry__+27152(SB) // _validate_one
+	MOVQ AX, ret+24(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__validate_utf8(SB), NOSPLIT | NOFRAME, $0 - 32
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -48(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_validate_utf8:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ m+16(FP), DX
+	CALL ·__native_entry__+31552(SB) // _validate_utf8
+	MOVQ AX, ret+24(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__validate_utf8_fast(SB), NOSPLIT | NOFRAME, $0 - 16
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -200(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_validate_utf8_fast:
+	MOVQ s+0(FP), DI
+	CALL ·__native_entry__+32496(SB) // _validate_utf8_fast
+	MOVQ AX, ret+8(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__value(SB), NOSPLIT | NOFRAME, $0 - 48
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -368(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_value:
+	MOVQ s+0(FP), DI
+	MOVQ n+8(FP), SI
+	MOVQ p+16(FP), DX
+	MOVQ v+24(FP), CX
+	MOVQ flags+32(FP), R8
+	CALL ·__native_entry__+16816(SB) // _value
+	MOVQ AX, ret+40(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__vnumber(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -280(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_vnumber:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ v+16(FP), DX
+	LEAQ ·__native_entry__+20608(SB), AX // _vnumber
+	JMP  AX
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__vsigned(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -16(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_vsigned:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ v+16(FP), DX
+	LEAQ ·__native_entry__+22144(SB), AX // _vsigned
+	JMP  AX
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__vstring(SB), NOSPLIT | NOFRAME, $0 - 32
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -104(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_vstring:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ v+16(FP), DX
+	MOVQ flags+24(FP), CX
+	LEAQ ·__native_entry__+19312(SB), AX // _vstring
+	JMP  AX
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__vunsigned(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -24(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_vunsigned:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ v+16(FP), DX
+	LEAQ ·__native_entry__+22496(SB), AX // _vunsigned
+	JMP  AX
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx2/native_export_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_export_amd64.go
new file mode 100644
index 000000000..8adf5e91f
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_export_amd64.go
@@ -0,0 +1,49 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package avx2
+
+var (
+    S_f64toa = _subr__f64toa
+    S_f32toa = _subr__f32toa
+    S_i64toa = _subr__i64toa
+    S_u64toa = _subr__u64toa
+    S_lspace = _subr__lspace
+)
+
+var (
+    S_quote   = _subr__quote
+    S_unquote = _subr__unquote
+)
+
+var (
+    S_value     = _subr__value
+    S_vstring   = _subr__vstring
+    S_vnumber   = _subr__vnumber
+    S_vsigned   = _subr__vsigned
+    S_vunsigned = _subr__vunsigned
+)
+
+var (
+    S_skip_one    = _subr__skip_one
+    S_skip_one_fast = _subr__skip_one_fast
+    S_skip_array  = _subr__skip_array
+    S_skip_object = _subr__skip_object
+    S_skip_number = _subr__skip_number
+    S_get_by_path = _subr__get_by_path
+)
diff --git a/vendor/github.com/bytedance/sonic/internal/native/avx2/native_subr_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_subr_amd64.go
new file mode 100644
index 000000000..bd8014e58
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/avx2/native_subr_amd64.go
@@ -0,0 +1,109 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package avx2
+
+//go:nosplit
+//go:noescape
+//goland:noinspection ALL
+func __native_entry__() uintptr
+
+var (
+    _subr__f32toa             = __native_entry__() + 35216
+    _subr__f64toa             = __native_entry__() + 752
+    _subr__get_by_path        = __native_entry__() + 30384
+    _subr__html_escape        = __native_entry__() + 11712
+    _subr__i64toa             = __native_entry__() + 4368
+    _subr__lspace             = __native_entry__() + 224
+    _subr__quote              = __native_entry__() + 6160
+    _subr__skip_array         = __native_entry__() + 22864
+    _subr__skip_number        = __native_entry__() + 26928
+    _subr__skip_object        = __native_entry__() + 24864
+    _subr__skip_one           = __native_entry__() + 27088
+    _subr__skip_one_fast      = __native_entry__() + 27504
+    _subr__u64toa             = __native_entry__() + 4640
+    _subr__unquote            = __native_entry__() + 8960
+    _subr__validate_one       = __native_entry__() + 27152
+    _subr__validate_utf8      = __native_entry__() + 31552
+    _subr__validate_utf8_fast = __native_entry__() + 32496
+    _subr__value              = __native_entry__() + 16816
+    _subr__vnumber            = __native_entry__() + 20608
+    _subr__vsigned            = __native_entry__() + 22144
+    _subr__vstring            = __native_entry__() + 19312
+    _subr__vunsigned          = __native_entry__() + 22496
+)
+
+const (
+    _stack__f32toa = 56
+    _stack__f64toa = 80
+    _stack__get_by_path = 320
+    _stack__html_escape = 72
+    _stack__i64toa = 16
+    _stack__lspace = 8
+    _stack__quote = 72
+    _stack__skip_array = 120
+    _stack__skip_number = 80
+    _stack__skip_object = 120
+    _stack__skip_one = 120
+    _stack__skip_one_fast = 216
+    _stack__u64toa = 8
+    _stack__unquote = 128
+    _stack__validate_one = 120
+    _stack__validate_utf8 = 48
+    _stack__validate_utf8_fast = 200
+    _stack__value = 368
+    _stack__vnumber = 280
+    _stack__vsigned = 16
+    _stack__vstring = 104
+    _stack__vunsigned = 24
+)
+
+var (
+    _ = _subr__f32toa
+    _ = _subr__f64toa
+    _ = _subr__get_by_path
+    _ = _subr__html_escape
+    _ = _subr__i64toa
+    _ = _subr__lspace
+    _ = _subr__quote
+    _ = _subr__skip_array
+    _ = _subr__skip_number
+    _ = _subr__skip_object
+    _ = _subr__skip_one
+    _ = _subr__skip_one_fast
+    _ = _subr__u64toa
+    _ = _subr__unquote
+    _ = _subr__validate_one
+    _ = _subr__validate_utf8
+    _ = _subr__validate_utf8_fast
+    _ = _subr__value
+    _ = _subr__vnumber
+    _ = _subr__vsigned
+    _ = _subr__vstring
+    _ = _subr__vunsigned
+)
+
+const (
+    _ = _stack__f32toa
+    _ = _stack__f64toa
+    _ = _stack__get_by_path
+    _ = _stack__html_escape
+    _ = _stack__i64toa
+    _ = _stack__lspace
+    _ = _stack__quote
+    _ = _stack__skip_array
+    _ = _stack__skip_number
+    _ = _stack__skip_object
+    _ = _stack__skip_one
+    _ = _stack__skip_one_fast
+    _ = _stack__u64toa
+    _ = _stack__unquote
+    _ = _stack__validate_one
+    _ = _stack__validate_utf8
+    _ = _stack__validate_utf8_fast
+    _ = _stack__value
+    _ = _stack__vnumber
+    _ = _stack__vsigned
+    _ = _stack__vstring
+    _ = _stack__vunsigned
+)
diff --git a/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.go
new file mode 100644
index 000000000..6aba0051f
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.go
@@ -0,0 +1,202 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package native
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/cpu`
+    `github.com/bytedance/sonic/internal/native/avx`
+    `github.com/bytedance/sonic/internal/native/avx2`
+    `github.com/bytedance/sonic/internal/native/sse`
+    `github.com/bytedance/sonic/internal/native/types`
+)
+
+const (
+    MaxFrameSize   uintptr = 400
+    BufPaddingSize int     = 64
+)
+
+var (
+    S_f64toa uintptr
+    S_f32toa uintptr
+    S_i64toa uintptr
+    S_u64toa uintptr
+    S_lspace uintptr
+)
+
+var (
+    S_quote   uintptr
+    S_unquote uintptr
+)
+
+var (
+    S_value     uintptr
+    S_vstring   uintptr
+    S_vnumber   uintptr
+    S_vsigned   uintptr
+    S_vunsigned uintptr
+)
+
+var (
+    S_skip_one    uintptr
+    S_skip_one_fast    uintptr
+    S_get_by_path    uintptr
+    S_skip_array  uintptr
+    S_skip_object uintptr
+    S_skip_number uintptr
+)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func Quote(s unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) int
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func Unquote(s unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) int
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func HTMLEscape(s unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) int
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func Value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) int
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func SkipOne(s *string, p *int, m *types.StateMachine, flags uint64) int
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func SkipOneFast(s *string, p *int) int
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func GetByPath(s *string, p *int, path *[]interface{}) int
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func ValidateOne(s *string, p *int, m *types.StateMachine) int
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func I64toa(out *byte, val int64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func U64toa(out *byte, val uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func F64toa(out *byte, val float64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func ValidateUTF8(s *string, p *int, m *types.StateMachine) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func ValidateUTF8Fast(s *string) (ret int)
+
+func useAVX() {
+    S_f64toa      = avx.S_f64toa
+    S_f32toa      = avx.S_f32toa
+    S_i64toa      = avx.S_i64toa
+    S_u64toa      = avx.S_u64toa
+    S_lspace      = avx.S_lspace
+    S_quote       = avx.S_quote
+    S_unquote     = avx.S_unquote
+    S_value       = avx.S_value
+    S_vstring     = avx.S_vstring
+    S_vnumber     = avx.S_vnumber
+    S_vsigned     = avx.S_vsigned
+    S_vunsigned   = avx.S_vunsigned
+    S_skip_one    = avx.S_skip_one
+    S_skip_one_fast = avx.S_skip_one_fast
+    S_skip_array  = avx.S_skip_array
+    S_skip_object = avx.S_skip_object
+    S_skip_number = avx.S_skip_number
+    S_get_by_path = avx.S_get_by_path
+}
+
+func useAVX2() {
+    S_f64toa      = avx2.S_f64toa
+    S_f32toa      = avx2.S_f32toa
+    S_i64toa      = avx2.S_i64toa
+    S_u64toa      = avx2.S_u64toa
+    S_lspace      = avx2.S_lspace
+    S_quote       = avx2.S_quote
+    S_unquote     = avx2.S_unquote
+    S_value       = avx2.S_value
+    S_vstring     = avx2.S_vstring
+    S_vnumber     = avx2.S_vnumber
+    S_vsigned     = avx2.S_vsigned
+    S_vunsigned   = avx2.S_vunsigned
+    S_skip_one    = avx2.S_skip_one
+    S_skip_one_fast = avx2.S_skip_one_fast
+    S_skip_array  = avx2.S_skip_array
+    S_skip_object = avx2.S_skip_object
+    S_skip_number = avx2.S_skip_number
+    S_get_by_path = avx2.S_get_by_path
+}
+
+func useSSE() {
+    S_f64toa = sse.S_f64toa
+    S_f32toa = sse.S_f32toa
+    S_i64toa = sse.S_i64toa
+    S_u64toa = sse.S_u64toa
+    S_lspace = sse.S_lspace
+    S_quote = sse.S_quote
+    S_unquote = sse.S_unquote
+    S_value = sse.S_value
+    S_vstring = sse.S_vstring
+    S_vnumber = sse.S_vnumber
+    S_vsigned = sse.S_vsigned
+    S_vunsigned = sse.S_vunsigned
+    S_skip_one = sse.S_skip_one
+    S_skip_one_fast = sse.S_skip_one_fast
+    S_skip_array = sse.S_skip_array
+    S_skip_object = sse.S_skip_object
+    S_skip_number = sse.S_skip_number
+    S_get_by_path = sse.S_get_by_path
+}
+
+func init() {
+    if cpu.HasAVX2 {
+        useAVX2()
+    } else if cpu.HasAVX {
+        useAVX()
+    } else if cpu.HasSSE {
+        useSSE()
+    } else {
+        panic("Unsupported CPU, maybe it's too old to run Sonic.")
+    }
+}
diff --git a/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.s b/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.s
new file mode 100644
index 000000000..858fe0212
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/dispatch_amd64.s
@@ -0,0 +1,137 @@
+//
+// Copyright 2021 ByteDance Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "go_asm.h"
+#include "funcdata.h"
+#include "textflag.h"
+
+TEXT ·Quote(SB), NOSPLIT, $0 - 48
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__quote(SB)
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__quote(SB)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__quote(SB)
+
+TEXT ·Unquote(SB), NOSPLIT, $0 - 48
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__unquote(SB)
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__unquote(SB)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__unquote(SB)
+
+TEXT ·HTMLEscape(SB), NOSPLIT, $0 - 40
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__html_escape(SB)
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__html_escape(SB)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__html_escape(SB)
+
+TEXT ·Value(SB), NOSPLIT, $0 - 48
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__value(SB)
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__value(SB)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__value(SB)
+
+TEXT ·SkipOne(SB), NOSPLIT, $0 - 40
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__skip_one(SB)
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__skip_one(SB)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__skip_one(SB)
+
+TEXT ·SkipOneFast(SB), NOSPLIT, $0 - 24
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__skip_one_fast(SB)
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__skip_one_fast(SB)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__skip_one_fast(SB)
+
+TEXT ·GetByPath(SB), NOSPLIT, $0 - 32
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__get_by_path(SB)
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__get_by_path(SB)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__get_by_path(SB)
+
+TEXT ·ValidateOne(SB), NOSPLIT, $0 - 32
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__validate_one(SB)
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__validate_one(SB)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__validate_one(SB)
+
+TEXT ·ValidateUTF8(SB), NOSPLIT, $0 - 40
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__validate_utf8(SB)
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__validate_utf8(SB)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__validate_utf8(SB)
+
+TEXT ·ValidateUTF8Fast(SB), NOSPLIT, $0 - 16
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__validate_utf8_fast(SB)
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__validate_utf8_fast(SB)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__validate_utf8_fast(SB)
+    
+TEXT ·I64toa(SB), NOSPLIT, $0 - 32
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__i64toa(SB)
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__i64toa(SB)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__i64toa(SB)
+
+TEXT ·U64toa(SB), NOSPLIT, $0 - 32
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__u64toa(SB)
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__u64toa(SB)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__u64toa(SB)
+
+TEXT ·F64toa(SB), NOSPLIT, $0 - 32
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX2(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx2·__f64toa(SB)
+    CMPB github·com∕bytedance∕sonic∕internal∕cpu·HasAVX(SB), $0
+    JE   2(PC)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕avx·__f64toa(SB)
+    JMP  github·com∕bytedance∕sonic∕internal∕native∕sse·__f64toa(SB)
+
diff --git a/vendor/github.com/bytedance/sonic/internal/native/fastfloat_amd64_test.tmpl b/vendor/github.com/bytedance/sonic/internal/native/fastfloat_amd64_test.tmpl
new file mode 100644
index 000000000..7ed9e4704
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/fastfloat_amd64_test.tmpl
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package {{PACKAGE}}
+
+import (
+    `math`
+    `strconv`
+    `testing`
+    `math/rand`
+    `encoding/json`
+
+    `github.com/stretchr/testify/assert`
+)
+
+func TestFastFloat_Encode(t *testing.T) {
+    var buf [64]byte
+    assert.Equal(t, "0"                         , string(buf[:__f64toa(&buf[0], 0)]))
+    assert.Equal(t, "-0"                         , string(buf[:__f64toa(&buf[0], math.Float64frombits(0x8000000000000000))]))
+    assert.Equal(t, "12340000000"               , string(buf[:__f64toa(&buf[0], 1234e7)]))
+    assert.Equal(t, "12.34"                     , string(buf[:__f64toa(&buf[0], 1234e-2)]))
+    assert.Equal(t, "0.001234"                  , string(buf[:__f64toa(&buf[0], 1234e-6)]))
+    assert.Equal(t, "1e+30"                      , string(buf[:__f64toa(&buf[0], 1e30)]))
+    assert.Equal(t, "1.234e+33"                  , string(buf[:__f64toa(&buf[0], 1234e30)]))
+    assert.Equal(t, "1.234e+308"                 , string(buf[:__f64toa(&buf[0], 1234e305)]))
+    assert.Equal(t, "1.234e-317"                , string(buf[:__f64toa(&buf[0], 1234e-320)]))
+    assert.Equal(t, "1.7976931348623157e+308"    , string(buf[:__f64toa(&buf[0], 1.7976931348623157e308)]))
+    assert.Equal(t, "-12340000000"              , string(buf[:__f64toa(&buf[0], -1234e7)]))
+    assert.Equal(t, "-12.34"                    , string(buf[:__f64toa(&buf[0], -1234e-2)]))
+    assert.Equal(t, "-0.001234"                 , string(buf[:__f64toa(&buf[0], -1234e-6)]))
+    assert.Equal(t, "-1e+30"                     , string(buf[:__f64toa(&buf[0], -1e30)]))
+    assert.Equal(t, "-1.234e+33"                 , string(buf[:__f64toa(&buf[0], -1234e30)]))
+    assert.Equal(t, "-1.234e+308"                , string(buf[:__f64toa(&buf[0], -1234e305)]))
+    assert.Equal(t, "-1.234e-317"               , string(buf[:__f64toa(&buf[0], -1234e-320)]))
+    assert.Equal(t, "-2.2250738585072014e-308"  , string(buf[:__f64toa(&buf[0], -2.2250738585072014e-308)]))
+}
+
+func TestFastFloat_Random(t *testing.T) {
+    var buf [64]byte
+    N := 10000
+    for i := 0; i < N; i++ {
+        b64 := uint64(rand.Uint32())<<32 | uint64(rand.Uint32())
+        f64 := math.Float64frombits(b64)
+
+        jout, jerr := json.Marshal(f64)
+        n := __f64toa(&buf[0], f64)
+        if jerr == nil {
+            assert.Equal(t, jout, buf[:n])
+        } else {
+            assert.True(t, n == 0)
+        }
+
+        f32 := math.Float32frombits(rand.Uint32())
+        jout, jerr = json.Marshal(f32)
+        n = __f32toa(&buf[0], f32)
+        if jerr == nil {
+            assert.Equal(t, jout, buf[:n])
+        } else {
+            assert.True(t, n == 0)
+        }
+    }
+}
+
+func BenchmarkParseFloat64(b *testing.B) {
+    var f64toaBenches = []struct {
+        name    string
+        float   float64
+    }{
+        {"Zero", 0},
+        {"Decimal", 33909},
+        {"Float", 339.7784},
+        {"Exp", -5.09e75},
+        {"NegExp", -5.11e-95},
+        {"LongExp", 1.234567890123456e-78},
+        {"Big", 123456789123456789123456789},
+    
+    }
+    for _, c := range f64toaBenches {
+        f64bench := []struct {
+            name string
+            test func(*testing.B)
+        }{{
+            name: "StdLib",
+            test: func(b *testing.B) { var buf [64]byte; for i := 0; i < b.N; i++ { strconv.AppendFloat(buf[:0], c.float, 'g', -1, 64) }},
+        }, {
+            name: "FastFloat",
+            test: func(b *testing.B) { var buf [64]byte; for i := 0; i < b.N; i++ { __f64toa(&buf[0], c.float) }},
+        }}
+        for _, bm := range f64bench {
+            name := bm.name + "_" + c.name
+            b.Run(name, bm.test)
+        }
+    }
+}
+
+func BenchmarkParseFloat32(b *testing.B) {
+    var f32toaBenches = []struct {
+        name    string
+        float   float32
+    }{
+        {"Zero", 0},
+        {"Integer", 33909},
+        {"ExactFraction", 3.375},
+        {"Point", 339.7784},
+        {"Exp", -5.09e25},
+        {"NegExp", -5.11e-25},
+        {"Shortest", 1.234567e-8},
+    }
+    for _, c := range f32toaBenches {
+        bench := []struct {
+            name string
+            test func(*testing.B)
+        }{{
+            name: "StdLib32",
+            test: func(b *testing.B) { var buf [64]byte; for i := 0; i < b.N; i++ { strconv.AppendFloat(buf[:0], float64(c.float), 'g', -1, 32) }},
+        }, {
+            name: "FastFloat32",
+            test: func(b *testing.B) { var buf [64]byte; for i := 0; i < b.N; i++ { __f32toa(&buf[0], c.float) }},
+        }}
+        for _, bm := range bench {
+            name := bm.name + "_" + c.name
+            b.Run(name, bm.test)
+        }
+    }
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/internal/native/fastint_amd64_test.tmpl b/vendor/github.com/bytedance/sonic/internal/native/fastint_amd64_test.tmpl
new file mode 100644
index 000000000..cb060909d
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/fastint_amd64_test.tmpl
@@ -0,0 +1,151 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package {{PACKAGE}}
+
+import (
+    `strconv`
+    `testing`
+    `fmt`
+
+    `github.com/stretchr/testify/assert`
+)
+
+func TestFastInt_IntToString(t *testing.T) {
+    var buf [32]byte
+    assert.Equal(t, "0"                    , string(buf[:__i64toa(&buf[0], 0)]))
+    assert.Equal(t, "1"                    , string(buf[:__i64toa(&buf[0], 1)]))
+    assert.Equal(t, "12"                   , string(buf[:__i64toa(&buf[0], 12)]))
+    assert.Equal(t, "123"                  , string(buf[:__i64toa(&buf[0], 123)]))
+    assert.Equal(t, "1234"                 , string(buf[:__i64toa(&buf[0], 1234)]))
+    assert.Equal(t, "12345"                , string(buf[:__i64toa(&buf[0], 12345)]))
+    assert.Equal(t, "123456"               , string(buf[:__i64toa(&buf[0], 123456)]))
+    assert.Equal(t, "1234567"              , string(buf[:__i64toa(&buf[0], 1234567)]))
+    assert.Equal(t, "12345678"             , string(buf[:__i64toa(&buf[0], 12345678)]))
+    assert.Equal(t, "123456789"            , string(buf[:__i64toa(&buf[0], 123456789)]))
+    assert.Equal(t, "1234567890"           , string(buf[:__i64toa(&buf[0], 1234567890)]))
+    assert.Equal(t, "12345678901"          , string(buf[:__i64toa(&buf[0], 12345678901)]))
+    assert.Equal(t, "123456789012"         , string(buf[:__i64toa(&buf[0], 123456789012)]))
+    assert.Equal(t, "1234567890123"        , string(buf[:__i64toa(&buf[0], 1234567890123)]))
+    assert.Equal(t, "12345678901234"       , string(buf[:__i64toa(&buf[0], 12345678901234)]))
+    assert.Equal(t, "123456789012345"      , string(buf[:__i64toa(&buf[0], 123456789012345)]))
+    assert.Equal(t, "1234567890123456"     , string(buf[:__i64toa(&buf[0], 1234567890123456)]))
+    assert.Equal(t, "12345678901234567"    , string(buf[:__i64toa(&buf[0], 12345678901234567)]))
+    assert.Equal(t, "123456789012345678"   , string(buf[:__i64toa(&buf[0], 123456789012345678)]))
+    assert.Equal(t, "1234567890123456789"  , string(buf[:__i64toa(&buf[0], 1234567890123456789)]))
+    assert.Equal(t, "9223372036854775807"  , string(buf[:__i64toa(&buf[0], 9223372036854775807)]))
+    assert.Equal(t, "-1"                   , string(buf[:__i64toa(&buf[0], -1)]))
+    assert.Equal(t, "-12"                  , string(buf[:__i64toa(&buf[0], -12)]))
+    assert.Equal(t, "-123"                 , string(buf[:__i64toa(&buf[0], -123)]))
+    assert.Equal(t, "-1234"                , string(buf[:__i64toa(&buf[0], -1234)]))
+    assert.Equal(t, "-12345"               , string(buf[:__i64toa(&buf[0], -12345)]))
+    assert.Equal(t, "-123456"              , string(buf[:__i64toa(&buf[0], -123456)]))
+    assert.Equal(t, "-1234567"             , string(buf[:__i64toa(&buf[0], -1234567)]))
+    assert.Equal(t, "-12345678"            , string(buf[:__i64toa(&buf[0], -12345678)]))
+    assert.Equal(t, "-123456789"           , string(buf[:__i64toa(&buf[0], -123456789)]))
+    assert.Equal(t, "-1234567890"          , string(buf[:__i64toa(&buf[0], -1234567890)]))
+    assert.Equal(t, "-12345678901"         , string(buf[:__i64toa(&buf[0], -12345678901)]))
+    assert.Equal(t, "-123456789012"        , string(buf[:__i64toa(&buf[0], -123456789012)]))
+    assert.Equal(t, "-1234567890123"       , string(buf[:__i64toa(&buf[0], -1234567890123)]))
+    assert.Equal(t, "-12345678901234"      , string(buf[:__i64toa(&buf[0], -12345678901234)]))
+    assert.Equal(t, "-123456789012345"     , string(buf[:__i64toa(&buf[0], -123456789012345)]))
+    assert.Equal(t, "-1234567890123456"    , string(buf[:__i64toa(&buf[0], -1234567890123456)]))
+    assert.Equal(t, "-12345678901234567"   , string(buf[:__i64toa(&buf[0], -12345678901234567)]))
+    assert.Equal(t, "-123456789012345678"  , string(buf[:__i64toa(&buf[0], -123456789012345678)]))
+    assert.Equal(t, "-1234567890123456789" , string(buf[:__i64toa(&buf[0], -1234567890123456789)]))
+    assert.Equal(t, "-9223372036854775808" , string(buf[:__i64toa(&buf[0], -9223372036854775808)]))
+}
+
+func TestFastInt_UintToString(t *testing.T) {
+    var buf [32]byte
+    assert.Equal(t, "0"                    , string(buf[:__u64toa(&buf[0], 0)]))
+    assert.Equal(t, "1"                    , string(buf[:__u64toa(&buf[0], 1)]))
+    assert.Equal(t, "12"                   , string(buf[:__u64toa(&buf[0], 12)]))
+    assert.Equal(t, "123"                  , string(buf[:__u64toa(&buf[0], 123)]))
+    assert.Equal(t, "1234"                 , string(buf[:__u64toa(&buf[0], 1234)]))
+    assert.Equal(t, "12345"                , string(buf[:__u64toa(&buf[0], 12345)]))
+    assert.Equal(t, "123456"               , string(buf[:__u64toa(&buf[0], 123456)]))
+    assert.Equal(t, "1234567"              , string(buf[:__u64toa(&buf[0], 1234567)]))
+    assert.Equal(t, "12345678"             , string(buf[:__u64toa(&buf[0], 12345678)]))
+    assert.Equal(t, "123456789"            , string(buf[:__u64toa(&buf[0], 123456789)]))
+    assert.Equal(t, "1234567890"           , string(buf[:__u64toa(&buf[0], 1234567890)]))
+    assert.Equal(t, "12345678901"          , string(buf[:__u64toa(&buf[0], 12345678901)]))
+    assert.Equal(t, "123456789012"         , string(buf[:__u64toa(&buf[0], 123456789012)]))
+    assert.Equal(t, "1234567890123"        , string(buf[:__u64toa(&buf[0], 1234567890123)]))
+    assert.Equal(t, "12345678901234"       , string(buf[:__u64toa(&buf[0], 12345678901234)]))
+    assert.Equal(t, "123456789012345"      , string(buf[:__u64toa(&buf[0], 123456789012345)]))
+    assert.Equal(t, "1234567890123456"     , string(buf[:__u64toa(&buf[0], 1234567890123456)]))
+    assert.Equal(t, "12345678901234567"    , string(buf[:__u64toa(&buf[0], 12345678901234567)]))
+    assert.Equal(t, "123456789012345678"   , string(buf[:__u64toa(&buf[0], 123456789012345678)]))
+    assert.Equal(t, "1234567890123456789"  , string(buf[:__u64toa(&buf[0], 1234567890123456789)]))
+    assert.Equal(t, "12345678901234567890" , string(buf[:__u64toa(&buf[0], 12345678901234567890)]))
+    assert.Equal(t, "18446744073709551615" , string(buf[:__u64toa(&buf[0], 18446744073709551615)]))
+}
+
+ func BenchmarkFastInt_IntToString(b *testing.B) {
+     benchmarks := []struct {
+         name string
+         test func(*testing.B)
+     }{{
+         name: "StdLib-Positive",
+         test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { strconv.AppendInt(buf[:0], int64(i), 10) }},
+     }, {
+         name: "StdLib-Negative",
+         test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { strconv.AppendInt(buf[:0], -int64(i), 10) }},
+     }, {
+         name: "FastInt-Positive",
+         test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { __i64toa(&buf[0], int64(i)) }},
+     }, {
+         name: "FastInt-Negative",
+         test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { __i64toa(&buf[0], -int64(i)) }},
+     }}
+     for _, bm := range benchmarks {
+         b.Run(bm.name, bm.test)
+     }
+ }
+ 
+ type utoaBench struct {
+     name string
+     num  uint64
+ }
+ 
+ func BenchmarkFastInt_UintToString(b *testing.B) {
+     maxUint := "18446744073709551615"
+     benchs := make([]utoaBench, len(maxUint) + 1)
+     benchs[0].name = "Zero"
+     benchs[0].num  = 0
+     for i := 1; i <= len(maxUint); i++ {
+         benchs[i].name = strconv.FormatInt(int64(i), 10) + "-Digs"
+         benchs[i].num, _ = strconv.ParseUint(string(maxUint[:i]), 10, 64)
+     }
+ 
+     for _, t := range(benchs) {
+         benchmarks := []struct {
+             name string
+             test func(*testing.B)
+         }{{
+             name: "StdLib",
+             test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { strconv.AppendUint(buf[:0], t.num, 10) }},
+         }, {
+             name: "FastInt",
+             test: func(b *testing.B) { var buf [32]byte; for i := 0; i < b.N; i++ { __u64toa(&buf[0], t.num) }},
+         }}
+         for _, bm := range benchmarks {
+             name := fmt.Sprintf("%s_%s", bm.name, t.name)
+             b.Run(name, bm.test)
+         }
+     }
+ }
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/internal/native/native_amd64.tmpl b/vendor/github.com/bytedance/sonic/internal/native/native_amd64.tmpl
new file mode 100644
index 000000000..357a9f480
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/native_amd64.tmpl
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package {{PACKAGE}}
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native/types`
+)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __i64toa(out *byte, val int64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __u64toa(out *byte, val uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __f64toa(out *byte, val float64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __f32toa(out *byte, val float32) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __lspace(sp unsafe.Pointer, nb int, off int) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __vstring(s *string, p *int, v *types.JsonState, flags uint64)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __vnumber(s *string, p *int, v *types.JsonState)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __vsigned(s *string, p *int, v *types.JsonState)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __vunsigned(s *string, p *int, v *types.JsonState)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_one_fast(s *string, p *int) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_number(s *string, p *int) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __validate_one(s *string, p *int, m *types.StateMachine) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __get_by_path(s *string, p *int, path *[]interface{}) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __validate_utf8(s *string, p *int, m *types.StateMachine) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __validate_utf8_fast(s *string)  (ret int)
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/internal/native/native_amd64_test.tmpl b/vendor/github.com/bytedance/sonic/internal/native/native_amd64_test.tmpl
new file mode 100644
index 000000000..bd9ce0c73
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/native_amd64_test.tmpl
@@ -0,0 +1,593 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package {{PACKAGE}}
+
+import (
+    `encoding/hex`
+    `fmt`
+    `math`
+    `testing`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/davecgh/go-spew/spew`
+    `github.com/stretchr/testify/assert`
+    `github.com/stretchr/testify/require`
+)
+
+func TestNative_Value(t *testing.T) {
+    var v types.JsonState
+    s := `   -12345`
+    p := (*rt.GoString)(unsafe.Pointer(&s))
+    x := __value(p.Ptr, p.Len, 0, &v, 0)
+    assert.Equal(t, 9, x)
+    assert.Equal(t, types.V_INTEGER, v.Vt)
+    assert.Equal(t, int64(-12345), v.Iv)
+    assert.Equal(t, 3, v.Ep)
+}
+
+func TestNative_Value_OutOfBound(t *testing.T) {
+    var v types.JsonState
+    mem := []byte{'"', '"'}
+    s := rt.Mem2Str(mem[:1])
+    p := (*rt.GoString)(unsafe.Pointer(&s))
+    x := __value(p.Ptr, p.Len, 0, &v, 0)
+    assert.Equal(t, 1, x)
+    assert.Equal(t, -int(types.ERR_EOF), int(v.Vt))
+}
+
+func TestNative_Quote(t *testing.T) {
+    s := "hello\b\f\n\r\t\\\"\u666fworld"
+    d := make([]byte, 256)
+    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
+    sp := (*rt.GoString)(unsafe.Pointer(&s))
+    rv := __quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, 0)
+    if rv < 0 {
+        require.NoError(t, types.ParsingError(-rv))
+    }
+    assert.Equal(t, len(s), rv)
+    assert.Equal(t, 35, len(d))
+    assert.Equal(t, `hello\u0008\u000c\n\r\t\\\"景world`, string(d))
+}
+
+func TestNative_QuoteNoMem(t *testing.T) {
+    s := "hello\b\f\n\r\t\\\"\u666fworld"
+    d := make([]byte, 10)
+    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
+    sp := (*rt.GoString)(unsafe.Pointer(&s))
+    rv := __quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, 0)
+    assert.Equal(t, -6, rv)
+    assert.Equal(t, 5, len(d))
+    assert.Equal(t, `hello`, string(d))
+}
+
+func TestNative_DoubleQuote(t *testing.T) {
+    s := "hello\b\f\n\r\t\\\"\u666fworld"
+    d := make([]byte, 256)
+    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
+    sp := (*rt.GoString)(unsafe.Pointer(&s))
+    rv := __quote(sp.Ptr, sp.Len, dp.Ptr, &dp.Len, types.F_DOUBLE_UNQUOTE)
+    if rv < 0 {
+        require.NoError(t, types.ParsingError(-rv))
+    }
+    assert.Equal(t, len(s), rv)
+    assert.Equal(t, 44, len(d))
+    assert.Equal(t, `hello\\u0008\\u000c\\n\\r\\t\\\\\\\"景world`, string(d))
+}
+
+func TestNative_Unquote(t *testing.T) {
+    s := `hello\b\f\n\r\t\\\"\u2333world`
+    d := make([]byte, 0, len(s))
+    ep := -1
+    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
+    sp := (*rt.GoString)(unsafe.Pointer(&s))
+    rv := __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
+    if rv < 0 {
+        require.NoError(t, types.ParsingError(-rv))
+    }
+    dp.Len = rv
+    assert.Equal(t, -1, ep)
+    assert.Equal(t, "hello\b\f\n\r\t\\\"\u2333world", string(d))
+}
+
+func TestNative_UnquoteError(t *testing.T) {
+    s := `asdf\`
+    d := make([]byte, 0, len(s))
+    ep := -1
+    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
+    sp := (*rt.GoString)(unsafe.Pointer(&s))
+    rv := __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
+    assert.Equal(t, -int(types.ERR_EOF), rv)
+    assert.Equal(t, 5, ep)
+    s = `asdf\gqwer`
+    d = make([]byte, 0, len(s))
+    ep = -1
+    dp = (*rt.GoSlice)(unsafe.Pointer(&d))
+    sp = (*rt.GoString)(unsafe.Pointer(&s))
+    rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
+    assert.Equal(t, -int(types.ERR_INVALID_ESCAPE), rv)
+    assert.Equal(t, 5, ep)
+    s = `asdf\u1gggqwer`
+    d = make([]byte, 0, len(s))
+    ep = -1
+    dp = (*rt.GoSlice)(unsafe.Pointer(&d))
+    sp = (*rt.GoString)(unsafe.Pointer(&s))
+    rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
+    assert.Equal(t, -int(types.ERR_INVALID_CHAR), rv)
+    assert.Equal(t, 7, ep)
+    s = `asdf\ud800qwer`
+    d = make([]byte, 0, len(s))
+    ep = -1
+    dp = (*rt.GoSlice)(unsafe.Pointer(&d))
+    sp = (*rt.GoString)(unsafe.Pointer(&s))
+    rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
+    assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
+    assert.Equal(t, 6, ep)
+    s = `asdf\\ud800qwer`
+    d = make([]byte, 0, len(s))
+    ep = -1
+    dp = (*rt.GoSlice)(unsafe.Pointer(&d))
+    sp = (*rt.GoString)(unsafe.Pointer(&s))
+    rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
+    assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
+    assert.Equal(t, 7, ep)
+    s = `asdf\ud800\ud800qwer`
+    d = make([]byte, 0, len(s))
+    ep = -1
+    dp = (*rt.GoSlice)(unsafe.Pointer(&d))
+    sp = (*rt.GoString)(unsafe.Pointer(&s))
+    rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, 0)
+    assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
+    assert.Equal(t, 12, ep)
+    s = `asdf\\ud800\\ud800qwer`
+    d = make([]byte, 0, len(s))
+    ep = -1
+    dp = (*rt.GoSlice)(unsafe.Pointer(&d))
+    sp = (*rt.GoString)(unsafe.Pointer(&s))
+    rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
+    assert.Equal(t, -int(types.ERR_INVALID_UNICODE), rv)
+    assert.Equal(t, 14, ep)
+}
+
+func TestNative_DoubleUnquote(t *testing.T) {
+    s := `hello\\b\\f\\n\\r\\t\\\\\\\"\\u2333world`
+    d := make([]byte, 0, len(s))
+    ep := -1
+    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
+    sp := (*rt.GoString)(unsafe.Pointer(&s))
+    rv := __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_DOUBLE_UNQUOTE)
+    if rv < 0 {
+        require.NoError(t, types.ParsingError(-rv))
+    }
+    dp.Len = rv
+    assert.Equal(t, -1, ep)
+    assert.Equal(t, "hello\b\f\n\r\t\\\"\u2333world", string(d))
+}
+
+func TestNative_UnquoteUnicodeReplacement(t *testing.T) {
+    s := `hello\ud800world`
+    d := make([]byte, 0, len(s))
+    ep := -1
+    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
+    sp := (*rt.GoString)(unsafe.Pointer(&s))
+    rv := __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_UNICODE_REPLACE)
+    if rv < 0 {
+        require.NoError(t, types.ParsingError(-rv))
+    }
+    dp.Len = rv
+    assert.Equal(t, -1, ep)
+    assert.Equal(t, "hello\ufffdworld", string(d))
+    s = `hello\ud800\ud800world`
+    d = make([]byte, 0, len(s))
+    ep = -1
+    dp = (*rt.GoSlice)(unsafe.Pointer(&d))
+    sp = (*rt.GoString)(unsafe.Pointer(&s))
+    rv = __unquote(sp.Ptr, sp.Len, dp.Ptr, &ep, types.F_UNICODE_REPLACE)
+    if rv < 0 {
+        require.NoError(t, types.ParsingError(-rv))
+    }
+    dp.Len = rv
+    assert.Equal(t, -1, ep)
+    assert.Equal(t, "hello\ufffd\ufffdworld", string(d))
+}
+
+func TestNative_HTMLEscape(t *testing.T) {
+    s := "hello\u2029\u2028<&>world"
+    d := make([]byte, 256)
+    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
+    sp := (*rt.GoString)(unsafe.Pointer(&s))
+    rv := __html_escape(sp.Ptr, sp.Len, dp.Ptr, &dp.Len)
+    if rv < 0 {
+        require.NoError(t, types.ParsingError(-rv))
+    }
+    assert.Equal(t, len(s), rv)
+    assert.Equal(t, 40, len(d))
+    assert.Equal(t, `hello\u2029\u2028\u003c\u0026\u003eworld`, string(d))
+}
+
+func TestNative_HTMLEscapeNoMem(t *testing.T) {
+    s := "hello\u2029\u2028<&>world"
+    d := make([]byte, 10)
+    dp := (*rt.GoSlice)(unsafe.Pointer(&d))
+    sp := (*rt.GoString)(unsafe.Pointer(&s))
+    rv := __html_escape(sp.Ptr, sp.Len, dp.Ptr, &dp.Len)
+    assert.Equal(t, -6, rv)
+    assert.Equal(t, 5, len(d))
+    assert.Equal(t, `hello`, string(d))
+}
+
+func TestNative_Vstring(t *testing.T) {
+    var v types.JsonState
+    i := 0
+    s := `test"test\n2"`
+    __vstring(&s, &i, &v, 0)
+    assert.Equal(t, 5, i)
+    assert.Equal(t, -1, v.Ep)
+    assert.Equal(t, int64(0), v.Iv)
+    __vstring(&s, &i, &v, 0)
+    assert.Equal(t, 13, i)
+    assert.Equal(t, 9, v.Ep)
+    assert.Equal(t, int64(5), v.Iv)
+}
+
+func TestNative_Vstring_ValidUnescapedChars(t *testing.T) {
+    var v types.JsonState
+    valid := uint64(types.F_VALIDATE_STRING)
+    i := 0
+    s := "test\x1f\""
+    __vstring(&s, &i, &v, valid)
+    assert.Equal(t, -int(types.ERR_INVALID_CHAR), int(v.Vt))
+}
+
+func TestNative_VstringEscapeEOF(t *testing.T) {
+    var v types.JsonState
+    i := 0
+    s := `xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"x`
+    __vstring(&s, &i, &v, 0)
+    assert.Equal(t, 95, i)
+    assert.Equal(t, 63, v.Ep)
+    assert.Equal(t, int64(0), v.Iv)
+}
+
+func TestNative_VstringHangUpOnRandomData(t *testing.T) {
+    v, e := hex.DecodeString(
+        "228dc61efd54ef80a908fb6026b7f2d5f92a257ba8b347c995f259eb8685376a" +
+        "8c4500262d9c308b3f3ec2577689cf345d9f86f9b5d18d3e463bec5c22df2d2e" +
+        "4506010eba1dae7278",
+    )
+    assert.Nil(t, e)
+    p := 1
+    s := rt.Mem2Str(v)
+    var js types.JsonState
+    __vstring(&s, &p, &js, 0)
+    fmt.Printf("js: %s\n", spew.Sdump(js))
+}
+
+func TestNative_Vnumber(t *testing.T) {
+    var v types.JsonState
+    i := 0
+    s := "1234"
+    __vnumber(&s, &i, &v)
+    assert.Equal(t, 4, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, int64(1234), v.Iv)
+    assert.Equal(t, types.V_INTEGER, v.Vt)
+    i = 0
+    s = "1.234"
+    __vnumber(&s, &i, &v)
+    assert.Equal(t, 5, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, 1.234, v.Dv)
+    assert.Equal(t, types.V_DOUBLE, v.Vt)
+    i = 0
+    s = "1.234e5"
+    __vnumber(&s, &i, &v)
+    assert.Equal(t, 7, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, 1.234e5, v.Dv)
+    assert.Equal(t, types.V_DOUBLE, v.Vt)
+    i = 0
+    s = "0.0125"
+    __vnumber(&s, &i, &v)
+    assert.Equal(t, 6, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, 0.0125, v.Dv)
+    assert.Equal(t, types.V_DOUBLE, v.Vt)
+    i = 0
+    s = "100000000000000000000"
+    __vnumber(&s, &i, &v)
+    assert.Equal(t, 21, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, 100000000000000000000.0, v.Dv)
+    assert.Equal(t, types.V_DOUBLE, v.Vt)
+    i = 0
+    s = "999999999999999900000"
+    __vnumber(&s, &i, &v)
+    assert.Equal(t, 21, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, 999999999999999900000.0, v.Dv)
+    assert.Equal(t, types.V_DOUBLE, v.Vt)
+    i = 0
+    s = "-1.234"
+    __vnumber(&s, &i, &v)
+    assert.Equal(t, 6, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, -1.234, v.Dv)
+    assert.Equal(t, types.V_DOUBLE, v.Vt)
+}
+
+func TestNative_Vsigned(t *testing.T) {
+    var v types.JsonState
+    i := 0
+    s := "1234"
+    __vsigned(&s, &i, &v)
+    assert.Equal(t, 4, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, int64(1234), v.Iv)
+    assert.Equal(t, types.V_INTEGER, v.Vt)
+    i = 0
+    s = "-1234"
+    __vsigned(&s, &i, &v)
+    assert.Equal(t, 5, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, int64(-1234), v.Iv)
+    assert.Equal(t, types.V_INTEGER, v.Vt)
+    i = 0
+    s = "9223372036854775807"
+    __vsigned(&s, &i, &v)
+    assert.Equal(t, 19, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, int64(math.MaxInt64), v.Iv)
+    assert.Equal(t, types.V_INTEGER, v.Vt)
+    i = 0
+    s = "-9223372036854775808"
+    __vsigned(&s, &i, &v)
+    assert.Equal(t, 20, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, int64(math.MinInt64), v.Iv)
+    assert.Equal(t, types.V_INTEGER, v.Vt)
+    i = 0
+    s = "9223372036854775808"
+    __vsigned(&s, &i, &v)
+    assert.Equal(t, 18, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt)
+    i = 0
+    s = "-9223372036854775809"
+    __vsigned(&s, &i, &v)
+    assert.Equal(t, 19, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt)
+    i = 0
+    s = "1.234"
+    __vsigned(&s, &i, &v)
+    assert.Equal(t, 1, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
+    i = 0
+    s = "0.0125"
+    __vsigned(&s, &i, &v)
+    assert.Equal(t, 1, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
+    i = 0
+    s = "-1234e5"
+    __vsigned(&s, &i, &v)
+    assert.Equal(t, 5, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
+    i = 0
+    s = "-1234e-5"
+    __vsigned(&s, &i, &v)
+    assert.Equal(t, 5, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
+}
+
+func TestNative_Vunsigned(t *testing.T) {
+    var v types.JsonState
+    i := 0
+    s := "1234"
+    __vunsigned(&s, &i, &v)
+    assert.Equal(t, 4, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, int64(1234), v.Iv)
+    assert.Equal(t, types.V_INTEGER, v.Vt)
+    i = 0
+    s = "18446744073709551615"
+    __vunsigned(&s, &i, &v)
+    assert.Equal(t, 20, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, ^int64(0), v.Iv)
+    assert.Equal(t, types.V_INTEGER, v.Vt)
+    i = 0
+    s = "18446744073709551616"
+    __vunsigned(&s, &i, &v)
+    assert.Equal(t, 19, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, types.ValueType(-int(types.ERR_INTEGER_OVERFLOW)), v.Vt)
+    i = 0
+    s = "-1234"
+    __vunsigned(&s, &i, &v)
+    assert.Equal(t, 0, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
+    i = 0
+    s = "1.234"
+    __vunsigned(&s, &i, &v)
+    assert.Equal(t, 1, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
+    i = 0
+    s = "0.0125"
+    __vunsigned(&s, &i, &v)
+    assert.Equal(t, 1, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
+    i = 0
+    s = "1234e5"
+    __vunsigned(&s, &i, &v)
+    assert.Equal(t, 4, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
+    i = 0
+    s = "-1234e5"
+    __vunsigned(&s, &i, &v)
+    assert.Equal(t, 0, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
+    i = 0
+    s = "-1.234e5"
+    __vunsigned(&s, &i, &v)
+    assert.Equal(t, 0, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
+    i = 0
+    s = "-1.234e-5"
+    __vunsigned(&s, &i, &v)
+    assert.Equal(t, 0, i)
+    assert.Equal(t, 0, v.Ep)
+    assert.Equal(t, types.ValueType(-int(types.ERR_INVALID_NUMBER_FMT)), v.Vt)
+}
+
+func TestNative_SkipOne(t *testing.T) {
+    p := 0
+    s := ` {"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
+    q := __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    assert.Equal(t, 42, p)
+    assert.Equal(t, 1, q)
+    p = 0
+    s = `1 2.5 -3 "asdf\nqwer" true false null {} []`
+    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    assert.Equal(t, 1, p)
+    assert.Equal(t, 0, q)
+    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    assert.Equal(t, 5, p)
+    assert.Equal(t, 2, q)
+    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    assert.Equal(t, 8, p)
+    assert.Equal(t, 6, q)
+    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    assert.Equal(t, 21, p)
+    assert.Equal(t, 9, q)
+    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    assert.Equal(t, 26, p)
+    assert.Equal(t, 22, q)
+    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    assert.Equal(t, 32, p)
+    assert.Equal(t, 27, q)
+    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    assert.Equal(t, 37, p)
+    assert.Equal(t, 33, q)
+    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    assert.Equal(t, 40, p)
+    assert.Equal(t, 38, q)
+    q = __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+    assert.Equal(t, 43, p)
+    assert.Equal(t, 41, q)
+}
+
+func TestNative_SkipOne_Error(t *testing.T) {
+    for _, s := range([]string{
+        "-", "+", "0.", "0. ", "+1", "0.0e ", "9e+", "0e-",
+        "tru", "fals", "nul", "trux", "fals ", 
+        `"asdf`, `"\\\"`,
+    }) {
+        p := 0
+        q := __skip_one(&s, &p, &types.StateMachine{}, uint64(0))
+        assert.True(t, q < 0)
+    }
+}
+
+func TestNative_SkipArray(t *testing.T) {
+    p := 0
+    s := `null, true, false, 1, 2.0, -3, {"asdf": "wqer"}],`
+    __skip_array(&s, &p, &types.StateMachine{}, uint64(0))
+    assert.Equal(t, p, 48)
+}
+
+func TestNative_SkipObject(t *testing.T) {
+    p := 0
+    s := `"asdf": "wqer"},`
+    __skip_object(&s, &p, &types.StateMachine{}, uint64(0))
+    assert.Equal(t, p, 15)
+}
+
+func TestNative_SkipNumber(t *testing.T) {
+    p := 0
+    s := `-1.23e+12`
+    q := __skip_number(&s, &p)
+    assert.Equal(t, 9, p)
+    assert.Equal(t, 0, q)
+}
+
+func TestNative_SkipOneFast(t *testing.T) {
+    p := 0
+    s := ` {"asdf": [null, true, false, 1, 2.0, -3]}, 1234.5`
+    q := __skip_one_fast(&s, &p)
+    assert.Equal(t, 42, p)
+    assert.Equal(t, 1, q)
+    p = 0
+    s = `1, 2.5, -3, "asdf\nqwer", true, false, null, {}, [],`
+    q = __skip_one_fast(&s, &p)
+    assert.Equal(t, 1, p)
+    assert.Equal(t, 0, q)
+    p += 1
+    q = __skip_one_fast(&s, &p)
+    assert.Equal(t, 6, p)
+    assert.Equal(t, 3, q)
+    p += 1
+    q = __skip_one_fast(&s, &p)
+    assert.Equal(t, 10, p)
+    assert.Equal(t, 8, q)
+    p += 1
+    q = __skip_one_fast(&s, &p)
+    assert.Equal(t, 24, p)
+    assert.Equal(t, 12, q)
+    p += 1
+    q = __skip_one_fast(&s, &p)
+    assert.Equal(t, 30, p)
+    assert.Equal(t, 26, q)
+    p += 1
+    q = __skip_one_fast(&s, &p)
+    assert.Equal(t, 37, p)
+    assert.Equal(t, 32, q)
+    p += 1
+    q = __skip_one_fast(&s, &p)
+    assert.Equal(t, 43, p)
+    assert.Equal(t, 39, q)
+    p += 1
+    q = __skip_one_fast(&s, &p)
+    assert.Equal(t, 47, p)
+    assert.Equal(t, 45, q)
+    p += 1
+    q = __skip_one_fast(&s, &p)
+    assert.Equal(t, 51, p)
+    assert.Equal(t, 49, q)
+}
+
+func TestNative_SkipOneFast_Error(t *testing.T) {
+    for _, s := range([]string{
+        "{{", "[{",  "{{}",
+        `"asdf`, `"\\\"`,
+    }) {
+        p := 0
+        q := __skip_one_fast(&s, &p)
+        assert.True(t, q < 0)
+    }
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/internal/native/native_export_amd64.tmpl b/vendor/github.com/bytedance/sonic/internal/native/native_export_amd64.tmpl
new file mode 100644
index 000000000..c7a10de94
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/native_export_amd64.tmpl
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package {{PACKAGE}}
+
+var (
+    S_f64toa = _subr__f64toa
+    S_f32toa = _subr__f32toa
+    S_i64toa = _subr__i64toa
+    S_u64toa = _subr__u64toa
+    S_lspace = _subr__lspace
+)
+
+var (
+    S_quote   = _subr__quote
+    S_unquote = _subr__unquote
+)
+
+var (
+    S_value     = _subr__value
+    S_vstring   = _subr__vstring
+    S_vnumber   = _subr__vnumber
+    S_vsigned   = _subr__vsigned
+    S_vunsigned = _subr__vunsigned
+)
+
+var (
+    S_skip_one    = _subr__skip_one
+    S_skip_one_fast = _subr__skip_one_fast
+    S_skip_array  = _subr__skip_array
+    S_skip_object = _subr__skip_object
+    S_skip_number = _subr__skip_number
+    S_get_by_path = _subr__get_by_path
+)
diff --git a/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.go
new file mode 100644
index 000000000..4cd4b0c7f
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.go
@@ -0,0 +1,135 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sse
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native/types`
+)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __i64toa(out *byte, val int64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __u64toa(out *byte, val uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __f64toa(out *byte, val float64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __f32toa(out *byte, val float32) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __lspace(sp unsafe.Pointer, nb int, off int) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __quote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __html_escape(sp unsafe.Pointer, nb int, dp unsafe.Pointer, dn *int) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __unquote(sp unsafe.Pointer, nb int, dp unsafe.Pointer, ep *int, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __value(s unsafe.Pointer, n int, p int, v *types.JsonState, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __vstring(s *string, p *int, v *types.JsonState, flags uint64)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __vnumber(s *string, p *int, v *types.JsonState)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __vsigned(s *string, p *int, v *types.JsonState)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __vunsigned(s *string, p *int, v *types.JsonState)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_one(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_one_fast(s *string, p *int) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_array(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_object(s *string, p *int, m *types.StateMachine, flags uint64) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __skip_number(s *string, p *int) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __validate_one(s *string, p *int, m *types.StateMachine) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __get_by_path(s *string, p *int, path *[]interface{}) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __validate_utf8(s *string, p *int, m *types.StateMachine) (ret int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __validate_utf8_fast(s *string)  (ret int)
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.s b/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.s
new file mode 100644
index 000000000..08a68f957
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/sse/native_amd64.s
@@ -0,0 +1,15078 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+#include "go_asm.h"
+#include "funcdata.h"
+#include "textflag.h"
+
+TEXT ·__native_entry__(SB), NOSPLIT, $0
+	NO_LOCAL_POINTERS
+	LONG $0xf9058d48; WORD $0xffff; BYTE $0xff // leaq         $-7(%rip), %rax
+	LONG $0x24448948; BYTE $0x08               // movq         %rax, $8(%rsp)
+	BYTE $0xc3                                 // retq
+	WORD $0x0000; BYTE $0x00                   // .p2align 4, 0x00
+
+LCPI0_0:
+	QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, '                '
+
+LCPI0_1:
+	QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'
+
+LCPI0_2:
+	QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n'
+
+LCPI0_3:
+	QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r'
+
+	// .p2align 4, 0x90
+_lspace:
+	BYTE $0x55                                         // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                           // movq         %rsp, %rbp
+	WORD $0x8948; BYTE $0xd0                           // movq         %rdx, %rax
+	LONG $0x17148d4c                                   // leaq         (%rdi,%rdx), %r10
+	WORD $0x8948; BYTE $0xf2                           // movq         %rsi, %rdx
+	WORD $0x2948; BYTE $0xc2                           // subq         %rax, %rdx
+	LONG $0x0066840f; WORD $0x0000                     // je           LBB0_7, $102(%rip)
+	WORD $0x8944; BYTE $0xd1                           // movl         %r10d, %ecx
+	WORD $0xe183; BYTE $0x0f                           // andl         $15, %ecx
+	LONG $0x005a840f; WORD $0x0000                     // je           LBB0_7, $90(%rip)
+	LONG $0x014f8d4c                                   // leaq         $1(%rdi), %r9
+	LONG $0xff4e8d48                                   // leaq         $-1(%rsi), %rcx
+	QUAD $0x000100002600b849; WORD $0x0000             // movabsq      $4294977024, %r8
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB0_3:
+	LONG $0x0714be0f               // movsbl       (%rdi,%rax), %edx
+	WORD $0xfa83; BYTE $0x20       // cmpl         $32, %edx
+	LONG $0x0100870f; WORD $0x0000 // ja           LBB0_22, $256(%rip)
+	LONG $0xd0a30f49               // btq          %rdx, %r8
+	LONG $0x00f6830f; WORD $0x0000 // jae          LBB0_22, $246(%rip)
+	LONG $0x01508d48               // leaq         $1(%rax), %rdx
+	WORD $0x3948; BYTE $0xc1       // cmpq         %rax, %rcx
+	LONG $0x000f840f; WORD $0x0000 // je           LBB0_6, $15(%rip)
+	WORD $0x0144; BYTE $0xc8       // addl         %r9d, %eax
+	WORD $0xe083; BYTE $0x0f       // andl         $15, %eax
+	WORD $0x8948; BYTE $0xd0       // movq         %rdx, %rax
+	LONG $0xffcd850f; WORD $0xffff // jne          LBB0_3, $-51(%rip)
+
+LBB0_6:
+	LONG $0x17148d4c         // leaq         (%rdi,%rdx), %r10
+	WORD $0x2948; BYTE $0xd6 // subq         %rdx, %rsi
+	WORD $0x8948; BYTE $0xf2 // movq         %rsi, %rdx
+
+LBB0_7:
+	LONG $0x10fa8348               // cmpq         $16, %rdx
+	LONG $0x007a820f; WORD $0x0000 // jb           LBB0_13, $122(%rip)
+	WORD $0x8948; BYTE $0xfe       // movq         %rdi, %rsi
+	WORD $0x294c; BYTE $0xd6       // subq         %r10, %rsi
+	QUAD $0xffffff2b056f0f66       // movdqa       $-213(%rip), %xmm0  /* LCPI0_0(%rip) */
+	QUAD $0xffffff330d6f0f66       // movdqa       $-205(%rip), %xmm1  /* LCPI0_1(%rip) */
+	QUAD $0xffffff3b156f0f66       // movdqa       $-197(%rip), %xmm2  /* LCPI0_2(%rip) */
+	QUAD $0xffffff431d6f0f66       // movdqa       $-189(%rip), %xmm3  /* LCPI0_3(%rip) */
+	WORD $0x9090; BYTE $0x90       // .p2align 4, 0x90
+
+LBB0_9:
+	LONG $0x6f0f4166; BYTE $0x22   // movdqa       (%r10), %xmm4
+	LONG $0xec6f0f66               // movdqa       %xmm4, %xmm5
+	LONG $0xe8740f66               // pcmpeqb      %xmm0, %xmm5
+	LONG $0xf46f0f66               // movdqa       %xmm4, %xmm6
+	LONG $0xf1740f66               // pcmpeqb      %xmm1, %xmm6
+	LONG $0xf5eb0f66               // por          %xmm5, %xmm6
+	LONG $0xec6f0f66               // movdqa       %xmm4, %xmm5
+	LONG $0xea740f66               // pcmpeqb      %xmm2, %xmm5
+	LONG $0xe3740f66               // pcmpeqb      %xmm3, %xmm4
+	LONG $0xe5eb0f66               // por          %xmm5, %xmm4
+	LONG $0xe6eb0f66               // por          %xmm6, %xmm4
+	LONG $0xc4d70f66               // pmovmskb     %xmm4, %eax
+	LONG $0xfff88366               // cmpw         $-1, %ax
+	LONG $0x0064850f; WORD $0x0000 // jne          LBB0_10, $100(%rip)
+	LONG $0x10c28349               // addq         $16, %r10
+	LONG $0xf0c28348               // addq         $-16, %rdx
+	LONG $0xf0c68348               // addq         $-16, %rsi
+	LONG $0x0ffa8348               // cmpq         $15, %rdx
+	LONG $0xffaf870f; WORD $0xffff // ja           LBB0_9, $-81(%rip)
+
+LBB0_13:
+	WORD $0x8548; BYTE $0xd2               // testq        %rdx, %rdx
+	LONG $0x003d840f; WORD $0x0000         // je           LBB0_20, $61(%rip)
+	LONG $0x12048d4d                       // leaq         (%r10,%rdx), %r8
+	WORD $0xc031                           // xorl         %eax, %eax
+	QUAD $0x000100002600b949; WORD $0x0000 // movabsq      $4294977024, %r9
+	LONG $0x90909090; WORD $0x9090         // .p2align 4, 0x90
+
+LBB0_15:
+	LONG $0x34be0f41; BYTE $0x02   // movsbl       (%r10,%rax), %esi
+	WORD $0xfe83; BYTE $0x20       // cmpl         $32, %esi
+	LONG $0x002e870f; WORD $0x0000 // ja           LBB0_17, $46(%rip)
+	LONG $0xf1a30f49               // btq          %rsi, %r9
+	LONG $0x0024830f; WORD $0x0000 // jae          LBB0_17, $36(%rip)
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3948; BYTE $0xc2       // cmpq         %rax, %rdx
+	LONG $0xffdc850f; WORD $0xffff // jne          LBB0_15, $-36(%rip)
+	WORD $0x894d; BYTE $0xc2       // movq         %r8, %r10
+
+LBB0_20:
+	WORD $0x2949; BYTE $0xfa // subq         %rdi, %r10
+
+LBB0_21:
+	WORD $0x894c; BYTE $0xd0 // movq         %r10, %rax
+
+LBB0_22:
+	BYTE $0x5d // popq         %rbp
+	BYTE $0xc3 // retq
+
+LBB0_10:
+	WORD $0xb70f; BYTE $0xc0 // movzwl       %ax, %eax
+	WORD $0xd0f7             // notl         %eax
+	WORD $0xbc0f; BYTE $0xc0 // bsfl         %eax, %eax
+	WORD $0x2948; BYTE $0xf0 // subq         %rsi, %rax
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB0_17:
+	WORD $0x2949; BYTE $0xfa             // subq         %rdi, %r10
+	WORD $0x0149; BYTE $0xc2             // addq         %rax, %r10
+	LONG $0xffffe3e9; BYTE $0xff         // jmp          LBB0_21, $-29(%rip)
+	QUAD $0x0000000000000000; BYTE $0x00 // .p2align 4, 0x00
+
+LCPI1_0:
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+
+	// .p2align 4, 0x90
+_f64toa:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	BYTE $0x50                                 // pushq        %rax
+	LONG $0x7e0f4866; BYTE $0xc2               // movq         %xmm0, %rdx
+	WORD $0x8948; BYTE $0xd0                   // movq         %rdx, %rax
+	LONG $0x34e8c148                           // shrq         $52, %rax
+	LONG $0x0007ff25; BYTE $0x00               // andl         $2047, %eax
+	LONG $0x0007ff3d; BYTE $0x00               // cmpl         $2047, %eax
+	LONG $0x0acb840f; WORD $0x0000             // je           LBB1_1, $2763(%rip)
+	WORD $0x8948; BYTE $0xfe                   // movq         %rdi, %rsi
+	WORD $0x07c6; BYTE $0x2d                   // movb         $45, (%rdi)
+	WORD $0x8949; BYTE $0xd5                   // movq         %rdx, %r13
+	LONG $0x3fedc149                           // shrq         $63, %r13
+	LONG $0x2f3c8d4e                           // leaq         (%rdi,%r13), %r15
+	QUAD $0x00000000550c8d48                   // leaq         (,%rdx,2), %rcx
+	WORD $0x8548; BYTE $0xc9                   // testq        %rcx, %rcx
+	LONG $0x01f5840f; WORD $0x0000             // je           LBB1_3, $501(%rip)
+	QUAD $0xffffffffffffbf48; WORD $0x000f     // movabsq      $4503599627370495, %rdi
+	WORD $0x2148; BYTE $0xfa                   // andq         %rdi, %rdx
+	WORD $0xc085                               // testl        %eax, %eax
+	LONG $0xd0758948                           // movq         %rsi, $-48(%rbp)
+	LONG $0x0a97840f; WORD $0x0000             // je           LBB1_5, $2711(%rip)
+	WORD $0xff48; BYTE $0xc7                   // incq         %rdi
+	WORD $0x0948; BYTE $0xd7                   // orq          %rdx, %rdi
+	LONG $0xfbcdb08d; WORD $0xffff             // leal         $-1075(%rax), %esi
+	LONG $0xfc01888d; WORD $0xffff             // leal         $-1023(%rax), %ecx
+	WORD $0xf983; BYTE $0x34                   // cmpl         $52, %ecx
+	LONG $0x001d870f; WORD $0x0000             // ja           LBB1_6, $29(%rip)
+	LONG $0x000433b9; BYTE $0x00               // movl         $1075, %ecx
+	WORD $0xc129                               // subl         %eax, %ecx
+	LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rbx
+	WORD $0xd348; BYTE $0xe3                   // shlq         %cl, %rbx
+	WORD $0xf748; BYTE $0xd3                   // notq         %rbx
+	WORD $0x8548; BYTE $0xdf                   // testq        %rbx, %rdi
+	LONG $0x0421840f; WORD $0x0000             // je           LBB1_11, $1057(%rip)
+
+LBB1_6:
+	WORD $0x8548; BYTE $0xd2                   // testq        %rdx, %rdx
+	WORD $0x940f; BYTE $0xc1                   // sete         %cl
+	WORD $0xf883; BYTE $0x02                   // cmpl         $2, %eax
+	WORD $0x930f; BYTE $0xc0                   // setae        %al
+	WORD $0xc820                               // andb         %cl, %al
+	QUAD $0x00000000bd0c8d4c                   // leaq         (,%rdi,4), %r9
+	WORD $0xb60f; BYTE $0xc0                   // movzbl       %al, %eax
+	LONG $0xb81c8d48                           // leaq         (%rax,%rdi,4), %rbx
+	LONG $0xfec38348                           // addq         $-2, %rbx
+	LONG $0x4413ce69; WORD $0x0013             // imull        $1262611, %esi, %ecx
+	LONG $0x01918d44; WORD $0xf801; BYTE $0xff // leal         $-524031(%rcx), %r10d
+	WORD $0xc084                               // testb        %al, %al
+	LONG $0xd1440f44                           // cmovel       %ecx, %r10d
+	QUAD $0x00000002bd048d4c                   // leaq         $2(,%rdi,4), %r8
+	LONG $0x16fac141                           // sarl         $22, %r10d
+	LONG $0xb1ca6941; WORD $0xe56c; BYTE $0xff // imull        $-1741647, %r10d, %ecx
+	WORD $0xe9c1; BYTE $0x13                   // shrl         $19, %ecx
+	WORD $0xf101                               // addl         %esi, %ecx
+	LONG $0x000124b8; BYTE $0x00               // movl         $292, %eax
+	WORD $0x2944; BYTE $0xd0                   // subl         %r10d, %eax
+	LONG $0x04e0c148                           // shlq         $4, %rax
+	LONG $0xd4158d48; WORD $0x00b2; BYTE $0x00 // leaq         $45780(%rip), %rdx  /* _pow10_ceil_sig.g(%rip) */
+	LONG $0x101c8b4c                           // movq         (%rax,%rdx), %r11
+	LONG $0x10748b4c; BYTE $0x08               // movq         $8(%rax,%rdx), %r14
+	WORD $0xc1fe                               // incb         %cl
+	WORD $0xd348; BYTE $0xe3                   // shlq         %cl, %rbx
+	WORD $0x8948; BYTE $0xd8                   // movq         %rbx, %rax
+	WORD $0xf749; BYTE $0xe6                   // mulq         %r14
+	WORD $0x8948; BYTE $0xd6                   // movq         %rdx, %rsi
+	WORD $0x8948; BYTE $0xd8                   // movq         %rbx, %rax
+	WORD $0xf749; BYTE $0xe3                   // mulq         %r11
+	WORD $0x0148; BYTE $0xf0                   // addq         %rsi, %rax
+	LONG $0x00d28348                           // adcq         $0, %rdx
+	WORD $0xf631                               // xorl         %esi, %esi
+	LONG $0xfffea948; WORD $0xffff             // testq        $-2, %rax
+	LONG $0xc6950f40                           // setne        %sil
+	WORD $0x0948; BYTE $0xd6                   // orq          %rdx, %rsi
+	WORD $0xd349; BYTE $0xe1                   // shlq         %cl, %r9
+	WORD $0x894c; BYTE $0xc8                   // movq         %r9, %rax
+	WORD $0xf749; BYTE $0xe6                   // mulq         %r14
+	WORD $0x8948; BYTE $0xd3                   // movq         %rdx, %rbx
+	WORD $0x894c; BYTE $0xc8                   // movq         %r9, %rax
+	WORD $0xf749; BYTE $0xe3                   // mulq         %r11
+	WORD $0x8949; BYTE $0xd1                   // movq         %rdx, %r9
+	WORD $0x0148; BYTE $0xd8                   // addq         %rbx, %rax
+	LONG $0x00d18349                           // adcq         $0, %r9
+	WORD $0xdb31                               // xorl         %ebx, %ebx
+	LONG $0xfffea948; WORD $0xffff             // testq        $-2, %rax
+	WORD $0x950f; BYTE $0xc3                   // setne        %bl
+	WORD $0x094c; BYTE $0xcb                   // orq          %r9, %rbx
+	WORD $0xd349; BYTE $0xe0                   // shlq         %cl, %r8
+	WORD $0x894c; BYTE $0xc0                   // movq         %r8, %rax
+	WORD $0xf749; BYTE $0xe6                   // mulq         %r14
+	WORD $0x8948; BYTE $0xd1                   // movq         %rdx, %rcx
+	WORD $0x894c; BYTE $0xc0                   // movq         %r8, %rax
+	WORD $0xf749; BYTE $0xe3                   // mulq         %r11
+	WORD $0x0148; BYTE $0xc8                   // addq         %rcx, %rax
+	LONG $0x00d28348                           // adcq         $0, %rdx
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0xfffea948; WORD $0xffff             // testq        $-2, %rax
+	WORD $0x950f; BYTE $0xc1                   // setne        %cl
+	WORD $0x0948; BYTE $0xd1                   // orq          %rdx, %rcx
+	WORD $0xe783; BYTE $0x01                   // andl         $1, %edi
+	WORD $0x0148; BYTE $0xfe                   // addq         %rdi, %rsi
+	WORD $0x2948; BYTE $0xf9                   // subq         %rdi, %rcx
+	LONG $0x28fb8348                           // cmpq         $40, %rbx
+	LONG $0x0043820f; WORD $0x0000             // jb           LBB1_28, $67(%rip)
+	QUAD $0xcccccccccccdba48; WORD $0xcccc     // movabsq      $-3689348814741910323, %rdx
+	WORD $0x894c; BYTE $0xc8                   // movq         %r9, %rax
+	WORD $0xf748; BYTE $0xe2                   // mulq         %rdx
+	WORD $0x8948; BYTE $0xd7                   // movq         %rdx, %rdi
+	LONG $0x05efc148                           // shrq         $5, %rdi
+	QUAD $0x00000000fd048d48                   // leaq         (,%rdi,8), %rax
+	LONG $0x80148d48                           // leaq         (%rax,%rax,4), %rdx
+	WORD $0x3948; BYTE $0xd6                   // cmpq         %rdx, %rsi
+	LONG $0xc0970f41                           // seta         %r8b
+	LONG $0x80148d48                           // leaq         (%rax,%rax,4), %rdx
+	LONG $0x28c28348                           // addq         $40, %rdx
+	WORD $0xc031                               // xorl         %eax, %eax
+	WORD $0x3948; BYTE $0xca                   // cmpq         %rcx, %rdx
+	WORD $0x960f; BYTE $0xc2                   // setbe        %dl
+	WORD $0x3841; BYTE $0xd0                   // cmpb         %dl, %r8b
+	LONG $0x0134840f; WORD $0x0000             // je           LBB1_8, $308(%rip)
+
+LBB1_28:
+	WORD $0x894d; BYTE $0xc8       // movq         %r9, %r8
+	LONG $0x02e8c149               // shrq         $2, %r8
+	WORD $0x894c; BYTE $0xca       // movq         %r9, %rdx
+	LONG $0xfce28348               // andq         $-4, %rdx
+	WORD $0x3948; BYTE $0xd6       // cmpq         %rdx, %rsi
+	LONG $0xc7970f40               // seta         %dil
+	LONG $0x04728d48               // leaq         $4(%rdx), %rsi
+	WORD $0x3948; BYTE $0xce       // cmpq         %rcx, %rsi
+	WORD $0x960f; BYTE $0xc0       // setbe        %al
+	WORD $0x3040; BYTE $0xf8       // xorb         %dil, %al
+	LONG $0x0055840f; WORD $0x0000 // je           LBB1_29, $85(%rip)
+	LONG $0x02ca8348               // orq          $2, %rdx
+	LONG $0x000001bf; BYTE $0x00   // movl         $1, %edi
+	WORD $0x3948; BYTE $0xd3       // cmpq         %rdx, %rbx
+	LONG $0x000e870f; WORD $0x0000 // ja           LBB1_32, $14(%rip)
+	WORD $0x940f; BYTE $0xc0       // sete         %al
+	LONG $0x02e9c041               // shrb         $2, %r9b
+	WORD $0x2041; BYTE $0xc1       // andb         %al, %r9b
+	LONG $0xf9b60f41               // movzbl       %r9b, %edi
+
+LBB1_32:
+	WORD $0x014c; BYTE $0xc7               // addq         %r8, %rdi
+	QUAD $0x0001ffffffe0bc49; WORD $0x0000 // movabsq      $8589934560, %r12
+	QUAD $0x540be41f24848d49               // leaq         $1410065439(%r12), %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x003c870f; WORD $0x0000         // ja           LBB1_34, $60(%rip)
+	LONG $0x0000ece9; BYTE $0x00           // jmp          LBB1_40, $236(%rip)
+
+LBB1_3:
+	LONG $0x3007c641             // movb         $48, (%r15)
+	WORD $0x2941; BYTE $0xf7     // subl         %esi, %r15d
+	WORD $0xff41; BYTE $0xc7     // incl         %r15d
+	WORD $0x8944; BYTE $0xfb     // movl         %r15d, %ebx
+	LONG $0x000891e9; BYTE $0x00 // jmp          LBB1_123, $2193(%rip)
+
+LBB1_29:
+	WORD $0x3948; BYTE $0xf1               // cmpq         %rsi, %rcx
+	LONG $0xffd88349                       // sbbq         $-1, %r8
+	WORD $0x894c; BYTE $0xc7               // movq         %r8, %rdi
+	QUAD $0x0001ffffffe0bc49; WORD $0x0000 // movabsq      $8589934560, %r12
+	QUAD $0x540be41f24848d49               // leaq         $1410065439(%r12), %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x00b5860f; WORD $0x0000         // jbe          LBB1_40, $181(%rip)
+
+LBB1_34:
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0be8c148                       // shrq         $11, %rax
+	LONG $0x00000bba; BYTE $0x00           // movl         $11, %edx
+	LONG $0x0edd3d48; WORD $0x02e9         // cmpq         $48828125, %rax
+	LONG $0x0136820f; WORD $0x0000         // jb           LBB1_49, $310(%rip)
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0ce8c148                       // shrq         $12, %rax
+	LONG $0x00000cba; BYTE $0x00           // movl         $12, %edx
+	LONG $0x4a513d48; WORD $0x0e8d         // cmpq         $244140625, %rax
+	LONG $0x011e820f; WORD $0x0000         // jb           LBB1_49, $286(%rip)
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0de8c148                       // shrq         $13, %rax
+	LONG $0x00000dba; BYTE $0x00           // movl         $13, %edx
+	LONG $0x73953d48; WORD $0x48c2         // cmpq         $1220703125, %rax
+	LONG $0x0106820f; WORD $0x0000         // jb           LBB1_49, $262(%rip)
+	LONG $0x00000eba; BYTE $0x00           // movl         $14, %edx
+	QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq      $100000000000000, %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x00ee820f; WORD $0x0000         // jb           LBB1_49, $238(%rip)
+	LONG $0x00000fba; BYTE $0x00           // movl         $15, %edx
+	QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq      $1000000000000000, %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x00d6820f; WORD $0x0000         // jb           LBB1_49, $214(%rip)
+	QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq      $10000000000000000, %rax
+	WORD $0xd231                           // xorl         %edx, %edx
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	WORD $0x920f; BYTE $0xc2               // setb         %dl
+	WORD $0xf283; BYTE $0x11               // xorl         $17, %edx
+	LONG $0x0000bce9; BYTE $0x00           // jmp          LBB1_49, $188(%rip)
+
+LBB1_8:
+	WORD $0xd088                           // movb         %dl, %al
+	WORD $0x0148; BYTE $0xc7               // addq         %rax, %rdi
+	WORD $0xff41; BYTE $0xc2               // incl         %r10d
+	QUAD $0x0001ffffffe0bc49; WORD $0x0000 // movabsq      $8589934560, %r12
+	QUAD $0x540be41f24848d49               // leaq         $1410065439(%r12), %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0xff4b870f; WORD $0xffff         // ja           LBB1_34, $-181(%rip)
+
+LBB1_40:
+	LONG $0x000001ba; BYTE $0x00               // movl         $1, %edx
+	LONG $0x0aff8348                           // cmpq         $10, %rdi
+	LONG $0x008a820f; WORD $0x0000             // jb           LBB1_49, $138(%rip)
+	LONG $0x000002ba; BYTE $0x00               // movl         $2, %edx
+	LONG $0x64ff8348                           // cmpq         $100, %rdi
+	LONG $0x007b820f; WORD $0x0000             // jb           LBB1_49, $123(%rip)
+	LONG $0x000003ba; BYTE $0x00               // movl         $3, %edx
+	LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq         $1000, %rdi
+	LONG $0x0069820f; WORD $0x0000             // jb           LBB1_49, $105(%rip)
+	LONG $0x000004ba; BYTE $0x00               // movl         $4, %edx
+	LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq         $10000, %rdi
+	LONG $0x0057820f; WORD $0x0000             // jb           LBB1_49, $87(%rip)
+	LONG $0x000005ba; BYTE $0x00               // movl         $5, %edx
+	LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq         $100000, %rdi
+	LONG $0x0045820f; WORD $0x0000             // jb           LBB1_49, $69(%rip)
+	LONG $0x000006ba; BYTE $0x00               // movl         $6, %edx
+	LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq         $1000000, %rdi
+	LONG $0x0033820f; WORD $0x0000             // jb           LBB1_49, $51(%rip)
+	LONG $0x000007ba; BYTE $0x00               // movl         $7, %edx
+	LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq         $10000000, %rdi
+	LONG $0x0021820f; WORD $0x0000             // jb           LBB1_49, $33(%rip)
+	LONG $0x000008ba; BYTE $0x00               // movl         $8, %edx
+	LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq         $100000000, %rdi
+	LONG $0x000f820f; WORD $0x0000             // jb           LBB1_49, $15(%rip)
+	LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq         $1000000000, %rdi
+	LONG $0x00000aba; BYTE $0x00               // movl         $10, %edx
+	WORD $0xda83; BYTE $0x00                   // sbbl         $0, %edx
+
+LBB1_49:
+	LONG $0x12348d46                                       // leal         (%rdx,%r10), %r14d
+	LONG $0x12048d42                                       // leal         (%rdx,%r10), %eax
+	WORD $0xc083; BYTE $0xea                               // addl         $-22, %eax
+	WORD $0xf883; BYTE $0xe4                               // cmpl         $-28, %eax
+	LONG $0x00a4870f; WORD $0x0000                         // ja           LBB1_62, $164(%rip)
+	LONG $0x01678d4d                                       // leaq         $1(%r15), %r12
+	WORD $0x894c; BYTE $0xe6                               // movq         %r12, %rsi
+	LONG $0x00772ae8; BYTE $0x00                           // callq        _format_significand, $30506(%rip)
+	WORD $0x8948; BYTE $0xc3                               // movq         %rax, %rbx
+	LONG $0xd0558b4c                                       // movq         $-48(%rbp), %r10
+	WORD $0x294c; BYTE $0xd0                               // subq         %r10, %rax
+	WORD $0x294c; BYTE $0xe8                               // subq         %r13, %rax
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB1_51:
+	WORD $0xff48; BYTE $0xc8       // decq         %rax
+	LONG $0x30ff7b80               // cmpb         $48, $-1(%rbx)
+	LONG $0xff5b8d48               // leaq         $-1(%rbx), %rbx
+	LONG $0xffef840f; WORD $0xffff // je           LBB1_51, $-17(%rip)
+	LONG $0x4fb60f41; BYTE $0x01   // movzbl       $1(%r15), %ecx
+	WORD $0x8841; BYTE $0x0f       // movb         %cl, (%r15)
+	LONG $0x02f88348               // cmpq         $2, %rax
+	LONG $0x00088c0f; WORD $0x0000 // jl           LBB1_54, $8(%rip)
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	LONG $0x2404c641; BYTE $0x2e   // movb         $46, (%r12)
+
+LBB1_54:
+	WORD $0x03c6; BYTE $0x65       // movb         $101, (%rbx)
+	WORD $0x8545; BYTE $0xf6       // testl        %r14d, %r14d
+	LONG $0x011d8e0f; WORD $0x0000 // jle          LBB1_55, $285(%rip)
+	WORD $0xff41; BYTE $0xce       // decl         %r14d
+	LONG $0x2b0143c6               // movb         $43, $1(%rbx)
+	WORD $0x8944; BYTE $0xf0       // movl         %r14d, %eax
+	WORD $0xf883; BYTE $0x64       // cmpl         $100, %eax
+	LONG $0x011f820f; WORD $0x0000 // jb           LBB1_59, $287(%rip)
+
+LBB1_58:
+	WORD $0xc189                               // movl         %eax, %ecx
+	LONG $0xcccccdba; BYTE $0xcc               // movl         $3435973837, %edx
+	LONG $0xd1af0f48                           // imulq        %rcx, %rdx
+	LONG $0x23eac148                           // shrq         $35, %rdx
+	WORD $0x0c8d; BYTE $0x12                   // leal         (%rdx,%rdx), %ecx
+	WORD $0x0c8d; BYTE $0x89                   // leal         (%rcx,%rcx,4), %ecx
+	WORD $0xc829                               // subl         %ecx, %eax
+	LONG $0x980d8d48; WORD $0x00ae; BYTE $0x00 // leaq         $44696(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x510cb70f                           // movzwl       (%rcx,%rdx,2), %ecx
+	LONG $0x024b8966                           // movw         %cx, $2(%rbx)
+	WORD $0x300c                               // orb          $48, %al
+	WORD $0x4388; BYTE $0x04                   // movb         %al, $4(%rbx)
+	LONG $0x05c38348                           // addq         $5, %rbx
+	LONG $0x000663e9; BYTE $0x00               // jmp          LBB1_122, $1635(%rip)
+
+LBB1_62:
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0x0105880f; WORD $0x0000 // js           LBB1_63, $261(%rip)
+	WORD $0x8945; BYTE $0xf6       // movl         %r14d, %r14d
+	LONG $0x371c8d4b               // leaq         (%r15,%r14), %rbx
+	WORD $0x894c; BYTE $0xfe       // movq         %r15, %rsi
+	LONG $0x00068ae8; BYTE $0x00   // callq        _format_integer, $1674(%rip)
+	WORD $0x3948; BYTE $0xd8       // cmpq         %rbx, %rax
+	LONG $0x0151830f; WORD $0x0000 // jae          LBB1_103, $337(%rip)
+	LONG $0xd0558b4c               // movq         $-48(%rbp), %r10
+	WORD $0x014d; BYTE $0xd5       // addq         %r10, %r13
+	WORD $0x014d; BYTE $0xf5       // addq         %r14, %r13
+	WORD $0x2949; BYTE $0xc5       // subq         %rax, %r13
+	LONG $0x08fd8349               // cmpq         $8, %r13
+	LONG $0x01ee830f; WORD $0x0000 // jae          LBB1_105, $494(%rip)
+
+LBB1_120:
+	WORD $0x8948; BYTE $0xc2     // movq         %rax, %rdx
+	LONG $0x000302e9; BYTE $0x00 // jmp          LBB1_121, $770(%rip)
+
+LBB1_11:
+	WORD $0xd348; BYTE $0xef               // shrq         %cl, %rdi
+	QUAD $0x0001ffffffe0b848; WORD $0x0000 // movabsq      $8589934560, %rax
+	LONG $0xe41f0548; WORD $0x540b         // addq         $1410065439, %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x012d860f; WORD $0x0000         // jbe          LBB1_17, $301(%rip)
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0be8c148                       // shrq         $11, %rax
+	LONG $0x00000bba; BYTE $0x00           // movl         $11, %edx
+	LONG $0x0edd3d48; WORD $0x02e9         // cmpq         $48828125, %rax
+	LONG $0x019f820f; WORD $0x0000         // jb           LBB1_27, $415(%rip)
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0ce8c148                       // shrq         $12, %rax
+	LONG $0x00000cba; BYTE $0x00           // movl         $12, %edx
+	LONG $0x4a513d48; WORD $0x0e8d         // cmpq         $244140625, %rax
+	LONG $0x0187820f; WORD $0x0000         // jb           LBB1_27, $391(%rip)
+	WORD $0x8948; BYTE $0xf8               // movq         %rdi, %rax
+	LONG $0x0de8c148                       // shrq         $13, %rax
+	LONG $0x00000dba; BYTE $0x00           // movl         $13, %edx
+	LONG $0x73953d48; WORD $0x48c2         // cmpq         $1220703125, %rax
+	LONG $0x016f820f; WORD $0x0000         // jb           LBB1_27, $367(%rip)
+	LONG $0x00000eba; BYTE $0x00           // movl         $14, %edx
+	QUAD $0x5af3107a4000b848; WORD $0x0000 // movabsq      $100000000000000, %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x0157820f; WORD $0x0000         // jb           LBB1_27, $343(%rip)
+	QUAD $0x8d7ea4c68000b848; WORD $0x0003 // movabsq      $1000000000000000, %rax
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x000010ba; BYTE $0x00           // movl         $16, %edx
+
+LBB1_26:
+	WORD $0xda83; BYTE $0x00     // sbbl         $0, %edx
+	LONG $0x00013de9; BYTE $0x00 // jmp          LBB1_27, $317(%rip)
+
+LBB1_55:
+	LONG $0x2d0143c6               // movb         $45, $1(%rbx)
+	LONG $0x000001b8; BYTE $0x00   // movl         $1, %eax
+	WORD $0x2944; BYTE $0xf0       // subl         %r14d, %eax
+	WORD $0xf883; BYTE $0x64       // cmpl         $100, %eax
+	LONG $0xfee1830f; WORD $0xffff // jae          LBB1_58, $-287(%rip)
+
+LBB1_59:
+	WORD $0xf883; BYTE $0x0a                   // cmpl         $10, %eax
+	LONG $0x0087820f; WORD $0x0000             // jb           LBB1_61, $135(%rip)
+	WORD $0xc089                               // movl         %eax, %eax
+	LONG $0x850d8d48; WORD $0x00ad; BYTE $0x00 // leaq         $44421(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	LONG $0x02438966                           // movw         %ax, $2(%rbx)
+	LONG $0x04c38348                           // addq         $4, %rbx
+	LONG $0x000555e9; BYTE $0x00               // jmp          LBB1_122, $1365(%rip)
+
+LBB1_63:
+	WORD $0x8545; BYTE $0xf6       // testl        %r14d, %r14d
+	LONG $0x02fa8f0f; WORD $0x0000 // jg           LBB1_76, $762(%rip)
+	LONG $0x07c74166; WORD $0x2e30 // movw         $11824, (%r15)
+	LONG $0x02c78349               // addq         $2, %r15
+	WORD $0x8545; BYTE $0xf6       // testl        %r14d, %r14d
+	LONG $0x02e7890f; WORD $0x0000 // jns          LBB1_76, $743(%rip)
+	WORD $0x8941; BYTE $0xd0       // movl         %edx, %r8d
+	WORD $0xf741; BYTE $0xd0       // notl         %r8d
+	WORD $0x2945; BYTE $0xd0       // subl         %r10d, %r8d
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x1ff88341               // cmpl         $31, %r8d
+	LONG $0x02bb820f; WORD $0x0000 // jb           LBB1_74, $699(%rip)
+	WORD $0xff49; BYTE $0xc0       // incq         %r8
+	WORD $0x894c; BYTE $0xc0       // movq         %r8, %rax
+	WORD $0x214c; BYTE $0xe0       // andq         %r12, %rax
+	LONG $0xe0488d48               // leaq         $-32(%rax), %rcx
+	WORD $0x8948; BYTE $0xce       // movq         %rcx, %rsi
+	LONG $0x05eec148               // shrq         $5, %rsi
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0x8941; BYTE $0xf1       // movl         %esi, %r9d
+	LONG $0x03e18341               // andl         $3, %r9d
+	LONG $0x60f98348               // cmpq         $96, %rcx
+	LONG $0x01f7830f; WORD $0x0000 // jae          LBB1_68, $503(%rip)
+	WORD $0xc931                   // xorl         %ecx, %ecx
+	LONG $0xd0558b4c               // movq         $-48(%rbp), %r10
+	LONG $0x000243e9; BYTE $0x00   // jmp          LBB1_70, $579(%rip)
+
+LBB1_103:
+	LONG $0xd0558b4c             // movq         $-48(%rbp), %r10
+	LONG $0x0004e8e9; BYTE $0x00 // jmp          LBB1_122, $1256(%rip)
+
+LBB1_61:
+	WORD $0x3004                 // addb         $48, %al
+	WORD $0x4388; BYTE $0x02     // movb         %al, $2(%rbx)
+	LONG $0x03c38348             // addq         $3, %rbx
+	LONG $0x0004dae9; BYTE $0x00 // jmp          LBB1_122, $1242(%rip)
+
+LBB1_17:
+	LONG $0x000001ba; BYTE $0x00               // movl         $1, %edx
+	LONG $0x0aff8348                           // cmpq         $10, %rdi
+	LONG $0x007b820f; WORD $0x0000             // jb           LBB1_27, $123(%rip)
+	LONG $0x000002ba; BYTE $0x00               // movl         $2, %edx
+	LONG $0x64ff8348                           // cmpq         $100, %rdi
+	LONG $0x006c820f; WORD $0x0000             // jb           LBB1_27, $108(%rip)
+	LONG $0x000003ba; BYTE $0x00               // movl         $3, %edx
+	LONG $0xe8ff8148; WORD $0x0003; BYTE $0x00 // cmpq         $1000, %rdi
+	LONG $0x005a820f; WORD $0x0000             // jb           LBB1_27, $90(%rip)
+	LONG $0x000004ba; BYTE $0x00               // movl         $4, %edx
+	LONG $0x10ff8148; WORD $0x0027; BYTE $0x00 // cmpq         $10000, %rdi
+	LONG $0x0048820f; WORD $0x0000             // jb           LBB1_27, $72(%rip)
+	LONG $0x000005ba; BYTE $0x00               // movl         $5, %edx
+	LONG $0xa0ff8148; WORD $0x0186; BYTE $0x00 // cmpq         $100000, %rdi
+	LONG $0x0036820f; WORD $0x0000             // jb           LBB1_27, $54(%rip)
+	LONG $0x000006ba; BYTE $0x00               // movl         $6, %edx
+	LONG $0x40ff8148; WORD $0x0f42; BYTE $0x00 // cmpq         $1000000, %rdi
+	LONG $0x0024820f; WORD $0x0000             // jb           LBB1_27, $36(%rip)
+	LONG $0x000007ba; BYTE $0x00               // movl         $7, %edx
+	LONG $0x80ff8148; WORD $0x9896; BYTE $0x00 // cmpq         $10000000, %rdi
+	LONG $0x0012820f; WORD $0x0000             // jb           LBB1_27, $18(%rip)
+	LONG $0x000008ba; BYTE $0x00               // movl         $8, %edx
+	LONG $0x00ff8148; WORD $0xf5e1; BYTE $0x05 // cmpq         $100000000, %rdi
+	LONG $0x0478830f; WORD $0x0000             // jae          LBB1_25, $1144(%rip)
+
+LBB1_27:
+	WORD $0x894c; BYTE $0xfe     // movq         %r15, %rsi
+	LONG $0x000487e8; BYTE $0x00 // callq        _format_integer, $1159(%rip)
+	WORD $0x8948; BYTE $0xc3     // movq         %rax, %rbx
+	WORD $0x5d2b; BYTE $0xd0     // subl         $-48(%rbp), %ebx
+	LONG $0x000440e9; BYTE $0x00 // jmp          LBB1_123, $1088(%rip)
+
+LBB1_105:
+	LONG $0x20fd8349               // cmpq         $32, %r13
+	LONG $0x0007830f; WORD $0x0000 // jae          LBB1_110, $7(%rip)
+	WORD $0xc931                   // xorl         %ecx, %ecx
+	LONG $0x0000c6e9; BYTE $0x00   // jmp          LBB1_107, $198(%rip)
+
+LBB1_110:
+	WORD $0x894c; BYTE $0xe9       // movq         %r13, %rcx
+	LONG $0xe0e18348               // andq         $-32, %rcx
+	LONG $0xe0798d48               // leaq         $-32(%rcx), %rdi
+	WORD $0x8948; BYTE $0xfe       // movq         %rdi, %rsi
+	LONG $0x05eec148               // shrq         $5, %rsi
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0xf289                   // movl         %esi, %edx
+	WORD $0xe283; BYTE $0x03       // andl         $3, %edx
+	LONG $0x60ff8348               // cmpq         $96, %rdi
+	LONG $0x0007830f; WORD $0x0000 // jae          LBB1_112, $7(%rip)
+	WORD $0xff31                   // xorl         %edi, %edi
+	LONG $0x00004de9; BYTE $0x00   // jmp          LBB1_114, $77(%rip)
+
+LBB1_112:
+	LONG $0xfce68348         // andq         $-4, %rsi
+	WORD $0xff31             // xorl         %edi, %edi
+	QUAD $0xfffff902056f0f66 // movdqa       $-1790(%rip), %xmm0  /* LCPI1_0(%rip) */
+	WORD $0x9090             // .p2align 4, 0x90
+
+LBB1_113:
+	LONG $0x047f0ff3; BYTE $0x38   // movdqu       %xmm0, (%rax,%rdi)
+	LONG $0x447f0ff3; WORD $0x1038 // movdqu       %xmm0, $16(%rax,%rdi)
+	LONG $0x447f0ff3; WORD $0x2038 // movdqu       %xmm0, $32(%rax,%rdi)
+	LONG $0x447f0ff3; WORD $0x3038 // movdqu       %xmm0, $48(%rax,%rdi)
+	LONG $0x447f0ff3; WORD $0x4038 // movdqu       %xmm0, $64(%rax,%rdi)
+	LONG $0x447f0ff3; WORD $0x5038 // movdqu       %xmm0, $80(%rax,%rdi)
+	LONG $0x447f0ff3; WORD $0x6038 // movdqu       %xmm0, $96(%rax,%rdi)
+	LONG $0x447f0ff3; WORD $0x7038 // movdqu       %xmm0, $112(%rax,%rdi)
+	LONG $0x80ef8348               // subq         $-128, %rdi
+	LONG $0xfcc68348               // addq         $-4, %rsi
+	LONG $0xffc3850f; WORD $0xffff // jne          LBB1_113, $-61(%rip)
+
+LBB1_114:
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0x0032840f; WORD $0x0000 // je           LBB1_117, $50(%rip)
+	LONG $0x07348d48               // leaq         (%rdi,%rax), %rsi
+	LONG $0x10c68348               // addq         $16, %rsi
+	LONG $0x05e2c148               // shlq         $5, %rdx
+	WORD $0xff31                   // xorl         %edi, %edi
+	QUAD $0xfffff8a4056f0f66       // movdqa       $-1884(%rip), %xmm0  /* LCPI1_0(%rip) */
+	LONG $0x90909090               // .p2align 4, 0x90
+
+LBB1_116:
+	LONG $0x447f0ff3; WORD $0xf03e // movdqu       %xmm0, $-16(%rsi,%rdi)
+	LONG $0x047f0ff3; BYTE $0x3e   // movdqu       %xmm0, (%rsi,%rdi)
+	LONG $0x20c78348               // addq         $32, %rdi
+	WORD $0x3948; BYTE $0xfa       // cmpq         %rdi, %rdx
+	LONG $0xffe8850f; WORD $0xffff // jne          LBB1_116, $-24(%rip)
+
+LBB1_117:
+	WORD $0x3949; BYTE $0xcd       // cmpq         %rcx, %r13
+	LONG $0x0370840f; WORD $0x0000 // je           LBB1_122, $880(%rip)
+	LONG $0x18c5f641               // testb        $24, %r13b
+	LONG $0x0059840f; WORD $0x0000 // je           LBB1_119, $89(%rip)
+
+LBB1_107:
+	WORD $0x894c; BYTE $0xee                                 // movq         %r13, %rsi
+	LONG $0xf8e68348                                         // andq         $-8, %rsi
+	WORD $0x8948; BYTE $0xc2                                 // movq         %rax, %rdx
+	WORD $0x0148; BYTE $0xf2                                 // addq         %rsi, %rdx
+	QUAD $0x303030303030bf48; WORD $0x3030                   // movabsq      $3472328296227680304, %rdi
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB1_108:
+	LONG $0x083c8948               // movq         %rdi, (%rax,%rcx)
+	LONG $0x08c18348               // addq         $8, %rcx
+	WORD $0x3948; BYTE $0xce       // cmpq         %rcx, %rsi
+	LONG $0xffef850f; WORD $0xffff // jne          LBB1_108, $-17(%rip)
+	WORD $0x3949; BYTE $0xf5       // cmpq         %rsi, %r13
+	LONG $0x0327840f; WORD $0x0000 // je           LBB1_122, $807(%rip)
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB1_121:
+	WORD $0x02c6; BYTE $0x30       // movb         $48, (%rdx)
+	WORD $0xff48; BYTE $0xc2       // incq         %rdx
+	WORD $0x3948; BYTE $0xda       // cmpq         %rbx, %rdx
+	LONG $0xfff1820f; WORD $0xffff // jb           LBB1_121, $-15(%rip)
+	LONG $0x00030de9; BYTE $0x00   // jmp          LBB1_122, $781(%rip)
+
+LBB1_119:
+	WORD $0x0148; BYTE $0xc8     // addq         %rcx, %rax
+	LONG $0xfffcdae9; BYTE $0xff // jmp          LBB1_120, $-806(%rip)
+
+LBB1_68:
+	LONG $0xfce68348         // andq         $-4, %rsi
+	LONG $0xd0558b4c         // movq         $-48(%rbp), %r10
+	LONG $0x2a1c8d4b         // leaq         (%r10,%r13), %rbx
+	LONG $0x72c38348         // addq         $114, %rbx
+	WORD $0xc931             // xorl         %ecx, %ecx
+	QUAD $0xfffff7fa056f0f66 // movdqa       $-2054(%rip), %xmm0  /* LCPI1_0(%rip) */
+
+LBB1_69:
+	LONG $0x447f0ff3; WORD $0x900b // movdqu       %xmm0, $-112(%rbx,%rcx)
+	LONG $0x447f0ff3; WORD $0xa00b // movdqu       %xmm0, $-96(%rbx,%rcx)
+	LONG $0x447f0ff3; WORD $0xb00b // movdqu       %xmm0, $-80(%rbx,%rcx)
+	LONG $0x447f0ff3; WORD $0xc00b // movdqu       %xmm0, $-64(%rbx,%rcx)
+	LONG $0x447f0ff3; WORD $0xd00b // movdqu       %xmm0, $-48(%rbx,%rcx)
+	LONG $0x447f0ff3; WORD $0xe00b // movdqu       %xmm0, $-32(%rbx,%rcx)
+	LONG $0x447f0ff3; WORD $0xf00b // movdqu       %xmm0, $-16(%rbx,%rcx)
+	LONG $0x047f0ff3; BYTE $0x0b   // movdqu       %xmm0, (%rbx,%rcx)
+	LONG $0x80e98348               // subq         $-128, %rcx
+	LONG $0xfcc68348               // addq         $-4, %rsi
+	LONG $0xffc3850f; WORD $0xffff // jne          LBB1_69, $-61(%rip)
+
+LBB1_70:
+	WORD $0x854d; BYTE $0xc9       // testq        %r9, %r9
+	LONG $0x0030840f; WORD $0x0000 // je           LBB1_73, $48(%rip)
+	WORD $0x014c; BYTE $0xe9       // addq         %r13, %rcx
+	WORD $0x014c; BYTE $0xd1       // addq         %r10, %rcx
+	LONG $0x12c18348               // addq         $18, %rcx
+	LONG $0x05e1c149               // shlq         $5, %r9
+	WORD $0xf631                   // xorl         %esi, %esi
+	QUAD $0xfffff79c056f0f66       // movdqa       $-2148(%rip), %xmm0  /* LCPI1_0(%rip) */
+
+LBB1_72:
+	LONG $0x447f0ff3; WORD $0xf031 // movdqu       %xmm0, $-16(%rcx,%rsi)
+	LONG $0x047f0ff3; BYTE $0x31   // movdqu       %xmm0, (%rcx,%rsi)
+	LONG $0x20c68348               // addq         $32, %rsi
+	WORD $0x3949; BYTE $0xf1       // cmpq         %rsi, %r9
+	LONG $0xffe8850f; WORD $0xffff // jne          LBB1_72, $-24(%rip)
+
+LBB1_73:
+	WORD $0x0149; BYTE $0xc7       // addq         %rax, %r15
+	WORD $0x3949; BYTE $0xc0       // cmpq         %rax, %r8
+	LONG $0x0017840f; WORD $0x0000 // je           LBB1_76, $23(%rip)
+
+LBB1_74:
+	WORD $0x0144; BYTE $0xf0 // addl         %r14d, %eax
+	WORD $0xd8f7             // negl         %eax
+	WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB1_75:
+	LONG $0x3007c641               // movb         $48, (%r15)
+	WORD $0xff49; BYTE $0xc7       // incq         %r15
+	WORD $0xc8ff                   // decl         %eax
+	LONG $0xfff1850f; WORD $0xffff // jne          LBB1_75, $-15(%rip)
+
+LBB1_76:
+	WORD $0x894c; BYTE $0xfe     // movq         %r15, %rsi
+	LONG $0x007279e8; BYTE $0x00 // callq        _format_significand, $29305(%rip)
+	WORD $0xc389                 // movl         %eax, %ebx
+	WORD $0x2844; BYTE $0xfb     // subb         %r15b, %bl
+	WORD $0x2844; BYTE $0xf3     // subb         %r14b, %bl
+	LONG $0x3e2c8d47             // leal         (%r14,%r15), %r13d
+	WORD $0x2941; BYTE $0xc5     // subl         %eax, %r13d
+	LONG $0xff458d45             // leal         $-1(%r13), %r8d
+	LONG $0xfe7d8d41             // leal         $-2(%r13), %edi
+	WORD $0xc931                 // xorl         %ecx, %ecx
+
+	// .p2align 4, 0x90
+LBB1_77:
+	WORD $0xda89                   // movl         %ebx, %edx
+	WORD $0x5a8d; BYTE $0x03       // leal         $3(%rdx), %ebx
+	WORD $0xc7ff                   // incl         %edi
+	LONG $0xff087c80; BYTE $0x30   // cmpb         $48, $-1(%rax,%rcx)
+	LONG $0xff498d48               // leaq         $-1(%rcx), %rcx
+	LONG $0xffea840f; WORD $0xffff // je           LBB1_77, $-22(%rip)
+	LONG $0x081c8d48               // leaq         (%rax,%rcx), %rbx
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	WORD $0x8545; BYTE $0xf6       // testl        %r14d, %r14d
+	LONG $0xd0558b4c               // movq         $-48(%rbp), %r10
+	LONG $0x02078e0f; WORD $0x0000 // jle          LBB1_122, $519(%rip)
+	WORD $0xc689                   // movl         %eax, %esi
+	WORD $0x2944; BYTE $0xfe       // subl         %r15d, %esi
+	WORD $0xce01                   // addl         %ecx, %esi
+	WORD $0xc6ff                   // incl         %esi
+	WORD $0x3941; BYTE $0xf6       // cmpl         %esi, %r14d
+	LONG $0x00308d0f; WORD $0x0000 // jge          LBB1_80, $48(%rip)
+	WORD $0x8941; BYTE $0xc1       // movl         %eax, %r9d
+	WORD $0x2945; BYTE $0xf1       // subl         %r14d, %r9d
+	WORD $0x2945; BYTE $0xf9       // subl         %r15d, %r9d
+	WORD $0xff41; BYTE $0xc1       // incl         %r9d
+	LONG $0x093c8d49               // leaq         (%r9,%rcx), %rdi
+	WORD $0xff85                   // testl        %edi, %edi
+	LONG $0x00e48e0f; WORD $0x0000 // jle          LBB1_99, $228(%rip)
+	WORD $0x8941; BYTE $0xf8       // movl         %edi, %r8d
+	LONG $0xff588d49               // leaq         $-1(%r8), %rbx
+	LONG $0x03fb8348               // cmpq         $3, %rbx
+	LONG $0x0069830f; WORD $0x0000 // jae          LBB1_100, $105(%rip)
+	WORD $0xdb31                   // xorl         %ebx, %ebx
+	LONG $0x000090e9; BYTE $0x00   // jmp          LBB1_96, $144(%rip)
+
+LBB1_80:
+	WORD $0x8945; BYTE $0xc3       // movl         %r8d, %r11d
+	WORD $0x2949; BYTE $0xcb       // subq         %rcx, %r11
+	WORD $0x8545; BYTE $0xdb       // testl        %r11d, %r11d
+	LONG $0x01b68e0f; WORD $0x0000 // jle          LBB1_122, $438(%rip)
+	WORD $0x0145; BYTE $0xfe       // addl         %r15d, %r14d
+	WORD $0x2941; BYTE $0xc6       // subl         %eax, %r14d
+	LONG $0xfec68341               // addl         $-2, %r14d
+	WORD $0x2949; BYTE $0xce       // subq         %rcx, %r14
+	WORD $0xd231                   // xorl         %edx, %edx
+	LONG $0x1ffe8341               // cmpl         $31, %r14d
+	LONG $0x018c820f; WORD $0x0000 // jb           LBB1_91, $396(%rip)
+	LONG $0xfec58341               // addl         $-2, %r13d
+	WORD $0x2949; BYTE $0xcd       // subq         %rcx, %r13
+	WORD $0x8945; BYTE $0xf0       // movl         %r14d, %r8d
+	WORD $0xff49; BYTE $0xc0       // incq         %r8
+	WORD $0x214d; BYTE $0xc4       // andq         %r8, %r12
+	WORD $0x8941; BYTE $0xf9       // movl         %edi, %r9d
+	WORD $0xff49; BYTE $0xc1       // incq         %r9
+	LONG $0xe0e18349               // andq         $-32, %r9
+	LONG $0x24548d49; BYTE $0xe0   // leaq         $-32(%r12), %rdx
+	WORD $0x8949; BYTE $0xd2       // movq         %rdx, %r10
+	LONG $0x05eac149               // shrq         $5, %r10
+	WORD $0xff49; BYTE $0xc2       // incq         %r10
+	LONG $0x60fa8348               // cmpq         $96, %rdx
+	LONG $0x0086830f; WORD $0x0000 // jae          LBB1_84, $134(%rip)
+	WORD $0xdb31                   // xorl         %ebx, %ebx
+	LONG $0x0000e4e9; BYTE $0x00   // jmp          LBB1_86, $228(%rip)
+
+LBB1_100:
+	WORD $0x0149; BYTE $0xc9       // addq         %rcx, %r9
+	LONG $0xfce18341               // andl         $-4, %r9d
+	WORD $0xf749; BYTE $0xd9       // negq         %r9
+	WORD $0xdb31                   // xorl         %ebx, %ebx
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB1_101:
+	LONG $0x183c8d48               // leaq         (%rax,%rbx), %rdi
+	LONG $0xfd39748b               // movl         $-3(%rcx,%rdi), %esi
+	LONG $0xfe397489               // movl         %esi, $-2(%rcx,%rdi)
+	LONG $0xfcc38348               // addq         $-4, %rbx
+	WORD $0x3949; BYTE $0xd9       // cmpq         %rbx, %r9
+	LONG $0xffe7850f; WORD $0xffff // jne          LBB1_101, $-25(%rip)
+	WORD $0xf748; BYTE $0xdb       // negq         %rbx
+
+LBB1_96:
+	LONG $0x03c0f641                           // testb        $3, %r8b
+	LONG $0x0032840f; WORD $0x0000             // je           LBB1_99, $50(%rip)
+	LONG $0xc2b60f44                           // movzbl       %dl, %r8d
+	LONG $0x03e08341                           // andl         $3, %r8d
+	WORD $0xf749; BYTE $0xd8                   // negq         %r8
+	WORD $0x8948; BYTE $0xc6                   // movq         %rax, %rsi
+	WORD $0x2948; BYTE $0xde                   // subq         %rbx, %rsi
+	WORD $0xff31                               // xorl         %edi, %edi
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB1_98:
+	LONG $0x3e1c8d48               // leaq         (%rsi,%rdi), %rbx
+	LONG $0x1914b60f               // movzbl       (%rcx,%rbx), %edx
+	LONG $0x01195488               // movb         %dl, $1(%rcx,%rbx)
+	WORD $0xff48; BYTE $0xcf       // decq         %rdi
+	WORD $0x3949; BYTE $0xf8       // cmpq         %rdi, %r8
+	LONG $0xffe8850f; WORD $0xffff // jne          LBB1_98, $-24(%rip)
+
+LBB1_99:
+	WORD $0x8944; BYTE $0xf2     // movl         %r14d, %edx
+	LONG $0x1704c641; BYTE $0x2e // movb         $46, (%r15,%rdx)
+	LONG $0x081c8d48             // leaq         (%rax,%rcx), %rbx
+	LONG $0x02c38348             // addq         $2, %rbx
+	LONG $0x0000e4e9; BYTE $0x00 // jmp          LBB1_122, $228(%rip)
+
+LBB1_84:
+	WORD $0x8944; BYTE $0xef // movl         %r13d, %edi
+	WORD $0xff48; BYTE $0xc7 // incq         %rdi
+	LONG $0xe0e78348         // andq         $-32, %rdi
+	LONG $0xe0c78348         // addq         $-32, %rdi
+	LONG $0x05efc148         // shrq         $5, %rdi
+	WORD $0xff48; BYTE $0xc7 // incq         %rdi
+	LONG $0xfce78348         // andq         $-4, %rdi
+	WORD $0xdb31             // xorl         %ebx, %ebx
+	QUAD $0xfffff5d0056f0f66 // movdqa       $-2608(%rip), %xmm0  /* LCPI1_0(%rip) */
+
+LBB1_85:
+	LONG $0x18148d48               // leaq         (%rax,%rbx), %rdx
+	LONG $0x447f0ff3; WORD $0x0111 // movdqu       %xmm0, $1(%rcx,%rdx)
+	LONG $0x447f0ff3; WORD $0x1111 // movdqu       %xmm0, $17(%rcx,%rdx)
+	LONG $0x447f0ff3; WORD $0x2111 // movdqu       %xmm0, $33(%rcx,%rdx)
+	LONG $0x447f0ff3; WORD $0x3111 // movdqu       %xmm0, $49(%rcx,%rdx)
+	LONG $0x447f0ff3; WORD $0x4111 // movdqu       %xmm0, $65(%rcx,%rdx)
+	LONG $0x447f0ff3; WORD $0x5111 // movdqu       %xmm0, $81(%rcx,%rdx)
+	LONG $0x447f0ff3; WORD $0x6111 // movdqu       %xmm0, $97(%rcx,%rdx)
+	LONG $0x447f0ff3; WORD $0x7111 // movdqu       %xmm0, $113(%rcx,%rdx)
+	LONG $0x80eb8348               // subq         $-128, %rbx
+	LONG $0xfcc78348               // addq         $-4, %rdi
+	LONG $0xffbe850f; WORD $0xffff // jne          LBB1_85, $-66(%rip)
+
+LBB1_86:
+	WORD $0x0149; BYTE $0xc1       // addq         %rax, %r9
+	LONG $0x03c2f641               // testb        $3, %r10b
+	LONG $0x004a840f; WORD $0x0000 // je           LBB1_89, $74(%rip)
+	WORD $0xfe41; BYTE $0xc5       // incb         %r13b
+	LONG $0x60e58041               // andb         $96, %r13b
+	LONG $0xe0c58041               // addb         $-32, %r13b
+	LONG $0x05edc041               // shrb         $5, %r13b
+	WORD $0xfe41; BYTE $0xc5       // incb         %r13b
+	LONG $0xd5b60f41               // movzbl       %r13b, %edx
+	WORD $0xe283; BYTE $0x03       // andl         $3, %edx
+	LONG $0x05e2c148               // shlq         $5, %rdx
+	WORD $0x0148; BYTE $0xd8       // addq         %rbx, %rax
+	LONG $0x11c08348               // addq         $17, %rax
+	WORD $0xf631                   // xorl         %esi, %esi
+	QUAD $0xfffff553056f0f66       // movdqa       $-2733(%rip), %xmm0  /* LCPI1_0(%rip) */
+
+LBB1_88:
+	LONG $0x303c8d48               // leaq         (%rax,%rsi), %rdi
+	LONG $0x447f0ff3; WORD $0xf039 // movdqu       %xmm0, $-16(%rcx,%rdi)
+	LONG $0x047f0ff3; BYTE $0x39   // movdqu       %xmm0, (%rcx,%rdi)
+	LONG $0x20c68348               // addq         $32, %rsi
+	WORD $0x3948; BYTE $0xf2       // cmpq         %rsi, %rdx
+	LONG $0xffe4850f; WORD $0xffff // jne          LBB1_88, $-28(%rip)
+
+LBB1_89:
+	LONG $0x091c8d4a               // leaq         (%rcx,%r9), %rbx
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	WORD $0x394d; BYTE $0xe0       // cmpq         %r12, %r8
+	LONG $0xd0558b4c               // movq         $-48(%rbp), %r10
+	LONG $0x0014840f; WORD $0x0000 // je           LBB1_122, $20(%rip)
+	WORD $0x8944; BYTE $0xe2       // movl         %r12d, %edx
+
+	// .p2align 4, 0x90
+LBB1_91:
+	WORD $0x03c6; BYTE $0x30       // movb         $48, (%rbx)
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	WORD $0xc2ff                   // incl         %edx
+	WORD $0x3944; BYTE $0xda       // cmpl         %r11d, %edx
+	LONG $0xffef8c0f; WORD $0xffff // jl           LBB1_91, $-17(%rip)
+
+LBB1_122:
+	WORD $0x2944; BYTE $0xd3 // subl         %r10d, %ebx
+
+LBB1_123:
+	WORD $0xd889     // movl         %ebx, %eax
+	LONG $0x08c48348 // addq         $8, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5d41     // popq         %r13
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB1_1:
+	WORD $0xdb31                 // xorl         %ebx, %ebx
+	LONG $0xffffe8e9; BYTE $0xff // jmp          LBB1_123, $-24(%rip)
+
+LBB1_5:
+	LONG $0xfffbcebe; BYTE $0xff // movl         $-1074, %esi
+	WORD $0x8948; BYTE $0xd7     // movq         %rdx, %rdi
+	LONG $0xfff594e9; BYTE $0xff // jmp          LBB1_6, $-2668(%rip)
+
+LBB1_25:
+	LONG $0x00ff8148; WORD $0x9aca; BYTE $0x3b // cmpq         $1000000000, %rdi
+	LONG $0x00000aba; BYTE $0x00               // movl         $10, %edx
+	LONG $0xfffa32e9; BYTE $0xff               // jmp          LBB1_26, $-1486(%rip)
+	LONG $0x90909090; WORD $0x9090             // .p2align 4, 0x90
+
+_format_integer:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	BYTE $0x53                     // pushq        %rbx
+	WORD $0x8941; BYTE $0xd0       // movl         %edx, %r8d
+	WORD $0x0149; BYTE $0xf0       // addq         %rsi, %r8
+	WORD $0x8948; BYTE $0xf8       // movq         %rdi, %rax
+	LONG $0x20e8c148               // shrq         $32, %rax
+	LONG $0x0016850f; WORD $0x0000 // jne          LBB2_2, $22(%rip)
+	WORD $0x894d; BYTE $0xc3       // movq         %r8, %r11
+	LONG $0x2710ff81; WORD $0x0000 // cmpl         $10000, %edi
+	LONG $0x00c3830f; WORD $0x0000 // jae          LBB2_5, $195(%rip)
+
+LBB2_4:
+	WORD $0xfa89                 // movl         %edi, %edx
+	LONG $0x00011ae9; BYTE $0x00 // jmp          LBB2_7, $282(%rip)
+
+LBB2_2:
+	QUAD $0x77118461cefdb948; WORD $0xabcc     // movabsq      $-6067343680855748867, %rcx
+	WORD $0x8948; BYTE $0xf8                   // movq         %rdi, %rax
+	WORD $0xf748; BYTE $0xe1                   // mulq         %rcx
+	LONG $0x1aeac148                           // shrq         $26, %rdx
+	LONG $0x1f00ca69; WORD $0xfa0a             // imull        $-100000000, %edx, %ecx
+	WORD $0xf901                               // addl         %edi, %ecx
+	LONG $0x1759b941; WORD $0xd1b7             // movl         $3518437209, %r9d
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	LONG $0xc1af0f49                           // imulq        %r9, %rax
+	LONG $0x2de8c148                           // shrq         $45, %rax
+	LONG $0x2710f869; WORD $0x0000             // imull        $10000, %eax, %edi
+	WORD $0xf929                               // subl         %edi, %ecx
+	WORD $0x8948; BYTE $0xc7                   // movq         %rax, %rdi
+	LONG $0xf9af0f49                           // imulq        %r9, %rdi
+	LONG $0x2defc148                           // shrq         $45, %rdi
+	LONG $0x2710ff69; WORD $0x0000             // imull        $10000, %edi, %edi
+	WORD $0xf829                               // subl         %edi, %eax
+	WORD $0xb70f; BYTE $0xf9                   // movzwl       %cx, %edi
+	WORD $0xefc1; BYTE $0x02                   // shrl         $2, %edi
+	LONG $0x7bcf6944; WORD $0x0014; BYTE $0x00 // imull        $5243, %edi, %r9d
+	LONG $0x11e9c141                           // shrl         $17, %r9d
+	LONG $0x64f96b41                           // imull        $100, %r9d, %edi
+	WORD $0xf929                               // subl         %edi, %ecx
+	LONG $0xd1b70f44                           // movzwl       %cx, %r10d
+	WORD $0xb70f; BYTE $0xf8                   // movzwl       %ax, %edi
+	WORD $0xefc1; BYTE $0x02                   // shrl         $2, %edi
+	LONG $0x147bff69; WORD $0x0000             // imull        $5243, %edi, %edi
+	WORD $0xefc1; BYTE $0x11                   // shrl         $17, %edi
+	WORD $0xcf6b; BYTE $0x64                   // imull        $100, %edi, %ecx
+	WORD $0xc829                               // subl         %ecx, %eax
+	LONG $0xd8b70f44                           // movzwl       %ax, %r11d
+	LONG $0x300d8d48; WORD $0x00a7; BYTE $0x00 // leaq         $42800(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x04b70f42; BYTE $0x51               // movzwl       (%rcx,%r10,2), %eax
+	LONG $0x40894166; BYTE $0xfe               // movw         %ax, $-2(%r8)
+	LONG $0x04b70f42; BYTE $0x49               // movzwl       (%rcx,%r9,2), %eax
+	LONG $0x40894166; BYTE $0xfc               // movw         %ax, $-4(%r8)
+	LONG $0x04b70f42; BYTE $0x59               // movzwl       (%rcx,%r11,2), %eax
+	LONG $0x40894166; BYTE $0xfa               // movw         %ax, $-6(%r8)
+	LONG $0xf8588d4d                           // leaq         $-8(%r8), %r11
+	LONG $0x790cb70f                           // movzwl       (%rcx,%rdi,2), %ecx
+	LONG $0x48894166; BYTE $0xf8               // movw         %cx, $-8(%r8)
+	WORD $0x8948; BYTE $0xd7                   // movq         %rdx, %rdi
+	LONG $0x2710ff81; WORD $0x0000             // cmpl         $10000, %edi
+	LONG $0xff3d820f; WORD $0xffff             // jb           LBB2_4, $-195(%rip)
+
+LBB2_5:
+	LONG $0x1759b941; WORD $0xd1b7             // movl         $3518437209, %r9d
+	LONG $0xe9158d4c; WORD $0x00a6; BYTE $0x00 // leaq         $42729(%rip), %r10  /* _Digits(%rip) */
+	QUAD $0x9090909090909090; BYTE $0x90       // .p2align 4, 0x90
+
+LBB2_6:
+	WORD $0xfa89                               // movl         %edi, %edx
+	LONG $0xd1af0f49                           // imulq        %r9, %rdx
+	LONG $0x2deac148                           // shrq         $45, %rdx
+	LONG $0xd8f0ca69; WORD $0xffff             // imull        $-10000, %edx, %ecx
+	WORD $0xf901                               // addl         %edi, %ecx
+	LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rcx, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xd86b; BYTE $0x64                   // imull        $100, %eax, %ebx
+	WORD $0xd929                               // subl         %ebx, %ecx
+	LONG $0x0cb70f41; BYTE $0x4a               // movzwl       (%r10,%rcx,2), %ecx
+	LONG $0x4b894166; BYTE $0xfe               // movw         %cx, $-2(%r11)
+	LONG $0x04b70f41; BYTE $0x42               // movzwl       (%r10,%rax,2), %eax
+	LONG $0x43894166; BYTE $0xfc               // movw         %ax, $-4(%r11)
+	LONG $0xfcc38349                           // addq         $-4, %r11
+	LONG $0xe0ffff81; WORD $0x05f5             // cmpl         $99999999, %edi
+	WORD $0xd789                               // movl         %edx, %edi
+	LONG $0xffb8870f; WORD $0xffff             // ja           LBB2_6, $-72(%rip)
+
+LBB2_7:
+	WORD $0xfa83; BYTE $0x64                   // cmpl         $100, %edx
+	LONG $0x002d820f; WORD $0x0000             // jb           LBB2_9, $45(%rip)
+	WORD $0xb70f; BYTE $0xc2                   // movzwl       %dx, %eax
+	WORD $0xe8c1; BYTE $0x02                   // shrl         $2, %eax
+	LONG $0x147bc069; WORD $0x0000             // imull        $5243, %eax, %eax
+	WORD $0xe8c1; BYTE $0x11                   // shrl         $17, %eax
+	WORD $0xc86b; BYTE $0x64                   // imull        $100, %eax, %ecx
+	WORD $0xca29                               // subl         %ecx, %edx
+	WORD $0xb70f; BYTE $0xca                   // movzwl       %dx, %ecx
+	LONG $0x71158d48; WORD $0x00a6; BYTE $0x00 // leaq         $42609(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x4a0cb70f                           // movzwl       (%rdx,%rcx,2), %ecx
+	LONG $0x4b894166; BYTE $0xfe               // movw         %cx, $-2(%r11)
+	LONG $0xfec38349                           // addq         $-2, %r11
+	WORD $0xc289                               // movl         %eax, %edx
+
+LBB2_9:
+	WORD $0xfa83; BYTE $0x0a                   // cmpl         $10, %edx
+	LONG $0x0018820f; WORD $0x0000             // jb           LBB2_11, $24(%rip)
+	WORD $0xd089                               // movl         %edx, %eax
+	LONG $0x500d8d48; WORD $0x00a6; BYTE $0x00 // leaq         $42576(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	LONG $0x43894166; BYTE $0xfe               // movw         %ax, $-2(%r11)
+	WORD $0x894c; BYTE $0xc0                   // movq         %r8, %rax
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB2_11:
+	WORD $0xc280; BYTE $0x30       // addb         $48, %dl
+	WORD $0x1688                   // movb         %dl, (%rsi)
+	WORD $0x894c; BYTE $0xc0       // movq         %r8, %rax
+	BYTE $0x5b                     // popq         %rbx
+	BYTE $0x5d                     // popq         %rbp
+	BYTE $0xc3                     // retq
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+_i64toa:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x8548; BYTE $0xf6                   // testq        %rsi, %rsi
+	LONG $0x00b1880f; WORD $0x0000             // js           LBB3_12, $177(%rip)
+	LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq         $9999, %rsi
+	LONG $0x00b6870f; WORD $0x0000             // ja           LBB3_9, $182(%rip)
+	WORD $0xb70f; BYTE $0xc6                   // movzwl       %si, %eax
+	WORD $0xe8c1; BYTE $0x02                   // shrl         $2, %eax
+	LONG $0x147bc069; WORD $0x0000             // imull        $5243, %eax, %eax
+	WORD $0xe8c1; BYTE $0x11                   // shrl         $17, %eax
+	LONG $0x00148d48                           // leaq         (%rax,%rax), %rdx
+	WORD $0xc06b; BYTE $0x64                   // imull        $100, %eax, %eax
+	WORD $0xf189                               // movl         %esi, %ecx
+	WORD $0xc129                               // subl         %eax, %ecx
+	WORD $0xb70f; BYTE $0xc9                   // movzwl       %cx, %ecx
+	WORD $0x0148; BYTE $0xc9                   // addq         %rcx, %rcx
+	LONG $0x03e8fe81; WORD $0x0000             // cmpl         $1000, %esi
+	LONG $0x0017820f; WORD $0x0000             // jb           LBB3_4, $23(%rip)
+	LONG $0xe3058d48; WORD $0x00a5; BYTE $0x00 // leaq         $42467(%rip), %rax  /* _Digits(%rip) */
+	LONG $0x0204b60f                           // movzbl       (%rdx,%rax), %eax
+	WORD $0x0788                               // movb         %al, (%rdi)
+	LONG $0x000001b8; BYTE $0x00               // movl         $1, %eax
+	LONG $0x00000be9; BYTE $0x00               // jmp          LBB3_5, $11(%rip)
+
+LBB3_4:
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xfe83; BYTE $0x64       // cmpl         $100, %esi
+	LONG $0x0046820f; WORD $0x0000 // jb           LBB3_6, $70(%rip)
+
+LBB3_5:
+	WORD $0xb70f; BYTE $0xd2                   // movzwl       %dx, %edx
+	LONG $0x01ca8348                           // orq          $1, %rdx
+	LONG $0xba358d48; WORD $0x00a5; BYTE $0x00 // leaq         $42426(%rip), %rsi  /* _Digits(%rip) */
+	LONG $0x3214b60f                           // movzbl       (%rdx,%rsi), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB3_7:
+	LONG $0xa8158d48; WORD $0x00a5; BYTE $0x00 // leaq         $42408(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x1114b60f                           // movzbl       (%rcx,%rdx), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB3_8:
+	WORD $0xb70f; BYTE $0xc9                   // movzwl       %cx, %ecx
+	LONG $0x01c98348                           // orq          $1, %rcx
+	LONG $0x8f158d48; WORD $0x00a5; BYTE $0x00 // leaq         $42383(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x110cb60f                           // movzbl       (%rcx,%rdx), %ecx
+	WORD $0xc289                               // movl         %eax, %edx
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x0c88; BYTE $0x17                   // movb         %cl, (%rdi,%rdx)
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB3_6:
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xfe83; BYTE $0x0a       // cmpl         $10, %esi
+	LONG $0xffc8830f; WORD $0xffff // jae          LBB3_7, $-56(%rip)
+	LONG $0xffffd5e9; BYTE $0xff   // jmp          LBB3_8, $-43(%rip)
+
+LBB3_12:
+	WORD $0x07c6; BYTE $0x2d     // movb         $45, (%rdi)
+	WORD $0xff48; BYTE $0xc7     // incq         %rdi
+	WORD $0xf748; BYTE $0xde     // negq         %rsi
+	LONG $0x000044e8; BYTE $0x00 // callq        _u64toa, $68(%rip)
+	WORD $0xc0ff                 // incl         %eax
+	BYTE $0x5d                   // popq         %rbp
+	BYTE $0xc3                   // retq
+
+LBB3_9:
+	LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq         $99999999, %rsi
+	LONG $0x0006870f; WORD $0x0000             // ja           LBB3_10, $6(%rip)
+	BYTE $0x5d                                 // popq         %rbp
+	LONG $0x00011de9; BYTE $0x00               // jmp          _u32toa_medium, $285(%rip)
+
+LBB3_10:
+	QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq      $9999999999999999, %rax
+	WORD $0x3948; BYTE $0xc6               // cmpq         %rax, %rsi
+	LONG $0x0006870f; WORD $0x0000         // ja           LBB3_11, $6(%rip)
+	BYTE $0x5d                             // popq         %rbp
+	LONG $0x000254e9; BYTE $0x00           // jmp          _u64toa_large_sse2, $596(%rip)
+
+LBB3_11:
+	BYTE $0x5d                                               // popq         %rbp
+	LONG $0x0003bee9; BYTE $0x00                             // jmp          _u64toa_xlarge_sse2, $958(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+_u64toa:
+	LONG $0x0ffe8148; WORD $0x0027; BYTE $0x00 // cmpq         $9999, %rsi
+	LONG $0x00a8870f; WORD $0x0000             // ja           LBB4_8, $168(%rip)
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0xb70f; BYTE $0xc6                   // movzwl       %si, %eax
+	WORD $0xe8c1; BYTE $0x02                   // shrl         $2, %eax
+	LONG $0x147bc069; WORD $0x0000             // imull        $5243, %eax, %eax
+	WORD $0xe8c1; BYTE $0x11                   // shrl         $17, %eax
+	LONG $0x00148d48                           // leaq         (%rax,%rax), %rdx
+	WORD $0xc06b; BYTE $0x64                   // imull        $100, %eax, %eax
+	WORD $0xf189                               // movl         %esi, %ecx
+	WORD $0xc129                               // subl         %eax, %ecx
+	WORD $0xb70f; BYTE $0xc9                   // movzwl       %cx, %ecx
+	WORD $0x0148; BYTE $0xc9                   // addq         %rcx, %rcx
+	LONG $0x03e8fe81; WORD $0x0000             // cmpl         $1000, %esi
+	LONG $0x0017820f; WORD $0x0000             // jb           LBB4_3, $23(%rip)
+	LONG $0xdc058d48; WORD $0x00a4; BYTE $0x00 // leaq         $42204(%rip), %rax  /* _Digits(%rip) */
+	LONG $0x0204b60f                           // movzbl       (%rdx,%rax), %eax
+	WORD $0x0788                               // movb         %al, (%rdi)
+	LONG $0x000001b8; BYTE $0x00               // movl         $1, %eax
+	LONG $0x00000be9; BYTE $0x00               // jmp          LBB4_4, $11(%rip)
+
+LBB4_3:
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xfe83; BYTE $0x64       // cmpl         $100, %esi
+	LONG $0x0046820f; WORD $0x0000 // jb           LBB4_5, $70(%rip)
+
+LBB4_4:
+	WORD $0xb70f; BYTE $0xd2                   // movzwl       %dx, %edx
+	LONG $0x01ca8348                           // orq          $1, %rdx
+	LONG $0xb3358d48; WORD $0x00a4; BYTE $0x00 // leaq         $42163(%rip), %rsi  /* _Digits(%rip) */
+	LONG $0x3214b60f                           // movzbl       (%rdx,%rsi), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB4_6:
+	LONG $0xa1158d48; WORD $0x00a4; BYTE $0x00 // leaq         $42145(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x1114b60f                           // movzbl       (%rcx,%rdx), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB4_7:
+	WORD $0xb70f; BYTE $0xc9                   // movzwl       %cx, %ecx
+	LONG $0x01c98348                           // orq          $1, %rcx
+	LONG $0x88158d48; WORD $0x00a4; BYTE $0x00 // leaq         $42120(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x110cb60f                           // movzbl       (%rcx,%rdx), %ecx
+	WORD $0xc289                               // movl         %eax, %edx
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x0c88; BYTE $0x17                   // movb         %cl, (%rdi,%rdx)
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB4_5:
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xfe83; BYTE $0x0a       // cmpl         $10, %esi
+	LONG $0xffc8830f; WORD $0xffff // jae          LBB4_6, $-56(%rip)
+	LONG $0xffffd5e9; BYTE $0xff   // jmp          LBB4_7, $-43(%rip)
+
+LBB4_8:
+	LONG $0xfffe8148; WORD $0xf5e0; BYTE $0x05 // cmpq         $99999999, %rsi
+	LONG $0x0005870f; WORD $0x0000             // ja           LBB4_9, $5(%rip)
+	LONG $0x000029e9; BYTE $0x00               // jmp          _u32toa_medium, $41(%rip)
+
+LBB4_9:
+	QUAD $0x86f26fc0ffffb848; WORD $0x0023 // movabsq      $9999999999999999, %rax
+	WORD $0x3948; BYTE $0xc6               // cmpq         %rax, %rsi
+	LONG $0x0005870f; WORD $0x0000         // ja           LBB4_10, $5(%rip)
+	LONG $0x000161e9; BYTE $0x00           // jmp          _u64toa_large_sse2, $353(%rip)
+
+LBB4_10:
+	LONG $0x0002cce9; BYTE $0x00               // jmp          _u64toa_xlarge_sse2, $716(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+_u32toa_medium:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0xf089                               // movl         %esi, %eax
+	LONG $0xb71759b9; BYTE $0xd1               // movl         $3518437209, %ecx
+	LONG $0xc8af0f48                           // imulq        %rax, %rcx
+	LONG $0x2de9c148                           // shrq         $45, %rcx
+	LONG $0x2710d169; WORD $0x0000             // imull        $10000, %ecx, %edx
+	WORD $0x8941; BYTE $0xf0                   // movl         %esi, %r8d
+	WORD $0x2941; BYTE $0xd0                   // subl         %edx, %r8d
+	LONG $0x83d06948; WORD $0x1bde; BYTE $0x43 // imulq        $1125899907, %rax, %rdx
+	LONG $0x31eac148                           // shrq         $49, %rdx
+	WORD $0xe283; BYTE $0xfe                   // andl         $-2, %edx
+	LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rcx, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xc06b; BYTE $0x64                   // imull        $100, %eax, %eax
+	WORD $0xc129                               // subl         %eax, %ecx
+	WORD $0x0148; BYTE $0xc9                   // addq         %rcx, %rcx
+	LONG $0x9680fe81; WORD $0x0098             // cmpl         $10000000, %esi
+	LONG $0x0017820f; WORD $0x0000             // jb           LBB5_2, $23(%rip)
+	LONG $0xdd058d48; WORD $0x00a3; BYTE $0x00 // leaq         $41949(%rip), %rax  /* _Digits(%rip) */
+	LONG $0x0204b60f                           // movzbl       (%rdx,%rax), %eax
+	WORD $0x0788                               // movb         %al, (%rdi)
+	LONG $0x000001b8; BYTE $0x00               // movl         $1, %eax
+	LONG $0x00000ee9; BYTE $0x00               // jmp          LBB5_3, $14(%rip)
+
+LBB5_2:
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x4240fe81; WORD $0x000f // cmpl         $1000000, %esi
+	LONG $0x0074820f; WORD $0x0000 // jb           LBB5_4, $116(%rip)
+
+LBB5_3:
+	WORD $0xd289                               // movl         %edx, %edx
+	LONG $0x01ca8348                           // orq          $1, %rdx
+	LONG $0xb2358d48; WORD $0x00a3; BYTE $0x00 // leaq         $41906(%rip), %rsi  /* _Digits(%rip) */
+	LONG $0x3214b60f                           // movzbl       (%rdx,%rsi), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB5_5:
+	LONG $0xa0158d48; WORD $0x00a3; BYTE $0x00 // leaq         $41888(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x1114b60f                           // movzbl       (%rcx,%rdx), %edx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xc0ff                               // incl         %eax
+	WORD $0x1488; BYTE $0x37                   // movb         %dl, (%rdi,%rsi)
+
+LBB5_6:
+	LONG $0xd0b70f41                           // movzwl       %r8w, %edx
+	WORD $0xeac1; BYTE $0x02                   // shrl         $2, %edx
+	LONG $0x147bd269; WORD $0x0000             // imull        $5243, %edx, %edx
+	WORD $0xeac1; BYTE $0x11                   // shrl         $17, %edx
+	WORD $0xf26b; BYTE $0x64                   // imull        $100, %edx, %esi
+	WORD $0x2941; BYTE $0xf0                   // subl         %esi, %r8d
+	LONG $0xc0b70f45                           // movzwl       %r8w, %r8d
+	WORD $0xc989                               // movl         %ecx, %ecx
+	LONG $0x01c98348                           // orq          $1, %rcx
+	LONG $0x6e0d8d4c; WORD $0x00a3; BYTE $0x00 // leaq         $41838(%rip), %r9  /* _Digits(%rip) */
+	LONG $0x0cb60f42; BYTE $0x09               // movzbl       (%rcx,%r9), %ecx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0x0c88; BYTE $0x37                   // movb         %cl, (%rdi,%rsi)
+	LONG $0x0cb70f41; BYTE $0x51               // movzwl       (%r9,%rdx,2), %ecx
+	LONG $0x374c8966; BYTE $0x01               // movw         %cx, $1(%rdi,%rsi)
+	LONG $0x0cb70f43; BYTE $0x41               // movzwl       (%r9,%r8,2), %ecx
+	LONG $0x374c8966; BYTE $0x03               // movw         %cx, $3(%rdi,%rsi)
+	WORD $0xc083; BYTE $0x05                   // addl         $5, %eax
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB5_4:
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x86a0fe81; WORD $0x0001 // cmpl         $100000, %esi
+	LONG $0xff96830f; WORD $0xffff // jae          LBB5_5, $-106(%rip)
+	LONG $0xffffa3e9; BYTE $0xff   // jmp          LBB5_6, $-93(%rip)
+	QUAD $0x0000000000000000       // .p2align 4, 0x00
+
+LCPI6_0:
+	QUAD $0x00000000d1b71759 // .quad 3518437209
+	QUAD $0x00000000d1b71759 // .quad 3518437209
+
+LCPI6_1:
+	WORD $0x20c5 // .word 8389
+	WORD $0x147b // .word 5243
+	WORD $0x3334 // .word 13108
+	WORD $0x8000 // .word 32768
+	WORD $0x20c5 // .word 8389
+	WORD $0x147b // .word 5243
+	WORD $0x3334 // .word 13108
+	WORD $0x8000 // .word 32768
+
+LCPI6_2:
+	WORD $0x0080 // .word 128
+	WORD $0x0800 // .word 2048
+	WORD $0x2000 // .word 8192
+	WORD $0x8000 // .word 32768
+	WORD $0x0080 // .word 128
+	WORD $0x0800 // .word 2048
+	WORD $0x2000 // .word 8192
+	WORD $0x8000 // .word 32768
+
+LCPI6_3:
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+
+LCPI6_4:
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+
+	// .p2align 4, 0x90
+_u64toa_large_sse2:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	QUAD $0x77118461cefdb948; WORD $0xabcc     // movabsq      $-6067343680855748867, %rcx
+	WORD $0x8948; BYTE $0xf0                   // movq         %rsi, %rax
+	WORD $0xf748; BYTE $0xe1                   // mulq         %rcx
+	LONG $0x1aeac148                           // shrq         $26, %rdx
+	LONG $0xe100c269; WORD $0x05f5             // imull        $100000000, %edx, %eax
+	WORD $0xc629                               // subl         %eax, %esi
+	LONG $0xc26e0f66                           // movd         %edx, %xmm0
+	QUAD $0xffffff840d6f0f66                   // movdqa       $-124(%rip), %xmm1  /* LCPI6_0(%rip) */
+	LONG $0xd06f0f66                           // movdqa       %xmm0, %xmm2
+	LONG $0xd1f40f66                           // pmuludq      %xmm1, %xmm2
+	LONG $0xd2730f66; BYTE $0x2d               // psrlq        $45, %xmm2
+	LONG $0x002710b8; BYTE $0x00               // movl         $10000, %eax
+	LONG $0x6e0f4866; BYTE $0xd8               // movq         %rax, %xmm3
+	LONG $0xe26f0f66                           // movdqa       %xmm2, %xmm4
+	LONG $0xe3f40f66                           // pmuludq      %xmm3, %xmm4
+	LONG $0xc4fa0f66                           // psubd        %xmm4, %xmm0
+	LONG $0xd0610f66                           // punpcklwd    %xmm0, %xmm2
+	LONG $0xf2730f66; BYTE $0x02               // psllq        $2, %xmm2
+	LONG $0xc2700ff2; BYTE $0x50               // pshuflw      $80, %xmm2, %xmm0
+	LONG $0xc0700f66; BYTE $0x50               // pshufd       $80, %xmm0, %xmm0
+	QUAD $0xffffff56156f0f66                   // movdqa       $-170(%rip), %xmm2  /* LCPI6_1(%rip) */
+	LONG $0xc2e40f66                           // pmulhuw      %xmm2, %xmm0
+	QUAD $0xffffff5a256f0f66                   // movdqa       $-166(%rip), %xmm4  /* LCPI6_2(%rip) */
+	LONG $0xc4e40f66                           // pmulhuw      %xmm4, %xmm0
+	QUAD $0xffffff5e2d6f0f66                   // movdqa       $-162(%rip), %xmm5  /* LCPI6_3(%rip) */
+	LONG $0xf06f0f66                           // movdqa       %xmm0, %xmm6
+	LONG $0xf5d50f66                           // pmullw       %xmm5, %xmm6
+	LONG $0xf6730f66; BYTE $0x10               // psllq        $16, %xmm6
+	LONG $0xc6f90f66                           // psubw        %xmm6, %xmm0
+	LONG $0xf66e0f66                           // movd         %esi, %xmm6
+	LONG $0xcef40f66                           // pmuludq      %xmm6, %xmm1
+	LONG $0xd1730f66; BYTE $0x2d               // psrlq        $45, %xmm1
+	LONG $0xd9f40f66                           // pmuludq      %xmm1, %xmm3
+	LONG $0xf3fa0f66                           // psubd        %xmm3, %xmm6
+	LONG $0xce610f66                           // punpcklwd    %xmm6, %xmm1
+	LONG $0xf1730f66; BYTE $0x02               // psllq        $2, %xmm1
+	LONG $0xc9700ff2; BYTE $0x50               // pshuflw      $80, %xmm1, %xmm1
+	LONG $0xc9700f66; BYTE $0x50               // pshufd       $80, %xmm1, %xmm1
+	LONG $0xcae40f66                           // pmulhuw      %xmm2, %xmm1
+	LONG $0xcce40f66                           // pmulhuw      %xmm4, %xmm1
+	LONG $0xe9d50f66                           // pmullw       %xmm1, %xmm5
+	LONG $0xf5730f66; BYTE $0x10               // psllq        $16, %xmm5
+	LONG $0xcdf90f66                           // psubw        %xmm5, %xmm1
+	LONG $0xc1670f66                           // packuswb     %xmm1, %xmm0
+	QUAD $0xffffff140d6f0f66                   // movdqa       $-236(%rip), %xmm1  /* LCPI6_4(%rip) */
+	LONG $0xc8fc0f66                           // paddb        %xmm0, %xmm1
+	LONG $0xd2ef0f66                           // pxor         %xmm2, %xmm2
+	LONG $0xd0740f66                           // pcmpeqb      %xmm0, %xmm2
+	LONG $0xc2d70f66                           // pmovmskb     %xmm2, %eax
+	WORD $0xd0f7                               // notl         %eax
+	LONG $0x0080000d; BYTE $0x00               // orl          $32768, %eax
+	WORD $0xbc0f; BYTE $0xc8                   // bsfl         %eax, %ecx
+	LONG $0x000010b8; BYTE $0x00               // movl         $16, %eax
+	WORD $0xc829                               // subl         %ecx, %eax
+	LONG $0x04e1c148                           // shlq         $4, %rcx
+	LONG $0x38158d48; WORD $0x00c9; BYTE $0x00 // leaq         $51512(%rip), %rdx  /* _VecShiftShuffles(%rip) */
+	LONG $0x00380f66; WORD $0x110c             // pshufb       (%rcx,%rdx), %xmm1
+	LONG $0x0f7f0ff3                           // movdqu       %xmm1, (%rdi)
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+	QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00
+
+LCPI7_0:
+	QUAD $0x00000000d1b71759 // .quad 3518437209
+	QUAD $0x00000000d1b71759 // .quad 3518437209
+
+LCPI7_1:
+	WORD $0x20c5 // .word 8389
+	WORD $0x147b // .word 5243
+	WORD $0x3334 // .word 13108
+	WORD $0x8000 // .word 32768
+	WORD $0x20c5 // .word 8389
+	WORD $0x147b // .word 5243
+	WORD $0x3334 // .word 13108
+	WORD $0x8000 // .word 32768
+
+LCPI7_2:
+	WORD $0x0080 // .word 128
+	WORD $0x0800 // .word 2048
+	WORD $0x2000 // .word 8192
+	WORD $0x8000 // .word 32768
+	WORD $0x0080 // .word 128
+	WORD $0x0800 // .word 2048
+	WORD $0x2000 // .word 8192
+	WORD $0x8000 // .word 32768
+
+LCPI7_3:
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+	WORD $0x000a // .word 10
+
+LCPI7_4:
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+
+	// .p2align 4, 0x90
+_u64toa_xlarge_sse2:
+	BYTE $0x55                             // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5               // movq         %rsp, %rbp
+	QUAD $0x652fb1137857b948; WORD $0x39a5 // movabsq      $4153837486827862103, %rcx
+	WORD $0x8948; BYTE $0xf0               // movq         %rsi, %rax
+	WORD $0xf748; BYTE $0xe1               // mulq         %rcx
+	LONG $0x33eac148                       // shrq         $51, %rdx
+	QUAD $0x86f26fc10000b848; WORD $0x0023 // movabsq      $10000000000000000, %rax
+	LONG $0xc2af0f48                       // imulq        %rdx, %rax
+	WORD $0x2948; BYTE $0xc6               // subq         %rax, %rsi
+	WORD $0xfa83; BYTE $0x09               // cmpl         $9, %edx
+	LONG $0x000f870f; WORD $0x0000         // ja           LBB7_2, $15(%rip)
+	WORD $0xc280; BYTE $0x30               // addb         $48, %dl
+	WORD $0x1788                           // movb         %dl, (%rdi)
+	LONG $0x000001b9; BYTE $0x00           // movl         $1, %ecx
+	LONG $0x0000a7e9; BYTE $0x00           // jmp          LBB7_7, $167(%rip)
+
+LBB7_2:
+	WORD $0xfa83; BYTE $0x63                   // cmpl         $99, %edx
+	LONG $0x001a870f; WORD $0x0000             // ja           LBB7_4, $26(%rip)
+	WORD $0xd089                               // movl         %edx, %eax
+	LONG $0x1d0d8d48; WORD $0x00a1; BYTE $0x00 // leaq         $41245(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	WORD $0x8966; BYTE $0x07                   // movw         %ax, (%rdi)
+	LONG $0x000002b9; BYTE $0x00               // movl         $2, %ecx
+	LONG $0x000084e9; BYTE $0x00               // jmp          LBB7_7, $132(%rip)
+
+LBB7_4:
+	WORD $0xd089                               // movl         %edx, %eax
+	WORD $0xe8c1; BYTE $0x02                   // shrl         $2, %eax
+	LONG $0x147bc069; WORD $0x0000             // imull        $5243, %eax, %eax
+	WORD $0xe8c1; BYTE $0x11                   // shrl         $17, %eax
+	LONG $0x03e7fa81; WORD $0x0000             // cmpl         $999, %edx
+	LONG $0x0037870f; WORD $0x0000             // ja           LBB7_6, $55(%rip)
+	WORD $0xc083; BYTE $0x30                   // addl         $48, %eax
+	WORD $0x0788                               // movb         %al, (%rdi)
+	WORD $0xb70f; BYTE $0xc2                   // movzwl       %dx, %eax
+	WORD $0xc189                               // movl         %eax, %ecx
+	WORD $0xe9c1; BYTE $0x02                   // shrl         $2, %ecx
+	LONG $0x147bc969; WORD $0x0000             // imull        $5243, %ecx, %ecx
+	WORD $0xe9c1; BYTE $0x11                   // shrl         $17, %ecx
+	WORD $0xc96b; BYTE $0x64                   // imull        $100, %ecx, %ecx
+	WORD $0xc829                               // subl         %ecx, %eax
+	WORD $0xb70f; BYTE $0xc0                   // movzwl       %ax, %eax
+	LONG $0xcd0d8d48; WORD $0x00a0; BYTE $0x00 // leaq         $41165(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	LONG $0x01478966                           // movw         %ax, $1(%rdi)
+	LONG $0x000003b9; BYTE $0x00               // movl         $3, %ecx
+	LONG $0x000033e9; BYTE $0x00               // jmp          LBB7_7, $51(%rip)
+
+LBB7_6:
+	WORD $0xc86b; BYTE $0x64                   // imull        $100, %eax, %ecx
+	WORD $0xca29                               // subl         %ecx, %edx
+	WORD $0xb70f; BYTE $0xc0                   // movzwl       %ax, %eax
+	LONG $0xac0d8d48; WORD $0x00a0; BYTE $0x00 // leaq         $41132(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	WORD $0x8966; BYTE $0x07                   // movw         %ax, (%rdi)
+	WORD $0xb70f; BYTE $0xc2                   // movzwl       %dx, %eax
+	LONG $0x4114b60f                           // movzbl       (%rcx,%rax,2), %edx
+	WORD $0x0148; BYTE $0xc0                   // addq         %rax, %rax
+	WORD $0x5788; BYTE $0x02                   // movb         %dl, $2(%rdi)
+	WORD $0xb70f; BYTE $0xc0                   // movzwl       %ax, %eax
+	LONG $0x0844b60f; BYTE $0x01               // movzbl       $1(%rax,%rcx), %eax
+	WORD $0x4788; BYTE $0x03                   // movb         %al, $3(%rdi)
+	LONG $0x000004b9; BYTE $0x00               // movl         $4, %ecx
+
+LBB7_7:
+	QUAD $0x77118461cefdba48; WORD $0xabcc // movabsq      $-6067343680855748867, %rdx
+	WORD $0x8948; BYTE $0xf0               // movq         %rsi, %rax
+	WORD $0xf748; BYTE $0xe2               // mulq         %rdx
+	LONG $0x1aeac148                       // shrq         $26, %rdx
+	LONG $0xc26e0f66                       // movd         %edx, %xmm0
+	QUAD $0xfffffea80d6f0f66               // movdqa       $-344(%rip), %xmm1  /* LCPI7_0(%rip) */
+	LONG $0xd86f0f66                       // movdqa       %xmm0, %xmm3
+	LONG $0xd9f40f66                       // pmuludq      %xmm1, %xmm3
+	LONG $0xd3730f66; BYTE $0x2d           // psrlq        $45, %xmm3
+	LONG $0x002710b8; BYTE $0x00           // movl         $10000, %eax
+	LONG $0x6e0f4866; BYTE $0xd0           // movq         %rax, %xmm2
+	LONG $0xe36f0f66                       // movdqa       %xmm3, %xmm4
+	LONG $0xe2f40f66                       // pmuludq      %xmm2, %xmm4
+	LONG $0xc4fa0f66                       // psubd        %xmm4, %xmm0
+	LONG $0xd8610f66                       // punpcklwd    %xmm0, %xmm3
+	LONG $0xf3730f66; BYTE $0x02           // psllq        $2, %xmm3
+	LONG $0xc3700ff2; BYTE $0x50           // pshuflw      $80, %xmm3, %xmm0
+	LONG $0xc0700f66; BYTE $0x50           // pshufd       $80, %xmm0, %xmm0
+	QUAD $0xfffffe7a256f0f66               // movdqa       $-390(%rip), %xmm4  /* LCPI7_1(%rip) */
+	LONG $0xc4e40f66                       // pmulhuw      %xmm4, %xmm0
+	QUAD $0xfffffe7e2d6f0f66               // movdqa       $-386(%rip), %xmm5  /* LCPI7_2(%rip) */
+	LONG $0xc5e40f66                       // pmulhuw      %xmm5, %xmm0
+	QUAD $0xfffffe821d6f0f66               // movdqa       $-382(%rip), %xmm3  /* LCPI7_3(%rip) */
+	LONG $0xf06f0f66                       // movdqa       %xmm0, %xmm6
+	LONG $0xf3d50f66                       // pmullw       %xmm3, %xmm6
+	LONG $0xf6730f66; BYTE $0x10           // psllq        $16, %xmm6
+	LONG $0xc6f90f66                       // psubw        %xmm6, %xmm0
+	LONG $0xe100c269; WORD $0x05f5         // imull        $100000000, %edx, %eax
+	WORD $0xc629                           // subl         %eax, %esi
+	LONG $0xf66e0f66                       // movd         %esi, %xmm6
+	LONG $0xcef40f66                       // pmuludq      %xmm6, %xmm1
+	LONG $0xd1730f66; BYTE $0x2d           // psrlq        $45, %xmm1
+	LONG $0xd1f40f66                       // pmuludq      %xmm1, %xmm2
+	LONG $0xf2fa0f66                       // psubd        %xmm2, %xmm6
+	LONG $0xce610f66                       // punpcklwd    %xmm6, %xmm1
+	LONG $0xf1730f66; BYTE $0x02           // psllq        $2, %xmm1
+	LONG $0xc9700ff2; BYTE $0x50           // pshuflw      $80, %xmm1, %xmm1
+	LONG $0xc9700f66; BYTE $0x50           // pshufd       $80, %xmm1, %xmm1
+	LONG $0xcce40f66                       // pmulhuw      %xmm4, %xmm1
+	LONG $0xcde40f66                       // pmulhuw      %xmm5, %xmm1
+	LONG $0xd9d50f66                       // pmullw       %xmm1, %xmm3
+	LONG $0xf3730f66; BYTE $0x10           // psllq        $16, %xmm3
+	LONG $0xcbf90f66                       // psubw        %xmm3, %xmm1
+	LONG $0xc1670f66                       // packuswb     %xmm1, %xmm0
+	QUAD $0xfffffe3005fc0f66               // paddb        $-464(%rip), %xmm0  /* LCPI7_4(%rip) */
+	WORD $0xc889                           // movl         %ecx, %eax
+	LONG $0x047f0ff3; BYTE $0x07           // movdqu       %xmm0, (%rdi,%rax)
+	WORD $0xc983; BYTE $0x10               // orl          $16, %ecx
+	WORD $0xc889                           // movl         %ecx, %eax
+	BYTE $0x5d                             // popq         %rbp
+	BYTE $0xc3                             // retq
+	WORD $0x0000                           // .p2align 4, 0x00
+
+LCPI8_0:
+	QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
+
+LCPI8_1:
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+
+LCPI8_2:
+	QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f'
+
+	// .p2align 4, 0x90
+_quote:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x20ec8348                           // subq         $32, %rsp
+	WORD $0x8949; BYTE $0xcb                   // movq         %rcx, %r11
+	WORD $0x8949; BYTE $0xd7                   // movq         %rdx, %r15
+	WORD $0x8b4c; BYTE $0x11                   // movq         (%rcx), %r10
+	LONG $0x01c0f641                           // testb        $1, %r8b
+	WORD $0x8948; BYTE $0xf0                   // movq         %rsi, %rax
+	LONG $0x380d8d48; WORD $0x00c7; BYTE $0x00 // leaq         $51000(%rip), %rcx  /* __SingleQuoteTab(%rip) */
+	LONG $0x31258d4c; WORD $0x00d7; BYTE $0x00 // leaq         $55089(%rip), %r12  /* __DoubleQuoteTab(%rip) */
+	LONG $0xe1440f4c                           // cmoveq       %rcx, %r12
+	QUAD $0x00000000f50c8d48                   // leaq         (,%rsi,8), %rcx
+	WORD $0x3949; BYTE $0xca                   // cmpq         %rcx, %r10
+	LONG $0x03fc8d0f; WORD $0x0000             // jge          LBB8_56, $1020(%rip)
+	WORD $0x894d; BYTE $0xfe                   // movq         %r15, %r14
+	WORD $0x8949; BYTE $0xf9                   // movq         %rdi, %r9
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0x03dc840f; WORD $0x0000             // je           LBB8_79, $988(%rip)
+	LONG $0xc85d894c                           // movq         %r11, $-56(%rbp)
+	QUAD $0xffffff71056f0f66                   // movdqa       $-143(%rip), %xmm0  /* LCPI8_0(%rip) */
+	QUAD $0xffffff790d6f0f66                   // movdqa       $-135(%rip), %xmm1  /* LCPI8_1(%rip) */
+	QUAD $0xffffff81156f0f66                   // movdqa       $-127(%rip), %xmm2  /* LCPI8_2(%rip) */
+	WORD $0x8948; BYTE $0xf9                   // movq         %rdi, %rcx
+	LONG $0xd07d894c                           // movq         %r15, $-48(%rbp)
+	WORD $0x894d; BYTE $0xfe                   // movq         %r15, %r14
+	LONG $0xc065894c                           // movq         %r12, $-64(%rbp)
+
+LBB8_3:
+	WORD $0x8949; BYTE $0xc9       // movq         %rcx, %r9
+	LONG $0x10f88348               // cmpq         $16, %rax
+	WORD $0x9d0f; BYTE $0xc3       // setge        %bl
+	WORD $0x894d; BYTE $0xd4       // movq         %r10, %r12
+	WORD $0x894d; BYTE $0xf7       // movq         %r14, %r15
+	WORD $0x8949; BYTE $0xc3       // movq         %rax, %r11
+	WORD $0x8949; BYTE $0xcd       // movq         %rcx, %r13
+	LONG $0x10fa8349               // cmpq         $16, %r10
+	LONG $0x007b8c0f; WORD $0x0000 // jl           LBB8_10, $123(%rip)
+	LONG $0x10f88348               // cmpq         $16, %rax
+	LONG $0x00718c0f; WORD $0x0000 // jl           LBB8_10, $113(%rip)
+	WORD $0x3145; BYTE $0xff       // xorl         %r15d, %r15d
+	WORD $0x8948; BYTE $0xc6       // movq         %rax, %rsi
+	WORD $0x894c; BYTE $0xd2       // movq         %r10, %rdx
+
+	// .p2align 4, 0x90
+LBB8_6:
+	LONG $0x6f0f43f3; WORD $0x391c // movdqu       (%r9,%r15), %xmm3
+	LONG $0xe36f0f66               // movdqa       %xmm3, %xmm4
+	LONG $0x7f0f43f3; WORD $0x3e1c // movdqu       %xmm3, (%r14,%r15)
+	LONG $0xeb6f0f66               // movdqa       %xmm3, %xmm5
+	LONG $0xeada0f66               // pminub       %xmm2, %xmm5
+	LONG $0xeb740f66               // pcmpeqb      %xmm3, %xmm5
+	LONG $0xd8740f66               // pcmpeqb      %xmm0, %xmm3
+	LONG $0xe1740f66               // pcmpeqb      %xmm1, %xmm4
+	LONG $0xe3eb0f66               // por          %xmm3, %xmm4
+	LONG $0xeceb0f66               // por          %xmm4, %xmm5
+	LONG $0xcdd70f66               // pmovmskb     %xmm5, %ecx
+	WORD $0xc985                   // testl        %ecx, %ecx
+	LONG $0x0132850f; WORD $0x0000 // jne          LBB8_23, $306(%rip)
+	LONG $0xf05e8d4c               // leaq         $-16(%rsi), %r11
+	LONG $0xf0628d4c               // leaq         $-16(%rdx), %r12
+	LONG $0x10c78349               // addq         $16, %r15
+	LONG $0x20fe8348               // cmpq         $32, %rsi
+	WORD $0x9d0f; BYTE $0xc3       // setge        %bl
+	LONG $0x00108c0f; WORD $0x0000 // jl           LBB8_9, $16(%rip)
+	WORD $0x894c; BYTE $0xde       // movq         %r11, %rsi
+	LONG $0x1ffa8348               // cmpq         $31, %rdx
+	WORD $0x894c; BYTE $0xe2       // movq         %r12, %rdx
+	LONG $0xff9f8f0f; WORD $0xffff // jg           LBB8_6, $-97(%rip)
+
+LBB8_9:
+	LONG $0x392c8d4f         // leaq         (%r9,%r15), %r13
+	WORD $0x014d; BYTE $0xf7 // addq         %r14, %r15
+
+LBB8_10:
+	WORD $0xdb84                   // testb        %bl, %bl
+	LONG $0x006b840f; WORD $0x0000 // je           LBB8_14, $107(%rip)
+	LONG $0x6f0f41f3; WORD $0x005d // movdqu       (%r13), %xmm3
+	LONG $0xe36f0f66               // movdqa       %xmm3, %xmm4
+	LONG $0xeb6f0f66               // movdqa       %xmm3, %xmm5
+	LONG $0xeada0f66               // pminub       %xmm2, %xmm5
+	LONG $0xeb740f66               // pcmpeqb      %xmm3, %xmm5
+	LONG $0x7e0f4866; BYTE $0xd9   // movq         %xmm3, %rcx
+	LONG $0xd8740f66               // pcmpeqb      %xmm0, %xmm3
+	LONG $0xe1740f66               // pcmpeqb      %xmm1, %xmm4
+	LONG $0xe3eb0f66               // por          %xmm3, %xmm4
+	LONG $0xeceb0f66               // por          %xmm4, %xmm5
+	LONG $0xd5d70f66               // pmovmskb     %xmm5, %edx
+	LONG $0x0000ca81; WORD $0x0001 // orl          $65536, %edx
+	LONG $0xdabc0f44               // bsfl         %edx, %r11d
+	WORD $0x394d; BYTE $0xdc       // cmpq         %r11, %r12
+	LONG $0x00c88d0f; WORD $0x0000 // jge          LBB8_24, $200(%rip)
+	LONG $0x08fc8349               // cmpq         $8, %r12
+	LONG $0x00fd820f; WORD $0x0000 // jb           LBB8_28, $253(%rip)
+	WORD $0x8949; BYTE $0x0f       // movq         %rcx, (%r15)
+	LONG $0x085d8d4d               // leaq         $8(%r13), %r11
+	LONG $0x08c78349               // addq         $8, %r15
+	LONG $0x245c8d49; BYTE $0xf8   // leaq         $-8(%r12), %rbx
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x00f38d0f; WORD $0x0000 // jge          LBB8_29, $243(%rip)
+	LONG $0x000100e9; BYTE $0x00   // jmp          LBB8_30, $256(%rip)
+
+LBB8_14:
+	WORD $0x854d; BYTE $0xdb               // testq        %r11, %r11
+	LONG $0x006e8e0f; WORD $0x0000         // jle          LBB8_21, $110(%rip)
+	WORD $0x854d; BYTE $0xe4               // testq        %r12, %r12
+	LONG $0x00658e0f; WORD $0x0000         // jle          LBB8_21, $101(%rip)
+	LONG $0xb84d894c                       // movq         %r9, $-72(%rbp)
+	WORD $0x3145; BYTE $0xc9               // xorl         %r9d, %r9d
+	WORD $0xd231                           // xorl         %edx, %edx
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB8_17:
+	LONG $0x4cb60f43; WORD $0x000d             // movzbl       (%r13,%r9), %ecx
+	WORD $0x8948; BYTE $0xcb                   // movq         %rcx, %rbx
+	LONG $0x04e3c148                           // shlq         $4, %rbx
+	LONG $0x9c358d48; WORD $0x00c5; BYTE $0x00 // leaq         $50588(%rip), %rsi  /* __SingleQuoteTab(%rip) */
+	LONG $0x333c8348; BYTE $0x00               // cmpq         $0, (%rbx,%rsi)
+	LONG $0x008b850f; WORD $0x0000             // jne          LBB8_27, $139(%rip)
+	LONG $0x13048d4d                           // leaq         (%r11,%rdx), %r8
+	LONG $0x0f0c8843                           // movb         %cl, (%r15,%r9)
+	LONG $0xff5a8d48                           // leaq         $-1(%rdx), %rbx
+	LONG $0x02f88349                           // cmpq         $2, %r8
+	LONG $0x00138c0f; WORD $0x0000             // jl           LBB8_20, $19(%rip)
+	WORD $0x014c; BYTE $0xe2                   // addq         %r12, %rdx
+	WORD $0xff49; BYTE $0xc1                   // incq         %r9
+	LONG $0x01fa8348                           // cmpq         $1, %rdx
+	WORD $0x8948; BYTE $0xda                   // movq         %rbx, %rdx
+	LONG $0xffb88f0f; WORD $0xffff             // jg           LBB8_17, $-72(%rip)
+
+LBB8_20:
+	WORD $0x2949; BYTE $0xdd // subq         %rbx, %r13
+	WORD $0x0149; BYTE $0xdb // addq         %rbx, %r11
+	LONG $0xb84d8b4c         // movq         $-72(%rbp), %r9
+
+LBB8_21:
+	WORD $0x854d; BYTE $0xdb       // testq        %r11, %r11
+	LONG $0xc0658b4c               // movq         $-64(%rbp), %r12
+	LONG $0x0043840f; WORD $0x0000 // je           LBB8_26, $67(%rip)
+	WORD $0xf749; BYTE $0xd5       // notq         %r13
+	WORD $0x014d; BYTE $0xcd       // addq         %r9, %r13
+	LONG $0x000129e9; BYTE $0x00   // jmp          LBB8_41, $297(%rip)
+
+LBB8_23:
+	LONG $0xc9bc0f66             // bsfw         %cx, %cx
+	LONG $0xe9b70f44             // movzwl       %cx, %r13d
+	WORD $0x014d; BYTE $0xfd     // addq         %r15, %r13
+	LONG $0x000115e9; BYTE $0x00 // jmp          LBB8_40, $277(%rip)
+
+LBB8_24:
+	LONG $0x08fb8341               // cmpl         $8, %r11d
+	LONG $0x00a4820f; WORD $0x0000 // jb           LBB8_34, $164(%rip)
+	WORD $0x8949; BYTE $0x0f       // movq         %rcx, (%r15)
+	LONG $0x08658d4d               // leaq         $8(%r13), %r12
+	LONG $0x08c78349               // addq         $8, %r15
+	LONG $0xf85b8d49               // leaq         $-8(%r11), %rbx
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x009b830f; WORD $0x0000 // jae          LBB8_35, $155(%rip)
+	LONG $0x0000a9e9; BYTE $0x00   // jmp          LBB8_36, $169(%rip)
+
+LBB8_26:
+	WORD $0x294d; BYTE $0xcd     // subq         %r9, %r13
+	LONG $0x0000e9e9; BYTE $0x00 // jmp          LBB8_41, $233(%rip)
+
+LBB8_27:
+	LONG $0xb84d8b4c             // movq         $-72(%rbp), %r9
+	WORD $0x294d; BYTE $0xcd     // subq         %r9, %r13
+	WORD $0x2949; BYTE $0xd5     // subq         %rdx, %r13
+	LONG $0x0000d6e9; BYTE $0x00 // jmp          LBB8_40, $214(%rip)
+
+LBB8_28:
+	WORD $0x894d; BYTE $0xeb       // movq         %r13, %r11
+	WORD $0x894c; BYTE $0xe3       // movq         %r12, %rbx
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x00128c0f; WORD $0x0000 // jl           LBB8_30, $18(%rip)
+
+LBB8_29:
+	WORD $0x8b41; BYTE $0x0b // movl         (%r11), %ecx
+	WORD $0x8941; BYTE $0x0f // movl         %ecx, (%r15)
+	LONG $0x04c38349         // addq         $4, %r11
+	LONG $0x04c78349         // addq         $4, %r15
+	LONG $0xfcc38348         // addq         $-4, %rbx
+
+LBB8_30:
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0x0022820f; WORD $0x0000 // jb           LBB8_31, $34(%rip)
+	LONG $0x0bb70f41               // movzwl       (%r11), %ecx
+	LONG $0x0f894166               // movw         %cx, (%r15)
+	LONG $0x02c38349               // addq         $2, %r11
+	LONG $0x02c78349               // addq         $2, %r15
+	LONG $0xfec38348               // addq         $-2, %rbx
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x000e850f; WORD $0x0000 // jne          LBB8_32, $14(%rip)
+	LONG $0x000010e9; BYTE $0x00   // jmp          LBB8_33, $16(%rip)
+
+LBB8_31:
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0007840f; WORD $0x0000 // je           LBB8_33, $7(%rip)
+
+LBB8_32:
+	LONG $0x0bb60f41         // movzbl       (%r11), %ecx
+	WORD $0x8841; BYTE $0x0f // movb         %cl, (%r15)
+
+LBB8_33:
+	WORD $0x014d; BYTE $0xec     // addq         %r13, %r12
+	WORD $0xf749; BYTE $0xd4     // notq         %r12
+	WORD $0x014d; BYTE $0xcc     // addq         %r9, %r12
+	WORD $0x894d; BYTE $0xe5     // movq         %r12, %r13
+	LONG $0x000067e9; BYTE $0x00 // jmp          LBB8_40, $103(%rip)
+
+LBB8_34:
+	WORD $0x894d; BYTE $0xec       // movq         %r13, %r12
+	WORD $0x894c; BYTE $0xdb       // movq         %r11, %rbx
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x0013820f; WORD $0x0000 // jb           LBB8_36, $19(%rip)
+
+LBB8_35:
+	LONG $0x240c8b41         // movl         (%r12), %ecx
+	WORD $0x8941; BYTE $0x0f // movl         %ecx, (%r15)
+	LONG $0x04c48349         // addq         $4, %r12
+	LONG $0x04c78349         // addq         $4, %r15
+	LONG $0xfcc38348         // addq         $-4, %rbx
+
+LBB8_36:
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0x0023820f; WORD $0x0000 // jb           LBB8_37, $35(%rip)
+	LONG $0x0cb70f41; BYTE $0x24   // movzwl       (%r12), %ecx
+	LONG $0x0f894166               // movw         %cx, (%r15)
+	LONG $0x02c48349               // addq         $2, %r12
+	LONG $0x02c78349               // addq         $2, %r15
+	LONG $0xfec38348               // addq         $-2, %rbx
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x000e850f; WORD $0x0000 // jne          LBB8_38, $14(%rip)
+	LONG $0x000011e9; BYTE $0x00   // jmp          LBB8_39, $17(%rip)
+
+LBB8_37:
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0008840f; WORD $0x0000 // je           LBB8_39, $8(%rip)
+
+LBB8_38:
+	LONG $0x0cb60f41; BYTE $0x24 // movzbl       (%r12), %ecx
+	WORD $0x8841; BYTE $0x0f     // movb         %cl, (%r15)
+
+LBB8_39:
+	WORD $0x294d; BYTE $0xcd // subq         %r9, %r13
+	WORD $0x014d; BYTE $0xdd // addq         %r11, %r13
+
+LBB8_40:
+	LONG $0xc0658b4c // movq         $-64(%rbp), %r12
+
+LBB8_41:
+	QUAD $0x000300000001bb49; WORD $0x0000 // movabsq      $12884901889, %r11
+	WORD $0x854d; BYTE $0xed               // testq        %r13, %r13
+	LONG $0x0323880f; WORD $0x0000         // js           LBB8_82, $803(%rip)
+	WORD $0x014d; BYTE $0xee               // addq         %r13, %r14
+	WORD $0x394c; BYTE $0xe8               // cmpq         %r13, %rax
+	LONG $0x00c2840f; WORD $0x0000         // je           LBB8_78, $194(%rip)
+	WORD $0x294d; BYTE $0xea               // subq         %r13, %r10
+	LONG $0x000015e9; BYTE $0x00           // jmp          LBB8_45, $21(%rip)
+	LONG $0x90909090; WORD $0x9090         // .p2align 4, 0x90
+
+LBB8_44:
+	WORD $0x0149; BYTE $0xf6       // addq         %rsi, %r14
+	WORD $0xff49; BYTE $0xc5       // incq         %r13
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	LONG $0x00a5840f; WORD $0x0000 // je           LBB8_78, $165(%rip)
+
+LBB8_45:
+	LONG $0x0cb60f43; BYTE $0x29           // movzbl       (%r9,%r13), %ecx
+	LONG $0x04e1c148                       // shlq         $4, %rcx
+	LONG $0x0c148b41                       // movl         (%r12,%rcx), %edx
+	WORD $0x8548; BYTE $0xd2               // testq        %rdx, %rdx
+	LONG $0x0082840f; WORD $0x0000         // je           LBB8_53, $130(%rip)
+	WORD $0x6348; BYTE $0xf2               // movslq       %edx, %rsi
+	WORD $0x2949; BYTE $0xf2               // subq         %rsi, %r10
+	LONG $0x02b28c0f; WORD $0x0000         // jl           LBB8_80, $690(%rip)
+	LONG $0x20e2c148                       // shlq         $32, %rdx
+	LONG $0x0c1c8d49                       // leaq         (%r12,%rcx), %rbx
+	LONG $0x08c38348                       // addq         $8, %rbx
+	WORD $0x394c; BYTE $0xda               // cmpq         %r11, %rdx
+	LONG $0x002a8c0f; WORD $0x0000         // jl           LBB8_49, $42(%rip)
+	WORD $0x0b8b                           // movl         (%rbx), %ecx
+	WORD $0x8941; BYTE $0x0e               // movl         %ecx, (%r14)
+	LONG $0x04c38348                       // addq         $4, %rbx
+	LONG $0x04468d4d                       // leaq         $4(%r14), %r8
+	LONG $0xfc4e8d48                       // leaq         $-4(%rsi), %rcx
+	LONG $0x02f98348                       // cmpq         $2, %rcx
+	LONG $0x001f830f; WORD $0x0000         // jae          LBB8_50, $31(%rip)
+	LONG $0x00002de9; BYTE $0x00           // jmp          LBB8_51, $45(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB8_49:
+	WORD $0x894d; BYTE $0xf0       // movq         %r14, %r8
+	WORD $0x8948; BYTE $0xf1       // movq         %rsi, %rcx
+	LONG $0x02f98348               // cmpq         $2, %rcx
+	LONG $0x0013820f; WORD $0x0000 // jb           LBB8_51, $19(%rip)
+
+LBB8_50:
+	WORD $0xb70f; BYTE $0x13 // movzwl       (%rbx), %edx
+	LONG $0x10894166         // movw         %dx, (%r8)
+	LONG $0x02c38348         // addq         $2, %rbx
+	LONG $0x02c08349         // addq         $2, %r8
+	LONG $0xfec18348         // addq         $-2, %rcx
+
+LBB8_51:
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0xff64840f; WORD $0xffff // je           LBB8_44, $-156(%rip)
+	WORD $0xb60f; BYTE $0x0b       // movzbl       (%rbx), %ecx
+	WORD $0x8841; BYTE $0x08       // movb         %cl, (%r8)
+	LONG $0xffff59e9; BYTE $0xff   // jmp          LBB8_44, $-167(%rip)
+
+LBB8_53:
+	LONG $0x290c8d4b               // leaq         (%r9,%r13), %rcx
+	WORD $0x294c; BYTE $0xe8       // subq         %r13, %rax
+	LONG $0xfc59850f; WORD $0xffff // jne          LBB8_3, $-935(%rip)
+
+LBB8_78:
+	WORD $0x014d; BYTE $0xe9 // addq         %r13, %r9
+	LONG $0xc85d8b4c         // movq         $-56(%rbp), %r11
+	LONG $0xd07d8b4c         // movq         $-48(%rbp), %r15
+
+LBB8_79:
+	WORD $0x294d; BYTE $0xfe     // subq         %r15, %r14
+	WORD $0x894d; BYTE $0x33     // movq         %r14, (%r11)
+	WORD $0x2949; BYTE $0xf9     // subq         %rdi, %r9
+	WORD $0x894c; BYTE $0xc8     // movq         %r9, %rax
+	LONG $0x00022ae9; BYTE $0x00 // jmp          LBB8_81, $554(%rip)
+
+LBB8_56:
+	QUAD $0xfffffb88056f0f66                   // movdqa       $-1144(%rip), %xmm0  /* LCPI8_0(%rip) */
+	QUAD $0xfffffb900d6f0f66                   // movdqa       $-1136(%rip), %xmm1  /* LCPI8_1(%rip) */
+	QUAD $0xfffffb98156f0f66                   // movdqa       $-1128(%rip), %xmm2  /* LCPI8_2(%rip) */
+	LONG $0x010d8d4c; WORD $0x00e3; BYTE $0x00 // leaq         $58113(%rip), %r9  /* __EscTab(%rip) */
+	WORD $0x894c; BYTE $0xfe                   // movq         %r15, %rsi
+	WORD $0x8948; BYTE $0xc3                   // movq         %rax, %rbx
+
+LBB8_57:
+	LONG $0x10fb8348               // cmpq         $16, %rbx
+	LONG $0x004b8c0f; WORD $0x0000 // jl           LBB8_60, $75(%rip)
+	BYTE $0x90                     // .p2align 4, 0x90
+
+LBB8_58:
+	LONG $0x1f6f0ff3               // movdqu       (%rdi), %xmm3
+	LONG $0xe36f0f66               // movdqa       %xmm3, %xmm4
+	LONG $0x1e7f0ff3               // movdqu       %xmm3, (%rsi)
+	LONG $0xeb6f0f66               // movdqa       %xmm3, %xmm5
+	LONG $0xeada0f66               // pminub       %xmm2, %xmm5
+	LONG $0xeb740f66               // pcmpeqb      %xmm3, %xmm5
+	LONG $0xd8740f66               // pcmpeqb      %xmm0, %xmm3
+	LONG $0xe1740f66               // pcmpeqb      %xmm1, %xmm4
+	LONG $0xe3eb0f66               // por          %xmm3, %xmm4
+	LONG $0xeceb0f66               // por          %xmm4, %xmm5
+	LONG $0xcdd70f66               // pmovmskb     %xmm5, %ecx
+	WORD $0xc985                   // testl        %ecx, %ecx
+	LONG $0x0128850f; WORD $0x0000 // jne          LBB8_70, $296(%rip)
+	LONG $0x10c78348               // addq         $16, %rdi
+	LONG $0x10c68348               // addq         $16, %rsi
+	LONG $0xf0c38348               // addq         $-16, %rbx
+	LONG $0x10fb8348               // cmpq         $16, %rbx
+	LONG $0xffb6830f; WORD $0xffff // jae          LBB8_58, $-74(%rip)
+
+LBB8_60:
+	LONG $0x08fb8348               // cmpq         $8, %rbx
+	LONG $0x007b8c0f; WORD $0x0000 // jl           LBB8_64, $123(%rip)
+	WORD $0xb60f; BYTE $0x0f       // movzbl       (%rdi), %ecx
+	LONG $0x0157b60f               // movzbl       $1(%rdi), %edx
+	LONG $0x14b60f42; BYTE $0x0a   // movzbl       (%rdx,%r9), %edx
+	WORD $0xd200                   // addb         %dl, %dl
+	LONG $0x09140a42               // orb          (%rcx,%r9), %dl
+	LONG $0x024fb60f               // movzbl       $2(%rdi), %ecx
+	LONG $0x0cb60f42; BYTE $0x09   // movzbl       (%rcx,%r9), %ecx
+	WORD $0xe1c0; BYTE $0x02       // shlb         $2, %cl
+	WORD $0xd108                   // orb          %dl, %cl
+	LONG $0x0357b60f               // movzbl       $3(%rdi), %edx
+	LONG $0x14b60f42; BYTE $0x0a   // movzbl       (%rdx,%r9), %edx
+	WORD $0xe2c0; BYTE $0x03       // shlb         $3, %dl
+	WORD $0xca08                   // orb          %cl, %dl
+	WORD $0x8b48; BYTE $0x0f       // movq         (%rdi), %rcx
+	WORD $0x8948; BYTE $0x0e       // movq         %rcx, (%rsi)
+	LONG $0x011f850f; WORD $0x0000 // jne          LBB8_75, $287(%rip)
+	LONG $0x044fb60f               // movzbl       $4(%rdi), %ecx
+	LONG $0x0557b60f               // movzbl       $5(%rdi), %edx
+	LONG $0x14b60f42; BYTE $0x0a   // movzbl       (%rdx,%r9), %edx
+	WORD $0xd200                   // addb         %dl, %dl
+	LONG $0x09140a42               // orb          (%rcx,%r9), %dl
+	LONG $0x064fb60f               // movzbl       $6(%rdi), %ecx
+	LONG $0x0cb60f42; BYTE $0x09   // movzbl       (%rcx,%r9), %ecx
+	WORD $0xe1c0; BYTE $0x02       // shlb         $2, %cl
+	WORD $0xd108                   // orb          %dl, %cl
+	LONG $0x0757b60f               // movzbl       $7(%rdi), %edx
+	LONG $0x14b60f42; BYTE $0x0a   // movzbl       (%rdx,%r9), %edx
+	WORD $0xe2c0; BYTE $0x03       // shlb         $3, %dl
+	WORD $0xca08                   // orb          %cl, %dl
+	LONG $0x00f5850f; WORD $0x0000 // jne          LBB8_76, $245(%rip)
+	LONG $0x08c68348               // addq         $8, %rsi
+	LONG $0x08c78348               // addq         $8, %rdi
+	LONG $0xf8c38348               // addq         $-8, %rbx
+
+LBB8_64:
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x00448c0f; WORD $0x0000 // jl           LBB8_67, $68(%rip)
+	WORD $0xb60f; BYTE $0x0f       // movzbl       (%rdi), %ecx
+	LONG $0x0157b60f               // movzbl       $1(%rdi), %edx
+	LONG $0x14b60f42; BYTE $0x0a   // movzbl       (%rdx,%r9), %edx
+	WORD $0xd200                   // addb         %dl, %dl
+	LONG $0x09140a42               // orb          (%rcx,%r9), %dl
+	LONG $0x024fb60f               // movzbl       $2(%rdi), %ecx
+	LONG $0x0cb60f42; BYTE $0x09   // movzbl       (%rcx,%r9), %ecx
+	WORD $0xe1c0; BYTE $0x02       // shlb         $2, %cl
+	WORD $0xd108                   // orb          %dl, %cl
+	LONG $0x0357b60f               // movzbl       $3(%rdi), %edx
+	LONG $0x14b60f42; BYTE $0x0a   // movzbl       (%rdx,%r9), %edx
+	WORD $0xe2c0; BYTE $0x03       // shlb         $3, %dl
+	WORD $0xca08                   // orb          %cl, %dl
+	WORD $0x0f8b                   // movl         (%rdi), %ecx
+	WORD $0x0e89                   // movl         %ecx, (%rsi)
+	LONG $0x009c850f; WORD $0x0000 // jne          LBB8_75, $156(%rip)
+	LONG $0x04c68348               // addq         $4, %rsi
+	LONG $0x04c78348               // addq         $4, %rdi
+	LONG $0xfcc38348               // addq         $-4, %rbx
+
+LBB8_67:
+	WORD $0x8548; BYTE $0xdb               // testq        %rbx, %rbx
+	LONG $0x00b28e0f; WORD $0x0000         // jle          LBB8_77, $178(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB8_68:
+	WORD $0xb60f; BYTE $0x0f       // movzbl       (%rdi), %ecx
+	LONG $0x093c8042; BYTE $0x00   // cmpb         $0, (%rcx,%r9)
+	LONG $0x002e850f; WORD $0x0000 // jne          LBB8_72, $46(%rip)
+	WORD $0xff48; BYTE $0xc7       // incq         %rdi
+	WORD $0x0e88                   // movb         %cl, (%rsi)
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	LONG $0xff4b8d48               // leaq         $-1(%rbx), %rcx
+	LONG $0x01fb8348               // cmpq         $1, %rbx
+	WORD $0x8948; BYTE $0xcb       // movq         %rcx, %rbx
+	LONG $0xffd98f0f; WORD $0xffff // jg           LBB8_68, $-39(%rip)
+	LONG $0x00007ce9; BYTE $0x00   // jmp          LBB8_77, $124(%rip)
+
+LBB8_70:
+	LONG $0xc9bc0f66         // bsfw         %cx, %cx
+	WORD $0xb70f; BYTE $0xc9 // movzwl       %cx, %ecx
+
+LBB8_71:
+	WORD $0x0148; BYTE $0xcf // addq         %rcx, %rdi
+	WORD $0x2948; BYTE $0xcb // subq         %rcx, %rbx
+	WORD $0x0148; BYTE $0xce // addq         %rcx, %rsi
+
+LBB8_72:
+	WORD $0xb60f; BYTE $0x0f // movzbl       (%rdi), %ecx
+	BYTE $0x90               // .p2align 4, 0x90
+
+LBB8_73:
+	WORD $0x8948; BYTE $0xf2       // movq         %rsi, %rdx
+	WORD $0xb60f; BYTE $0xc9       // movzbl       %cl, %ecx
+	LONG $0x04e1c148               // shlq         $4, %rcx
+	LONG $0x0c346349               // movslq       (%r12,%rcx), %rsi
+	LONG $0x0c4c8b49; BYTE $0x08   // movq         $8(%r12,%rcx), %rcx
+	WORD $0x8948; BYTE $0x0a       // movq         %rcx, (%rdx)
+	WORD $0x0148; BYTE $0xd6       // addq         %rdx, %rsi
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0x00458c0f; WORD $0x0000 // jl           LBB8_77, $69(%rip)
+	WORD $0xff48; BYTE $0xcb       // decq         %rbx
+	LONG $0x014fb60f               // movzbl       $1(%rdi), %ecx
+	WORD $0xff48; BYTE $0xc7       // incq         %rdi
+	LONG $0x093c8042; BYTE $0x00   // cmpb         $0, (%rcx,%r9)
+	LONG $0xffc8850f; WORD $0xffff // jne          LBB8_73, $-56(%rip)
+	LONG $0xfffe48e9; BYTE $0xff   // jmp          LBB8_57, $-440(%rip)
+
+LBB8_75:
+	WORD $0xb60f; BYTE $0xca     // movzbl       %dl, %ecx
+	WORD $0xbc0f; BYTE $0xc9     // bsfl         %ecx, %ecx
+	LONG $0xffffabe9; BYTE $0xff // jmp          LBB8_71, $-85(%rip)
+
+LBB8_76:
+	WORD $0xb60f; BYTE $0xca     // movzbl       %dl, %ecx
+	WORD $0xbc0f; BYTE $0xc9     // bsfl         %ecx, %ecx
+	LONG $0x04518d48             // leaq         $4(%rcx), %rdx
+	WORD $0x0148; BYTE $0xcf     // addq         %rcx, %rdi
+	LONG $0x04c78348             // addq         $4, %rdi
+	WORD $0x2948; BYTE $0xd3     // subq         %rdx, %rbx
+	WORD $0x0148; BYTE $0xce     // addq         %rcx, %rsi
+	LONG $0x04c68348             // addq         $4, %rsi
+	LONG $0xffff94e9; BYTE $0xff // jmp          LBB8_72, $-108(%rip)
+
+LBB8_77:
+	WORD $0x294c; BYTE $0xfe     // subq         %r15, %rsi
+	WORD $0x8949; BYTE $0x33     // movq         %rsi, (%r11)
+	LONG $0x000017e9; BYTE $0x00 // jmp          LBB8_81, $23(%rip)
+
+LBB8_80:
+	LONG $0xd0752b4c         // subq         $-48(%rbp), %r14
+	LONG $0xc8458b48         // movq         $-56(%rbp), %rax
+	WORD $0x894c; BYTE $0x30 // movq         %r14, (%rax)
+	WORD $0x294c; BYTE $0xcf // subq         %r9, %rdi
+	WORD $0xf749; BYTE $0xd5 // notq         %r13
+	WORD $0x0149; BYTE $0xfd // addq         %rdi, %r13
+	WORD $0x894c; BYTE $0xe8 // movq         %r13, %rax
+
+LBB8_81:
+	LONG $0x20c48348 // addq         $32, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5d41     // popq         %r13
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB8_82:
+	LONG $0xd04d8b48             // movq         $-48(%rbp), %rcx
+	WORD $0x014c; BYTE $0xe9     // addq         %r13, %rcx
+	WORD $0xf748; BYTE $0xd1     // notq         %rcx
+	WORD $0x014c; BYTE $0xf1     // addq         %r14, %rcx
+	LONG $0xc8458b48             // movq         $-56(%rbp), %rax
+	WORD $0x8948; BYTE $0x08     // movq         %rcx, (%rax)
+	WORD $0x294c; BYTE $0xcf     // subq         %r9, %rdi
+	WORD $0x014c; BYTE $0xef     // addq         %r13, %rdi
+	WORD $0x8948; BYTE $0xf8     // movq         %rdi, %rax
+	LONG $0xffffcfe9; BYTE $0xff // jmp          LBB8_81, $-49(%rip)
+	LONG $0x00000000; BYTE $0x00 // .p2align 4, 0x00
+
+LCPI9_0:
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+
+	// .p2align 4, 0x90
+_unquote:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x48ec8348                           // subq         $72, %rsp
+	WORD $0x8548; BYTE $0xf6                   // testq        %rsi, %rsi
+	LONG $0x062b840f; WORD $0x0000             // je           LBB9_1, $1579(%rip)
+	LONG $0xd04d8948                           // movq         %rcx, $-48(%rbp)
+	WORD $0x8945; BYTE $0xc2                   // movl         %r8d, %r10d
+	LONG $0x01e28341                           // andl         $1, %r10d
+	LONG $0x84258d4c; WORD $0x00e1; BYTE $0x00 // leaq         $57732(%rip), %r12  /* __UnquoteTab(%rip) */
+	QUAD $0xffffffbc0d6f0f66                   // movdqa       $-68(%rip), %xmm1  /* LCPI9_0(%rip) */
+	WORD $0x8949; BYTE $0xff                   // movq         %rdi, %r15
+	WORD $0x8949; BYTE $0xf5                   // movq         %rsi, %r13
+	WORD $0x8949; BYTE $0xd6                   // movq         %rdx, %r14
+	LONG $0xb845894c                           // movq         %r8, $-72(%rbp)
+
+LBB9_4:
+	LONG $0x5c3f8041                                       // cmpb         $92, (%r15)
+	LONG $0x0015850f; WORD $0x0000                         // jne          LBB9_6, $21(%rip)
+	WORD $0x3145; BYTE $0xdb                               // xorl         %r11d, %r11d
+	LONG $0x0000cde9; BYTE $0x00                           // jmp          LBB9_18, $205(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB9_6:
+	WORD $0x894d; BYTE $0xe9       // movq         %r13, %r9
+	WORD $0x894c; BYTE $0xf1       // movq         %r14, %rcx
+	WORD $0x894d; BYTE $0xfb       // movq         %r15, %r11
+	LONG $0x10fd8349               // cmpq         $16, %r13
+	LONG $0x00458c0f; WORD $0x0000 // jl           LBB9_12, $69(%rip)
+	WORD $0xc931                   // xorl         %ecx, %ecx
+	WORD $0x894c; BYTE $0xe8       // movq         %r13, %rax
+	QUAD $0x9090909090909090       // .p2align 4, 0x90
+
+LBB9_8:
+	LONG $0x6f0f41f3; WORD $0x0f04 // movdqu       (%r15,%rcx), %xmm0
+	LONG $0x7f0f41f3; WORD $0x0e04 // movdqu       %xmm0, (%r14,%rcx)
+	LONG $0xc1740f66               // pcmpeqb      %xmm1, %xmm0
+	LONG $0xd8d70f66               // pmovmskb     %xmm0, %ebx
+	WORD $0xdb85                   // testl        %ebx, %ebx
+	LONG $0x006b850f; WORD $0x0000 // jne          LBB9_9, $107(%rip)
+	LONG $0xf0488d4c               // leaq         $-16(%rax), %r9
+	LONG $0x10c18348               // addq         $16, %rcx
+	LONG $0x1ff88348               // cmpq         $31, %rax
+	WORD $0x894c; BYTE $0xc8       // movq         %r9, %rax
+	LONG $0xffcf870f; WORD $0xffff // ja           LBB9_8, $-49(%rip)
+	LONG $0x0f1c8d4d               // leaq         (%r15,%rcx), %r11
+	WORD $0x014c; BYTE $0xf1       // addq         %r14, %rcx
+
+LBB9_12:
+	WORD $0x854d; BYTE $0xc9                               // testq        %r9, %r9
+	LONG $0x058a840f; WORD $0x0000                         // je           LBB9_2, $1418(%rip)
+	WORD $0xc031                                           // xorl         %eax, %eax
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB9_14:
+	LONG $0x1cb60f41; BYTE $0x03   // movzbl       (%r11,%rax), %ebx
+	WORD $0xfb80; BYTE $0x5c       // cmpb         $92, %bl
+	LONG $0x0014840f; WORD $0x0000 // je           LBB9_16, $20(%rip)
+	WORD $0x1c88; BYTE $0x01       // movb         %bl, (%rcx,%rax)
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3949; BYTE $0xc1       // cmpq         %rax, %r9
+	LONG $0xffe3850f; WORD $0xffff // jne          LBB9_14, $-29(%rip)
+	LONG $0x000559e9; BYTE $0x00   // jmp          LBB9_2, $1369(%rip)
+
+LBB9_16:
+	WORD $0x294d; BYTE $0xfb       // subq         %r15, %r11
+	WORD $0x0149; BYTE $0xc3       // addq         %rax, %r11
+	LONG $0xfffb8349               // cmpq         $-1, %r11
+	LONG $0x001e850f; WORD $0x0000 // jne          LBB9_18, $30(%rip)
+	LONG $0x000544e9; BYTE $0x00   // jmp          LBB9_2, $1348(%rip)
+
+LBB9_9:
+	LONG $0xc3bc0f66               // bsfw         %bx, %ax
+	LONG $0xd8b70f44               // movzwl       %ax, %r11d
+	WORD $0x0149; BYTE $0xcb       // addq         %rcx, %r11
+	LONG $0xfffb8349               // cmpq         $-1, %r11
+	LONG $0x052f840f; WORD $0x0000 // je           LBB9_2, $1327(%rip)
+	LONG $0x90909090               // .p2align 4, 0x90
+
+LBB9_18:
+	LONG $0x024b8d49               // leaq         $2(%r11), %rcx
+	WORD $0x2949; BYTE $0xcd       // subq         %rcx, %r13
+	LONG $0x05ea880f; WORD $0x0000 // js           LBB9_19, $1514(%rip)
+	WORD $0x014d; BYTE $0xdf       // addq         %r11, %r15
+	LONG $0x02c78349               // addq         $2, %r15
+	WORD $0x854d; BYTE $0xd2       // testq        %r10, %r10
+	LONG $0x0251850f; WORD $0x0000 // jne          LBB9_21, $593(%rip)
+
+LBB9_32:
+	WORD $0x014d; BYTE $0xde                                             // addq         %r11, %r14
+	LONG $0x47b60f41; BYTE $0xff                                         // movzbl       $-1(%r15), %eax
+	LONG $0x04b60f42; BYTE $0x20                                         // movzbl       (%rax,%r12), %eax
+	LONG $0x0000ff3d; BYTE $0x00                                         // cmpl         $255, %eax
+	LONG $0x002b840f; WORD $0x0000                                       // je           LBB9_38, $43(%rip)
+	WORD $0xc085                                                         // testl        %eax, %eax
+	LONG $0x05d5840f; WORD $0x0000                                       // je           LBB9_34, $1493(%rip)
+	WORD $0x8841; BYTE $0x06                                             // movb         %al, (%r14)
+	WORD $0xff49; BYTE $0xc6                                             // incq         %r14
+	WORD $0x854d; BYTE $0xed                                             // testq        %r13, %r13
+	LONG $0xfed5850f; WORD $0xffff                                       // jne          LBB9_4, $-299(%rip)
+	LONG $0x0005b9e9; BYTE $0x00                                         // jmp          LBB9_37, $1465(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB9_38:
+	LONG $0x03fd8349                           // cmpq         $3, %r13
+	LONG $0x058d860f; WORD $0x0000             // jbe          LBB9_19, $1421(%rip)
+	WORD $0x8b41; BYTE $0x1f                   // movl         (%r15), %ebx
+	WORD $0xd989                               // movl         %ebx, %ecx
+	WORD $0xd1f7                               // notl         %ecx
+	LONG $0xcfd0838d; WORD $0xcfcf             // leal         $-808464432(%rbx), %eax
+	LONG $0x8080e181; WORD $0x8080             // andl         $-2139062144, %ecx
+	WORD $0xc185                               // testl        %eax, %ecx
+	LONG $0x04be850f; WORD $0x0000             // jne          LBB9_43, $1214(%rip)
+	LONG $0x1919838d; WORD $0x1919             // leal         $421075225(%rbx), %eax
+	WORD $0xd809                               // orl          %ebx, %eax
+	LONG $0x808080a9; BYTE $0x80               // testl        $-2139062144, %eax
+	LONG $0x04ab850f; WORD $0x0000             // jne          LBB9_43, $1195(%rip)
+	WORD $0xd889                               // movl         %ebx, %eax
+	LONG $0x7f7f7f25; BYTE $0x7f               // andl         $2139062143, %eax
+	LONG $0xc0c0bb41; WORD $0xc0c0             // movl         $-1061109568, %r11d
+	WORD $0x2941; BYTE $0xc3                   // subl         %eax, %r11d
+	LONG $0x46888d44; WORD $0x4646; BYTE $0x46 // leal         $1179010630(%rax), %r9d
+	WORD $0x2141; BYTE $0xcb                   // andl         %ecx, %r11d
+	WORD $0x8545; BYTE $0xcb                   // testl        %r9d, %r11d
+	LONG $0x0488850f; WORD $0x0000             // jne          LBB9_43, $1160(%rip)
+	LONG $0xe0e0b941; WORD $0xe0e0             // movl         $-522133280, %r9d
+	WORD $0x2941; BYTE $0xc1                   // subl         %eax, %r9d
+	LONG $0x39393905; BYTE $0x39               // addl         $960051513, %eax
+	WORD $0x2144; BYTE $0xc9                   // andl         %r9d, %ecx
+	WORD $0xc185                               // testl        %eax, %ecx
+	LONG $0x046f850f; WORD $0x0000             // jne          LBB9_43, $1135(%rip)
+	WORD $0xcb0f                               // bswapl       %ebx
+	WORD $0xd989                               // movl         %ebx, %ecx
+	WORD $0xd1f7                               // notl         %ecx
+	WORD $0xe9c1; BYTE $0x04                   // shrl         $4, %ecx
+	LONG $0x0101e181; WORD $0x0101             // andl         $16843009, %ecx
+	WORD $0x0c8d; BYTE $0xc9                   // leal         (%rcx,%rcx,8), %ecx
+	LONG $0x0f0fe381; WORD $0x0f0f             // andl         $252645135, %ebx
+	WORD $0xcb01                               // addl         %ecx, %ebx
+	WORD $0xd989                               // movl         %ebx, %ecx
+	WORD $0xe9c1; BYTE $0x04                   // shrl         $4, %ecx
+	WORD $0xd909                               // orl          %ebx, %ecx
+	WORD $0xb60f; BYTE $0xd9                   // movzbl       %cl, %ebx
+	WORD $0xe9c1; BYTE $0x08                   // shrl         $8, %ecx
+	LONG $0xff00e181; WORD $0x0000             // andl         $65280, %ecx
+	WORD $0xcb09                               // orl          %ecx, %ebx
+	LONG $0x044f8d4d                           // leaq         $4(%r15), %r9
+	LONG $0xfc4d8d49                           // leaq         $-4(%r13), %rcx
+	LONG $0x0080fb81; WORD $0x0000             // cmpl         $128, %ebx
+	LONG $0x01a7820f; WORD $0x0000             // jb           LBB9_54, $423(%rip)
+	LONG $0x02c0f641                           // testb        $2, %r8b
+	LONG $0x01ae840f; WORD $0x0000             // je           LBB9_65, $430(%rip)
+	WORD $0x894d; BYTE $0xcf                   // movq         %r9, %r15
+	WORD $0x8941; BYTE $0xdc                   // movl         %ebx, %r12d
+	WORD $0x8949; BYTE $0xcd                   // movq         %rcx, %r13
+
+LBB9_59:
+	LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl         $2047, %r12d
+	LONG $0x028b860f; WORD $0x0000             // jbe          LBB9_67, $651(%rip)
+	QUAD $0xffff200024848d41                   // leal         $-57344(%r12), %eax
+	LONG $0xfff7ff3d; BYTE $0xff               // cmpl         $-2049, %eax
+	LONG $0x01b6860f; WORD $0x0000             // jbe          LBB9_70, $438(%rip)
+	WORD $0x854d; BYTE $0xd2                   // testq        %r10, %r10
+	LONG $0xc07d8948                           // movq         %rdi, $-64(%rbp)
+	LONG $0xb0758948                           // movq         %rsi, $-80(%rbp)
+	LONG $0x00ca850f; WORD $0x0000             // jne          LBB9_62, $202(%rip)
+	LONG $0xa855894c                           // movq         %r10, $-88(%rbp)
+	LONG $0xa0558948                           // movq         %rdx, $-96(%rbp)
+	LONG $0x06fd8349                           // cmpq         $6, %r13
+	LONG $0x00e38c0f; WORD $0x0000             // jl           LBB9_94, $227(%rip)
+
+LBB9_91:
+	LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl         $56319, %r12d
+	LONG $0x00d6870f; WORD $0x0000             // ja           LBB9_94, $214(%rip)
+	LONG $0x5c3f8041                           // cmpb         $92, (%r15)
+	LONG $0x00cc850f; WORD $0x0000             // jne          LBB9_94, $204(%rip)
+	LONG $0x017f8041; BYTE $0x75               // cmpb         $117, $1(%r15)
+	LONG $0x00c1850f; WORD $0x0000             // jne          LBB9_94, $193(%rip)
+	LONG $0x025f8b41                           // movl         $2(%r15), %ebx
+	WORD $0xdf89                               // movl         %ebx, %edi
+	LONG $0x0005e6e8; BYTE $0x00               // callq        _unhex16_is, $1510(%rip)
+	WORD $0xc084                               // testb        %al, %al
+	LONG $0x04d2840f; WORD $0x0000             // je           LBB9_100, $1234(%rip)
+	WORD $0xcb0f                               // bswapl       %ebx
+	WORD $0xd889                               // movl         %ebx, %eax
+	WORD $0xd0f7                               // notl         %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	LONG $0x01010125; BYTE $0x01               // andl         $16843009, %eax
+	WORD $0x048d; BYTE $0xc0                   // leal         (%rax,%rax,8), %eax
+	LONG $0x0f0fe381; WORD $0x0f0f             // andl         $252645135, %ebx
+	WORD $0xc301                               // addl         %eax, %ebx
+	WORD $0xd889                               // movl         %ebx, %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	WORD $0xd809                               // orl          %ebx, %eax
+	WORD $0xb60f; BYTE $0xc8                   // movzbl       %al, %ecx
+	WORD $0xe8c1; BYTE $0x08                   // shrl         $8, %eax
+	LONG $0x00ff0025; BYTE $0x00               // andl         $65280, %eax
+	WORD $0x1c8d; BYTE $0x08                   // leal         (%rax,%rcx), %ebx
+	LONG $0x06c78349                           // addq         $6, %r15
+	LONG $0xfac58349                           // addq         $-6, %r13
+	WORD $0xc801                               // addl         %ecx, %eax
+	LONG $0xff200005; BYTE $0xff               // addl         $-57344, %eax
+	LONG $0xfffbff3d; BYTE $0xff               // cmpl         $-1025, %eax
+	LONG $0xc07d8b48                           // movq         $-64(%rbp), %rdi
+	LONG $0xa0558b48                           // movq         $-96(%rbp), %rdx
+	LONG $0xb0758b48                           // movq         $-80(%rbp), %rsi
+	QUAD $0xfffffcd80d6f0f66                   // movdqa       $-808(%rip), %xmm1  /* LCPI9_0(%rip) */
+	LONG $0x0144870f; WORD $0x0000             // ja           LBB9_110, $324(%rip)
+	LONG $0x06c74166; WORD $0xbfef             // movw         $-16401, (%r14)
+	LONG $0x0246c641; BYTE $0xbd               // movb         $-67, $2(%r14)
+	LONG $0x03c68349                           // addq         $3, %r14
+	WORD $0x8941; BYTE $0xdc                   // movl         %ebx, %r12d
+	LONG $0x0080fb81; WORD $0x0000             // cmpl         $128, %ebx
+	LONG $0xa8558b4c                           // movq         $-88(%rbp), %r10
+	LONG $0xff0a830f; WORD $0xffff             // jae          LBB9_59, $-246(%rip)
+	LONG $0x00009fe9; BYTE $0x00               // jmp          LBB9_55, $159(%rip)
+
+LBB9_62:
+	WORD $0x854d; BYTE $0xed       // testq        %r13, %r13
+	LONG $0x04218e0f; WORD $0x0000 // jle          LBB9_63, $1057(%rip)
+	LONG $0x5c3f8041               // cmpb         $92, (%r15)
+	LONG $0x026f850f; WORD $0x0000 // jne          LBB9_96, $623(%rip)
+	WORD $0xff49; BYTE $0xcd       // decq         %r13
+	WORD $0xff49; BYTE $0xc7       // incq         %r15
+	LONG $0xa855894c               // movq         %r10, $-88(%rbp)
+	LONG $0xa0558948               // movq         %rdx, $-96(%rbp)
+	LONG $0x06fd8349               // cmpq         $6, %r13
+	LONG $0xff1d8d0f; WORD $0xffff // jge          LBB9_91, $-227(%rip)
+
+LBB9_94:
+	LONG $0x02b845f6               // testb        $2, $-72(%rbp)
+	LONG $0x02a9840f; WORD $0x0000 // je           LBB9_77, $681(%rip)
+	LONG $0x06c74166; WORD $0xbfef // movw         $-16401, (%r14)
+	LONG $0x0246c641; BYTE $0xbd   // movb         $-67, $2(%r14)
+	LONG $0x03c68349               // addq         $3, %r14
+	LONG $0x00011ae9; BYTE $0x00   // jmp          LBB9_86, $282(%rip)
+
+LBB9_21:
+	WORD $0x8545; BYTE $0xed       // testl        %r13d, %r13d
+	LONG $0x0380840f; WORD $0x0000 // je           LBB9_19, $896(%rip)
+	LONG $0xff7f8041; BYTE $0x5c   // cmpb         $92, $-1(%r15)
+	LONG $0x03a9850f; WORD $0x0000 // jne          LBB9_23, $937(%rip)
+	LONG $0x5c3f8041               // cmpb         $92, (%r15)
+	LONG $0x0027850f; WORD $0x0000 // jne          LBB9_31, $39(%rip)
+	LONG $0x01fd8341               // cmpl         $1, %r13d
+	LONG $0x03618e0f; WORD $0x0000 // jle          LBB9_19, $865(%rip)
+	LONG $0x4fb60f41; BYTE $0x01   // movzbl       $1(%r15), %ecx
+	WORD $0xf983; BYTE $0x22       // cmpl         $34, %ecx
+	LONG $0x0009840f; WORD $0x0000 // je           LBB9_30, $9(%rip)
+	WORD $0xf983; BYTE $0x5c       // cmpl         $92, %ecx
+	LONG $0x0397850f; WORD $0x0000 // jne          LBB9_29, $919(%rip)
+
+LBB9_30:
+	WORD $0xff49; BYTE $0xc7 // incq         %r15
+	WORD $0xff49; BYTE $0xcd // decq         %r13
+
+LBB9_31:
+	WORD $0xff49; BYTE $0xc7     // incq         %r15
+	WORD $0xff49; BYTE $0xcd     // decq         %r13
+	LONG $0xfffd5fe9; BYTE $0xff // jmp          LBB9_32, $-673(%rip)
+
+LBB9_54:
+	WORD $0x8949; BYTE $0xcd // movq         %rcx, %r13
+	WORD $0x894d; BYTE $0xcf // movq         %r9, %r15
+
+LBB9_55:
+	WORD $0x8841; BYTE $0x1e     // movb         %bl, (%r14)
+	WORD $0xff49; BYTE $0xc6     // incq         %r14
+	LONG $0x00005ae9; BYTE $0x00 // jmp          LBB9_56, $90(%rip)
+
+LBB9_65:
+	LONG $0x0800fb81; WORD $0x0000                     // cmpl         $2048, %ebx
+	LONG $0x00de820f; WORD $0x0000                     // jb           LBB9_66, $222(%rip)
+	LONG $0x2000838d; WORD $0xffff                     // leal         $-57344(%rbx), %eax
+	LONG $0xfff8003d; BYTE $0xff                       // cmpl         $-2048, %eax
+	LONG $0x00f6830f; WORD $0x0000                     // jae          LBB9_71, $246(%rip)
+	WORD $0x8949; BYTE $0xcd                           // movq         %rcx, %r13
+	WORD $0x8941; BYTE $0xdc                           // movl         %ebx, %r12d
+	WORD $0x894d; BYTE $0xcf                           // movq         %r9, %r15
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB9_70:
+	WORD $0x8944; BYTE $0xe0 // movl         %r12d, %eax
+	WORD $0xe8c1; BYTE $0x0c // shrl         $12, %eax
+	WORD $0xe00c             // orb          $-32, %al
+	WORD $0x8841; BYTE $0x06 // movb         %al, (%r14)
+	WORD $0x8944; BYTE $0xe0 // movl         %r12d, %eax
+	WORD $0xe8c1; BYTE $0x06 // shrl         $6, %eax
+	WORD $0x3f24             // andb         $63, %al
+	WORD $0x800c             // orb          $-128, %al
+	LONG $0x01468841         // movb         %al, $1(%r14)
+	LONG $0x3fe48041         // andb         $63, %r12b
+	LONG $0x80cc8041         // orb          $-128, %r12b
+	LONG $0x02668845         // movb         %r12b, $2(%r14)
+	LONG $0x03c68349         // addq         $3, %r14
+
+LBB9_56:
+	LONG $0xb8458b4c                           // movq         $-72(%rbp), %r8
+	LONG $0x5c258d4c; WORD $0x00dd; BYTE $0x00 // leaq         $56668(%rip), %r12  /* __UnquoteTab(%rip) */
+	WORD $0x854d; BYTE $0xed                   // testq        %r13, %r13
+	LONG $0xfbe4850f; WORD $0xffff             // jne          LBB9_4, $-1052(%rip)
+	LONG $0x0002c8e9; BYTE $0x00               // jmp          LBB9_37, $712(%rip)
+
+LBB9_110:
+	WORD $0xd889 // movl         %ebx, %eax
+
+LBB9_85:
+	LONG $0x0ae4c141             // shll         $10, %r12d
+	WORD $0xc189                 // movl         %eax, %ecx
+	WORD $0x0144; BYTE $0xe1     // addl         %r12d, %ecx
+	WORD $0x0144; BYTE $0xe0     // addl         %r12d, %eax
+	LONG $0xa0240005; BYTE $0xfc // addl         $-56613888, %eax
+	WORD $0xc289                 // movl         %eax, %edx
+	WORD $0xeac1; BYTE $0x12     // shrl         $18, %edx
+	WORD $0xca80; BYTE $0xf0     // orb          $-16, %dl
+	WORD $0x8841; BYTE $0x16     // movb         %dl, (%r14)
+	WORD $0xc289                 // movl         %eax, %edx
+	WORD $0xeac1; BYTE $0x0c     // shrl         $12, %edx
+	WORD $0xe280; BYTE $0x3f     // andb         $63, %dl
+	WORD $0xca80; BYTE $0x80     // orb          $-128, %dl
+	LONG $0x01568841             // movb         %dl, $1(%r14)
+	WORD $0xe8c1; BYTE $0x06     // shrl         $6, %eax
+	WORD $0x3f24                 // andb         $63, %al
+	WORD $0x800c                 // orb          $-128, %al
+	LONG $0x02468841             // movb         %al, $2(%r14)
+	WORD $0xe180; BYTE $0x3f     // andb         $63, %cl
+	WORD $0xc980; BYTE $0x80     // orb          $-128, %cl
+	LONG $0x034e8841             // movb         %cl, $3(%r14)
+	LONG $0x04c68349             // addq         $4, %r14
+
+LBB9_86:
+	LONG $0xc07d8b48                           // movq         $-64(%rbp), %rdi
+	LONG $0xa0558b48                           // movq         $-96(%rbp), %rdx
+	LONG $0xa8558b4c                           // movq         $-88(%rbp), %r10
+	LONG $0xb0758b48                           // movq         $-80(%rbp), %rsi
+	LONG $0xb8458b4c                           // movq         $-72(%rbp), %r8
+	LONG $0xed258d4c; WORD $0x00dc; BYTE $0x00 // leaq         $56557(%rip), %r12  /* __UnquoteTab(%rip) */
+	QUAD $0xfffffb250d6f0f66                   // movdqa       $-1243(%rip), %xmm1  /* LCPI9_0(%rip) */
+	WORD $0x854d; BYTE $0xed                   // testq        %r13, %r13
+	LONG $0xfb6d850f; WORD $0xffff             // jne          LBB9_4, $-1171(%rip)
+	LONG $0x000251e9; BYTE $0x00               // jmp          LBB9_37, $593(%rip)
+
+LBB9_66:
+	WORD $0x8949; BYTE $0xcd // movq         %rcx, %r13
+	WORD $0x8941; BYTE $0xdc // movl         %ebx, %r12d
+	WORD $0x894d; BYTE $0xcf // movq         %r9, %r15
+
+LBB9_67:
+	WORD $0x8944; BYTE $0xe0     // movl         %r12d, %eax
+	WORD $0xe8c1; BYTE $0x06     // shrl         $6, %eax
+	WORD $0xc00c                 // orb          $-64, %al
+	WORD $0x8841; BYTE $0x06     // movb         %al, (%r14)
+	LONG $0x3fe48041             // andb         $63, %r12b
+	LONG $0x80cc8041             // orb          $-128, %r12b
+	LONG $0x01668845             // movb         %r12b, $1(%r14)
+	LONG $0x02c68349             // addq         $2, %r14
+	LONG $0xffff47e9; BYTE $0xff // jmp          LBB9_56, $-185(%rip)
+
+LBB9_71:
+	WORD $0x8949; BYTE $0xdc       // movq         %rbx, %r12
+	LONG $0x984d8948               // movq         %rcx, $-104(%rbp)
+	LONG $0xc84d894c               // movq         %r9, $-56(%rbp)
+	LONG $0xb0758948               // movq         %rsi, $-80(%rbp)
+	LONG $0xa0558948               // movq         %rdx, $-96(%rbp)
+	LONG $0xc07d8948               // movq         %rdi, $-64(%rbp)
+	LONG $0xa855894c               // movq         %r10, $-88(%rbp)
+	WORD $0x854d; BYTE $0xd2       // testq        %r10, %r10
+	LONG $0x00c7850f; WORD $0x0000 // jne          LBB9_72, $199(%rip)
+	LONG $0x987d8348; BYTE $0x06   // cmpq         $6, $-104(%rbp)
+	LONG $0x00ee820f; WORD $0x0000 // jb           LBB9_76, $238(%rip)
+
+LBB9_78:
+	LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl         $56319, %r12d
+	LONG $0x00e1870f; WORD $0x0000             // ja           LBB9_76, $225(%rip)
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	WORD $0x3880; BYTE $0x5c                   // cmpb         $92, (%rax)
+	LONG $0x00d4850f; WORD $0x0000             // jne          LBB9_76, $212(%rip)
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	LONG $0x75017880                           // cmpb         $117, $1(%rax)
+	LONG $0x00c6850f; WORD $0x0000             // jne          LBB9_76, $198(%rip)
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	WORD $0x588b; BYTE $0x02                   // movl         $2(%rax), %ebx
+	WORD $0xdf89                               // movl         %ebx, %edi
+	LONG $0x000339e8; BYTE $0x00               // callq        _unhex16_is, $825(%rip)
+	WORD $0xc084                               // testb        %al, %al
+	LONG $0x0221840f; WORD $0x0000             // je           LBB9_82, $545(%rip)
+	WORD $0xcb0f                               // bswapl       %ebx
+	WORD $0xd889                               // movl         %ebx, %eax
+	WORD $0xd0f7                               // notl         %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	LONG $0x01010125; BYTE $0x01               // andl         $16843009, %eax
+	WORD $0x048d; BYTE $0xc0                   // leal         (%rax,%rax,8), %eax
+	LONG $0x0f0fe381; WORD $0x0f0f             // andl         $252645135, %ebx
+	WORD $0xc301                               // addl         %eax, %ebx
+	WORD $0xd889                               // movl         %ebx, %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	WORD $0xd809                               // orl          %ebx, %eax
+	WORD $0xb60f; BYTE $0xc8                   // movzbl       %al, %ecx
+	WORD $0xe8c1; BYTE $0x08                   // shrl         $8, %eax
+	LONG $0x00ff0025; BYTE $0x00               // andl         $65280, %eax
+	LONG $0xc8458348; BYTE $0x06               // addq         $6, $-56(%rbp)
+	WORD $0x148d; BYTE $0x08                   // leal         (%rax,%rcx), %edx
+	LONG $0x2000c281; WORD $0xffff             // addl         $-57344, %edx
+	LONG $0xfc00fa81; WORD $0xffff             // cmpl         $-1024, %edx
+	LONG $0x02ae820f; WORD $0x0000             // jb           LBB9_98, $686(%rip)
+	WORD $0xc809                               // orl          %ecx, %eax
+	LONG $0x986d8b4c                           // movq         $-104(%rbp), %r13
+	LONG $0xfac58349                           // addq         $-6, %r13
+	LONG $0xc87d8b4c                           // movq         $-56(%rbp), %r15
+	LONG $0xfffe9de9; BYTE $0xff               // jmp          LBB9_85, $-355(%rip)
+
+LBB9_96:
+	LONG $0x02b845f6               // testb        $2, $-72(%rbp)
+	LONG $0x028d840f; WORD $0x0000 // je           LBB9_97, $653(%rip)
+	LONG $0x06c74166; WORD $0xbfef // movw         $-16401, (%r14)
+	LONG $0x0246c641; BYTE $0xbd   // movb         $-67, $2(%r14)
+	LONG $0x03c68349               // addq         $3, %r14
+	LONG $0xc07d8b48               // movq         $-64(%rbp), %rdi
+	LONG $0xb0758b48               // movq         $-80(%rbp), %rsi
+	LONG $0xfffe5ce9; BYTE $0xff   // jmp          LBB9_56, $-420(%rip)
+
+LBB9_72:
+	LONG $0x05fd8349               // cmpq         $5, %r13
+	LONG $0x028a820f; WORD $0x0000 // jb           LBB9_87, $650(%rip)
+	LONG $0xc8458b48               // movq         $-56(%rbp), %rax
+	WORD $0x3880; BYTE $0x5c       // cmpb         $92, (%rax)
+	LONG $0x025e850f; WORD $0x0000 // jne          LBB9_98, $606(%rip)
+	LONG $0xfbc58349               // addq         $-5, %r13
+	LONG $0x05c78349               // addq         $5, %r15
+	LONG $0x986d894c               // movq         %r13, $-104(%rbp)
+	LONG $0xc87d894c               // movq         %r15, $-56(%rbp)
+	LONG $0x987d8348; BYTE $0x06   // cmpq         $6, $-104(%rbp)
+	LONG $0xff12830f; WORD $0xffff // jae          LBB9_78, $-238(%rip)
+
+LBB9_76:
+	LONG $0xc87d8b4c // movq         $-56(%rbp), %r15
+
+LBB9_77:
+	LONG $0xa8458b48                           // movq         $-88(%rbp), %rax
+	LONG $0xc0450348                           // addq         $-64(%rbp), %rax
+	WORD $0x2949; BYTE $0xc7                   // subq         %rax, %r15
+	LONG $0xfcc78349                           // addq         $-4, %r15
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	WORD $0x894c; BYTE $0x38                   // movq         %r15, (%rax)
+	LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq         $-4, %r14
+	LONG $0x00000ce9; BYTE $0x00               // jmp          LBB9_52, $12(%rip)
+
+LBB9_1:
+	WORD $0x3145; BYTE $0xed // xorl         %r13d, %r13d
+	WORD $0x8949; BYTE $0xd6 // movq         %rdx, %r14
+
+LBB9_2:
+	WORD $0x014d; BYTE $0xee // addq         %r13, %r14
+	WORD $0x2949; BYTE $0xd6 // subq         %rdx, %r14
+
+LBB9_52:
+	WORD $0x894c; BYTE $0xf0 // movq         %r14, %rax
+	LONG $0x48c48348         // addq         $72, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB9_43:
+	WORD $0x894c; BYTE $0xf8                   // movq         %r15, %rax
+	WORD $0x2948; BYTE $0xf8                   // subq         %rdi, %rax
+	LONG $0xd0758b48                           // movq         $-48(%rbp), %rsi
+	WORD $0x8948; BYTE $0x06                   // movq         %rax, (%rsi)
+	LONG $0x0fb60f41                           // movzbl       (%r15), %ecx
+	WORD $0x518d; BYTE $0xc6                   // leal         $-58(%rcx), %edx
+	LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r14
+	WORD $0xfa80; BYTE $0xf5                   // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000             // ja           LBB9_45, $15(%rip)
+	WORD $0xe180; BYTE $0xdf                   // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9                   // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa                   // cmpb         $-6, %cl
+	LONG $0xffbb820f; WORD $0xffff             // jb           LBB9_52, $-69(%rip)
+
+LBB9_45:
+	LONG $0x01488d48               // leaq         $1(%rax), %rcx
+	WORD $0x8948; BYTE $0x0e       // movq         %rcx, (%rsi)
+	LONG $0x4fb60f41; BYTE $0x01   // movzbl       $1(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_47, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xff94820f; WORD $0xffff // jb           LBB9_52, $-108(%rip)
+
+LBB9_47:
+	LONG $0x02488d48               // leaq         $2(%rax), %rcx
+	WORD $0x8948; BYTE $0x0e       // movq         %rcx, (%rsi)
+	LONG $0x4fb60f41; BYTE $0x02   // movzbl       $2(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_49, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xff6d820f; WORD $0xffff // jb           LBB9_52, $-147(%rip)
+
+LBB9_49:
+	LONG $0x03488d48               // leaq         $3(%rax), %rcx
+	WORD $0x8948; BYTE $0x0e       // movq         %rcx, (%rsi)
+	LONG $0x4fb60f41; BYTE $0x03   // movzbl       $3(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_51, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xff46820f; WORD $0xffff // jb           LBB9_52, $-186(%rip)
+
+LBB9_51:
+	LONG $0x04c08348             // addq         $4, %rax
+	WORD $0x8948; BYTE $0x06     // movq         %rax, (%rsi)
+	LONG $0xffff3ae9; BYTE $0xff // jmp          LBB9_52, $-198(%rip)
+
+LBB9_19:
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	WORD $0x8948; BYTE $0x30                   // movq         %rsi, (%rax)
+	LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r14
+	LONG $0xffff27e9; BYTE $0xff               // jmp          LBB9_52, $-217(%rip)
+
+LBB9_37:
+	WORD $0x3145; BYTE $0xed     // xorl         %r13d, %r13d
+	LONG $0xffff19e9; BYTE $0xff // jmp          LBB9_2, $-231(%rip)
+
+LBB9_34:
+	WORD $0xf748; BYTE $0xd7                   // notq         %rdi
+	WORD $0x0149; BYTE $0xff                   // addq         %rdi, %r15
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	WORD $0x894c; BYTE $0x38                   // movq         %r15, (%rax)
+	LONG $0xfdc6c749; WORD $0xffff; BYTE $0xff // movq         $-3, %r14
+	LONG $0xffff06e9; BYTE $0xff               // jmp          LBB9_52, $-250(%rip)
+
+LBB9_23:
+	WORD $0xf748; BYTE $0xd7 // notq         %rdi
+	WORD $0x0149; BYTE $0xff // addq         %rdi, %r15
+
+LBB9_24:
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	WORD $0x894c; BYTE $0x38                   // movq         %r15, (%rax)
+	LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r14
+	LONG $0xfffeede9; BYTE $0xff               // jmp          LBB9_52, $-275(%rip)
+
+LBB9_29:
+	WORD $0x2949; BYTE $0xff     // subq         %rdi, %r15
+	WORD $0xff49; BYTE $0xc7     // incq         %r15
+	LONG $0xffffe2e9; BYTE $0xff // jmp          LBB9_24, $-30(%rip)
+
+LBB9_63:
+	LONG $0x02b845f6               // testb        $2, $-72(%rbp)
+	LONG $0x0108840f; WORD $0x0000 // je           LBB9_87, $264(%rip)
+	LONG $0x06c74166; WORD $0xbfef // movw         $-16401, (%r14)
+	LONG $0x0246c641; BYTE $0xbd   // movb         $-67, $2(%r14)
+	LONG $0x03c68349               // addq         $3, %r14
+	WORD $0x3145; BYTE $0xed       // xorl         %r13d, %r13d
+	LONG $0xfffebbe9; BYTE $0xff   // jmp          LBB9_2, $-325(%rip)
+
+LBB9_82:
+	LONG $0xc87d8b4c // movq         $-56(%rbp), %r15
+
+LBB9_100:
+	WORD $0x894c; BYTE $0xf8                   // movq         %r15, %rax
+	LONG $0xc0452b48                           // subq         $-64(%rbp), %rax
+	LONG $0x02c08348                           // addq         $2, %rax
+	LONG $0xd04d8b48                           // movq         $-48(%rbp), %rcx
+	WORD $0x8948; BYTE $0x01                   // movq         %rax, (%rcx)
+	LONG $0x4fb60f41; BYTE $0x02               // movzbl       $2(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6                   // leal         $-58(%rcx), %edx
+	LONG $0xfec6c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r14
+	WORD $0xfa80; BYTE $0xf5                   // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000             // ja           LBB9_102, $15(%rip)
+	WORD $0xe180; BYTE $0xdf                   // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9                   // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa                   // cmpb         $-6, %cl
+	LONG $0xfe84820f; WORD $0xffff             // jb           LBB9_52, $-380(%rip)
+
+LBB9_102:
+	LONG $0x01488d48               // leaq         $1(%rax), %rcx
+	LONG $0xd0558b48               // movq         $-48(%rbp), %rdx
+	WORD $0x8948; BYTE $0x0a       // movq         %rcx, (%rdx)
+	LONG $0x4fb60f41; BYTE $0x03   // movzbl       $3(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_104, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xfe59820f; WORD $0xffff // jb           LBB9_52, $-423(%rip)
+
+LBB9_104:
+	LONG $0x02488d48               // leaq         $2(%rax), %rcx
+	LONG $0xd0558b48               // movq         $-48(%rbp), %rdx
+	WORD $0x8948; BYTE $0x0a       // movq         %rcx, (%rdx)
+	LONG $0x4fb60f41; BYTE $0x04   // movzbl       $4(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_106, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xfe2e820f; WORD $0xffff // jb           LBB9_52, $-466(%rip)
+
+LBB9_106:
+	LONG $0x03488d48               // leaq         $3(%rax), %rcx
+	LONG $0xd0558b48               // movq         $-48(%rbp), %rdx
+	WORD $0x8948; BYTE $0x0a       // movq         %rcx, (%rdx)
+	LONG $0x4fb60f41; BYTE $0x05   // movzbl       $5(%r15), %ecx
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB9_108, $15(%rip)
+	WORD $0xe180; BYTE $0xdf       // andb         $-33, %cl
+	WORD $0xc180; BYTE $0xb9       // addb         $-71, %cl
+	WORD $0xf980; BYTE $0xfa       // cmpb         $-6, %cl
+	LONG $0xfe03820f; WORD $0xffff // jb           LBB9_52, $-509(%rip)
+
+LBB9_108:
+	LONG $0x04c08348             // addq         $4, %rax
+	LONG $0xd04d8b48             // movq         $-48(%rbp), %rcx
+	WORD $0x8948; BYTE $0x01     // movq         %rax, (%rcx)
+	LONG $0xfffdf3e9; BYTE $0xff // jmp          LBB9_52, $-525(%rip)
+
+LBB9_97:
+	LONG $0xc87d894c // movq         %r15, $-56(%rbp)
+
+LBB9_98:
+	LONG $0xc8658b4c                           // movq         $-56(%rbp), %r12
+	LONG $0xc0652b4c                           // subq         $-64(%rbp), %r12
+	LONG $0xfcc48349                           // addq         $-4, %r12
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	WORD $0x894c; BYTE $0x20                   // movq         %r12, (%rax)
+	LONG $0xfcc6c749; WORD $0xffff; BYTE $0xff // movq         $-4, %r14
+	LONG $0xfffdd0e9; BYTE $0xff               // jmp          LBB9_52, $-560(%rip)
+
+LBB9_87:
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	LONG $0xb04d8b48                           // movq         $-80(%rbp), %rcx
+	WORD $0x8948; BYTE $0x08                   // movq         %rcx, (%rax)
+	LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r14
+	LONG $0xfffdb9e9; BYTE $0xff               // jmp          LBB9_52, $-583(%rip)
+	QUAD $0x9090909090909090                   // .p2align 4, 0x90
+
+_unhex16_is:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0xf889                   // movl         %edi, %eax
+	WORD $0xd0f7                   // notl         %eax
+	LONG $0xcfd08f8d; WORD $0xcfcf // leal         $-808464432(%rdi), %ecx
+	LONG $0x80808025; BYTE $0x80   // andl         $-2139062144, %eax
+	WORD $0xc885                   // testl        %ecx, %eax
+	LONG $0x0007840f; WORD $0x0000 // je           LBB10_2, $7(%rip)
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xb60f; BYTE $0xc0       // movzbl       %al, %eax
+	BYTE $0x5d                     // popq         %rbp
+	BYTE $0xc3                     // retq
+
+LBB10_2:
+	LONG $0x19198f8d; WORD $0x1919 // leal         $421075225(%rdi), %ecx
+	WORD $0xf909                   // orl          %edi, %ecx
+	LONG $0x8080c1f7; WORD $0x8080 // testl        $-2139062144, %ecx
+	LONG $0x0007840f; WORD $0x0000 // je           LBB10_4, $7(%rip)
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xb60f; BYTE $0xc0       // movzbl       %al, %eax
+	BYTE $0x5d                     // popq         %rbp
+	BYTE $0xc3                     // retq
+
+LBB10_4:
+	LONG $0x7f7fe781; WORD $0x7f7f // andl         $2139062143, %edi
+	LONG $0xc0c0c0b9; BYTE $0xc0   // movl         $-1061109568, %ecx
+	WORD $0xf929                   // subl         %edi, %ecx
+	LONG $0x4646978d; WORD $0x4646 // leal         $1179010630(%rdi), %edx
+	WORD $0xc121                   // andl         %eax, %ecx
+	WORD $0xd185                   // testl        %edx, %ecx
+	LONG $0x0007840f; WORD $0x0000 // je           LBB10_6, $7(%rip)
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0xb60f; BYTE $0xc0       // movzbl       %al, %eax
+	BYTE $0x5d                     // popq         %rbp
+	BYTE $0xc3                     // retq
+
+LBB10_6:
+	LONG $0xe0e0e0b9; BYTE $0xe0   // movl         $-522133280, %ecx
+	WORD $0xf929                   // subl         %edi, %ecx
+	LONG $0x3939c781; WORD $0x3939 // addl         $960051513, %edi
+	WORD $0xc821                   // andl         %ecx, %eax
+	WORD $0xf885                   // testl        %edi, %eax
+	WORD $0x940f; BYTE $0xc0       // sete         %al
+	WORD $0xb60f; BYTE $0xc0       // movzbl       %al, %eax
+	BYTE $0x5d                     // popq         %rbp
+	BYTE $0xc3                     // retq
+	LONG $0x00000000; WORD $0x0000 // .p2align 4, 0x00
+
+LCPI11_0:
+	QUAD $0x2626262626262626; QUAD $0x2626262626262626 // .space 16, '&&&&&&&&&&&&&&&&'
+
+LCPI11_1:
+	QUAD $0xe2e2e2e2e2e2e2e2; QUAD $0xe2e2e2e2e2e2e2e2 // .space 16, '\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2'
+
+LCPI11_2:
+	QUAD $0xfdfdfdfdfdfdfdfd; QUAD $0xfdfdfdfdfdfdfdfd // .space 16, '\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd\xfd'
+
+LCPI11_3:
+	QUAD $0x3c3c3c3c3c3c3c3c; QUAD $0x3c3c3c3c3c3c3c3c // .space 16, '<<<<<<<<<<<<<<<<'
+
+	// .p2align 4, 0x90
+_html_escape:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x10ec8348                           // subq         $16, %rsp
+	LONG $0xc84d8948                           // movq         %rcx, $-56(%rbp)
+	WORD $0x8949; BYTE $0xd6                   // movq         %rdx, %r14
+	LONG $0xd0558948                           // movq         %rdx, $-48(%rbp)
+	WORD $0x8948; BYTE $0xf8                   // movq         %rdi, %rax
+	WORD $0x8548; BYTE $0xf6                   // testq        %rsi, %rsi
+	LONG $0x04b18e0f; WORD $0x0000             // jle          LBB11_70, $1201(%rip)
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	WORD $0x8b4c; BYTE $0x08                   // movq         (%rax), %r9
+	QUAD $0xffffff89056f0f66                   // movdqa       $-119(%rip), %xmm0  /* LCPI11_0(%rip) */
+	QUAD $0xffffff910d6f0f66                   // movdqa       $-111(%rip), %xmm1  /* LCPI11_1(%rip) */
+	QUAD $0xffffff99156f0f66                   // movdqa       $-103(%rip), %xmm2  /* LCPI11_2(%rip) */
+	QUAD $0xffffffa11d6f0f66                   // movdqa       $-95(%rip), %xmm3  /* LCPI11_3(%rip) */
+	LONG $0xfa1d8d4c; WORD $0x00d8; BYTE $0x00 // leaq         $55546(%rip), %r11  /* __HtmlQuoteTab(%rip) */
+	WORD $0x8949; BYTE $0xfc                   // movq         %rdi, %r12
+	LONG $0xd0758b4c                           // movq         $-48(%rbp), %r14
+	WORD $0x9090; BYTE $0x90                   // .p2align 4, 0x90
+
+LBB11_2:
+	WORD $0x854d; BYTE $0xc9                   // testq        %r9, %r9
+	LONG $0x048e8e0f; WORD $0x0000             // jle          LBB11_3, $1166(%rip)
+	LONG $0x10fe8348                           // cmpq         $16, %rsi
+	WORD $0x930f; BYTE $0xc0                   // setae        %al
+	WORD $0x894d; BYTE $0xcd                   // movq         %r9, %r13
+	WORD $0x894d; BYTE $0xf0                   // movq         %r14, %r8
+	WORD $0x8948; BYTE $0xf1                   // movq         %rsi, %rcx
+	WORD $0x894d; BYTE $0xe7                   // movq         %r12, %r15
+	LONG $0x10f98349                           // cmpq         $16, %r9
+	LONG $0x0082820f; WORD $0x0000             // jb           LBB11_12, $130(%rip)
+	LONG $0x10fe8348                           // cmpq         $16, %rsi
+	LONG $0x0078820f; WORD $0x0000             // jb           LBB11_12, $120(%rip)
+	WORD $0x3145; BYTE $0xc0                   // xorl         %r8d, %r8d
+	WORD $0x8948; BYTE $0xf3                   // movq         %rsi, %rbx
+	WORD $0x894c; BYTE $0xca                   // movq         %r9, %rdx
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB11_7:
+	LONG $0x6f0f43f3; WORD $0x0424 // movdqu       (%r12,%r8), %xmm4
+	LONG $0xec6f0f66               // movdqa       %xmm4, %xmm5
+	LONG $0xf46f0f66               // movdqa       %xmm4, %xmm6
+	LONG $0x7f0f43f3; WORD $0x0624 // movdqu       %xmm4, (%r14,%r8)
+	LONG $0xe0740f66               // pcmpeqb      %xmm0, %xmm4
+	LONG $0xe9740f66               // pcmpeqb      %xmm1, %xmm5
+	LONG $0xeceb0f66               // por          %xmm4, %xmm5
+	LONG $0xf2db0f66               // pand         %xmm2, %xmm6
+	LONG $0xf3740f66               // pcmpeqb      %xmm3, %xmm6
+	LONG $0xf5eb0f66               // por          %xmm5, %xmm6
+	LONG $0xc6d70f66               // pmovmskb     %xmm6, %eax
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x0158850f; WORD $0x0000 // jne          LBB11_8, $344(%rip)
+	LONG $0xf04b8d48               // leaq         $-16(%rbx), %rcx
+	LONG $0xf06a8d4c               // leaq         $-16(%rdx), %r13
+	LONG $0x10c08349               // addq         $16, %r8
+	LONG $0x20fb8348               // cmpq         $32, %rbx
+	WORD $0x9d0f; BYTE $0xc0       // setge        %al
+	LONG $0x00108c0f; WORD $0x0000 // jl           LBB11_11, $16(%rip)
+	WORD $0x8948; BYTE $0xcb       // movq         %rcx, %rbx
+	LONG $0x1ffa8348               // cmpq         $31, %rdx
+	WORD $0x894c; BYTE $0xea       // movq         %r13, %rdx
+	LONG $0xff9f8f0f; WORD $0xffff // jg           LBB11_7, $-97(%rip)
+
+LBB11_11:
+	LONG $0x043c8d4f         // leaq         (%r12,%r8), %r15
+	WORD $0x014d; BYTE $0xf0 // addq         %r14, %r8
+
+LBB11_12:
+	WORD $0xc084                               // testb        %al, %al
+	LONG $0x0070840f; WORD $0x0000             // je           LBB11_13, $112(%rip)
+	LONG $0x6f0f41f3; BYTE $0x27               // movdqu       (%r15), %xmm4
+	LONG $0xec6f0f66                           // movdqa       %xmm4, %xmm5
+	LONG $0xe8740f66                           // pcmpeqb      %xmm0, %xmm5
+	LONG $0xf46f0f66                           // movdqa       %xmm4, %xmm6
+	LONG $0xf1740f66                           // pcmpeqb      %xmm1, %xmm6
+	LONG $0xf5eb0f66                           // por          %xmm5, %xmm6
+	LONG $0x7e0f4866; BYTE $0xe0               // movq         %xmm4, %rax
+	LONG $0xe2db0f66                           // pand         %xmm2, %xmm4
+	LONG $0xe3740f66                           // pcmpeqb      %xmm3, %xmm4
+	LONG $0xe6eb0f66                           // por          %xmm6, %xmm4
+	LONG $0xccd70f66                           // pmovmskb     %xmm4, %ecx
+	LONG $0x0000c981; WORD $0x0001             // orl          $65536, %ecx
+	LONG $0xd1bc0f44                           // bsfl         %ecx, %r10d
+	WORD $0x394d; BYTE $0xd5                   // cmpq         %r10, %r13
+	LONG $0x00f88d0f; WORD $0x0000             // jge          LBB11_24, $248(%rip)
+	LONG $0x08fd8349                           // cmpq         $8, %r13
+	LONG $0x0131820f; WORD $0x0000             // jb           LBB11_35, $305(%rip)
+	WORD $0x8949; BYTE $0x00                   // movq         %rax, (%r8)
+	LONG $0x08578d4d                           // leaq         $8(%r15), %r10
+	LONG $0x08c08349                           // addq         $8, %r8
+	LONG $0xf85d8d49                           // leaq         $-8(%r13), %rbx
+	LONG $0x04fb8348                           // cmpq         $4, %rbx
+	LONG $0x01288d0f; WORD $0x0000             // jge          LBB11_38, $296(%rip)
+	LONG $0x000135e9; BYTE $0x00               // jmp          LBB11_39, $309(%rip)
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB11_13:
+	WORD $0x8548; BYTE $0xc9               // testq        %rcx, %rcx
+	LONG $0x00878e0f; WORD $0x0000         // jle          LBB11_21, $135(%rip)
+	WORD $0x854d; BYTE $0xed               // testq        %r13, %r13
+	LONG $0x007e8e0f; WORD $0x0000         // jle          LBB11_21, $126(%rip)
+	WORD $0xd231                           // xorl         %edx, %edx
+	WORD $0xc031                           // xorl         %eax, %eax
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB11_16:
+	LONG $0x1cb60f45; BYTE $0x17           // movzbl       (%r15,%rdx), %r11d
+	LONG $0x3efb8349                       // cmpq         $62, %r11
+	LONG $0x0014870f; WORD $0x0000         // ja           LBB11_17, $20(%rip)
+	QUAD $0x004000000000bb48; WORD $0x5000 // movabsq      $5764607797912141824, %rbx
+	LONG $0xdba30f4c                       // btq          %r11, %rbx
+	LONG $0x00ae820f; WORD $0x0000         // jb           LBB11_45, $174(%rip)
+
+LBB11_17:
+	LONG $0xe2fb8141; WORD $0x0000; BYTE $0x00 // cmpl         $226, %r11d
+	LONG $0x00a1840f; WORD $0x0000             // je           LBB11_45, $161(%rip)
+	LONG $0x01148d4c                           // leaq         (%rcx,%rax), %r10
+	LONG $0x101c8845                           // movb         %r11b, (%r8,%rdx)
+	LONG $0xff588d48                           // leaq         $-1(%rax), %rbx
+	LONG $0x02fa8349                           // cmpq         $2, %r10
+	LONG $0x00138c0f; WORD $0x0000             // jl           LBB11_20, $19(%rip)
+	WORD $0x014c; BYTE $0xe8                   // addq         %r13, %rax
+	WORD $0xff48; BYTE $0xc2                   // incq         %rdx
+	LONG $0x01f88348                           // cmpq         $1, %rax
+	WORD $0x8948; BYTE $0xd8                   // movq         %rbx, %rax
+	LONG $0xffa78f0f; WORD $0xffff             // jg           LBB11_16, $-89(%rip)
+
+LBB11_20:
+	WORD $0x2949; BYTE $0xdf                   // subq         %rbx, %r15
+	WORD $0x0148; BYTE $0xd9                   // addq         %rbx, %rcx
+	LONG $0x4a1d8d4c; WORD $0x00d7; BYTE $0x00 // leaq         $55114(%rip), %r11  /* __HtmlQuoteTab(%rip) */
+	QUAD $0x9090909090909090; WORD $0x9090     // .p2align 4, 0x90
+
+LBB11_21:
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x0160840f; WORD $0x0000 // je           LBB11_22, $352(%rip)
+	WORD $0xf749; BYTE $0xd7       // notq         %r15
+	WORD $0x014d; BYTE $0xe7       // addq         %r12, %r15
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x0168890f; WORD $0x0000 // jns          LBB11_49, $360(%rip)
+	LONG $0x000287e9; BYTE $0x00   // jmp          LBB11_48, $647(%rip)
+	WORD $0x9090; BYTE $0x90       // .p2align 4, 0x90
+
+LBB11_8:
+	LONG $0xc0bc0f66               // bsfw         %ax, %ax
+	LONG $0xf8b70f44               // movzwl       %ax, %r15d
+	WORD $0x014d; BYTE $0xc7       // addq         %r8, %r15
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x014c890f; WORD $0x0000 // jns          LBB11_49, $332(%rip)
+	LONG $0x00026be9; BYTE $0x00   // jmp          LBB11_48, $619(%rip)
+
+LBB11_24:
+	LONG $0x08fa8341               // cmpl         $8, %r10d
+	LONG $0x008f820f; WORD $0x0000 // jb           LBB11_25, $143(%rip)
+	WORD $0x8949; BYTE $0x00       // movq         %rax, (%r8)
+	LONG $0x086f8d4d               // leaq         $8(%r15), %r13
+	LONG $0x08c08349               // addq         $8, %r8
+	LONG $0xf85a8d49               // leaq         $-8(%r10), %rbx
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x0086830f; WORD $0x0000 // jae          LBB11_28, $134(%rip)
+	LONG $0x000094e9; BYTE $0x00   // jmp          LBB11_29, $148(%rip)
+
+LBB11_45:
+	WORD $0x294d; BYTE $0xe7                   // subq         %r12, %r15
+	WORD $0x2949; BYTE $0xc7                   // subq         %rax, %r15
+	LONG $0xd21d8d4c; WORD $0x00d6; BYTE $0x00 // leaq         $54994(%rip), %r11  /* __HtmlQuoteTab(%rip) */
+	WORD $0x854d; BYTE $0xff                   // testq        %r15, %r15
+	LONG $0x0109890f; WORD $0x0000             // jns          LBB11_49, $265(%rip)
+	LONG $0x000228e9; BYTE $0x00               // jmp          LBB11_48, $552(%rip)
+
+LBB11_35:
+	WORD $0x894d; BYTE $0xfa       // movq         %r15, %r10
+	WORD $0x894c; BYTE $0xeb       // movq         %r13, %rbx
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x00128c0f; WORD $0x0000 // jl           LBB11_39, $18(%rip)
+
+LBB11_38:
+	WORD $0x8b41; BYTE $0x02 // movl         (%r10), %eax
+	WORD $0x8941; BYTE $0x00 // movl         %eax, (%r8)
+	LONG $0x04c28349         // addq         $4, %r10
+	LONG $0x04c08349         // addq         $4, %r8
+	LONG $0xfcc38348         // addq         $-4, %rbx
+
+LBB11_39:
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0x007c830f; WORD $0x0000 // jae          LBB11_40, $124(%rip)
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0007840f; WORD $0x0000 // je           LBB11_43, $7(%rip)
+
+LBB11_42:
+	LONG $0x02b60f41         // movzbl       (%r10), %eax
+	WORD $0x8841; BYTE $0x00 // movb         %al, (%r8)
+
+LBB11_43:
+	WORD $0x014d; BYTE $0xfd       // addq         %r15, %r13
+	WORD $0xf749; BYTE $0xd5       // notq         %r13
+	WORD $0x014d; BYTE $0xe5       // addq         %r12, %r13
+	WORD $0x894d; BYTE $0xef       // movq         %r13, %r15
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x00b3890f; WORD $0x0000 // jns          LBB11_49, $179(%rip)
+	LONG $0x0001d2e9; BYTE $0x00   // jmp          LBB11_48, $466(%rip)
+
+LBB11_25:
+	WORD $0x894d; BYTE $0xfd       // movq         %r15, %r13
+	WORD $0x894c; BYTE $0xd3       // movq         %r10, %rbx
+	LONG $0x04fb8348               // cmpq         $4, %rbx
+	LONG $0x0013820f; WORD $0x0000 // jb           LBB11_29, $19(%rip)
+
+LBB11_28:
+	LONG $0x00458b41         // movl         (%r13), %eax
+	WORD $0x8941; BYTE $0x00 // movl         %eax, (%r8)
+	LONG $0x04c58349         // addq         $4, %r13
+	LONG $0x04c08349         // addq         $4, %r8
+	LONG $0xfcc38348         // addq         $-4, %rbx
+
+LBB11_29:
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0x0047830f; WORD $0x0000 // jae          LBB11_30, $71(%rip)
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0008840f; WORD $0x0000 // je           LBB11_33, $8(%rip)
+
+LBB11_32:
+	LONG $0x45b60f41; BYTE $0x00 // movzbl       (%r13), %eax
+	WORD $0x8841; BYTE $0x00     // movb         %al, (%r8)
+
+LBB11_33:
+	WORD $0x294d; BYTE $0xe7       // subq         %r12, %r15
+	WORD $0x014d; BYTE $0xd7       // addq         %r10, %r15
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x0061890f; WORD $0x0000 // jns          LBB11_49, $97(%rip)
+	LONG $0x000180e9; BYTE $0x00   // jmp          LBB11_48, $384(%rip)
+
+LBB11_40:
+	LONG $0x02b70f41               // movzwl       (%r10), %eax
+	LONG $0x00894166               // movw         %ax, (%r8)
+	LONG $0x02c28349               // addq         $2, %r10
+	LONG $0x02c08349               // addq         $2, %r8
+	LONG $0xfec38348               // addq         $-2, %rbx
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0xff70850f; WORD $0xffff // jne          LBB11_42, $-144(%rip)
+	LONG $0xffff72e9; BYTE $0xff   // jmp          LBB11_43, $-142(%rip)
+
+LBB11_30:
+	LONG $0x45b70f41; BYTE $0x00   // movzwl       (%r13), %eax
+	LONG $0x00894166               // movw         %ax, (%r8)
+	LONG $0x02c58349               // addq         $2, %r13
+	LONG $0x02c08349               // addq         $2, %r8
+	LONG $0xfec38348               // addq         $-2, %rbx
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0xffa4850f; WORD $0xffff // jne          LBB11_32, $-92(%rip)
+	LONG $0xffffa7e9; BYTE $0xff   // jmp          LBB11_33, $-89(%rip)
+
+LBB11_22:
+	WORD $0x294d; BYTE $0xe7                           // subq         %r12, %r15
+	WORD $0x854d; BYTE $0xff                           // testq        %r15, %r15
+	LONG $0x012f880f; WORD $0x0000                     // js           LBB11_48, $303(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB11_49:
+	WORD $0x014d; BYTE $0xfc       // addq         %r15, %r12
+	WORD $0x014d; BYTE $0xfe       // addq         %r15, %r14
+	WORD $0x294c; BYTE $0xfe       // subq         %r15, %rsi
+	LONG $0x01378e0f; WORD $0x0000 // jle          LBB11_50, $311(%rip)
+	WORD $0x294d; BYTE $0xf9       // subq         %r15, %r9
+	LONG $0x0cb60f41; BYTE $0x24   // movzbl       (%r12), %ecx
+	WORD $0xf980; BYTE $0xe2       // cmpb         $-30, %cl
+	LONG $0x00b3840f; WORD $0x0000 // je           LBB11_53, $179(%rip)
+	WORD $0x894c; BYTE $0xe0       // movq         %r12, %rax
+
+LBB11_57:
+	WORD $0xb60f; BYTE $0xc9               // movzbl       %cl, %ecx
+	LONG $0x04e1c148                       // shlq         $4, %rcx
+	LONG $0x19148b4a                       // movq         (%rcx,%r11), %rdx
+	WORD $0x6348; BYTE $0xda               // movslq       %edx, %rbx
+	WORD $0x2949; BYTE $0xd9               // subq         %rbx, %r9
+	LONG $0x01228c0f; WORD $0x0000         // jl           LBB11_58, $290(%rip)
+	LONG $0x20e2c148                       // shlq         $32, %rdx
+	LONG $0x19148d4e                       // leaq         (%rcx,%r11), %r10
+	LONG $0x08c28349                       // addq         $8, %r10
+	QUAD $0x000300000001b948; WORD $0x0000 // movabsq      $12884901889, %rcx
+	WORD $0x3948; BYTE $0xca               // cmpq         %rcx, %rdx
+	LONG $0x00278c0f; WORD $0x0000         // jl           LBB11_62, $39(%rip)
+	WORD $0x8b41; BYTE $0x0a               // movl         (%r10), %ecx
+	WORD $0x8941; BYTE $0x0e               // movl         %ecx, (%r14)
+	LONG $0x04c28349                       // addq         $4, %r10
+	LONG $0x04468d4d                       // leaq         $4(%r14), %r8
+	LONG $0xfc4b8d48                       // leaq         $-4(%rbx), %rcx
+	LONG $0x02f98348                       // cmpq         $2, %rcx
+	LONG $0x001b830f; WORD $0x0000         // jae          LBB11_65, $27(%rip)
+	LONG $0x00002ae9; BYTE $0x00           // jmp          LBB11_66, $42(%rip)
+	LONG $0x90909090; WORD $0x9090         // .p2align 4, 0x90
+
+LBB11_62:
+	WORD $0x894d; BYTE $0xf0       // movq         %r14, %r8
+	WORD $0x8948; BYTE $0xd9       // movq         %rbx, %rcx
+	LONG $0x02f98348               // cmpq         $2, %rcx
+	LONG $0x0014820f; WORD $0x0000 // jb           LBB11_66, $20(%rip)
+
+LBB11_65:
+	LONG $0x12b70f41 // movzwl       (%r10), %edx
+	LONG $0x10894166 // movw         %dx, (%r8)
+	LONG $0x02c28349 // addq         $2, %r10
+	LONG $0x02c08349 // addq         $2, %r8
+	LONG $0xfec18348 // addq         $-2, %rcx
+
+LBB11_66:
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x0007840f; WORD $0x0000 // je           LBB11_68, $7(%rip)
+	LONG $0x0ab60f41               // movzbl       (%r10), %ecx
+	WORD $0x8841; BYTE $0x08       // movb         %cl, (%r8)
+
+LBB11_68:
+	WORD $0x0149; BYTE $0xde // addq         %rbx, %r14
+
+LBB11_69:
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	LONG $0xff4e8d48               // leaq         $-1(%rsi), %rcx
+	WORD $0x8949; BYTE $0xc4       // movq         %rax, %r12
+	LONG $0x01fe8348               // cmpq         $1, %rsi
+	WORD $0x8948; BYTE $0xce       // movq         %rcx, %rsi
+	LONG $0xfc02870f; WORD $0xffff // ja           LBB11_2, $-1022(%rip)
+	LONG $0x000076e9; BYTE $0x00   // jmp          LBB11_70, $118(%rip)
+
+LBB11_53:
+	LONG $0x03fe8348               // cmpq         $3, %rsi
+	LONG $0x002c820f; WORD $0x0000 // jb           LBB11_59, $44(%rip)
+	LONG $0x247c8041; WORD $0x8001 // cmpb         $-128, $1(%r12)
+	LONG $0x0020850f; WORD $0x0000 // jne          LBB11_59, $32(%rip)
+	LONG $0x4cb60f41; WORD $0x0224 // movzbl       $2(%r12), %ecx
+	WORD $0xc889                   // movl         %ecx, %eax
+	WORD $0xfe24                   // andb         $-2, %al
+	WORD $0xa83c                   // cmpb         $-88, %al
+	LONG $0x000e850f; WORD $0x0000 // jne          LBB11_59, $14(%rip)
+	LONG $0x24448d49; BYTE $0x02   // leaq         $2(%r12), %rax
+	LONG $0xfec68348               // addq         $-2, %rsi
+	LONG $0xffff1ae9; BYTE $0xff   // jmp          LBB11_57, $-230(%rip)
+
+LBB11_59:
+	WORD $0x854d; BYTE $0xc9       // testq        %r9, %r9
+	LONG $0x00558e0f; WORD $0x0000 // jle          LBB11_3, $85(%rip)
+	LONG $0xe206c641               // movb         $-30, (%r14)
+	WORD $0xff49; BYTE $0xc6       // incq         %r14
+	WORD $0xff49; BYTE $0xc9       // decq         %r9
+	WORD $0x894c; BYTE $0xe0       // movq         %r12, %rax
+	LONG $0xffff93e9; BYTE $0xff   // jmp          LBB11_69, $-109(%rip)
+
+LBB11_48:
+	LONG $0xd04d8b48             // movq         $-48(%rbp), %rcx
+	WORD $0x014c; BYTE $0xf9     // addq         %r15, %rcx
+	WORD $0xf748; BYTE $0xd1     // notq         %rcx
+	WORD $0x014c; BYTE $0xf1     // addq         %r14, %rcx
+	LONG $0xc8458b48             // movq         $-56(%rbp), %rax
+	WORD $0x8948; BYTE $0x08     // movq         %rcx, (%rax)
+	WORD $0x294c; BYTE $0xe7     // subq         %r12, %rdi
+	WORD $0x014c; BYTE $0xff     // addq         %r15, %rdi
+	WORD $0x8948; BYTE $0xf8     // movq         %rdi, %rax
+	LONG $0x00002ae9; BYTE $0x00 // jmp          LBB11_71, $42(%rip)
+
+LBB11_50:
+	WORD $0x894c; BYTE $0xe0 // movq         %r12, %rax
+
+LBB11_70:
+	LONG $0xd0752b4c             // subq         $-48(%rbp), %r14
+	LONG $0xc84d8b48             // movq         $-56(%rbp), %rcx
+	WORD $0x894c; BYTE $0x31     // movq         %r14, (%rcx)
+	WORD $0x2948; BYTE $0xf8     // subq         %rdi, %rax
+	LONG $0x000014e9; BYTE $0x00 // jmp          LBB11_71, $20(%rip)
+
+LBB11_58:
+	LONG $0xd0752b4c         // subq         $-48(%rbp), %r14
+	LONG $0xc8458b48         // movq         $-56(%rbp), %rax
+	WORD $0x894c; BYTE $0x30 // movq         %r14, (%rax)
+
+LBB11_3:
+	WORD $0xf749; BYTE $0xd4 // notq         %r12
+	WORD $0x0149; BYTE $0xfc // addq         %rdi, %r12
+	WORD $0x894c; BYTE $0xe0 // movq         %r12, %rax
+
+LBB11_71:
+	LONG $0x10c48348 // addq         $16, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5d41     // popq         %r13
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+	BYTE $0x90       // .p2align 4, 0x90
+
+_atof_eisel_lemire64:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5741                   // pushq        %r15
+	WORD $0x5641                   // pushq        %r14
+	WORD $0x5441                   // pushq        %r12
+	BYTE $0x53                     // pushq        %rbx
+	LONG $0xfea4868d; WORD $0xffff // leal         $-348(%rsi), %eax
+	LONG $0xfffd483d; BYTE $0xff   // cmpl         $-696, %eax
+	LONG $0x0122820f; WORD $0x0000 // jb           LBB12_1, $290(%rip)
+	WORD $0x8949; BYTE $0xc8       // movq         %rcx, %r8
+	WORD $0x8941; BYTE $0xd1       // movl         %edx, %r9d
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0x000d840f; WORD $0x0000 // je           LBB12_4, $13(%rip)
+	LONG $0xd7bd0f4c               // bsrq         %rdi, %r10
+	LONG $0x3ff28349               // xorq         $63, %r10
+	LONG $0x000006e9; BYTE $0x00   // jmp          LBB12_5, $6(%rip)
+
+LBB12_4:
+	LONG $0x0040ba41; WORD $0x0000 // movl         $64, %r10d
+
+LBB12_5:
+	WORD $0x8944; BYTE $0xd1                   // movl         %r10d, %ecx
+	WORD $0xd348; BYTE $0xe7                   // shlq         %cl, %rdi
+	LONG $0x015c8e8d; WORD $0x0000             // leal         $348(%rsi), %ecx
+	LONG $0x04e1c148                           // shlq         $4, %rcx
+	LONG $0x3b258d4c; WORD $0x005e; BYTE $0x00 // leaq         $24123(%rip), %r12  /* _POW10_M128_TAB(%rip) */
+	WORD $0x8948; BYTE $0xf8                   // movq         %rdi, %rax
+	LONG $0x2164f74a; BYTE $0x08               // mulq         $8(%rcx,%r12)
+	WORD $0x8949; BYTE $0xc7                   // movq         %rax, %r15
+	WORD $0x8949; BYTE $0xd3                   // movq         %rdx, %r11
+	WORD $0x8944; BYTE $0xdb                   // movl         %r11d, %ebx
+	LONG $0x01ffe381; WORD $0x0000             // andl         $511, %ebx
+	LONG $0xfffb8148; WORD $0x0001; BYTE $0x00 // cmpq         $511, %rbx
+	LONG $0x0050850f; WORD $0x0000             // jne          LBB12_11, $80(%rip)
+	WORD $0x8949; BYTE $0xfe                   // movq         %rdi, %r14
+	WORD $0xf749; BYTE $0xd6                   // notq         %r14
+	WORD $0x894c; BYTE $0xfa                   // movq         %r15, %rdx
+	WORD $0x394d; BYTE $0xf7                   // cmpq         %r14, %r15
+	LONG $0x0041860f; WORD $0x0000             // jbe          LBB12_13, $65(%rip)
+	WORD $0x8948; BYTE $0xf8                   // movq         %rdi, %rax
+	LONG $0x2124f74a                           // mulq         (%rcx,%r12)
+	WORD $0x014c; BYTE $0xfa                   // addq         %r15, %rdx
+	LONG $0x00d38349                           // adcq         $0, %r11
+	WORD $0x8944; BYTE $0xd9                   // movl         %r11d, %ecx
+	WORD $0xd1f7                               // notl         %ecx
+	LONG $0x37e1c148                           // shlq         $55, %rcx
+	LONG $0x0013850f; WORD $0x0000             // jne          LBB12_12, $19(%rip)
+	LONG $0xfffa8348                           // cmpq         $-1, %rdx
+	LONG $0x0009850f; WORD $0x0000             // jne          LBB12_12, $9(%rip)
+	WORD $0x394c; BYTE $0xf0                   // cmpq         %r14, %rax
+	LONG $0x0083870f; WORD $0x0000             // ja           LBB12_1, $131(%rip)
+
+LBB12_12:
+	WORD $0x8944; BYTE $0xdb       // movl         %r11d, %ebx
+	LONG $0x01ffe381; WORD $0x0000 // andl         $511, %ebx
+	LONG $0x000003e9; BYTE $0x00   // jmp          LBB12_13, $3(%rip)
+
+LBB12_11:
+	WORD $0x894c; BYTE $0xfa // movq         %r15, %rdx
+
+LBB12_13:
+	WORD $0x894c; BYTE $0xd8       // movq         %r11, %rax
+	LONG $0x3fe8c148               // shrq         $63, %rax
+	WORD $0x488d; BYTE $0x09       // leal         $9(%rax), %ecx
+	WORD $0xd349; BYTE $0xeb       // shrq         %cl, %r11
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0x0018850f; WORD $0x0000 // jne          LBB12_17, $24(%rip)
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x000f850f; WORD $0x0000 // jne          LBB12_17, $15(%rip)
+	WORD $0x8944; BYTE $0xd9       // movl         %r11d, %ecx
+	WORD $0xe183; BYTE $0x03       // andl         $3, %ecx
+	WORD $0xf983; BYTE $0x01       // cmpl         $1, %ecx
+	LONG $0x0044840f; WORD $0x0000 // je           LBB12_1, $68(%rip)
+
+LBB12_17:
+	LONG $0x526ace69; WORD $0x0003             // imull        $217706, %esi, %ecx
+	WORD $0xf9c1; BYTE $0x10                   // sarl         $16, %ecx
+	LONG $0x043fc181; WORD $0x0000             // addl         $1087, %ecx
+	WORD $0x6348; BYTE $0xf1                   // movslq       %ecx, %rsi
+	WORD $0x294c; BYTE $0xd6                   // subq         %r10, %rsi
+	WORD $0x8944; BYTE $0xda                   // movl         %r11d, %edx
+	WORD $0xe283; BYTE $0x01                   // andl         $1, %edx
+	WORD $0x014c; BYTE $0xda                   // addq         %r11, %rdx
+	WORD $0x8948; BYTE $0xd1                   // movq         %rdx, %rcx
+	LONG $0x36e9c148                           // shrq         $54, %rcx
+	WORD $0x0148; BYTE $0xf0                   // addq         %rsi, %rax
+	LONG $0x01f98348                           // cmpq         $1, %rcx
+	LONG $0x00d88348                           // sbbq         $0, %rax
+	LONG $0x01b08d48; WORD $0xfff8; BYTE $0xff // leaq         $-2047(%rax), %rsi
+	LONG $0x02fe8148; WORD $0xfff8; BYTE $0xff // cmpq         $-2046, %rsi
+	LONG $0x000b830f; WORD $0x0000             // jae          LBB12_19, $11(%rip)
+
+LBB12_1:
+	WORD $0xc031 // xorl         %eax, %eax
+
+LBB12_20:
+	BYTE $0x5b   // popq         %rbx
+	WORD $0x5c41 // popq         %r12
+	WORD $0x5e41 // popq         %r14
+	WORD $0x5f41 // popq         %r15
+	BYTE $0x5d   // popq         %rbp
+	BYTE $0xc3   // retq
+
+LBB12_19:
+	LONG $0x01f98348                       // cmpq         $1, %rcx
+	WORD $0x02b1                           // movb         $2, %cl
+	WORD $0xd980; BYTE $0x00               // sbbb         $0, %cl
+	WORD $0xd348; BYTE $0xea               // shrq         %cl, %rdx
+	LONG $0x34e0c148                       // shlq         $52, %rax
+	QUAD $0xffffffffffffb948; WORD $0x000f // movabsq      $4503599627370495, %rcx
+	WORD $0x2148; BYTE $0xd1               // andq         %rdx, %rcx
+	WORD $0x0948; BYTE $0xc1               // orq          %rax, %rcx
+	QUAD $0x000000000000b848; WORD $0x8000 // movabsq      $-9223372036854775808, %rax
+	WORD $0x0948; BYTE $0xc8               // orq          %rcx, %rax
+	LONG $0xfff98341                       // cmpl         $-1, %r9d
+	LONG $0xc1450f48                       // cmovneq      %rcx, %rax
+	WORD $0x8949; BYTE $0x00               // movq         %rax, (%r8)
+	WORD $0x01b0                           // movb         $1, %al
+	LONG $0xffffb8e9; BYTE $0xff           // jmp          LBB12_20, $-72(%rip)
+	QUAD $0x9090909090909090               // .p2align 4, 0x90
+
+_decimal_to_f64:
+	BYTE $0x55                             // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5               // movq         %rsp, %rbp
+	WORD $0x5741                           // pushq        %r15
+	WORD $0x5641                           // pushq        %r14
+	WORD $0x5541                           // pushq        %r13
+	WORD $0x5441                           // pushq        %r12
+	BYTE $0x53                             // pushq        %rbx
+	BYTE $0x50                             // pushq        %rax
+	WORD $0x8948; BYTE $0xf3               // movq         %rsi, %rbx
+	WORD $0x8949; BYTE $0xff               // movq         %rdi, %r15
+	QUAD $0x000000000000bd49; WORD $0x0010 // movabsq      $4503599627370496, %r13
+	LONG $0x00107f83                       // cmpl         $0, $16(%rdi)
+	LONG $0x0021840f; WORD $0x0000         // je           LBB13_3, $33(%rip)
+	LONG $0x14478b41                       // movl         $20(%r15), %eax
+	LONG $0x0001363d; BYTE $0x00           // cmpl         $310, %eax
+	LONG $0x001d8e0f; WORD $0x0000         // jle          LBB13_4, $29(%rip)
+
+LBB13_2:
+	WORD $0x3145; BYTE $0xe4               // xorl         %r12d, %r12d
+	QUAD $0x000000000000be49; WORD $0x7ff0 // movabsq      $9218868437227405312, %r14
+	LONG $0x000397e9; BYTE $0x00           // jmp          LBB13_69, $919(%rip)
+
+LBB13_3:
+	WORD $0x3145; BYTE $0xf6     // xorl         %r14d, %r14d
+	WORD $0x3145; BYTE $0xe4     // xorl         %r12d, %r12d
+	LONG $0x00038ce9; BYTE $0x00 // jmp          LBB13_69, $908(%rip)
+
+LBB13_4:
+	WORD $0x3145; BYTE $0xe4       // xorl         %r12d, %r12d
+	LONG $0xfffeb63d; BYTE $0xff   // cmpl         $-330, %eax
+	LONG $0x00088d0f; WORD $0x0000 // jge          LBB13_6, $8(%rip)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	LONG $0x000376e9; BYTE $0x00   // jmp          LBB13_69, $886(%rip)
+
+LBB13_6:
+	WORD $0xc085                                       // testl        %eax, %eax
+	LONG $0xd05d8948                                   // movq         %rbx, $-48(%rbp)
+	LONG $0x00aa8e0f; WORD $0x0000                     // jle          LBB13_17, $170(%rip)
+	WORD $0x3145; BYTE $0xe4                           // xorl         %r12d, %r12d
+	LONG $0x10358d4c; WORD $0x0088; BYTE $0x00         // leaq         $34832(%rip), %r14  /* _POW_TAB(%rip) */
+	LONG $0x000039e9; BYTE $0x00                       // jmp          LBB13_11, $57(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB13_8:
+	LONG $0xffffe5be; BYTE $0xff   // movl         $-27, %esi
+	LONG $0x00001bbb; BYTE $0x00   // movl         $27, %ebx
+	LONG $0x107f8341; BYTE $0x00   // cmpl         $0, $16(%r15)
+	LONG $0x000a840f; WORD $0x0000 // je           LBB13_10, $10(%rip)
+
+LBB13_9:
+	WORD $0xdef7                 // negl         %esi
+	WORD $0x894c; BYTE $0xff     // movq         %r15, %rdi
+	LONG $0x0053f1e8; BYTE $0x00 // callq        _right_shift, $21489(%rip)
+
+LBB13_10:
+	WORD $0x0141; BYTE $0xdc       // addl         %ebx, %r12d
+	LONG $0x14478b41               // movl         $20(%r15), %eax
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x00628e0f; WORD $0x0000 // jle          LBB13_17, $98(%rip)
+
+LBB13_11:
+	WORD $0xf883; BYTE $0x08       // cmpl         $8, %eax
+	LONG $0xffc9870f; WORD $0xffff // ja           LBB13_8, $-55(%rip)
+	WORD $0xc089                   // movl         %eax, %eax
+	LONG $0x861c8b41               // movl         (%r14,%rax,4), %ebx
+	LONG $0x107f8341; BYTE $0x00   // cmpl         $0, $16(%r15)
+	LONG $0xffd7840f; WORD $0xffff // je           LBB13_10, $-41(%rip)
+	WORD $0xde89                   // movl         %ebx, %esi
+	WORD $0xdef7                   // negl         %esi
+	WORD $0xfe83; BYTE $0xc3       // cmpl         $-61, %esi
+	LONG $0xffc0870f; WORD $0xffff // ja           LBB13_9, $-64(%rip)
+	WORD $0x894d; BYTE $0xf5       // movq         %r14, %r13
+	QUAD $0x9090909090909090       // .p2align 4, 0x90
+
+LBB13_15:
+	WORD $0x8941; BYTE $0xf6               // movl         %esi, %r14d
+	WORD $0x894c; BYTE $0xff               // movq         %r15, %rdi
+	LONG $0x00003cbe; BYTE $0x00           // movl         $60, %esi
+	LONG $0x0053a0e8; BYTE $0x00           // callq        _right_shift, $21408(%rip)
+	LONG $0x3c768d41                       // leal         $60(%r14), %esi
+	LONG $0x88fe8341                       // cmpl         $-120, %r14d
+	LONG $0xffe2820f; WORD $0xffff         // jb           LBB13_15, $-30(%rip)
+	WORD $0x894d; BYTE $0xee               // movq         %r13, %r14
+	QUAD $0x000000000000bd49; WORD $0x0010 // movabsq      $4503599627370496, %r13
+	LONG $0xffff85e9; BYTE $0xff           // jmp          LBB13_9, $-123(%rip)
+
+LBB13_17:
+	LONG $0x69358d4c; WORD $0x0087; BYTE $0x00 // leaq         $34665(%rip), %r14  /* _POW_TAB(%rip) */
+	LONG $0x000025e9; BYTE $0x00               // jmp          LBB13_19, $37(%rip)
+
+LBB13_23:
+	LONG $0x00001bbb; BYTE $0x00   // movl         $27, %ebx
+	LONG $0x107f8341; BYTE $0x00   // cmpl         $0, $16(%r15)
+	LONG $0x0012840f; WORD $0x0000 // je           LBB13_18, $18(%rip)
+	LONG $0x90909090               // .p2align 4, 0x90
+
+LBB13_25:
+	WORD $0x894c; BYTE $0xff     // movq         %r15, %rdi
+	WORD $0xde89                 // movl         %ebx, %esi
+	LONG $0x005166e8; BYTE $0x00 // callq        _left_shift, $20838(%rip)
+	LONG $0x14478b41             // movl         $20(%r15), %eax
+
+LBB13_18:
+	WORD $0x2941; BYTE $0xdc // subl         %ebx, %r12d
+
+LBB13_19:
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x0017880f; WORD $0x0000 // js           LBB13_22, $23(%rip)
+	LONG $0x0032850f; WORD $0x0000 // jne          LBB13_26, $50(%rip)
+	WORD $0x8b49; BYTE $0x0f       // movq         (%r15), %rcx
+	WORD $0x3980; BYTE $0x35       // cmpb         $53, (%rcx)
+	LONG $0x000e8c0f; WORD $0x0000 // jl           LBB13_24, $14(%rip)
+	LONG $0x000021e9; BYTE $0x00   // jmp          LBB13_26, $33(%rip)
+
+	// .p2align 4, 0x90
+LBB13_22:
+	WORD $0xf883; BYTE $0xf8       // cmpl         $-8, %eax
+	LONG $0xffb3820f; WORD $0xffff // jb           LBB13_23, $-77(%rip)
+
+LBB13_24:
+	WORD $0xc189                   // movl         %eax, %ecx
+	WORD $0xd9f7                   // negl         %ecx
+	LONG $0x8e1c8b41               // movl         (%r14,%rcx,4), %ebx
+	LONG $0x107f8341; BYTE $0x00   // cmpl         $0, $16(%r15)
+	LONG $0xffb4850f; WORD $0xffff // jne          LBB13_25, $-76(%rip)
+	LONG $0xffffbde9; BYTE $0xff   // jmp          LBB13_18, $-67(%rip)
+
+LBB13_26:
+	LONG $0x02fc8141; WORD $0xfffc; BYTE $0xff                           // cmpl         $-1022, %r12d
+	LONG $0x00568f0f; WORD $0x0000                                       // jg           LBB13_32, $86(%rip)
+	LONG $0x107f8341; BYTE $0x00                                         // cmpl         $0, $16(%r15)
+	LONG $0xd05d8b48                                                     // movq         $-48(%rbp), %rbx
+	LONG $0x0075840f; WORD $0x0000                                       // je           LBB13_35, $117(%rip)
+	LONG $0xc6fc8141; WORD $0xfffb; BYTE $0xff                           // cmpl         $-1082, %r12d
+	LONG $0x0073870f; WORD $0x0000                                       // ja           LBB13_36, $115(%rip)
+	LONG $0xc1c48141; WORD $0x0003; BYTE $0x00                           // addl         $961, %r12d
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB13_30:
+	WORD $0x894c; BYTE $0xff       // movq         %r15, %rdi
+	LONG $0x00003cbe; BYTE $0x00   // movl         $60, %esi
+	LONG $0x0052c3e8; BYTE $0x00   // callq        _right_shift, $21187(%rip)
+	LONG $0x3cc48341               // addl         $60, %r12d
+	LONG $0x88fc8341               // cmpl         $-120, %r12d
+	LONG $0xffe5820f; WORD $0xffff // jb           LBB13_30, $-27(%rip)
+	LONG $0x3cc48341               // addl         $60, %r12d
+	LONG $0x000040e9; BYTE $0x00   // jmp          LBB13_37, $64(%rip)
+
+LBB13_32:
+	LONG $0x00fc8141; WORD $0x0004; BYTE $0x00 // cmpl         $1024, %r12d
+	LONG $0xd05d8b48                           // movq         $-48(%rbp), %rbx
+	QUAD $0x000000000000be49; WORD $0x7ff0     // movabsq      $9218868437227405312, %r14
+	LONG $0x00088e0f; WORD $0x0000             // jle          LBB13_34, $8(%rip)
+	WORD $0x3145; BYTE $0xe4                   // xorl         %r12d, %r12d
+	LONG $0x0001c9e9; BYTE $0x00               // jmp          LBB13_69, $457(%rip)
+
+LBB13_34:
+	WORD $0xff41; BYTE $0xcc     // decl         %r12d
+	WORD $0x8945; BYTE $0xe6     // movl         %r12d, %r14d
+	LONG $0x000026e9; BYTE $0x00 // jmp          LBB13_38, $38(%rip)
+
+LBB13_35:
+	LONG $0xfc02be41; WORD $0xffff // movl         $-1022, %r14d
+	LONG $0x000033e9; BYTE $0x00   // jmp          LBB13_40, $51(%rip)
+
+LBB13_36:
+	LONG $0xfdc48141; WORD $0x0003; BYTE $0x00 // addl         $1021, %r12d
+
+LBB13_37:
+	WORD $0xf741; BYTE $0xdc       // negl         %r12d
+	WORD $0x894c; BYTE $0xff       // movq         %r15, %rdi
+	WORD $0x8944; BYTE $0xe6       // movl         %r12d, %esi
+	LONG $0x00525ee8; BYTE $0x00   // callq        _right_shift, $21086(%rip)
+	LONG $0xfc02be41; WORD $0xffff // movl         $-1022, %r14d
+
+LBB13_38:
+	LONG $0x107f8341; BYTE $0x00   // cmpl         $0, $16(%r15)
+	LONG $0x000d840f; WORD $0x0000 // je           LBB13_40, $13(%rip)
+	WORD $0x894c; BYTE $0xff       // movq         %r15, %rdi
+	LONG $0x000035be; BYTE $0x00   // movl         $53, %esi
+	LONG $0x005050e8; BYTE $0x00   // callq        _left_shift, $20560(%rip)
+
+LBB13_40:
+	LONG $0x14478b41                           // movl         $20(%r15), %eax
+	LONG $0xffc4c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r12
+	WORD $0xf883; BYTE $0x14                   // cmpl         $20, %eax
+	LONG $0x014d8f0f; WORD $0x0000             // jg           LBB13_68, $333(%rip)
+	WORD $0xc085                               // testl        %eax, %eax
+	LONG $0x00558e0f; WORD $0x0000             // jle          LBB13_46, $85(%rip)
+	LONG $0x10578b41                           // movl         $16(%r15), %edx
+	WORD $0xf631                               // xorl         %esi, %esi
+	WORD $0xd285                               // testl        %edx, %edx
+	WORD $0x4e0f; BYTE $0xd6                   // cmovlel      %esi, %edx
+	LONG $0xff488d4c                           // leaq         $-1(%rax), %r9
+	WORD $0x3949; BYTE $0xd1                   // cmpq         %rdx, %r9
+	LONG $0xca430f4c                           // cmovaeq      %rdx, %r9
+	LONG $0x01418d4d                           // leaq         $1(%r9), %r8
+	WORD $0x3145; BYTE $0xe4                   // xorl         %r12d, %r12d
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB13_43:
+	WORD $0x3948; BYTE $0xf2       // cmpq         %rsi, %rdx
+	LONG $0x002e840f; WORD $0x0000 // je           LBB13_47, $46(%rip)
+	LONG $0xa43c8d4b               // leaq         (%r12,%r12,4), %rdi
+	WORD $0x8b49; BYTE $0x0f       // movq         (%r15), %rcx
+	LONG $0x0cbe0f48; BYTE $0x31   // movsbq       (%rcx,%rsi), %rcx
+	LONG $0x79248d4c               // leaq         (%rcx,%rdi,2), %r12
+	LONG $0xd0c48349               // addq         $-48, %r12
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0xffd7850f; WORD $0xffff // jne          LBB13_43, $-41(%rip)
+	WORD $0x894d; BYTE $0xc1       // movq         %r8, %r9
+	LONG $0x000006e9; BYTE $0x00   // jmp          LBB13_47, $6(%rip)
+
+LBB13_46:
+	WORD $0x3145; BYTE $0xc9 // xorl         %r9d, %r9d
+	WORD $0x3145; BYTE $0xe4 // xorl         %r12d, %r12d
+
+LBB13_47:
+	WORD $0x3944; BYTE $0xc8                   // cmpl         %r9d, %eax
+	LONG $0x00608e0f; WORD $0x0000             // jle          LBB13_55, $96(%rip)
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0x2944; BYTE $0xce                   // subl         %r9d, %esi
+	WORD $0x8944; BYTE $0xca                   // movl         %r9d, %edx
+	WORD $0xd2f7                               // notl         %edx
+	WORD $0xc201                               // addl         %eax, %edx
+	WORD $0xe683; BYTE $0x07                   // andl         $7, %esi
+	LONG $0x001f840f; WORD $0x0000             // je           LBB13_52, $31(%rip)
+	WORD $0xdef7                               // negl         %esi
+	WORD $0xff31                               // xorl         %edi, %edi
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB13_50:
+	WORD $0x014d; BYTE $0xe4       // addq         %r12, %r12
+	LONG $0xa4248d4f               // leaq         (%r12,%r12,4), %r12
+	WORD $0xcfff                   // decl         %edi
+	WORD $0xfe39                   // cmpl         %edi, %esi
+	LONG $0xffef850f; WORD $0xffff // jne          LBB13_50, $-17(%rip)
+	WORD $0x2941; BYTE $0xf9       // subl         %edi, %r9d
+
+LBB13_52:
+	WORD $0xfa83; BYTE $0x07                                 // cmpl         $7, %edx
+	LONG $0x0023820f; WORD $0x0000                           // jb           LBB13_55, $35(%rip)
+	WORD $0xc289                                             // movl         %eax, %edx
+	WORD $0x2944; BYTE $0xca                                 // subl         %r9d, %edx
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB13_54:
+	LONG $0x00e4694d; WORD $0xf5e1; BYTE $0x05 // imulq        $100000000, %r12, %r12
+	WORD $0xc283; BYTE $0xf8                   // addl         $-8, %edx
+	LONG $0xfff0850f; WORD $0xffff             // jne          LBB13_54, $-16(%rip)
+
+LBB13_55:
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x004b880f; WORD $0x0000 // js           LBB13_62, $75(%rip)
+	LONG $0x10578b41               // movl         $16(%r15), %edx
+	WORD $0xc239                   // cmpl         %eax, %edx
+	LONG $0x003f8e0f; WORD $0x0000 // jle          LBB13_62, $63(%rip)
+	WORD $0x8b49; BYTE $0x37       // movq         (%r15), %rsi
+	LONG $0x060cb60f               // movzbl       (%rsi,%rax), %ecx
+	WORD $0xf980; BYTE $0x35       // cmpb         $53, %cl
+	LONG $0x00af850f; WORD $0x0000 // jne          LBB13_64, $175(%rip)
+	WORD $0x788d; BYTE $0x01       // leal         $1(%rax), %edi
+	WORD $0xd739                   // cmpl         %edx, %edi
+	LONG $0x00a4850f; WORD $0x0000 // jne          LBB13_64, $164(%rip)
+	WORD $0x01b2                   // movb         $1, %dl
+	LONG $0x1c7f8341; BYTE $0x00   // cmpl         $0, $28(%r15)
+	LONG $0x0019850f; WORD $0x0000 // jne          LBB13_65, $25(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x000e840f; WORD $0x0000 // je           LBB13_62, $14(%rip)
+	WORD $0xc8ff                   // decl         %eax
+	LONG $0x0614b60f               // movzbl       (%rsi,%rax), %edx
+	WORD $0xe280; BYTE $0x01       // andb         $1, %dl
+	LONG $0x000002e9; BYTE $0x00   // jmp          LBB13_65, $2(%rip)
+
+LBB13_62:
+	WORD $0xd231 // xorl         %edx, %edx
+
+LBB13_65:
+	WORD $0xb60f; BYTE $0xc2                   // movzbl       %dl, %eax
+	WORD $0x0149; BYTE $0xc4                   // addq         %rax, %r12
+	QUAD $0x000000000000b848; WORD $0x0020     // movabsq      $9007199254740992, %rax
+	WORD $0x3949; BYTE $0xc4                   // cmpq         %rax, %r12
+	LONG $0x0013850f; WORD $0x0000             // jne          LBB13_68, $19(%rip)
+	LONG $0xfefe8141; WORD $0x0003; BYTE $0x00 // cmpl         $1022, %r14d
+	LONG $0xfc7c8f0f; WORD $0xffff             // jg           LBB13_2, $-900(%rip)
+	WORD $0xff41; BYTE $0xc6                   // incl         %r14d
+	WORD $0x894d; BYTE $0xec                   // movq         %r13, %r12
+
+LBB13_68:
+	WORD $0x894c; BYTE $0xe0                   // movq         %r12, %rax
+	WORD $0x214c; BYTE $0xe8                   // andq         %r13, %rax
+	LONG $0xffc68141; WORD $0x0003; BYTE $0x00 // addl         $1023, %r14d
+	LONG $0xffe68141; WORD $0x0007; BYTE $0x00 // andl         $2047, %r14d
+	LONG $0x34e6c149                           // shlq         $52, %r14
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0xf0440f4c                           // cmoveq       %rax, %r14
+
+LBB13_69:
+	WORD $0xff49; BYTE $0xcd               // decq         %r13
+	WORD $0x214d; BYTE $0xe5               // andq         %r12, %r13
+	WORD $0x094d; BYTE $0xf5               // orq          %r14, %r13
+	QUAD $0x000000000000b848; WORD $0x8000 // movabsq      $-9223372036854775808, %rax
+	WORD $0x094c; BYTE $0xe8               // orq          %r13, %rax
+	LONG $0x187f8341; BYTE $0x00           // cmpl         $0, $24(%r15)
+	LONG $0xc5440f49                       // cmoveq       %r13, %rax
+	WORD $0x8948; BYTE $0x03               // movq         %rax, (%rbx)
+	WORD $0xc031                           // xorl         %eax, %eax
+	LONG $0x08c48348                       // addq         $8, %rsp
+	BYTE $0x5b                             // popq         %rbx
+	WORD $0x5c41                           // popq         %r12
+	WORD $0x5d41                           // popq         %r13
+	WORD $0x5e41                           // popq         %r14
+	WORD $0x5f41                           // popq         %r15
+	BYTE $0x5d                             // popq         %rbp
+	BYTE $0xc3                             // retq
+
+LBB13_64:
+	WORD $0xf980; BYTE $0x35     // cmpb         $53, %cl
+	WORD $0x9d0f; BYTE $0xc2     // setge        %dl
+	LONG $0xffff77e9; BYTE $0xff // jmp          LBB13_65, $-137(%rip)
+	WORD $0x9090                 // .p2align 4, 0x90
+
+_atof_native:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5741                   // pushq        %r15
+	WORD $0x5641                   // pushq        %r14
+	WORD $0x5541                   // pushq        %r13
+	WORD $0x5441                   // pushq        %r12
+	BYTE $0x53                     // pushq        %rbx
+	LONG $0x28ec8348               // subq         $40, %rsp
+	QUAD $0x00000000d045c748       // movq         $0, $-48(%rbp)
+	LONG $0xb0558948               // movq         %rdx, $-80(%rbp)
+	LONG $0xb84d8948               // movq         %rcx, $-72(%rbp)
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x0126840f; WORD $0x0000 // je           LBB14_18, $294(%rip)
+	LONG $0x08f98348               // cmpq         $8, %rcx
+	LONG $0x0007830f; WORD $0x0000 // jae          LBB14_3, $7(%rip)
+	WORD $0xdb31                   // xorl         %ebx, %ebx
+	LONG $0x000105e9; BYTE $0x00   // jmp          LBB14_17, $261(%rip)
+
+LBB14_3:
+	LONG $0x20f98348               // cmpq         $32, %rcx
+	LONG $0x0007830f; WORD $0x0000 // jae          LBB14_5, $7(%rip)
+	WORD $0xdb31                   // xorl         %ebx, %ebx
+	LONG $0x0000bee9; BYTE $0x00   // jmp          LBB14_14, $190(%rip)
+
+LBB14_5:
+	WORD $0x8948; BYTE $0xcb       // movq         %rcx, %rbx
+	LONG $0xe0e38348               // andq         $-32, %rbx
+	LONG $0xe0438d48               // leaq         $-32(%rbx), %rax
+	WORD $0x8949; BYTE $0xc1       // movq         %rax, %r9
+	LONG $0x05e9c149               // shrq         $5, %r9
+	WORD $0xff49; BYTE $0xc1       // incq         %r9
+	WORD $0x8945; BYTE $0xc8       // movl         %r9d, %r8d
+	LONG $0x03e08341               // andl         $3, %r8d
+	LONG $0x60f88348               // cmpq         $96, %rax
+	LONG $0x0007830f; WORD $0x0000 // jae          LBB14_7, $7(%rip)
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x00004ce9; BYTE $0x00   // jmp          LBB14_9, $76(%rip)
+
+LBB14_7:
+	LONG $0xfce18349                                         // andq         $-4, %r9
+	WORD $0xc031                                             // xorl         %eax, %eax
+	WORD $0x570f; BYTE $0xc0                                 // xorps        %xmm0, %xmm0
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB14_8:
+	LONG $0x0204110f               // movups       %xmm0, (%rdx,%rax)
+	LONG $0x0244110f; BYTE $0x10   // movups       %xmm0, $16(%rdx,%rax)
+	LONG $0x0244110f; BYTE $0x20   // movups       %xmm0, $32(%rdx,%rax)
+	LONG $0x0244110f; BYTE $0x30   // movups       %xmm0, $48(%rdx,%rax)
+	LONG $0x0244110f; BYTE $0x40   // movups       %xmm0, $64(%rdx,%rax)
+	LONG $0x0244110f; BYTE $0x50   // movups       %xmm0, $80(%rdx,%rax)
+	LONG $0x0244110f; BYTE $0x60   // movups       %xmm0, $96(%rdx,%rax)
+	LONG $0x0244110f; BYTE $0x70   // movups       %xmm0, $112(%rdx,%rax)
+	LONG $0x80e88348               // subq         $-128, %rax
+	LONG $0xfcc18349               // addq         $-4, %r9
+	LONG $0xffcb850f; WORD $0xffff // jne          LBB14_8, $-53(%rip)
+
+LBB14_9:
+	WORD $0x854d; BYTE $0xc0       // testq        %r8, %r8
+	LONG $0x002a840f; WORD $0x0000 // je           LBB14_12, $42(%rip)
+	LONG $0x100c8d4c               // leaq         (%rax,%rdx), %r9
+	LONG $0x10c18349               // addq         $16, %r9
+	LONG $0x05e0c149               // shlq         $5, %r8
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0x570f; BYTE $0xc0       // xorps        %xmm0, %xmm0
+	BYTE $0x90                     // .p2align 4, 0x90
+
+LBB14_11:
+	LONG $0x44110f41; WORD $0xf001 // movups       %xmm0, $-16(%r9,%rax)
+	LONG $0x04110f41; BYTE $0x01   // movups       %xmm0, (%r9,%rax)
+	LONG $0x20c08348               // addq         $32, %rax
+	WORD $0x3949; BYTE $0xc0       // cmpq         %rax, %r8
+	LONG $0xffe8850f; WORD $0xffff // jne          LBB14_11, $-24(%rip)
+
+LBB14_12:
+	WORD $0x3948; BYTE $0xcb       // cmpq         %rcx, %rbx
+	LONG $0x004f840f; WORD $0x0000 // je           LBB14_18, $79(%rip)
+	WORD $0xc1f6; BYTE $0x18       // testb        $24, %cl
+	LONG $0x0036840f; WORD $0x0000 // je           LBB14_17, $54(%rip)
+
+LBB14_14:
+	WORD $0x8948; BYTE $0xd8                   // movq         %rbx, %rax
+	WORD $0x8948; BYTE $0xcb                   // movq         %rcx, %rbx
+	LONG $0xf8e38348                           // andq         $-8, %rbx
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+LBB14_15:
+	QUAD $0x000000000204c748       // movq         $0, (%rdx,%rax)
+	LONG $0x08c08348               // addq         $8, %rax
+	WORD $0x3948; BYTE $0xc3       // cmpq         %rax, %rbx
+	LONG $0xffeb850f; WORD $0xffff // jne          LBB14_15, $-21(%rip)
+	WORD $0x3948; BYTE $0xcb       // cmpq         %rcx, %rbx
+	LONG $0x0012840f; WORD $0x0000 // je           LBB14_18, $18(%rip)
+	WORD $0x9090                   // .p2align 4, 0x90
+
+LBB14_17:
+	LONG $0x001a04c6               // movb         $0, (%rdx,%rbx)
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	WORD $0x3948; BYTE $0xd9       // cmpq         %rbx, %rcx
+	LONG $0xfff0850f; WORD $0xffff // jne          LBB14_17, $-16(%rip)
+
+LBB14_18:
+	LONG $0x00c045c7; WORD $0x0000; BYTE $0x00 // movl         $0, $-64(%rbp)
+	QUAD $0x00000000c845c748                   // movq         $0, $-56(%rbp)
+	WORD $0x3145; BYTE $0xc0                   // xorl         %r8d, %r8d
+	WORD $0x3f80; BYTE $0x2d                   // cmpb         $45, (%rdi)
+	LONG $0x001b850f; WORD $0x0000             // jne          LBB14_19, $27(%rip)
+	LONG $0x01c845c7; WORD $0x0000; BYTE $0x00 // movl         $1, $-56(%rbp)
+	LONG $0x0001bd41; WORD $0x0000             // movl         $1, %r13d
+	WORD $0x3949; BYTE $0xf5                   // cmpq         %rsi, %r13
+	LONG $0x00118c0f; WORD $0x0000             // jl           LBB14_22, $17(%rip)
+	LONG $0x0001b6e9; BYTE $0x00               // jmp          LBB14_54, $438(%rip)
+
+LBB14_19:
+	WORD $0x3145; BYTE $0xed       // xorl         %r13d, %r13d
+	WORD $0x3949; BYTE $0xf5       // cmpq         %rsi, %r13
+	LONG $0x01aa8d0f; WORD $0x0000 // jge          LBB14_54, $426(%rip)
+
+LBB14_22:
+	WORD $0xb741; BYTE $0x01     // movb         $1, %r15b
+	WORD $0x3145; BYTE $0xc0     // xorl         %r8d, %r8d
+	WORD $0x3145; BYTE $0xc9     // xorl         %r9d, %r9d
+	WORD $0x3145; BYTE $0xe4     // xorl         %r12d, %r12d
+	WORD $0x3145; BYTE $0xdb     // xorl         %r11d, %r11d
+	WORD $0xdb31                 // xorl         %ebx, %ebx
+	LONG $0x000028e9; BYTE $0x00 // jmp          LBB14_23, $40(%rip)
+	QUAD $0x9090909090909090     // .p2align 4, 0x90
+
+LBB14_33:
+	LONG $0x000001bb; BYTE $0x00   // movl         $1, %ebx
+	WORD $0x8945; BYTE $0xdc       // movl         %r11d, %r12d
+	WORD $0x2e3c                   // cmpb         $46, %al
+	LONG $0x0095850f; WORD $0x0000 // jne          LBB14_36, $149(%rip)
+
+LBB14_34:
+	WORD $0xff49; BYTE $0xc5       // incq         %r13
+	WORD $0x3949; BYTE $0xf5       // cmpq         %rsi, %r13
+	LONG $0xc79c0f41               // setl         %r15b
+	LONG $0x007c840f; WORD $0x0000 // je           LBB14_35, $124(%rip)
+
+LBB14_23:
+	WORD $0x8941; BYTE $0xda                   // movl         %ebx, %r10d
+	WORD $0x8945; BYTE $0xe6                   // movl         %r12d, %r14d
+	LONG $0x04b60f42; BYTE $0x2f               // movzbl       (%rdi,%r13), %eax
+	WORD $0x588d; BYTE $0xd0                   // leal         $-48(%rax), %ebx
+	WORD $0xfb80; BYTE $0x09                   // cmpb         $9, %bl
+	LONG $0xffc9870f; WORD $0xffff             // ja           LBB14_33, $-55(%rip)
+	WORD $0x303c                               // cmpb         $48, %al
+	LONG $0x0021850f; WORD $0x0000             // jne          LBB14_29, $33(%rip)
+	WORD $0x8545; BYTE $0xdb                   // testl        %r11d, %r11d
+	LONG $0x0043840f; WORD $0x0000             // je           LBB14_26, $67(%rip)
+	WORD $0x6349; BYTE $0xd8                   // movslq       %r8d, %rbx
+	WORD $0x3948; BYTE $0xcb                   // cmpq         %rcx, %rbx
+	LONG $0x0018820f; WORD $0x0000             // jb           LBB14_32, $24(%rip)
+	LONG $0x000019e9; BYTE $0x00               // jmp          LBB14_28, $25(%rip)
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB14_29:
+	WORD $0x6349; BYTE $0xdb       // movslq       %r11d, %rbx
+	WORD $0x3948; BYTE $0xcb       // cmpq         %rcx, %rbx
+	LONG $0x0014830f; WORD $0x0000 // jae          LBB14_30, $20(%rip)
+
+LBB14_32:
+	WORD $0x0488; BYTE $0x1a // movb         %al, (%rdx,%rbx)
+	WORD $0xff41; BYTE $0xc0 // incl         %r8d
+
+LBB14_28:
+	WORD $0x8945; BYTE $0xf4     // movl         %r14d, %r12d
+	WORD $0x8945; BYTE $0xc3     // movl         %r8d, %r11d
+	WORD $0x8944; BYTE $0xd3     // movl         %r10d, %ebx
+	LONG $0xffff90e9; BYTE $0xff // jmp          LBB14_34, $-112(%rip)
+
+LBB14_30:
+	LONG $0x0001b941; WORD $0x0000 // movl         $1, %r9d
+	LONG $0x000006e9; BYTE $0x00   // jmp          LBB14_31, $6(%rip)
+
+LBB14_26:
+	WORD $0xff41; BYTE $0xce // decl         %r14d
+	WORD $0x3145; BYTE $0xdb // xorl         %r11d, %r11d
+
+LBB14_31:
+	WORD $0x8945; BYTE $0xf4     // movl         %r14d, %r12d
+	WORD $0x8944; BYTE $0xd3     // movl         %r10d, %ebx
+	LONG $0xffff74e9; BYTE $0xff // jmp          LBB14_34, $-140(%rip)
+
+LBB14_35:
+	WORD $0x8945; BYTE $0xe6 // movl         %r12d, %r14d
+	WORD $0x8949; BYTE $0xf5 // movq         %rsi, %r13
+	WORD $0x8941; BYTE $0xda // movl         %ebx, %r10d
+
+LBB14_36:
+	LONG $0xc4758944               // movl         %r14d, $-60(%rbp)
+	LONG $0xcc4d8944               // movl         %r9d, $-52(%rbp)
+	LONG $0xc0458944               // movl         %r8d, $-64(%rbp)
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0x0012840f; WORD $0x0000 // je           LBB14_37, $18(%rip)
+	WORD $0x8945; BYTE $0xf0       // movl         %r14d, %r8d
+	LONG $0x01c7f641               // testb        $1, %r15b
+	LONG $0x0013850f; WORD $0x0000 // jne          LBB14_40, $19(%rip)
+	LONG $0x0000c4e9; BYTE $0x00   // jmp          LBB14_55, $196(%rip)
+
+LBB14_37:
+	LONG $0xc4458944               // movl         %r8d, $-60(%rbp)
+	LONG $0x01c7f641               // testb        $1, %r15b
+	LONG $0x00b6840f; WORD $0x0000 // je           LBB14_55, $182(%rip)
+
+LBB14_40:
+	WORD $0x8944; BYTE $0xe8       // movl         %r13d, %eax
+	LONG $0x070cb60f               // movzbl       (%rdi,%rax), %ecx
+	WORD $0xc983; BYTE $0x20       // orl          $32, %ecx
+	WORD $0xf983; BYTE $0x65       // cmpl         $101, %ecx
+	LONG $0x00a3850f; WORD $0x0000 // jne          LBB14_55, $163(%rip)
+	LONG $0x0754b60f; BYTE $0x01   // movzbl       $1(%rdi,%rax), %edx
+	WORD $0xfa83; BYTE $0x2d       // cmpl         $45, %edx
+	LONG $0x0017840f; WORD $0x0000 // je           LBB14_45, $23(%rip)
+	LONG $0x000001b9; BYTE $0x00   // movl         $1, %ecx
+	WORD $0xfa83; BYTE $0x2b       // cmpl         $43, %edx
+	LONG $0x0028850f; WORD $0x0000 // jne          LBB14_43, $40(%rip)
+	LONG $0x02c58341               // addl         $2, %r13d
+	LONG $0x000009e9; BYTE $0x00   // jmp          LBB14_46, $9(%rip)
+
+LBB14_45:
+	LONG $0x02c58341             // addl         $2, %r13d
+	LONG $0xffffffb9; BYTE $0xff // movl         $-1, %ecx
+
+LBB14_46:
+	WORD $0x8944; BYTE $0xe8       // movl         %r13d, %eax
+	WORD $0x6348; BYTE $0xd0       // movslq       %eax, %rdx
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0x3948; BYTE $0xf2       // cmpq         %rsi, %rdx
+	LONG $0x00168c0f; WORD $0x0000 // jl           LBB14_48, $22(%rip)
+	LONG $0x000055e9; BYTE $0x00   // jmp          LBB14_53, $85(%rip)
+
+LBB14_43:
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x6348; BYTE $0xd0       // movslq       %eax, %rdx
+	WORD $0xc031                   // xorl         %eax, %eax
+	WORD $0x3948; BYTE $0xf2       // cmpq         %rsi, %rdx
+	LONG $0x00448d0f; WORD $0x0000 // jge          LBB14_53, $68(%rip)
+
+LBB14_48:
+	WORD $0xc031                               // xorl         %eax, %eax
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+LBB14_49:
+	LONG $0x171cbe0f               // movsbl       (%rdi,%rdx), %ebx
+	WORD $0xfb83; BYTE $0x30       // cmpl         $48, %ebx
+	LONG $0x00298c0f; WORD $0x0000 // jl           LBB14_53, $41(%rip)
+	WORD $0xfb80; BYTE $0x39       // cmpb         $57, %bl
+	LONG $0x0020870f; WORD $0x0000 // ja           LBB14_53, $32(%rip)
+	LONG $0x00270f3d; BYTE $0x00   // cmpl         $9999, %eax
+	LONG $0x00158f0f; WORD $0x0000 // jg           LBB14_53, $21(%rip)
+	WORD $0x048d; BYTE $0x80       // leal         (%rax,%rax,4), %eax
+	WORD $0x048d; BYTE $0x43       // leal         (%rbx,%rax,2), %eax
+	WORD $0xc083; BYTE $0xd0       // addl         $-48, %eax
+	WORD $0xff48; BYTE $0xc2       // incq         %rdx
+	WORD $0x3948; BYTE $0xd6       // cmpq         %rdx, %rsi
+	LONG $0xffca850f; WORD $0xffff // jne          LBB14_49, $-54(%rip)
+
+LBB14_53:
+	WORD $0xaf0f; BYTE $0xc1 // imull        %ecx, %eax
+	WORD $0x0141; BYTE $0xc0 // addl         %eax, %r8d
+
+LBB14_54:
+	LONG $0xc4458944 // movl         %r8d, $-60(%rbp)
+
+LBB14_55:
+	LONG $0xb07d8d48                                                     // leaq         $-80(%rbp), %rdi
+	LONG $0xd0758d48                                                     // leaq         $-48(%rbp), %rsi
+	LONG $0xfff893e8; BYTE $0xff                                         // callq        _decimal_to_f64, $-1901(%rip)
+	LONG $0x45100ff2; BYTE $0xd0                                         // movsd        $-48(%rbp), %xmm0
+	LONG $0x28c48348                                                     // addq         $40, %rsp
+	BYTE $0x5b                                                           // popq         %rbx
+	WORD $0x5c41                                                         // popq         %r12
+	WORD $0x5d41                                                         // popq         %r13
+	WORD $0x5e41                                                         // popq         %r14
+	WORD $0x5f41                                                         // popq         %r15
+	BYTE $0x5d                                                           // popq         %rbp
+	BYTE $0xc3                                                           // retq
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+_value:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x28ec8348                           // subq         $40, %rsp
+	WORD $0x894d; BYTE $0xc7                   // movq         %r8, %r15
+	WORD $0x8949; BYTE $0xce                   // movq         %rcx, %r14
+	WORD $0x8948; BYTE $0xf3                   // movq         %rsi, %rbx
+	WORD $0x8949; BYTE $0xfc                   // movq         %rdi, %r12
+	LONG $0xd0558948                           // movq         %rdx, $-48(%rbp)
+	LONG $0xb07d8948                           // movq         %rdi, $-80(%rbp)
+	LONG $0xb8758948                           // movq         %rsi, $-72(%rbp)
+	LONG $0xd0558d48                           // leaq         $-48(%rbp), %rdx
+	LONG $0x0005eee8; BYTE $0x00               // callq        _advance_ns, $1518(%rip)
+	WORD $0xbe0f; BYTE $0xc0                   // movsbl       %al, %eax
+	WORD $0xf883; BYTE $0x7d                   // cmpl         $125, %eax
+	LONG $0x00bc870f; WORD $0x0000             // ja           LBB15_11, $188(%rip)
+	LONG $0x9f0d8d48; WORD $0x0003; BYTE $0x00 // leaq         $927(%rip), %rcx  /* LJTI15_0(%rip) */
+	LONG $0x81046348                           // movslq       (%rcx,%rax,4), %rax
+	WORD $0x0148; BYTE $0xc8                   // addq         %rcx, %rax
+	JMP  AX
+
+LBB15_2:
+	LONG $0xc875894c               // movq         %r14, $-56(%rbp)
+	LONG $0xd0758b4c               // movq         $-48(%rbp), %r14
+	LONG $0xff6e8d4d               // leaq         $-1(%r14), %r13
+	LONG $0xd06d894c               // movq         %r13, $-48(%rbp)
+	LONG $0x02c7f641               // testb        $2, %r15b
+	LONG $0x001a850f; WORD $0x0000 // jne          LBB15_4, $26(%rip)
+	LONG $0xb07d8d48               // leaq         $-80(%rbp), %rdi
+	LONG $0xd0758d48               // leaq         $-48(%rbp), %rsi
+	LONG $0xc8558b48               // movq         $-56(%rbp), %rdx
+	LONG $0x000e07e8; BYTE $0x00   // callq        _vnumber, $3591(%rip)
+	LONG $0xd07d8b4c               // movq         $-48(%rbp), %r15
+	LONG $0x00034de9; BYTE $0x00   // jmp          LBB15_58, $845(%rip)
+
+LBB15_4:
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x2c3c8043; BYTE $0x2d   // cmpb         $45, (%r12,%r13)
+	LONG $0x2c3c8d4f               // leaq         (%r12,%r13), %r15
+	WORD $0x940f; BYTE $0xc0       // sete         %al
+	WORD $0x0149; BYTE $0xc7       // addq         %rax, %r15
+	WORD $0x2948; BYTE $0xc3       // subq         %rax, %rbx
+	LONG $0x030c840f; WORD $0x0000 // je           LBB15_53, $780(%rip)
+	WORD $0x3949; BYTE $0xdd       // cmpq         %rbx, %r13
+	LONG $0x000e830f; WORD $0x0000 // jae          LBB15_7, $14(%rip)
+	LONG $0x07b60f41               // movzbl       (%r15), %eax
+	WORD $0xc604                   // addb         $-58, %al
+	WORD $0xf63c                   // cmpb         $-10, %al
+	LONG $0x0307820f; WORD $0x0000 // jb           LBB15_55, $775(%rip)
+
+LBB15_7:
+	WORD $0x894c; BYTE $0xff                   // movq         %r15, %rdi
+	WORD $0x8948; BYTE $0xde                   // movq         %rbx, %rsi
+	LONG $0x001f42e8; BYTE $0x00               // callq        _do_skip_number, $8002(%rip)
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0x02ed880f; WORD $0x0000             // js           LBB15_54, $749(%rip)
+	WORD $0x0149; BYTE $0xc7                   // addq         %rax, %r15
+	WORD $0x294d; BYTE $0xe7                   // subq         %r12, %r15
+	WORD $0x854d; BYTE $0xf6                   // testq        %r14, %r14
+	LONG $0x02f28e0f; WORD $0x0000             // jle          LBB15_57, $754(%rip)
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	LONG $0x0800c748; WORD $0x0000; BYTE $0x00 // movq         $8, (%rax)
+	LONG $0x1868894c                           // movq         %r13, $24(%rax)
+	LONG $0x0002e5e9; BYTE $0x00               // jmp          LBB15_58, $741(%rip)
+
+LBB15_10:
+	LONG $0x0106c749; WORD $0x0000; BYTE $0x00 // movq         $1, (%r14)
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0x0002d5e9; BYTE $0x00               // jmp          LBB15_58, $725(%rip)
+
+LBB15_11:
+	LONG $0xfe06c749; WORD $0xffff; BYTE $0xff // movq         $-2, (%r14)
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	WORD $0xff49; BYTE $0xcf                   // decq         %r15
+	LONG $0x0002c2e9; BYTE $0x00               // jmp          LBB15_58, $706(%rip)
+
+LBB15_12:
+	QUAD $0xffffffffc045c748                   // movq         $-1, $-64(%rbp)
+	LONG $0xd0658b4c                           // movq         $-48(%rbp), %r12
+	LONG $0xb07d8d48                           // leaq         $-80(%rbp), %rdi
+	LONG $0xc0558d48                           // leaq         $-64(%rbp), %rdx
+	WORD $0x894c; BYTE $0xe6                   // movq         %r12, %rsi
+	WORD $0x894c; BYTE $0xf9                   // movq         %r15, %rcx
+	LONG $0x000814e8; BYTE $0x00               // callq        _advance_string, $2068(%rip)
+	WORD $0x8949; BYTE $0xc7                   // movq         %rax, %r15
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0x0174880f; WORD $0x0000             // js           LBB15_32, $372(%rip)
+	LONG $0xd07d894c                           // movq         %r15, $-48(%rbp)
+	LONG $0x1066894d                           // movq         %r12, $16(%r14)
+	LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq         $7, (%r14)
+	LONG $0xc0458b48                           // movq         $-64(%rbp), %rax
+	WORD $0x394c; BYTE $0xf8                   // cmpq         %r15, %rax
+	LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rcx
+	LONG $0xc84c0f48                           // cmovlq       %rax, %rcx
+	LONG $0x184e8949                           // movq         %rcx, $24(%r14)
+	LONG $0x00026de9; BYTE $0x00               // jmp          LBB15_58, $621(%rip)
+
+LBB15_14:
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl        $-2147483648, %r15d
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0x00000bba; BYTE $0x00               // movl         $11, %edx
+	LONG $0x00011ae9; BYTE $0x00               // jmp          LBB15_31, $282(%rip)
+
+LBB15_15:
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl        $-2147483648, %r15d
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0x00000aba; BYTE $0x00               // movl         $10, %edx
+	LONG $0x000100e9; BYTE $0x00               // jmp          LBB15_31, $256(%rip)
+
+LBB15_16:
+	LONG $0x0506c749; WORD $0x0000; BYTE $0x00 // movq         $5, (%r14)
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0x000229e9; BYTE $0x00               // jmp          LBB15_58, $553(%rip)
+
+LBB15_17:
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl        $-2147483648, %r15d
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0x00000cba; BYTE $0x00               // movl         $12, %edx
+	LONG $0x0000d6e9; BYTE $0x00               // jmp          LBB15_31, $214(%rip)
+
+LBB15_18:
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0xfc4b8d48                           // leaq         $-4(%rbx), %rcx
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x3949; BYTE $0xcf                   // cmpq         %rcx, %r15
+	LONG $0x008a870f; WORD $0x0000             // ja           LBB15_25, $138(%rip)
+	LONG $0x3c0c8b43                           // movl         (%r12,%r15), %ecx
+	LONG $0x6c61f981; WORD $0x6573             // cmpl         $1702063201, %ecx
+	LONG $0x00d3850f; WORD $0x0000             // jne          LBB15_33, $211(%rip)
+	LONG $0x04c78349                           // addq         $4, %r15
+	LONG $0x000004b8; BYTE $0x00               // movl         $4, %eax
+	LONG $0x000069e9; BYTE $0x00               // jmp          LBB15_24, $105(%rip)
+
+LBB15_21:
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0xfd4b8d48                           // leaq         $-3(%rbx), %rcx
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x3949; BYTE $0xcf                   // cmpq         %rcx, %r15
+	LONG $0x0054870f; WORD $0x0000             // ja           LBB15_25, $84(%rip)
+	LONG $0x3c4c8b43; BYTE $0xff               // movl         $-1(%r12,%r15), %ecx
+	LONG $0x756ef981; WORD $0x6c6c             // cmpl         $1819047278, %ecx
+	LONG $0x00db850f; WORD $0x0000             // jne          LBB15_37, $219(%rip)
+	LONG $0x03c78349                           // addq         $3, %r15
+	LONG $0x000002b8; BYTE $0x00               // movl         $2, %eax
+	LONG $0x000032e9; BYTE $0x00               // jmp          LBB15_24, $50(%rip)
+
+LBB15_26:
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0xfd4b8d48                           // leaq         $-3(%rbx), %rcx
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x3949; BYTE $0xcf                   // cmpq         %rcx, %r15
+	LONG $0x001d870f; WORD $0x0000             // ja           LBB15_25, $29(%rip)
+	LONG $0x3c4c8b43; BYTE $0xff               // movl         $-1(%r12,%r15), %ecx
+	LONG $0x7274f981; WORD $0x6575             // cmpl         $1702195828, %ecx
+	LONG $0x00e2850f; WORD $0x0000             // jne          LBB15_41, $226(%rip)
+	LONG $0x03c78349                           // addq         $3, %r15
+	LONG $0x000003b8; BYTE $0x00               // movl         $3, %eax
+
+LBB15_24:
+	WORD $0x894c; BYTE $0xfb // movq         %r15, %rbx
+
+LBB15_25:
+	LONG $0xd05d8948             // movq         %rbx, $-48(%rbp)
+	WORD $0x8949; BYTE $0xdf     // movq         %rbx, %r15
+	WORD $0x8949; BYTE $0x06     // movq         %rax, (%r14)
+	LONG $0x00015ee9; BYTE $0x00 // jmp          LBB15_58, $350(%rip)
+
+LBB15_29:
+	LONG $0x0606c749; WORD $0x0000; BYTE $0x00 // movq         $6, (%r14)
+	LONG $0xd07d8b4c                           // movq         $-48(%rbp), %r15
+	LONG $0x00014ee9; BYTE $0x00               // jmp          LBB15_58, $334(%rip)
+
+LBB15_30:
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0x00c7f741; WORD $0x0000; BYTE $0x80 // testl        $-2147483648, %r15d
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0x00000dba; BYTE $0x00               // movl         $13, %edx
+
+LBB15_31:
+	LONG $0xd1440f48             // cmoveq       %rcx, %rdx
+	WORD $0x940f; BYTE $0xc0     // sete         %al
+	WORD $0x8949; BYTE $0x16     // movq         %rdx, (%r14)
+	LONG $0xd07d8b4c             // movq         $-48(%rbp), %r15
+	WORD $0x2949; BYTE $0xc7     // subq         %rax, %r15
+	LONG $0x000123e9; BYTE $0x00 // jmp          LBB15_58, $291(%rip)
+
+LBB15_32:
+	LONG $0xd05d8948             // movq         %rbx, $-48(%rbp)
+	WORD $0x894d; BYTE $0x3e     // movq         %r15, (%r14)
+	WORD $0x8949; BYTE $0xdf     // movq         %rbx, %r15
+	LONG $0x000114e9; BYTE $0x00 // jmp          LBB15_58, $276(%rip)
+
+LBB15_33:
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	WORD $0xf980; BYTE $0x61                   // cmpb         $97, %cl
+	LONG $0x00d5850f; WORD $0x0000             // jne          LBB15_49, $213(%rip)
+	LONG $0x3c7c8043; WORD $0x6c01             // cmpb         $108, $1(%r12,%r15)
+	LONG $0x00aa850f; WORD $0x0000             // jne          LBB15_46, $170(%rip)
+	LONG $0x3c7c8043; WORD $0x7302             // cmpb         $115, $2(%r12,%r15)
+	LONG $0x00b5850f; WORD $0x0000             // jne          LBB15_47, $181(%rip)
+	LONG $0x044f8d49                           // leaq         $4(%r15), %rcx
+	LONG $0x3c7c8043; WORD $0x6503             // cmpb         $101, $3(%r12,%r15)
+	LONG $0x037f8d4d                           // leaq         $3(%r15), %r15
+	LONG $0xf9440f4c                           // cmoveq       %rcx, %r15
+	LONG $0x0000a2e9; BYTE $0x00               // jmp          LBB15_48, $162(%rip)
+
+LBB15_37:
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	WORD $0xf980; BYTE $0x6e                   // cmpb         $110, %cl
+	LONG $0x006c850f; WORD $0x0000             // jne          LBB15_45, $108(%rip)
+	LONG $0x3c3c8043; BYTE $0x75               // cmpb         $117, (%r12,%r15)
+	LONG $0x0077850f; WORD $0x0000             // jne          LBB15_51, $119(%rip)
+	LONG $0x3c7c8043; WORD $0x6c01             // cmpb         $108, $1(%r12,%r15)
+	LONG $0x0068850f; WORD $0x0000             // jne          LBB15_50, $104(%rip)
+	LONG $0x034f8d49                           // leaq         $3(%r15), %rcx
+	LONG $0x3c7c8043; WORD $0x6c02             // cmpb         $108, $2(%r12,%r15)
+	LONG $0x027f8d4d                           // leaq         $2(%r15), %r15
+	LONG $0xf9440f4c                           // cmoveq       %rcx, %r15
+	LONG $0x000054e9; BYTE $0x00               // jmp          LBB15_51, $84(%rip)
+
+LBB15_41:
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	WORD $0xf980; BYTE $0x74                   // cmpb         $116, %cl
+	LONG $0x002e850f; WORD $0x0000             // jne          LBB15_45, $46(%rip)
+	LONG $0x3c3c8043; BYTE $0x72               // cmpb         $114, (%r12,%r15)
+	LONG $0x0039850f; WORD $0x0000             // jne          LBB15_51, $57(%rip)
+	LONG $0x3c7c8043; WORD $0x7501             // cmpb         $117, $1(%r12,%r15)
+	LONG $0x002a850f; WORD $0x0000             // jne          LBB15_50, $42(%rip)
+	LONG $0x034f8d49                           // leaq         $3(%r15), %rcx
+	LONG $0x3c7c8043; WORD $0x6502             // cmpb         $101, $2(%r12,%r15)
+	LONG $0x027f8d4d                           // leaq         $2(%r15), %r15
+	LONG $0xf9440f4c                           // cmoveq       %rcx, %r15
+	LONG $0x000016e9; BYTE $0x00               // jmp          LBB15_51, $22(%rip)
+
+LBB15_45:
+	WORD $0xff49; BYTE $0xcf     // decq         %r15
+	WORD $0x8949; BYTE $0x06     // movq         %rax, (%r14)
+	LONG $0x00004ee9; BYTE $0x00 // jmp          LBB15_58, $78(%rip)
+
+LBB15_46:
+	WORD $0xff49; BYTE $0xc7     // incq         %r15
+	LONG $0x000013e9; BYTE $0x00 // jmp          LBB15_48, $19(%rip)
+
+LBB15_50:
+	WORD $0xff49; BYTE $0xc7 // incq         %r15
+
+LBB15_51:
+	LONG $0xd07d894c             // movq         %r15, $-48(%rbp)
+	WORD $0x8949; BYTE $0x06     // movq         %rax, (%r14)
+	LONG $0x000037e9; BYTE $0x00 // jmp          LBB15_58, $55(%rip)
+
+LBB15_47:
+	LONG $0x02c78349 // addq         $2, %r15
+
+LBB15_48:
+	LONG $0xd07d894c // movq         %r15, $-48(%rbp)
+
+LBB15_49:
+	WORD $0x8949; BYTE $0x06     // movq         %rax, (%r14)
+	LONG $0x000027e9; BYTE $0x00 // jmp          LBB15_58, $39(%rip)
+
+LBB15_53:
+	LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r13
+	LONG $0x00000de9; BYTE $0x00               // jmp          LBB15_56, $13(%rip)
+
+LBB15_54:
+	WORD $0xf748; BYTE $0xd0 // notq         %rax
+	WORD $0x0149; BYTE $0xc7 // addq         %rax, %r15
+
+LBB15_55:
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+
+LBB15_56:
+	WORD $0x294d; BYTE $0xe7 // subq         %r12, %r15
+	LONG $0xd07d894c         // movq         %r15, $-48(%rbp)
+
+LBB15_57:
+	LONG $0xc8458b48         // movq         $-56(%rbp), %rax
+	WORD $0x894c; BYTE $0x28 // movq         %r13, (%rax)
+
+LBB15_58:
+	WORD $0x894c; BYTE $0xf8 // movq         %r15, %rax
+	LONG $0x28c48348         // addq         $40, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+	WORD $0x9090; BYTE $0x90 // .p2align 2, 0x90
+
+	// .set L15_0_set_10, LBB15_10-LJTI15_0
+	// .set L15_0_set_11, LBB15_11-LJTI15_0
+	// .set L15_0_set_12, LBB15_12-LJTI15_0
+	// .set L15_0_set_14, LBB15_14-LJTI15_0
+	// .set L15_0_set_2, LBB15_2-LJTI15_0
+	// .set L15_0_set_15, LBB15_15-LJTI15_0
+	// .set L15_0_set_16, LBB15_16-LJTI15_0
+	// .set L15_0_set_17, LBB15_17-LJTI15_0
+	// .set L15_0_set_18, LBB15_18-LJTI15_0
+	// .set L15_0_set_21, LBB15_21-LJTI15_0
+	// .set L15_0_set_26, LBB15_26-LJTI15_0
+	// .set L15_0_set_29, LBB15_29-LJTI15_0
+	// .set L15_0_set_30, LBB15_30-LJTI15_0
+LJTI15_0:
+	LONG $0xfffffd06 // .long L15_0_set_10
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd29 // .long L15_0_set_12
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd7e // .long L15_0_set_14
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffc6a // .long L15_0_set_2
+	LONG $0xfffffd98 // .long L15_0_set_15
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffdb2 // .long L15_0_set_16
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffdc2 // .long L15_0_set_17
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffddc // .long L15_0_set_18
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffe12 // .long L15_0_set_21
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffe49 // .long L15_0_set_26
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffe8d // .long L15_0_set_29
+	LONG $0xfffffd16 // .long L15_0_set_11
+	LONG $0xfffffe9d // .long L15_0_set_30
+	LONG $0x00000000 // .p2align 4, 0x00
+
+LCPI16_0:
+	QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, '                '
+
+LCPI16_1:
+	QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'
+
+LCPI16_2:
+	QUAD $0x0a0a0a0a0a0a0a0a; QUAD $0x0a0a0a0a0a0a0a0a // .space 16, '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n'
+
+LCPI16_3:
+	QUAD $0x0d0d0d0d0d0d0d0d; QUAD $0x0d0d0d0d0d0d0d0d // .space 16, '\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r'
+
+	// .p2align 4, 0x90
+_advance_ns:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x8b4c; BYTE $0x02       // movq         (%rdx), %r8
+	WORD $0x3949; BYTE $0xf0       // cmpq         %rsi, %r8
+	LONG $0x0029830f; WORD $0x0000 // jae          LBB16_6, $41(%rip)
+	LONG $0x04b60f42; BYTE $0x07   // movzbl       (%rdi,%r8), %eax
+	WORD $0xf883; BYTE $0x0d       // cmpl         $13, %eax
+	LONG $0x001b840f; WORD $0x0000 // je           LBB16_6, $27(%rip)
+	WORD $0xf883; BYTE $0x20       // cmpl         $32, %eax
+	LONG $0x0012840f; WORD $0x0000 // je           LBB16_6, $18(%rip)
+	WORD $0xf504                   // addb         $-11, %al
+	WORD $0xfe3c                   // cmpb         $-2, %al
+	LONG $0x0008830f; WORD $0x0000 // jae          LBB16_6, $8(%rip)
+	WORD $0x894c; BYTE $0xc0       // movq         %r8, %rax
+	LONG $0x000213e9; BYTE $0x00   // jmp          LBB16_5, $531(%rip)
+
+LBB16_6:
+	LONG $0x01408d49               // leaq         $1(%r8), %rax
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0x0022830f; WORD $0x0000 // jae          LBB16_10, $34(%rip)
+	LONG $0x070cb60f               // movzbl       (%rdi,%rax), %ecx
+	WORD $0xf983; BYTE $0x0d       // cmpl         $13, %ecx
+	LONG $0x0015840f; WORD $0x0000 // je           LBB16_10, $21(%rip)
+	WORD $0xf983; BYTE $0x20       // cmpl         $32, %ecx
+	LONG $0x000c840f; WORD $0x0000 // je           LBB16_10, $12(%rip)
+	WORD $0xc180; BYTE $0xf5       // addb         $-11, %cl
+	WORD $0xf980; BYTE $0xfe       // cmpb         $-2, %cl
+	LONG $0x01e4820f; WORD $0x0000 // jb           LBB16_5, $484(%rip)
+
+LBB16_10:
+	LONG $0x02408d49               // leaq         $2(%r8), %rax
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0x0022830f; WORD $0x0000 // jae          LBB16_14, $34(%rip)
+	LONG $0x070cb60f               // movzbl       (%rdi,%rax), %ecx
+	WORD $0xf983; BYTE $0x0d       // cmpl         $13, %ecx
+	LONG $0x0015840f; WORD $0x0000 // je           LBB16_14, $21(%rip)
+	WORD $0xf983; BYTE $0x20       // cmpl         $32, %ecx
+	LONG $0x000c840f; WORD $0x0000 // je           LBB16_14, $12(%rip)
+	WORD $0xc180; BYTE $0xf5       // addb         $-11, %cl
+	WORD $0xf980; BYTE $0xfe       // cmpb         $-2, %cl
+	LONG $0x01b5820f; WORD $0x0000 // jb           LBB16_5, $437(%rip)
+
+LBB16_14:
+	LONG $0x03408d49               // leaq         $3(%r8), %rax
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0x0022830f; WORD $0x0000 // jae          LBB16_18, $34(%rip)
+	LONG $0x070cb60f               // movzbl       (%rdi,%rax), %ecx
+	WORD $0xf983; BYTE $0x0d       // cmpl         $13, %ecx
+	LONG $0x0015840f; WORD $0x0000 // je           LBB16_18, $21(%rip)
+	WORD $0xf983; BYTE $0x20       // cmpl         $32, %ecx
+	LONG $0x000c840f; WORD $0x0000 // je           LBB16_18, $12(%rip)
+	WORD $0xc180; BYTE $0xf5       // addb         $-11, %cl
+	WORD $0xf980; BYTE $0xfe       // cmpb         $-2, %cl
+	LONG $0x0186820f; WORD $0x0000 // jb           LBB16_5, $390(%rip)
+
+LBB16_18:
+	LONG $0x04c08349                                         // addq         $4, %r8
+	WORD $0x3949; BYTE $0xf0                                 // cmpq         %rsi, %r8
+	LONG $0x0159830f; WORD $0x0000                           // jae          LBB16_19, $345(%rip)
+	LONG $0x070c8d4e                                         // leaq         (%rdi,%r8), %r9
+	WORD $0x8949; BYTE $0xf3                                 // movq         %rsi, %r11
+	WORD $0x294d; BYTE $0xc3                                 // subq         %r8, %r11
+	LONG $0x0073840f; WORD $0x0000                           // je           LBB16_27, $115(%rip)
+	WORD $0x8944; BYTE $0xc8                                 // movl         %r9d, %eax
+	WORD $0xe083; BYTE $0x0f                                 // andl         $15, %eax
+	LONG $0x0067840f; WORD $0x0000                           // je           LBB16_27, $103(%rip)
+	LONG $0x0005ba41; WORD $0x0000                           // movl         $5, %r10d
+	WORD $0x2949; BYTE $0xf2                                 // subq         %rsi, %r10
+	QUAD $0x000100002600b949; WORD $0x0000                   // movabsq      $4294977024, %r9
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB16_23:
+	LONG $0x0cbe0f42; BYTE $0x07   // movsbl       (%rdi,%r8), %ecx
+	WORD $0xf983; BYTE $0x20       // cmpl         $32, %ecx
+	LONG $0x0122870f; WORD $0x0000 // ja           LBB16_42, $290(%rip)
+	LONG $0xc9a30f49               // btq          %rcx, %r9
+	LONG $0x0118830f; WORD $0x0000 // jae          LBB16_42, $280(%rip)
+	LONG $0x02048d4b               // leaq         (%r10,%r8), %rax
+	LONG $0x01488d49               // leaq         $1(%r8), %rcx
+	LONG $0x04f88348               // cmpq         $4, %rax
+	LONG $0x0012840f; WORD $0x0000 // je           LBB16_26, $18(%rip)
+	LONG $0x07048d42               // leal         (%rdi,%r8), %eax
+	WORD $0xc0ff                   // incl         %eax
+	WORD $0x8949; BYTE $0xc8       // movq         %rcx, %r8
+	WORD $0xe083; BYTE $0x0f       // andl         $15, %eax
+	LONG $0xffc4850f; WORD $0xffff // jne          LBB16_23, $-60(%rip)
+
+LBB16_26:
+	LONG $0x0f0c8d4c         // leaq         (%rdi,%rcx), %r9
+	WORD $0x8949; BYTE $0xf3 // movq         %rsi, %r11
+	WORD $0x2949; BYTE $0xcb // subq         %rcx, %r11
+
+LBB16_27:
+	LONG $0x10fb8349                       // cmpq         $16, %r11
+	LONG $0x0081820f; WORD $0x0000         // jb           LBB16_33, $129(%rip)
+	WORD $0x8948; BYTE $0xf9               // movq         %rdi, %rcx
+	WORD $0x294c; BYTE $0xc9               // subq         %r9, %rcx
+	QUAD $0xfffffe52056f0f66               // movdqa       $-430(%rip), %xmm0  /* LCPI16_0(%rip) */
+	QUAD $0xfffffe5a0d6f0f66               // movdqa       $-422(%rip), %xmm1  /* LCPI16_1(%rip) */
+	QUAD $0xfffffe62156f0f66               // movdqa       $-414(%rip), %xmm2  /* LCPI16_2(%rip) */
+	QUAD $0xfffffe6a1d6f0f66               // movdqa       $-406(%rip), %xmm3  /* LCPI16_3(%rip) */
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB16_29:
+	LONG $0x6f0f4166; BYTE $0x21   // movdqa       (%r9), %xmm4
+	LONG $0xec6f0f66               // movdqa       %xmm4, %xmm5
+	LONG $0xe8740f66               // pcmpeqb      %xmm0, %xmm5
+	LONG $0xf46f0f66               // movdqa       %xmm4, %xmm6
+	LONG $0xf1740f66               // pcmpeqb      %xmm1, %xmm6
+	LONG $0xf5eb0f66               // por          %xmm5, %xmm6
+	LONG $0xec6f0f66               // movdqa       %xmm4, %xmm5
+	LONG $0xea740f66               // pcmpeqb      %xmm2, %xmm5
+	LONG $0xe3740f66               // pcmpeqb      %xmm3, %xmm4
+	LONG $0xe5eb0f66               // por          %xmm5, %xmm4
+	LONG $0xe6eb0f66               // por          %xmm6, %xmm4
+	LONG $0xc4d70f66               // pmovmskb     %xmm4, %eax
+	LONG $0xfff88366               // cmpw         $-1, %ax
+	LONG $0x0069850f; WORD $0x0000 // jne          LBB16_30, $105(%rip)
+	LONG $0x10c18349               // addq         $16, %r9
+	LONG $0xf0c38349               // addq         $-16, %r11
+	LONG $0xf0c18348               // addq         $-16, %rcx
+	LONG $0x0ffb8349               // cmpq         $15, %r11
+	LONG $0xffaf870f; WORD $0xffff // ja           LBB16_29, $-81(%rip)
+
+LBB16_33:
+	WORD $0x854d; BYTE $0xdb               // testq        %r11, %r11
+	LONG $0x0037840f; WORD $0x0000         // je           LBB16_40, $55(%rip)
+	LONG $0x19048d4f                       // leaq         (%r9,%r11), %r8
+	WORD $0xc931                           // xorl         %ecx, %ecx
+	QUAD $0x000100002600ba49; WORD $0x0000 // movabsq      $4294977024, %r10
+
+LBB16_35:
+	LONG $0x04be0f41; BYTE $0x09   // movsbl       (%r9,%rcx), %eax
+	WORD $0xf883; BYTE $0x20       // cmpl         $32, %eax
+	LONG $0x005b870f; WORD $0x0000 // ja           LBB16_37, $91(%rip)
+	LONG $0xc2a30f49               // btq          %rax, %r10
+	LONG $0x0051830f; WORD $0x0000 // jae          LBB16_37, $81(%rip)
+	WORD $0xff48; BYTE $0xc1       // incq         %rcx
+	WORD $0x3949; BYTE $0xcb       // cmpq         %rcx, %r11
+	LONG $0xffdc850f; WORD $0xffff // jne          LBB16_35, $-36(%rip)
+	WORD $0x894d; BYTE $0xc1       // movq         %r8, %r9
+
+LBB16_40:
+	WORD $0x2949; BYTE $0xf9 // subq         %rdi, %r9
+
+LBB16_41:
+	WORD $0x894d; BYTE $0xc8     // movq         %r9, %r8
+	LONG $0x000014e9; BYTE $0x00 // jmp          LBB16_42, $20(%rip)
+
+LBB16_19:
+	WORD $0x894c; BYTE $0x02     // movq         %r8, (%rdx)
+	LONG $0x000028e9; BYTE $0x00 // jmp          LBB16_43, $40(%rip)
+
+LBB16_30:
+	WORD $0xb70f; BYTE $0xc0 // movzwl       %ax, %eax
+	WORD $0xd0f7             // notl         %eax
+	LONG $0xc0bc0f44         // bsfl         %eax, %r8d
+	WORD $0x2949; BYTE $0xc8 // subq         %rcx, %r8
+
+LBB16_42:
+	WORD $0x894c; BYTE $0xc0       // movq         %r8, %rax
+	WORD $0x3949; BYTE $0xf0       // cmpq         %rsi, %r8
+	LONG $0x0010830f; WORD $0x0000 // jae          LBB16_43, $16(%rip)
+
+LBB16_5:
+	LONG $0x01488d48         // leaq         $1(%rax), %rcx
+	WORD $0x8948; BYTE $0x0a // movq         %rcx, (%rdx)
+	LONG $0x0704b60f         // movzbl       (%rdi,%rax), %eax
+	WORD $0xbe0f; BYTE $0xc0 // movsbl       %al, %eax
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB16_43:
+	WORD $0xc031             // xorl         %eax, %eax
+	WORD $0xbe0f; BYTE $0xc0 // movsbl       %al, %eax
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB16_37:
+	WORD $0x2949; BYTE $0xf9     // subq         %rdi, %r9
+	WORD $0x0149; BYTE $0xc9     // addq         %rcx, %r9
+	LONG $0xffffb6e9; BYTE $0xff // jmp          LBB16_41, $-74(%rip)
+	WORD $0x9090                 // .p2align 4, 0x90
+
+_vstring:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x10ec8348                           // subq         $16, %rsp
+	WORD $0x8949; BYTE $0xd6                   // movq         %rdx, %r14
+	WORD $0x8948; BYTE $0xf3                   // movq         %rsi, %rbx
+	WORD $0x8949; BYTE $0xff                   // movq         %rdi, %r15
+	QUAD $0xffffffffd845c748                   // movq         $-1, $-40(%rbp)
+	WORD $0x8b4c; BYTE $0x26                   // movq         (%rsi), %r12
+	LONG $0xd8558d48                           // leaq         $-40(%rbp), %rdx
+	WORD $0x894c; BYTE $0xe6                   // movq         %r12, %rsi
+	LONG $0x000081e8; BYTE $0x00               // callq        _advance_string, $129(%rip)
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0x0029880f; WORD $0x0000             // js           LBB17_1, $41(%rip)
+	WORD $0x8948; BYTE $0x03                   // movq         %rax, (%rbx)
+	LONG $0x1066894d                           // movq         %r12, $16(%r14)
+	LONG $0x0706c749; WORD $0x0000; BYTE $0x00 // movq         $7, (%r14)
+	LONG $0xd84d8b48                           // movq         $-40(%rbp), %rcx
+	WORD $0x3948; BYTE $0xc1                   // cmpq         %rax, %rcx
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xc14c0f48                           // cmovlq       %rcx, %rax
+	LONG $0x18468949                           // movq         %rax, $24(%r14)
+	LONG $0x00000ae9; BYTE $0x00               // jmp          LBB17_3, $10(%rip)
+
+LBB17_1:
+	LONG $0x084f8b49         // movq         $8(%r15), %rcx
+	WORD $0x8948; BYTE $0x0b // movq         %rcx, (%rbx)
+	WORD $0x8949; BYTE $0x06 // movq         %rax, (%r14)
+
+LBB17_3:
+	LONG $0x10c48348         // addq         $16, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+	QUAD $0x0000000000000000 // .p2align 4, 0x00
+
+LCPI18_0:
+	QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
+
+LCPI18_1:
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+
+LCPI18_2:
+	QUAD $0x1f1f1f1f1f1f1f1f; QUAD $0x1f1f1f1f1f1f1f1f // .space 16, '\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f\x1f'
+
+	// .p2align 4, 0x90
+_advance_string:
+	WORD $0xc1f6; BYTE $0x20       // testb        $32, %cl
+	LONG $0x0005850f; WORD $0x0000 // jne          LBB18_2, $5(%rip)
+	LONG $0x0045a2e9; BYTE $0x00   // jmp          _advance_string_default, $17826(%rip)
+
+LBB18_2:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x18ec8348                           // subq         $24, %rsp
+	LONG $0x087f8b4c                           // movq         $8(%rdi), %r15
+	WORD $0x2949; BYTE $0xf7                   // subq         %rsi, %r15
+	LONG $0x04c3840f; WORD $0x0000             // je           LBB18_47, $1219(%rip)
+	WORD $0x8b48; BYTE $0x07                   // movq         (%rdi), %rax
+	LONG $0xd0458948                           // movq         %rax, $-48(%rbp)
+	LONG $0xc0558948                           // movq         %rdx, $-64(%rbp)
+	LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq         $-1, (%rdx)
+	LONG $0x40ff8349                           // cmpq         $64, %r15
+	LONG $0x03d0820f; WORD $0x0000             // jb           LBB18_48, $976(%rip)
+	QUAD $0xffffffffc845c748                   // movq         $-1, $-56(%rbp)
+	WORD $0x3145; BYTE $0xf6                   // xorl         %r14d, %r14d
+	QUAD $0xffff74056f0f4466; BYTE $0xff       // movdqa       $-140(%rip), %xmm8  /* LCPI18_0(%rip) */
+	QUAD $0xffff7b0d6f0f4466; BYTE $0xff       // movdqa       $-133(%rip), %xmm9  /* LCPI18_1(%rip) */
+	QUAD $0xffff82156f0f4466; BYTE $0xff       // movdqa       $-126(%rip), %xmm10  /* LCPI18_2(%rip) */
+	WORD $0x9090                               // .p2align 4, 0x90
+
+LBB18_5:
+	LONG $0xd0458b48               // movq         $-48(%rbp), %rax
+	LONG $0x1c6f0ff3; BYTE $0x30   // movdqu       (%rax,%rsi), %xmm3
+	LONG $0x446f0ff3; WORD $0x1030 // movdqu       $16(%rax,%rsi), %xmm0
+	LONG $0x4c6f0ff3; WORD $0x2030 // movdqu       $32(%rax,%rsi), %xmm1
+	LONG $0x546f0ff3; WORD $0x3030 // movdqu       $48(%rax,%rsi), %xmm2
+	LONG $0xfb6f0f66               // movdqa       %xmm3, %xmm7
+	LONG $0x740f4166; BYTE $0xf8   // pcmpeqb      %xmm8, %xmm7
+	LONG $0xd70f4466; BYTE $0xe7   // pmovmskb     %xmm7, %r12d
+	LONG $0xf86f0f66               // movdqa       %xmm0, %xmm7
+	LONG $0xf06f0f66               // movdqa       %xmm0, %xmm6
+	LONG $0xda0f4166; BYTE $0xf2   // pminub       %xmm10, %xmm6
+	LONG $0xf0740f66               // pcmpeqb      %xmm0, %xmm6
+	LONG $0x740f4166; BYTE $0xc0   // pcmpeqb      %xmm8, %xmm0
+	LONG $0xd70f4466; BYTE $0xc0   // pmovmskb     %xmm0, %r8d
+	LONG $0xc16f0f66               // movdqa       %xmm1, %xmm0
+	LONG $0xe96f0f66               // movdqa       %xmm1, %xmm5
+	LONG $0xda0f4166; BYTE $0xea   // pminub       %xmm10, %xmm5
+	LONG $0xe9740f66               // pcmpeqb      %xmm1, %xmm5
+	LONG $0x740f4166; BYTE $0xc8   // pcmpeqb      %xmm8, %xmm1
+	LONG $0xd70f4466; BYTE $0xc9   // pmovmskb     %xmm1, %r9d
+	LONG $0xca6f0f66               // movdqa       %xmm2, %xmm1
+	LONG $0xe26f0f66               // movdqa       %xmm2, %xmm4
+	LONG $0xda0f4166; BYTE $0xe2   // pminub       %xmm10, %xmm4
+	LONG $0xe2740f66               // pcmpeqb      %xmm2, %xmm4
+	LONG $0x740f4166; BYTE $0xd0   // pcmpeqb      %xmm8, %xmm2
+	LONG $0xd70f4466; BYTE $0xd2   // pmovmskb     %xmm2, %r10d
+	LONG $0xd36f0f66               // movdqa       %xmm3, %xmm2
+	LONG $0x740f4166; BYTE $0xd1   // pcmpeqb      %xmm9, %xmm2
+	LONG $0xd70f4466; BYTE $0xea   // pmovmskb     %xmm2, %r13d
+	LONG $0x740f4166; BYTE $0xf9   // pcmpeqb      %xmm9, %xmm7
+	LONG $0xcfd70f66               // pmovmskb     %xmm7, %ecx
+	LONG $0x740f4166; BYTE $0xc1   // pcmpeqb      %xmm9, %xmm0
+	LONG $0xd70f4466; BYTE $0xd8   // pmovmskb     %xmm0, %r11d
+	LONG $0x740f4166; BYTE $0xc9   // pcmpeqb      %xmm9, %xmm1
+	LONG $0xd1d70f66               // pmovmskb     %xmm1, %edx
+	LONG $0xded70f66               // pmovmskb     %xmm6, %ebx
+	LONG $0xc5d70f66               // pmovmskb     %xmm5, %eax
+	LONG $0xfcd70f66               // pmovmskb     %xmm4, %edi
+	LONG $0x30e2c149               // shlq         $48, %r10
+	LONG $0x20e1c149               // shlq         $32, %r9
+	WORD $0x094d; BYTE $0xd1       // orq          %r10, %r9
+	LONG $0x10e0c149               // shlq         $16, %r8
+	WORD $0x094d; BYTE $0xc8       // orq          %r9, %r8
+	WORD $0x094d; BYTE $0xc4       // orq          %r8, %r12
+	LONG $0x30e2c148               // shlq         $48, %rdx
+	LONG $0x20e3c149               // shlq         $32, %r11
+	WORD $0x0949; BYTE $0xd3       // orq          %rdx, %r11
+	LONG $0x10e1c148               // shlq         $16, %rcx
+	WORD $0x094c; BYTE $0xd9       // orq          %r11, %rcx
+	LONG $0x30e7c148               // shlq         $48, %rdi
+	LONG $0x20e0c148               // shlq         $32, %rax
+	WORD $0x0948; BYTE $0xf8       // orq          %rdi, %rax
+	LONG $0x10e3c148               // shlq         $16, %rbx
+	WORD $0x0948; BYTE $0xc3       // orq          %rax, %rbx
+	WORD $0x0949; BYTE $0xcd       // orq          %rcx, %r13
+	LONG $0x0049850f; WORD $0x0000 // jne          LBB18_11, $73(%rip)
+	WORD $0x854d; BYTE $0xf6       // testq        %r14, %r14
+	LONG $0x005d850f; WORD $0x0000 // jne          LBB18_13, $93(%rip)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+
+LBB18_8:
+	LONG $0xc36f0f66               // movdqa       %xmm3, %xmm0
+	LONG $0xda0f4166; BYTE $0xc2   // pminub       %xmm10, %xmm0
+	LONG $0xc3740f66               // pcmpeqb      %xmm3, %xmm0
+	LONG $0xc0d70f66               // pmovmskb     %xmm0, %eax
+	WORD $0x0948; BYTE $0xc3       // orq          %rax, %rbx
+	WORD $0x854d; BYTE $0xe4       // testq        %r12, %r12
+	LONG $0x008b850f; WORD $0x0000 // jne          LBB18_14, $139(%rip)
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x00d5850f; WORD $0x0000 // jne          LBB18_20, $213(%rip)
+	LONG $0xc0c78349               // addq         $-64, %r15
+	LONG $0x40c68348               // addq         $64, %rsi
+	LONG $0x3fff8349               // cmpq         $63, %r15
+	LONG $0xfeca870f; WORD $0xffff // ja           LBB18_5, $-310(%rip)
+	LONG $0x0000e3e9; BYTE $0x00   // jmp          LBB18_22, $227(%rip)
+
+LBB18_11:
+	LONG $0xc87d8348; BYTE $0xff   // cmpq         $-1, $-56(%rbp)
+	LONG $0x0012850f; WORD $0x0000 // jne          LBB18_13, $18(%rip)
+	LONG $0xcdbc0f49               // bsfq         %r13, %rcx
+	WORD $0x0148; BYTE $0xf1       // addq         %rsi, %rcx
+	LONG $0xc0458b48               // movq         $-64(%rbp), %rax
+	LONG $0xc84d8948               // movq         %rcx, $-56(%rbp)
+	WORD $0x8948; BYTE $0x08       // movq         %rcx, (%rax)
+
+LBB18_13:
+	WORD $0x894c; BYTE $0xf0               // movq         %r14, %rax
+	WORD $0xf748; BYTE $0xd0               // notq         %rax
+	WORD $0x214c; BYTE $0xe8               // andq         %r13, %rax
+	LONG $0x000c8d48                       // leaq         (%rax,%rax), %rcx
+	WORD $0x094c; BYTE $0xf1               // orq          %r14, %rcx
+	WORD $0x8948; BYTE $0xca               // movq         %rcx, %rdx
+	WORD $0xf748; BYTE $0xd2               // notq         %rdx
+	WORD $0x214c; BYTE $0xea               // andq         %r13, %rdx
+	QUAD $0xaaaaaaaaaaaabf48; WORD $0xaaaa // movabsq      $-6148914691236517206, %rdi
+	WORD $0x2148; BYTE $0xfa               // andq         %rdi, %rdx
+	WORD $0x3145; BYTE $0xf6               // xorl         %r14d, %r14d
+	WORD $0x0148; BYTE $0xc2               // addq         %rax, %rdx
+	LONG $0xc6920f41                       // setb         %r14b
+	WORD $0x0148; BYTE $0xd2               // addq         %rdx, %rdx
+	QUAD $0x555555555555b848; WORD $0x5555 // movabsq      $6148914691236517205, %rax
+	WORD $0x3148; BYTE $0xc2               // xorq         %rax, %rdx
+	WORD $0x2148; BYTE $0xca               // andq         %rcx, %rdx
+	WORD $0xf748; BYTE $0xd2               // notq         %rdx
+	WORD $0x2149; BYTE $0xd4               // andq         %rdx, %r12
+	LONG $0xffff58e9; BYTE $0xff           // jmp          LBB18_8, $-168(%rip)
+
+LBB18_14:
+	LONG $0xc4bc0f49               // bsfq         %r12, %rax
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0022840f; WORD $0x0000 // je           LBB18_18, $34(%rip)
+	LONG $0xcbbc0f48               // bsfq         %rbx, %rcx
+	WORD $0x3948; BYTE $0xc1       // cmpq         %rax, %rcx
+	LONG $0x0023820f; WORD $0x0000 // jb           LBB18_19, $35(%rip)
+
+LBB18_16:
+	WORD $0x0148; BYTE $0xf0 // addq         %rsi, %rax
+	WORD $0xff48; BYTE $0xc0 // incq         %rax
+
+LBB18_17:
+	LONG $0x18c48348 // addq         $24, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5d41     // popq         %r13
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB18_18:
+	LONG $0x000040b9; BYTE $0x00   // movl         $64, %ecx
+	WORD $0x3948; BYTE $0xc1       // cmpq         %rax, %rcx
+	LONG $0xffdd830f; WORD $0xffff // jae          LBB18_16, $-35(%rip)
+
+LBB18_19:
+	WORD $0x0148; BYTE $0xf1                   // addq         %rsi, %rcx
+	LONG $0xc0458b48                           // movq         $-64(%rbp), %rax
+	WORD $0x8948; BYTE $0x08                   // movq         %rcx, (%rax)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	LONG $0xffffcde9; BYTE $0xff               // jmp          LBB18_17, $-51(%rip)
+
+LBB18_20:
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	LONG $0xc87d8348; BYTE $0xff               // cmpq         $-1, $-56(%rbp)
+	LONG $0xffbb850f; WORD $0xffff             // jne          LBB18_17, $-69(%rip)
+	LONG $0xcbbc0f48                           // bsfq         %rbx, %rcx
+	WORD $0x0148; BYTE $0xf1                   // addq         %rsi, %rcx
+	LONG $0xc0558b48                           // movq         $-64(%rbp), %rdx
+	WORD $0x8948; BYTE $0x0a                   // movq         %rcx, (%rdx)
+	LONG $0xffffa8e9; BYTE $0xff               // jmp          LBB18_17, $-88(%rip)
+
+LBB18_22:
+	LONG $0xd0750348               // addq         $-48(%rbp), %rsi
+	LONG $0x20ff8349               // cmpq         $32, %r15
+	LONG $0x00e1820f; WORD $0x0000 // jb           LBB18_35, $225(%rip)
+
+LBB18_23:
+	LONG $0x066f0ff3               // movdqu       (%rsi), %xmm0
+	QUAD $0xfffffd280d6f0f66       // movdqa       $-728(%rip), %xmm1  /* LCPI18_0(%rip) */
+	LONG $0xd06f0f66               // movdqa       %xmm0, %xmm2
+	QUAD $0xfffffd3c1d6f0f66       // movdqa       $-708(%rip), %xmm3  /* LCPI18_2(%rip) */
+	LONG $0xe06f0f66               // movdqa       %xmm0, %xmm4
+	LONG $0xe3da0f66               // pminub       %xmm3, %xmm4
+	LONG $0xe0740f66               // pcmpeqb      %xmm0, %xmm4
+	LONG $0xc1740f66               // pcmpeqb      %xmm1, %xmm0
+	LONG $0xc0d70f66               // pmovmskb     %xmm0, %eax
+	LONG $0x466f0ff3; BYTE $0x10   // movdqu       $16(%rsi), %xmm0
+	LONG $0xc8740f66               // pcmpeqb      %xmm0, %xmm1
+	LONG $0xc9d70f66               // pmovmskb     %xmm1, %ecx
+	QUAD $0xfffffd030d6f0f66       // movdqa       $-765(%rip), %xmm1  /* LCPI18_1(%rip) */
+	LONG $0xd1740f66               // pcmpeqb      %xmm1, %xmm2
+	LONG $0xd70f4466; BYTE $0xd2   // pmovmskb     %xmm2, %r10d
+	LONG $0xc8740f66               // pcmpeqb      %xmm0, %xmm1
+	LONG $0xd1d70f66               // pmovmskb     %xmm1, %edx
+	LONG $0xd70f4466; BYTE $0xcc   // pmovmskb     %xmm4, %r9d
+	LONG $0xd8da0f66               // pminub       %xmm0, %xmm3
+	LONG $0xd8740f66               // pcmpeqb      %xmm0, %xmm3
+	LONG $0xdbd70f66               // pmovmskb     %xmm3, %ebx
+	LONG $0x10e1c148               // shlq         $16, %rcx
+	WORD $0x0948; BYTE $0xc8       // orq          %rcx, %rax
+	LONG $0x10e2c148               // shlq         $16, %rdx
+	LONG $0x10e3c148               // shlq         $16, %rbx
+	WORD $0x0949; BYTE $0xd2       // orq          %rdx, %r10
+	LONG $0x011f850f; WORD $0x0000 // jne          LBB18_49, $287(%rip)
+	WORD $0x854d; BYTE $0xf6       // testq        %r14, %r14
+	LONG $0x013a850f; WORD $0x0000 // jne          LBB18_51, $314(%rip)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+
+LBB18_26:
+	WORD $0x094c; BYTE $0xcb       // orq          %r9, %rbx
+	LONG $0x000040b9; BYTE $0x00   // movl         $64, %ecx
+	LONG $0x000040ba; BYTE $0x00   // movl         $64, %edx
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0004840f; WORD $0x0000 // je           LBB18_28, $4(%rip)
+	LONG $0xd0bc0f48               // bsfq         %rax, %rdx
+
+LBB18_28:
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0004840f; WORD $0x0000 // je           LBB18_30, $4(%rip)
+	LONG $0xcbbc0f48               // bsfq         %rbx, %rcx
+
+LBB18_30:
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0019840f; WORD $0x0000 // je           LBB18_33, $25(%rip)
+	WORD $0x3948; BYTE $0xd1       // cmpq         %rdx, %rcx
+	LONG $0x0135820f; WORD $0x0000 // jb           LBB18_52, $309(%rip)
+	LONG $0xd0752b48               // subq         $-48(%rbp), %rsi
+	LONG $0x16048d48               // leaq         (%rsi,%rdx), %rax
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	LONG $0xfffecae9; BYTE $0xff   // jmp          LBB18_17, $-310(%rip)
+
+LBB18_33:
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x011c850f; WORD $0x0000 // jne          LBB18_52, $284(%rip)
+	LONG $0x20c68348               // addq         $32, %rsi
+	LONG $0xe0c78349               // addq         $-32, %r15
+
+LBB18_35:
+	WORD $0x854d; BYTE $0xf6                   // testq        %r14, %r14
+	LONG $0x0125850f; WORD $0x0000             // jne          LBB18_54, $293(%rip)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x854d; BYTE $0xff                   // testq        %r15, %r15
+	LONG $0xfea0840f; WORD $0xffff             // je           LBB18_17, $-352(%rip)
+
+LBB18_37:
+	LONG $0xc0558b48 // movq         $-64(%rbp), %rdx
+
+LBB18_38:
+	WORD $0xb60f; BYTE $0x0e                   // movzbl       (%rsi), %ecx
+	WORD $0xf983; BYTE $0x22                   // cmpl         $34, %ecx
+	LONG $0x0063840f; WORD $0x0000             // je           LBB18_46, $99(%rip)
+	WORD $0xf983; BYTE $0x5c                   // cmpl         $92, %ecx
+	LONG $0x0026840f; WORD $0x0000             // je           LBB18_43, $38(%rip)
+	WORD $0xf980; BYTE $0x1f                   // cmpb         $31, %cl
+	LONG $0x0143860f; WORD $0x0000             // jbe          LBB18_58, $323(%rip)
+	LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rcx
+	LONG $0x000001bf; BYTE $0x00               // movl         $1, %edi
+
+LBB18_42:
+	WORD $0x0148; BYTE $0xfe       // addq         %rdi, %rsi
+	WORD $0x0149; BYTE $0xcf       // addq         %rcx, %r15
+	LONG $0xffca850f; WORD $0xffff // jne          LBB18_38, $-54(%rip)
+	LONG $0xfffe61e9; BYTE $0xff   // jmp          LBB18_17, $-415(%rip)
+
+LBB18_43:
+	LONG $0x01ff8349                           // cmpq         $1, %r15
+	LONG $0xfe57840f; WORD $0xffff             // je           LBB18_17, $-425(%rip)
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0x000002bf; BYTE $0x00               // movl         $2, %edi
+	LONG $0xc87d8348; BYTE $0xff               // cmpq         $-1, $-56(%rbp)
+	LONG $0xffce850f; WORD $0xffff             // jne          LBB18_42, $-50(%rip)
+	WORD $0x8948; BYTE $0xf3                   // movq         %rsi, %rbx
+	LONG $0xd05d2b48                           // subq         $-48(%rbp), %rbx
+	LONG $0xc85d8948                           // movq         %rbx, $-56(%rbp)
+	WORD $0x8948; BYTE $0x1a                   // movq         %rbx, (%rdx)
+	LONG $0xffffbbe9; BYTE $0xff               // jmp          LBB18_42, $-69(%rip)
+
+LBB18_46:
+	LONG $0xd0752b48             // subq         $-48(%rbp), %rsi
+	WORD $0xff48; BYTE $0xc6     // incq         %rsi
+	WORD $0x8948; BYTE $0xf0     // movq         %rsi, %rax
+	LONG $0xfffe1ee9; BYTE $0xff // jmp          LBB18_17, $-482(%rip)
+
+LBB18_48:
+	LONG $0xd0750348               // addq         $-48(%rbp), %rsi
+	QUAD $0xffffffffc845c748       // movq         $-1, $-56(%rbp)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	LONG $0x20ff8349               // cmpq         $32, %r15
+	LONG $0xfe6b830f; WORD $0xffff // jae          LBB18_23, $-405(%rip)
+	LONG $0xffff47e9; BYTE $0xff   // jmp          LBB18_35, $-185(%rip)
+
+LBB18_49:
+	LONG $0xc87d8348; BYTE $0xff   // cmpq         $-1, $-56(%rbp)
+	LONG $0x0019850f; WORD $0x0000 // jne          LBB18_51, $25(%rip)
+	WORD $0x8948; BYTE $0xf1       // movq         %rsi, %rcx
+	LONG $0xd04d2b48               // subq         $-48(%rbp), %rcx
+	LONG $0xd2bc0f49               // bsfq         %r10, %rdx
+	WORD $0x0148; BYTE $0xca       // addq         %rcx, %rdx
+	LONG $0xc04d8b48               // movq         $-64(%rbp), %rcx
+	LONG $0xc8558948               // movq         %rdx, $-56(%rbp)
+	WORD $0x8948; BYTE $0x11       // movq         %rdx, (%rcx)
+
+LBB18_51:
+	WORD $0x8944; BYTE $0xf1       // movl         %r14d, %ecx
+	WORD $0xd1f7                   // notl         %ecx
+	WORD $0x2144; BYTE $0xd1       // andl         %r10d, %ecx
+	WORD $0x148d; BYTE $0x09       // leal         (%rcx,%rcx), %edx
+	LONG $0x4e048d45               // leal         (%r14,%rcx,2), %r8d
+	WORD $0xd2f7                   // notl         %edx
+	WORD $0x2144; BYTE $0xd2       // andl         %r10d, %edx
+	LONG $0xaaaae281; WORD $0xaaaa // andl         $-1431655766, %edx
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	WORD $0xca01                   // addl         %ecx, %edx
+	LONG $0xc6920f41               // setb         %r14b
+	WORD $0xd201                   // addl         %edx, %edx
+	LONG $0x5555f281; WORD $0x5555 // xorl         $1431655765, %edx
+	WORD $0x2144; BYTE $0xc2       // andl         %r8d, %edx
+	WORD $0xd2f7                   // notl         %edx
+	WORD $0xd021                   // andl         %edx, %eax
+	LONG $0xfffe92e9; BYTE $0xff   // jmp          LBB18_26, $-366(%rip)
+
+LBB18_52:
+	LONG $0xd0752b48         // subq         $-48(%rbp), %rsi
+	WORD $0x0148; BYTE $0xce // addq         %rcx, %rsi
+
+LBB18_53:
+	LONG $0xc0458b48                           // movq         $-64(%rbp), %rax
+	WORD $0x8948; BYTE $0x30                   // movq         %rsi, (%rax)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	LONG $0xfffd8be9; BYTE $0xff               // jmp          LBB18_17, $-629(%rip)
+
+LBB18_54:
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x003b840f; WORD $0x0000 // je           LBB18_47, $59(%rip)
+	LONG $0xc87d8348; BYTE $0xff   // cmpq         $-1, $-56(%rbp)
+	LONG $0x0015850f; WORD $0x0000 // jne          LBB18_57, $21(%rip)
+	LONG $0xd04d8b48               // movq         $-48(%rbp), %rcx
+	WORD $0xf748; BYTE $0xd1       // notq         %rcx
+	WORD $0x0148; BYTE $0xf1       // addq         %rsi, %rcx
+	LONG $0xc0458b48               // movq         $-64(%rbp), %rax
+	LONG $0xc84d8948               // movq         %rcx, $-56(%rbp)
+	WORD $0x8948; BYTE $0x08       // movq         %rcx, (%rax)
+
+LBB18_57:
+	WORD $0xff48; BYTE $0xc6                   // incq         %rsi
+	WORD $0xff49; BYTE $0xcf                   // decq         %r15
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x854d; BYTE $0xff                   // testq        %r15, %r15
+	LONG $0xfeac850f; WORD $0xffff             // jne          LBB18_37, $-340(%rip)
+	LONG $0xfffd47e9; BYTE $0xff               // jmp          LBB18_17, $-697(%rip)
+
+LBB18_47:
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xfffd3be9; BYTE $0xff               // jmp          LBB18_17, $-709(%rip)
+
+LBB18_58:
+	LONG $0xd0752b48                           // subq         $-48(%rbp), %rsi
+	LONG $0xffff94e9; BYTE $0xff               // jmp          LBB18_53, $-108(%rip)
+	QUAD $0x0000000000000000; LONG $0x00000000 // .p2align 4, 0x00
+
+LCPI19_0:
+	LONG $0x43300000 // .long 1127219200
+	LONG $0x45300000 // .long 1160773632
+	LONG $0x00000000 // .long 0
+	LONG $0x00000000 // .long 0
+
+LCPI19_1:
+	QUAD $0x4330000000000000 // .quad 0x4330000000000000
+	QUAD $0x4530000000000000 // .quad 0x4530000000000000
+
+	// .p2align 3, 0x00
+LCPI19_2:
+	QUAD $0x430c6bf526340000 // .quad 0x430c6bf526340000
+
+LCPI19_3:
+	QUAD $0xc30c6bf526340000 // .quad 0xc30c6bf526340000
+
+	// .p2align 4, 0x90
+_vnumber:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x38ec8348                           // subq         $56, %rsp
+	WORD $0x8948; BYTE $0xd3                   // movq         %rdx, %rbx
+	WORD $0x8949; BYTE $0xf6                   // movq         %rsi, %r14
+	WORD $0x8b48; BYTE $0x06                   // movq         (%rsi), %rax
+	WORD $0x8b4c; BYTE $0x3f                   // movq         (%rdi), %r15
+	LONG $0x086f8b4c                           // movq         $8(%rdi), %r13
+	LONG $0x20528b4c                           // movq         $32(%rdx), %r10
+	LONG $0x285a8b4c                           // movq         $40(%rdx), %r11
+	LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq         $9, (%rdx)
+	LONG $0xc0570f66                           // xorpd        %xmm0, %xmm0
+	LONG $0x42110f66; BYTE $0x08               // movupd       %xmm0, $8(%rdx)
+	WORD $0x8b48; BYTE $0x0e                   // movq         (%rsi), %rcx
+	LONG $0x184a8948                           // movq         %rcx, $24(%rdx)
+	WORD $0x394c; BYTE $0xe8                   // cmpq         %r13, %rax
+	LONG $0x02c9830f; WORD $0x0000             // jae          LBB19_51, $713(%rip)
+	LONG $0x0cb60f41; BYTE $0x07               // movzbl       (%r15,%rax), %ecx
+	LONG $0x000001bf; BYTE $0x00               // movl         $1, %edi
+	WORD $0xf980; BYTE $0x2d                   // cmpb         $45, %cl
+	LONG $0x0016850f; WORD $0x0000             // jne          LBB19_4, $22(%rip)
+	WORD $0xff48; BYTE $0xc0                   // incq         %rax
+	WORD $0x394c; BYTE $0xe8                   // cmpq         %r13, %rax
+	LONG $0x02aa830f; WORD $0x0000             // jae          LBB19_51, $682(%rip)
+	LONG $0x0cb60f41; BYTE $0x07               // movzbl       (%r15,%rax), %ecx
+	LONG $0xffffffbf; BYTE $0xff               // movl         $-1, %edi
+
+LBB19_4:
+	WORD $0x518d; BYTE $0xc6       // leal         $-58(%rcx), %edx
+	WORD $0xfa80; BYTE $0xf5       // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000 // ja           LBB19_6, $15(%rip)
+
+LBB19_5:
+	WORD $0x8949; BYTE $0x06                   // movq         %rax, (%r14)
+	LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq         $-2, (%rbx)
+	LONG $0x00028fe9; BYTE $0x00               // jmp          LBB19_52, $655(%rip)
+
+LBB19_6:
+	WORD $0xf980; BYTE $0x30               // cmpb         $48, %cl
+	LONG $0x0032850f; WORD $0x0000         // jne          LBB19_10, $50(%rip)
+	LONG $0x01488d48                       // leaq         $1(%rax), %rcx
+	WORD $0x394c; BYTE $0xe8               // cmpq         %r13, %rax
+	LONG $0x00a6830f; WORD $0x0000         // jae          LBB19_18, $166(%rip)
+	LONG $0x14b60f41; BYTE $0x0f           // movzbl       (%r15,%rcx), %edx
+	WORD $0xc283; BYTE $0xd2               // addl         $-46, %edx
+	WORD $0xfa83; BYTE $0x37               // cmpl         $55, %edx
+	LONG $0x0095870f; WORD $0x0000         // ja           LBB19_18, $149(%rip)
+	QUAD $0x000000800001be48; WORD $0x0080 // movabsq      $36028797027352577, %rsi
+	LONG $0xd6a30f48                       // btq          %rdx, %rsi
+	LONG $0x0081830f; WORD $0x0000         // jae          LBB19_18, $129(%rip)
+
+LBB19_10:
+	WORD $0x7d89; BYTE $0xd4       // movl         %edi, $-44(%rbp)
+	WORD $0x01b1                   // movb         $1, %cl
+	WORD $0x4d89; BYTE $0xc8       // movl         %ecx, $-56(%rbp)
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	LONG $0x0063830f; WORD $0x0000 // jae          LBB19_17, $99(%rip)
+	WORD $0x3145; BYTE $0xe4       // xorl         %r12d, %r12d
+	LONG $0xffd0b941; WORD $0xffff // movl         $4294967248, %r9d
+	WORD $0x3145; BYTE $0xc0       // xorl         %r8d, %r8d
+	WORD $0xc931                   // xorl         %ecx, %ecx
+	LONG $0x000012e9; BYTE $0x00   // jmp          LBB19_13, $18(%rip)
+	LONG $0x90909090               // .p2align 4, 0x90
+
+LBB19_12:
+	WORD $0xc1ff                   // incl         %ecx
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3949; BYTE $0xc5       // cmpq         %rax, %r13
+	LONG $0x0036840f; WORD $0x0000 // je           LBB19_16, $54(%rip)
+
+LBB19_13:
+	LONG $0x14be0f49; BYTE $0x07   // movsbq       (%r15,%rax), %rdx
+	WORD $0x7a8d; BYTE $0xd0       // leal         $-48(%rdx), %edi
+	LONG $0x09ff8040               // cmpb         $9, %dil
+	LONG $0x0041870f; WORD $0x0000 // ja           LBB19_19, $65(%rip)
+	LONG $0x12f88341               // cmpl         $18, %r8d
+	LONG $0xffd68f0f; WORD $0xffff // jg           LBB19_12, $-42(%rip)
+	LONG $0xa43c8d4b               // leaq         (%r12,%r12,4), %rdi
+	WORD $0x0144; BYTE $0xca       // addl         %r9d, %edx
+	LONG $0x7a248d4c               // leaq         (%rdx,%rdi,2), %r12
+	WORD $0xff41; BYTE $0xc0       // incl         %r8d
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3949; BYTE $0xc5       // cmpq         %rax, %r13
+	LONG $0xffca850f; WORD $0xffff // jne          LBB19_13, $-54(%rip)
+
+LBB19_16:
+	WORD $0x894c; BYTE $0xe8     // movq         %r13, %rax
+	LONG $0x00005be9; BYTE $0x00 // jmp          LBB19_24, $91(%rip)
+
+LBB19_17:
+	WORD $0xc931                 // xorl         %ecx, %ecx
+	WORD $0x3145; BYTE $0xc0     // xorl         %r8d, %r8d
+	WORD $0x3145; BYTE $0xe4     // xorl         %r12d, %r12d
+	LONG $0x00004ee9; BYTE $0x00 // jmp          LBB19_24, $78(%rip)
+
+LBB19_18:
+	WORD $0x8949; BYTE $0x0e     // movq         %rcx, (%r14)
+	LONG $0x0001cbe9; BYTE $0x00 // jmp          LBB19_52, $459(%rip)
+
+LBB19_19:
+	WORD $0xfa80; BYTE $0x2e                   // cmpb         $46, %dl
+	LONG $0x003d850f; WORD $0x0000             // jne          LBB19_24, $61(%rip)
+	LONG $0x01508d48                           // leaq         $1(%rax), %rdx
+	LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq         $8, (%rbx)
+	WORD $0x394c; BYTE $0xea                   // cmpq         %r13, %rdx
+	LONG $0x01a4830f; WORD $0x0000             // jae          LBB19_51, $420(%rip)
+	LONG $0x44b60f41; WORD $0x0107             // movzbl       $1(%r15,%rax), %eax
+	WORD $0xc604                               // addb         $-58, %al
+	WORD $0xf53c                               // cmpb         $-11, %al
+	LONG $0x000f870f; WORD $0x0000             // ja           LBB19_23, $15(%rip)
+	WORD $0x8949; BYTE $0x16                   // movq         %rdx, (%r14)
+	LONG $0xfe03c748; WORD $0xffff; BYTE $0xff // movq         $-2, (%rbx)
+	LONG $0x00018fe9; BYTE $0x00               // jmp          LBB19_52, $399(%rip)
+
+LBB19_23:
+	LONG $0x00c845c7; WORD $0x0000; BYTE $0x00 // movl         $0, $-56(%rbp)
+	WORD $0x8948; BYTE $0xd0                   // movq         %rdx, %rax
+
+LBB19_24:
+	WORD $0xd231                                       // xorl         %edx, %edx
+	WORD $0xc985                                       // testl        %ecx, %ecx
+	WORD $0x9f0f; BYTE $0xc2                           // setg         %dl
+	WORD $0x5589; BYTE $0xbc                           // movl         %edx, $-68(%rbp)
+	WORD $0x854d; BYTE $0xe4                           // testq        %r12, %r12
+	LONG $0x005d850f; WORD $0x0000                     // jne          LBB19_33, $93(%rip)
+	WORD $0xc985                                       // testl        %ecx, %ecx
+	LONG $0x0055850f; WORD $0x0000                     // jne          LBB19_33, $85(%rip)
+	WORD $0x394c; BYTE $0xe8                           // cmpq         %r13, %rax
+	LONG $0x0044830f; WORD $0x0000                     // jae          LBB19_31, $68(%rip)
+	WORD $0xc689                                       // movl         %eax, %esi
+	WORD $0x2944; BYTE $0xee                           // subl         %r13d, %esi
+	WORD $0x3145; BYTE $0xc0                           // xorl         %r8d, %r8d
+	WORD $0xc931                                       // xorl         %ecx, %ecx
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB19_28:
+	LONG $0x073c8041; BYTE $0x30   // cmpb         $48, (%r15,%rax)
+	LONG $0x0029850f; WORD $0x0000 // jne          LBB19_32, $41(%rip)
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0xc9ff                   // decl         %ecx
+	WORD $0x3949; BYTE $0xc5       // cmpq         %rax, %r13
+	LONG $0xffe7850f; WORD $0xffff // jne          LBB19_28, $-25(%rip)
+	WORD $0x3145; BYTE $0xe4       // xorl         %r12d, %r12d
+	WORD $0x458b; BYTE $0xc8       // movl         $-56(%rbp), %eax
+	WORD $0xc084                   // testb        %al, %al
+	LONG $0x0144850f; WORD $0x0000 // jne          LBB19_54, $324(%rip)
+
+LBB19_59:
+	WORD $0x558b; BYTE $0xd4     // movl         $-44(%rbp), %edx
+	LONG $0x000173e9; BYTE $0x00 // jmp          LBB19_60, $371(%rip)
+
+LBB19_31:
+	WORD $0xc931             // xorl         %ecx, %ecx
+	WORD $0x3145; BYTE $0xc0 // xorl         %r8d, %r8d
+
+LBB19_32:
+	WORD $0x3145; BYTE $0xe4 // xorl         %r12d, %r12d
+
+LBB19_33:
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	LONG $0x004c830f; WORD $0x0000 // jae          LBB19_39, $76(%rip)
+	LONG $0x12f88341               // cmpl         $18, %r8d
+	LONG $0x00428f0f; WORD $0x0000 // jg           LBB19_39, $66(%rip)
+	LONG $0xffd0b941; WORD $0xffff // movl         $4294967248, %r9d
+
+	// .p2align 4, 0x90
+LBB19_36:
+	LONG $0x14b60f41; BYTE $0x07   // movzbl       (%r15,%rax), %edx
+	WORD $0x7a8d; BYTE $0xd0       // leal         $-48(%rdx), %edi
+	LONG $0x09ff8040               // cmpb         $9, %dil
+	LONG $0x002a870f; WORD $0x0000 // ja           LBB19_39, $42(%rip)
+	LONG $0xa43c8d4b               // leaq         (%r12,%r12,4), %rdi
+	WORD $0x0144; BYTE $0xca       // addl         %r9d, %edx
+	LONG $0x7a248d4c               // leaq         (%rdx,%rdi,2), %r12
+	WORD $0xc9ff                   // decl         %ecx
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	LONG $0x0011830f; WORD $0x0000 // jae          LBB19_39, $17(%rip)
+	LONG $0x01508d41               // leal         $1(%r8), %edx
+	LONG $0x12f88341               // cmpl         $18, %r8d
+	WORD $0x8941; BYTE $0xd0       // movl         %edx, %r8d
+	LONG $0xffc48c0f; WORD $0xffff // jl           LBB19_36, $-60(%rip)
+
+LBB19_39:
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	LONG $0x00c6830f; WORD $0x0000 // jae          LBB19_53, $198(%rip)
+	LONG $0x34b60f41; BYTE $0x07   // movzbl       (%r15,%rax), %esi
+	WORD $0x568d; BYTE $0xd0       // leal         $-48(%rsi), %edx
+	WORD $0xfa80; BYTE $0x09       // cmpb         $9, %dl
+	LONG $0x0030870f; WORD $0x0000 // ja           LBB19_45, $48(%rip)
+	LONG $0xff558d49               // leaq         $-1(%r13), %rdx
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB19_42:
+	WORD $0x3948; BYTE $0xc2                   // cmpq         %rax, %rdx
+	LONG $0x0182840f; WORD $0x0000             // je           LBB19_58, $386(%rip)
+	LONG $0x74b60f41; WORD $0x0107             // movzbl       $1(%r15,%rax), %esi
+	WORD $0x7e8d; BYTE $0xd0                   // leal         $-48(%rsi), %edi
+	WORD $0xff48; BYTE $0xc0                   // incq         %rax
+	LONG $0x09ff8040                           // cmpb         $9, %dil
+	LONG $0xffe1860f; WORD $0xffff             // jbe          LBB19_42, $-31(%rip)
+	LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl         $1, $-68(%rbp)
+
+LBB19_45:
+	LONG $0xd6b60f40                           // movzbl       %sil, %edx
+	WORD $0xca83; BYTE $0x20                   // orl          $32, %edx
+	WORD $0xfa83; BYTE $0x65                   // cmpl         $101, %edx
+	LONG $0x0075850f; WORD $0x0000             // jne          LBB19_53, $117(%rip)
+	LONG $0x01788d48                           // leaq         $1(%rax), %rdi
+	LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq         $8, (%rbx)
+	WORD $0x394c; BYTE $0xef                   // cmpq         %r13, %rdi
+	LONG $0x0048830f; WORD $0x0000             // jae          LBB19_51, $72(%rip)
+	LONG $0x34b60f41; BYTE $0x3f               // movzbl       (%r15,%rdi), %esi
+	WORD $0xfe83; BYTE $0x2d                   // cmpl         $45, %esi
+	LONG $0x000f840f; WORD $0x0000             // je           LBB19_49, $15(%rip)
+	LONG $0x0001b841; WORD $0x0000             // movl         $1, %r8d
+	WORD $0xfe83; BYTE $0x2b                   // cmpl         $43, %esi
+	LONG $0x02ac850f; WORD $0x0000             // jne          LBB19_86, $684(%rip)
+
+LBB19_49:
+	LONG $0x02c08348               // addq         $2, %rax
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	WORD $0x558b; BYTE $0xd4       // movl         $-44(%rbp), %edx
+	LONG $0x001b830f; WORD $0x0000 // jae          LBB19_51, $27(%rip)
+	WORD $0xff31                   // xorl         %edi, %edi
+	LONG $0x2bfe8040               // cmpb         $43, %sil
+	LONG $0xc7940f40               // sete         %dil
+	LONG $0x3f048d44               // leal         (%rdi,%rdi), %r8d
+	WORD $0xff41; BYTE $0xc8       // decl         %r8d
+	LONG $0x34b60f41; BYTE $0x07   // movzbl       (%r15,%rax), %esi
+	LONG $0x000287e9; BYTE $0x00   // jmp          LBB19_87, $647(%rip)
+
+LBB19_51:
+	WORD $0x894d; BYTE $0x2e                   // movq         %r13, (%r14)
+	LONG $0xff03c748; WORD $0xffff; BYTE $0xff // movq         $-1, (%rbx)
+
+LBB19_52:
+	LONG $0x38c48348 // addq         $56, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5d41     // popq         %r13
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB19_53:
+	WORD $0xce89                   // movl         %ecx, %esi
+	WORD $0x8949; BYTE $0xc5       // movq         %rax, %r13
+	WORD $0x458b; BYTE $0xc8       // movl         $-56(%rbp), %eax
+	WORD $0xc084                   // testb        %al, %al
+	LONG $0xfebc840f; WORD $0xffff // je           LBB19_59, $-324(%rip)
+
+LBB19_54:
+	WORD $0xf685                           // testl        %esi, %esi
+	WORD $0x558b; BYTE $0xd4               // movl         $-44(%rbp), %edx
+	LONG $0x0025850f; WORD $0x0000         // jne          LBB19_57, $37(%rip)
+	QUAD $0x000000000000b848; WORD $0x8000 // movabsq      $-9223372036854775808, %rax
+	WORD $0x6348; BYTE $0xca               // movslq       %edx, %rcx
+	WORD $0x854d; BYTE $0xe4               // testq        %r12, %r12
+	LONG $0x00e9890f; WORD $0x0000         // jns          LBB19_68, $233(%rip)
+	WORD $0x894c; BYTE $0xe7               // movq         %r12, %rdi
+	WORD $0x2148; BYTE $0xcf               // andq         %rcx, %rdi
+	WORD $0x3948; BYTE $0xc7               // cmpq         %rax, %rdi
+	LONG $0x00da840f; WORD $0x0000         // je           LBB19_68, $218(%rip)
+
+LBB19_57:
+	LONG $0x0803c748; WORD $0x0000; BYTE $0x00 // movq         $8, (%rbx)
+
+LBB19_60:
+	QUAD $0x00000000b045c748                   // movq         $0, $-80(%rbp)
+	LONG $0x6e0f4966; BYTE $0xcc               // movq         %r12, %xmm1
+	QUAD $0xfffffc490d620f66                   // punpckldq    $-951(%rip), %xmm1  /* LCPI19_0(%rip) */
+	QUAD $0xfffffc510d5c0f66                   // subpd        $-943(%rip), %xmm1  /* LCPI19_1(%rip) */
+	LONG $0xc1280f66                           // movapd       %xmm1, %xmm0
+	LONG $0xc1150f66                           // unpckhpd     %xmm1, %xmm0
+	LONG $0xc1580ff2                           // addsd        %xmm1, %xmm0
+	LONG $0x45110ff2; BYTE $0xc0               // movsd        %xmm0, $-64(%rbp)
+	WORD $0x894c; BYTE $0xe0                   // movq         %r12, %rax
+	LONG $0x34e8c148                           // shrq         $52, %rax
+	LONG $0x010f850f; WORD $0x0000             // jne          LBB19_73, $271(%rip)
+	LONG $0x7e0f4866; BYTE $0xc1               // movq         %xmm0, %rcx
+	WORD $0xd089                               // movl         %edx, %eax
+	WORD $0xe8c1; BYTE $0x1f                   // shrl         $31, %eax
+	LONG $0x3fe0c148                           // shlq         $63, %rax
+	WORD $0x0948; BYTE $0xc8                   // orq          %rcx, %rax
+	LONG $0xc0458948                           // movq         %rax, $-64(%rbp)
+	WORD $0x854d; BYTE $0xe4                   // testq        %r12, %r12
+	LONG $0x018c840f; WORD $0x0000             // je           LBB19_81, $396(%rip)
+	WORD $0xf685                               // testl        %esi, %esi
+	LONG $0x0184840f; WORD $0x0000             // je           LBB19_81, $388(%rip)
+	LONG $0x6e0f4866; BYTE $0xc0               // movq         %rax, %xmm0
+	WORD $0x468d; BYTE $0xff                   // leal         $-1(%rsi), %eax
+	WORD $0xf883; BYTE $0x24                   // cmpl         $36, %eax
+	LONG $0x0040870f; WORD $0x0000             // ja           LBB19_66, $64(%rip)
+	WORD $0xfe83; BYTE $0x17                   // cmpl         $23, %esi
+	LONG $0x0095820f; WORD $0x0000             // jb           LBB19_69, $149(%rip)
+	WORD $0x468d; BYTE $0xea                   // leal         $-22(%rsi), %eax
+	LONG $0x790d8d48; WORD $0x00e1; BYTE $0x00 // leaq         $57721(%rip), %rcx  /* _P10_TAB(%rip) */
+	LONG $0x04590ff2; BYTE $0xc1               // mulsd        (%rcx,%rax,8), %xmm0
+	LONG $0x45110ff2; BYTE $0xc0               // movsd        %xmm0, $-64(%rbp)
+	LONG $0x000016b8; BYTE $0x00               // movl         $22, %eax
+	LONG $0x000079e9; BYTE $0x00               // jmp          LBB19_70, $121(%rip)
+
+LBB19_58:
+	LONG $0x01bc45c7; WORD $0x0000; BYTE $0x00 // movl         $1, $-68(%rbp)
+	WORD $0xce89                               // movl         %ecx, %esi
+	WORD $0x458b; BYTE $0xc8                   // movl         $-56(%rbp), %eax
+	WORD $0xc084                               // testb        %al, %al
+	LONG $0xff1c850f; WORD $0xffff             // jne          LBB19_54, $-228(%rip)
+	LONG $0xfffdd3e9; BYTE $0xff               // jmp          LBB19_59, $-557(%rip)
+
+LBB19_66:
+	WORD $0xfe83; BYTE $0xea                   // cmpl         $-22, %esi
+	LONG $0x008f820f; WORD $0x0000             // jb           LBB19_73, $143(%rip)
+	WORD $0xdef7                               // negl         %esi
+	LONG $0x3a058d48; WORD $0x00e1; BYTE $0x00 // leaq         $57658(%rip), %rax  /* _P10_TAB(%rip) */
+	LONG $0x045e0ff2; BYTE $0xf0               // divsd        (%rax,%rsi,8), %xmm0
+	LONG $0x45110ff2; BYTE $0xc0               // movsd        %xmm0, $-64(%rbp)
+	LONG $0x0000d9e9; BYTE $0x00               // jmp          LBB19_77, $217(%rip)
+
+LBB19_68:
+	LONG $0x6e0f4966; BYTE $0xc4 // movq         %r12, %xmm0
+	LONG $0xe1af0f4c             // imulq        %rcx, %r12
+	LONG $0x1063894c             // movq         %r12, $16(%rbx)
+	QUAD $0xfffffb7605620f66     // punpckldq    $-1162(%rip), %xmm0  /* LCPI19_0(%rip) */
+	QUAD $0xfffffb7e055c0f66     // subpd        $-1154(%rip), %xmm0  /* LCPI19_1(%rip) */
+	LONG $0xc8280f66             // movapd       %xmm0, %xmm1
+	LONG $0xc8150f66             // unpckhpd     %xmm0, %xmm1
+	LONG $0xc8580ff2             // addsd        %xmm0, %xmm1
+	WORD $0x2148; BYTE $0xc8     // andq         %rcx, %rax
+	LONG $0x7e0f4866; BYTE $0xc9 // movq         %xmm1, %rcx
+	WORD $0x0948; BYTE $0xc1     // orq          %rax, %rcx
+	LONG $0x084b8948             // movq         %rcx, $8(%rbx)
+	LONG $0x000109e9; BYTE $0x00 // jmp          LBB19_85, $265(%rip)
+
+LBB19_69:
+	WORD $0xf089 // movl         %esi, %eax
+
+LBB19_70:
+	QUAD $0xfffffb64052e0f66                   // ucomisd      $-1180(%rip), %xmm0  /* LCPI19_2(%rip) */
+	LONG $0x002a870f; WORD $0x0000             // ja           LBB19_73, $42(%rip)
+	QUAD $0xfffffb5e0d100ff2                   // movsd        $-1186(%rip), %xmm1  /* LCPI19_3(%rip) */
+	LONG $0xc82e0f66                           // ucomisd      %xmm0, %xmm1
+	LONG $0x0018870f; WORD $0x0000             // ja           LBB19_73, $24(%rip)
+	WORD $0xc089                               // movl         %eax, %eax
+	LONG $0xc30d8d48; WORD $0x00e0; BYTE $0x00 // leaq         $57539(%rip), %rcx  /* _P10_TAB(%rip) */
+	LONG $0x04590ff2; BYTE $0xc1               // mulsd        (%rcx,%rax,8), %xmm0
+	LONG $0x45110ff2; BYTE $0xc0               // movsd        %xmm0, $-64(%rbp)
+	LONG $0x000062e9; BYTE $0x00               // jmp          LBB19_77, $98(%rip)
+
+LBB19_73:
+	LONG $0xa05d894c               // movq         %r11, $-96(%rbp)
+	LONG $0xc855894c               // movq         %r10, $-56(%rbp)
+	LONG $0xc04d8d48               // leaq         $-64(%rbp), %rcx
+	WORD $0x894c; BYTE $0xe7       // movq         %r12, %rdi
+	LONG $0xa8758948               // movq         %rsi, $-88(%rbp)
+	LONG $0xffe38ce8; BYTE $0xff   // callq        _atof_eisel_lemire64, $-7284(%rip)
+	WORD $0xc084                   // testb        %al, %al
+	LONG $0x004c840f; WORD $0x0000 // je           LBB19_79, $76(%rip)
+	LONG $0x00bc7d83               // cmpl         $0, $-68(%rbp)
+	LONG $0x006d840f; WORD $0x0000 // je           LBB19_80, $109(%rip)
+	WORD $0xff49; BYTE $0xc4       // incq         %r12
+	LONG $0xb04d8d48               // leaq         $-80(%rbp), %rcx
+	WORD $0x894c; BYTE $0xe7       // movq         %r12, %rdi
+	LONG $0xa8758b48               // movq         $-88(%rbp), %rsi
+	WORD $0x558b; BYTE $0xd4       // movl         $-44(%rbp), %edx
+	LONG $0xffe364e8; BYTE $0xff   // callq        _atof_eisel_lemire64, $-7324(%rip)
+	WORD $0xc084                   // testb        %al, %al
+	LONG $0x0024840f; WORD $0x0000 // je           LBB19_79, $36(%rip)
+	LONG $0x4d100ff2; BYTE $0xb0   // movsd        $-80(%rbp), %xmm1
+	LONG $0x45100ff2; BYTE $0xc0   // movsd        $-64(%rbp), %xmm0
+	LONG $0xc82e0f66               // ucomisd      %xmm0, %xmm1
+	LONG $0x0010850f; WORD $0x0000 // jne          LBB19_79, $16(%rip)
+	LONG $0x000a8a0f; WORD $0x0000 // jp           LBB19_79, $10(%rip)
+
+LBB19_77:
+	LONG $0x7e0f4866; BYTE $0xc0 // movq         %xmm0, %rax
+	LONG $0x00002fe9; BYTE $0x00 // jmp          LBB19_81, $47(%rip)
+
+LBB19_79:
+	WORD $0x8b49; BYTE $0x06     // movq         (%r14), %rax
+	WORD $0x0149; BYTE $0xc7     // addq         %rax, %r15
+	WORD $0x894c; BYTE $0xee     // movq         %r13, %rsi
+	WORD $0x2948; BYTE $0xc6     // subq         %rax, %rsi
+	WORD $0x894c; BYTE $0xff     // movq         %r15, %rdi
+	LONG $0xc8558b48             // movq         $-56(%rbp), %rdx
+	LONG $0xa04d8b48             // movq         $-96(%rbp), %rcx
+	LONG $0xffe8cce8; BYTE $0xff // callq        _atof_native, $-5940(%rip)
+	LONG $0x45110ff2; BYTE $0xc0 // movsd        %xmm0, $-64(%rbp)
+	LONG $0x7e0f4866; BYTE $0xc0 // movq         %xmm0, %rax
+	LONG $0x000009e9; BYTE $0x00 // jmp          LBB19_82, $9(%rip)
+
+LBB19_80:
+	LONG $0xc0458b48 // movq         $-64(%rbp), %rax
+
+LBB19_81:
+	LONG $0x6e0f4866; BYTE $0xc0 // movq         %rax, %xmm0
+
+LBB19_82:
+	QUAD $0x000000000000b948; WORD $0x8000     // movabsq      $-9223372036854775808, %rcx
+	WORD $0xff48; BYTE $0xc9                   // decq         %rcx
+	WORD $0x2148; BYTE $0xc1                   // andq         %rax, %rcx
+	QUAD $0x000000000000b848; WORD $0x7ff0     // movabsq      $9218868437227405312, %rax
+	WORD $0x3948; BYTE $0xc1                   // cmpq         %rax, %rcx
+	LONG $0x0007850f; WORD $0x0000             // jne          LBB19_84, $7(%rip)
+	LONG $0xf803c748; WORD $0xffff; BYTE $0xff // movq         $-8, (%rbx)
+
+LBB19_84:
+	LONG $0x43110ff2; BYTE $0x08 // movsd        %xmm0, $8(%rbx)
+
+LBB19_85:
+	WORD $0x894d; BYTE $0x2e     // movq         %r13, (%r14)
+	LONG $0xfffd89e9; BYTE $0xff // jmp          LBB19_52, $-631(%rip)
+
+LBB19_86:
+	WORD $0x8948; BYTE $0xf8 // movq         %rdi, %rax
+	WORD $0x558b; BYTE $0xd4 // movl         $-44(%rbp), %edx
+
+LBB19_87:
+	LONG $0xc6c68040               // addb         $-58, %sil
+	LONG $0xf6fe8040               // cmpb         $-10, %sil
+	LONG $0xfad7820f; WORD $0xffff // jb           LBB19_5, $-1321(%rip)
+	WORD $0xf631                   // xorl         %esi, %esi
+	WORD $0x394c; BYTE $0xe8       // cmpq         %r13, %rax
+	LONG $0x0035830f; WORD $0x0000 // jae          LBB19_93, $53(%rip)
+	WORD $0xf631                   // xorl         %esi, %esi
+
+LBB19_90:
+	LONG $0x0cb60f45; BYTE $0x07   // movzbl       (%r15,%rax), %r9d
+	LONG $0xd0798d41               // leal         $-48(%r9), %edi
+	LONG $0x09ff8040               // cmpb         $9, %dil
+	LONG $0x0020870f; WORD $0x0000 // ja           LBB19_93, $32(%rip)
+	LONG $0x2710fe81; WORD $0x0000 // cmpl         $10000, %esi
+	WORD $0x3c8d; BYTE $0xb6       // leal         (%rsi,%rsi,4), %edi
+	LONG $0x797c8d41; BYTE $0xd0   // leal         $-48(%r9,%rdi,2), %edi
+	WORD $0x4c0f; BYTE $0xf7       // cmovll       %edi, %esi
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3949; BYTE $0xc5       // cmpq         %rax, %r13
+	LONG $0xffd0850f; WORD $0xffff // jne          LBB19_90, $-48(%rip)
+	WORD $0x894c; BYTE $0xe8       // movq         %r13, %rax
+
+LBB19_93:
+	LONG $0xf0af0f41                                   // imull        %r8d, %esi
+	WORD $0xce01                                       // addl         %ecx, %esi
+	WORD $0x8949; BYTE $0xc5                           // movq         %rax, %r13
+	LONG $0xfffd7de9; BYTE $0xff                       // jmp          LBB19_60, $-643(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+_vsigned:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	BYTE $0x53                                 // pushq        %rbx
+	WORD $0x8b48; BYTE $0x06                   // movq         (%rsi), %rax
+	WORD $0x8b4c; BYTE $0x0f                   // movq         (%rdi), %r9
+	LONG $0x085f8b4c                           // movq         $8(%rdi), %r11
+	LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq         $9, (%rdx)
+	WORD $0x570f; BYTE $0xc0                   // xorps        %xmm0, %xmm0
+	LONG $0x0842110f                           // movups       %xmm0, $8(%rdx)
+	WORD $0x8b48; BYTE $0x0e                   // movq         (%rsi), %rcx
+	LONG $0x184a8948                           // movq         %rcx, $24(%rdx)
+	WORD $0x394c; BYTE $0xd8                   // cmpq         %r11, %rax
+	LONG $0x0046830f; WORD $0x0000             // jae          LBB20_1, $70(%rip)
+	LONG $0x0cb60f41; BYTE $0x01               // movzbl       (%r9,%rax), %ecx
+	LONG $0x0001b841; WORD $0x0000             // movl         $1, %r8d
+	WORD $0xf980; BYTE $0x2d                   // cmpb         $45, %cl
+	LONG $0x0018850f; WORD $0x0000             // jne          LBB20_5, $24(%rip)
+	WORD $0xff48; BYTE $0xc0                   // incq         %rax
+	WORD $0x394c; BYTE $0xd8                   // cmpq         %r11, %rax
+	LONG $0x0026830f; WORD $0x0000             // jae          LBB20_1, $38(%rip)
+	LONG $0x0cb60f41; BYTE $0x01               // movzbl       (%r9,%rax), %ecx
+	LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r8
+
+LBB20_5:
+	WORD $0x798d; BYTE $0xc6                   // leal         $-58(%rcx), %edi
+	LONG $0xf5ff8040                           // cmpb         $-11, %dil
+	LONG $0x001a870f; WORD $0x0000             // ja           LBB20_7, $26(%rip)
+	WORD $0x8948; BYTE $0x06                   // movq         %rax, (%rsi)
+	LONG $0xfe02c748; WORD $0xffff; BYTE $0xff // movq         $-2, (%rdx)
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB20_1:
+	WORD $0x894c; BYTE $0x1e                   // movq         %r11, (%rsi)
+	LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq         $-1, (%rdx)
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB20_7:
+	WORD $0xf980; BYTE $0x30               // cmpb         $48, %cl
+	LONG $0x0032850f; WORD $0x0000         // jne          LBB20_12, $50(%rip)
+	LONG $0x01508d4c                       // leaq         $1(%rax), %r10
+	WORD $0x394c; BYTE $0xd8               // cmpq         %r11, %rax
+	LONG $0x0081830f; WORD $0x0000         // jae          LBB20_11, $129(%rip)
+	LONG $0x3cb60f43; BYTE $0x11           // movzbl       (%r9,%r10), %edi
+	WORD $0xc783; BYTE $0xd2               // addl         $-46, %edi
+	WORD $0xff83; BYTE $0x37               // cmpl         $55, %edi
+	LONG $0x0070870f; WORD $0x0000         // ja           LBB20_11, $112(%rip)
+	QUAD $0x000000800001b948; WORD $0x0080 // movabsq      $36028797027352577, %rcx
+	LONG $0xf9a30f48                       // btq          %rdi, %rcx
+	LONG $0x005c830f; WORD $0x0000         // jae          LBB20_11, $92(%rip)
+
+LBB20_12:
+	WORD $0x394c; BYTE $0xd8             // cmpq         %r11, %rax
+	WORD $0x894d; BYTE $0xda             // movq         %r11, %r10
+	LONG $0xd0470f4c                     // cmovaq       %rax, %r10
+	WORD $0xc931                         // xorl         %ecx, %ecx
+	QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB20_13:
+	WORD $0x394c; BYTE $0xd8       // cmpq         %r11, %rax
+	LONG $0x007d830f; WORD $0x0000 // jae          LBB20_23, $125(%rip)
+	LONG $0x3cbe0f49; BYTE $0x01   // movsbq       (%r9,%rax), %rdi
+	WORD $0x5f8d; BYTE $0xd0       // leal         $-48(%rdi), %ebx
+	WORD $0xfb80; BYTE $0x09       // cmpb         $9, %bl
+	LONG $0x0033870f; WORD $0x0000 // ja           LBB20_18, $51(%rip)
+	LONG $0x0ac96b48               // imulq        $10, %rcx, %rcx
+	LONG $0x0013800f; WORD $0x0000 // jo           LBB20_17, $19(%rip)
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0xc783; BYTE $0xd0       // addl         $-48, %edi
+	LONG $0xf8af0f49               // imulq        %r8, %rdi
+	WORD $0x0148; BYTE $0xf9       // addq         %rdi, %rcx
+	LONG $0xffc9810f; WORD $0xffff // jno          LBB20_13, $-55(%rip)
+
+LBB20_17:
+	WORD $0xff48; BYTE $0xc8                   // decq         %rax
+	WORD $0x8948; BYTE $0x06                   // movq         %rax, (%rsi)
+	LONG $0xfb02c748; WORD $0xffff; BYTE $0xff // movq         $-5, (%rdx)
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB20_11:
+	WORD $0x894c; BYTE $0x16 // movq         %r10, (%rsi)
+	BYTE $0x5b               // popq         %rbx
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB20_18:
+	WORD $0x394c; BYTE $0xd8       // cmpq         %r11, %rax
+	LONG $0x002d830f; WORD $0x0000 // jae          LBB20_22, $45(%rip)
+	LONG $0x3cb60f41; BYTE $0x01   // movzbl       (%r9,%rax), %edi
+	WORD $0xff83; BYTE $0x2e       // cmpl         $46, %edi
+	LONG $0x0012840f; WORD $0x0000 // je           LBB20_25, $18(%rip)
+	WORD $0xff83; BYTE $0x45       // cmpl         $69, %edi
+	LONG $0x0009840f; WORD $0x0000 // je           LBB20_25, $9(%rip)
+	WORD $0xff83; BYTE $0x65       // cmpl         $101, %edi
+	LONG $0x000d850f; WORD $0x0000 // jne          LBB20_22, $13(%rip)
+
+LBB20_25:
+	WORD $0x8948; BYTE $0x06                   // movq         %rax, (%rsi)
+	LONG $0xfa02c748; WORD $0xffff; BYTE $0xff // movq         $-6, (%rdx)
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB20_22:
+	WORD $0x8949; BYTE $0xc2 // movq         %rax, %r10
+
+LBB20_23:
+	WORD $0x894c; BYTE $0x16 // movq         %r10, (%rsi)
+	LONG $0x104a8948         // movq         %rcx, $16(%rdx)
+	BYTE $0x5b               // popq         %rbx
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+	// .p2align 4, 0x90
+_vunsigned:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5641                               // pushq        %r14
+	BYTE $0x53                                 // pushq        %rbx
+	WORD $0x8949; BYTE $0xd0                   // movq         %rdx, %r8
+	WORD $0x8b48; BYTE $0x0e                   // movq         (%rsi), %rcx
+	WORD $0x8b4c; BYTE $0x0f                   // movq         (%rdi), %r9
+	LONG $0x08778b4c                           // movq         $8(%rdi), %r14
+	LONG $0x0902c748; WORD $0x0000; BYTE $0x00 // movq         $9, (%rdx)
+	WORD $0x570f; BYTE $0xc0                   // xorps        %xmm0, %xmm0
+	LONG $0x0842110f                           // movups       %xmm0, $8(%rdx)
+	WORD $0x8b48; BYTE $0x06                   // movq         (%rsi), %rax
+	LONG $0x18428948                           // movq         %rax, $24(%rdx)
+	WORD $0x394c; BYTE $0xf1                   // cmpq         %r14, %rcx
+	LONG $0x001c830f; WORD $0x0000             // jae          LBB21_1, $28(%rip)
+	LONG $0x04b60f41; BYTE $0x09               // movzbl       (%r9,%rcx), %eax
+	WORD $0x2d3c                               // cmpb         $45, %al
+	LONG $0x001e850f; WORD $0x0000             // jne          LBB21_4, $30(%rip)
+
+LBB21_3:
+	WORD $0x8948; BYTE $0x0e                   // movq         %rcx, (%rsi)
+	LONG $0xfa00c749; WORD $0xffff; BYTE $0xff // movq         $-6, (%r8)
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5e41                               // popq         %r14
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB21_1:
+	WORD $0x894c; BYTE $0x36                   // movq         %r14, (%rsi)
+	LONG $0xff00c749; WORD $0xffff; BYTE $0xff // movq         $-1, (%r8)
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5e41                               // popq         %r14
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB21_4:
+	WORD $0x508d; BYTE $0xc6                   // leal         $-58(%rax), %edx
+	WORD $0xfa80; BYTE $0xf5                   // cmpb         $-11, %dl
+	LONG $0x000f870f; WORD $0x0000             // ja           LBB21_6, $15(%rip)
+	WORD $0x8948; BYTE $0x0e                   // movq         %rcx, (%rsi)
+	LONG $0xfe00c749; WORD $0xffff; BYTE $0xff // movq         $-2, (%r8)
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5e41                               // popq         %r14
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB21_6:
+	WORD $0x303c                           // cmpb         $48, %al
+	LONG $0x0026850f; WORD $0x0000         // jne          LBB21_10, $38(%rip)
+	LONG $0x44b60f41; WORD $0x0109         // movzbl       $1(%r9,%rcx), %eax
+	WORD $0xc083; BYTE $0xd2               // addl         $-46, %eax
+	WORD $0xf883; BYTE $0x37               // cmpl         $55, %eax
+	LONG $0x00c2870f; WORD $0x0000         // ja           LBB21_9, $194(%rip)
+	QUAD $0x000000800001ba48; WORD $0x0080 // movabsq      $36028797027352577, %rdx
+	LONG $0xc2a30f48                       // btq          %rax, %rdx
+	LONG $0x00ae830f; WORD $0x0000         // jae          LBB21_9, $174(%rip)
+
+LBB21_10:
+	WORD $0x3949; BYTE $0xce       // cmpq         %rcx, %r14
+	WORD $0x8949; BYTE $0xca       // movq         %rcx, %r10
+	LONG $0xd6470f4d               // cmovaq       %r14, %r10
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x000abb41; WORD $0x0000 // movl         $10, %r11d
+	QUAD $0x9090909090909090       // .p2align 4, 0x90
+
+LBB21_11:
+	WORD $0x394c; BYTE $0xf1       // cmpq         %r14, %rcx
+	LONG $0x007f830f; WORD $0x0000 // jae          LBB21_22, $127(%rip)
+	LONG $0x1cbe0f41; BYTE $0x09   // movsbl       (%r9,%rcx), %ebx
+	WORD $0x538d; BYTE $0xd0       // leal         $-48(%rbx), %edx
+	WORD $0xfa80; BYTE $0x09       // cmpb         $9, %dl
+	LONG $0x0042870f; WORD $0x0000 // ja           LBB21_17, $66(%rip)
+	WORD $0xf749; BYTE $0xe3       // mulq         %r11
+	LONG $0x0027800f; WORD $0x0000 // jo           LBB21_16, $39(%rip)
+	WORD $0xff48; BYTE $0xc1       // incq         %rcx
+	WORD $0xc383; BYTE $0xd0       // addl         $-48, %ebx
+	WORD $0xff31                   // xorl         %edi, %edi
+	WORD $0x0148; BYTE $0xd8       // addq         %rbx, %rax
+	LONG $0xc7920f40               // setb         %dil
+	WORD $0x8948; BYTE $0xfa       // movq         %rdi, %rdx
+	WORD $0xf748; BYTE $0xda       // negq         %rdx
+	WORD $0x3148; BYTE $0xd7       // xorq         %rdx, %rdi
+	LONG $0x0009850f; WORD $0x0000 // jne          LBB21_16, $9(%rip)
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0xffb6890f; WORD $0xffff // jns          LBB21_11, $-74(%rip)
+
+LBB21_16:
+	WORD $0xff48; BYTE $0xc9                   // decq         %rcx
+	WORD $0x8948; BYTE $0x0e                   // movq         %rcx, (%rsi)
+	LONG $0xfb00c749; WORD $0xffff; BYTE $0xff // movq         $-5, (%r8)
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5e41                               // popq         %r14
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB21_17:
+	WORD $0x394c; BYTE $0xf1       // cmpq         %r14, %rcx
+	LONG $0x0020830f; WORD $0x0000 // jae          LBB21_21, $32(%rip)
+	LONG $0x14b60f41; BYTE $0x09   // movzbl       (%r9,%rcx), %edx
+	WORD $0xfa83; BYTE $0x2e       // cmpl         $46, %edx
+	LONG $0xff0c840f; WORD $0xffff // je           LBB21_3, $-244(%rip)
+	WORD $0xfa83; BYTE $0x45       // cmpl         $69, %edx
+	LONG $0xff03840f; WORD $0xffff // je           LBB21_3, $-253(%rip)
+	WORD $0xfa83; BYTE $0x65       // cmpl         $101, %edx
+	LONG $0xfefa840f; WORD $0xffff // je           LBB21_3, $-262(%rip)
+
+LBB21_21:
+	WORD $0x8949; BYTE $0xca // movq         %rcx, %r10
+
+LBB21_22:
+	WORD $0x894c; BYTE $0x16 // movq         %r10, (%rsi)
+	LONG $0x10408949         // movq         %rax, $16(%r8)
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5e41             // popq         %r14
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB21_9:
+	WORD $0xff48; BYTE $0xc1 // incq         %rcx
+	WORD $0x8948; BYTE $0x0e // movq         %rcx, (%rsi)
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5e41             // popq         %r14
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+	BYTE $0x00               // .p2align 4, 0x00
+
+LCPI22_0:
+	QUAD $0x0000000000000001 // .quad 1
+	QUAD $0x0000000000000005 // .quad 5
+
+	// .p2align 4, 0x90
+_skip_array:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x8948; BYTE $0xd0                   // movq         %rdx, %rax
+	WORD $0x8948; BYTE $0xf2                   // movq         %rsi, %rdx
+	WORD $0x8948; BYTE $0xfe                   // movq         %rdi, %rsi
+	LONG $0xdc05280f; WORD $0xffff; BYTE $0xff // movaps       $-36(%rip), %xmm0  /* LCPI22_0(%rip) */
+	WORD $0x110f; BYTE $0x00                   // movups       %xmm0, (%rax)
+	WORD $0x8948; BYTE $0xc7                   // movq         %rax, %rdi
+	BYTE $0x5d                                 // popq         %rbp
+	LONG $0x000000e9; BYTE $0x00               // jmp          _fsm_exec, $0(%rip)
+
+	// .p2align 4, 0x90
+_fsm_exec:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x28ec8348                           // subq         $40, %rsp
+	LONG $0xb84d8948                           // movq         %rcx, $-72(%rbp)
+	LONG $0x003f8348                           // cmpq         $0, (%rdi)
+	LONG $0x03b1840f; WORD $0x0000             // je           LBB23_2, $945(%rip)
+	WORD $0x8949; BYTE $0xd4                   // movq         %rdx, %r12
+	WORD $0x8949; BYTE $0xff                   // movq         %rdi, %r15
+	LONG $0xd0758948                           // movq         %rsi, $-48(%rbp)
+	LONG $0xffc6c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r14
+	LONG $0xc8558948                           // movq         %rdx, $-56(%rbp)
+	LONG $0x000033e9; BYTE $0x00               // jmp          LBB23_7, $51(%rip)
+
+LBB23_3:
+	WORD $0x8b49; BYTE $0x0f                   // movq         (%r15), %rcx
+	LONG $0x000006b8; BYTE $0x00               // movl         $6, %eax
+	LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq         $4095, %rcx
+	LONG $0x03a78f0f; WORD $0x0000             // jg           LBB23_62, $935(%rip)
+	WORD $0x9090                               // .p2align 4, 0x90
+
+LBB23_4:
+	LONG $0x01518d48         // leaq         $1(%rcx), %rdx
+	WORD $0x8949; BYTE $0x17 // movq         %rdx, (%r15)
+	WORD $0x8948; BYTE $0xca // movq         %rcx, %rdx
+
+LBB23_5:
+	LONG $0xd7448949; BYTE $0x08 // movq         %rax, $8(%r15,%rdx,8)
+
+LBB23_6:
+	LONG $0x003f8349               // cmpq         $0, (%r15)
+	WORD $0x894c; BYTE $0xf0       // movq         %r14, %rax
+	LONG $0x035c840f; WORD $0x0000 // je           LBB23_54, $860(%rip)
+
+LBB23_7:
+	LONG $0xd06d8b4c               // movq         $-48(%rbp), %r13
+	LONG $0x007d8b49               // movq         (%r13), %rdi
+	LONG $0x08758b49               // movq         $8(%r13), %rsi
+	WORD $0x894c; BYTE $0xe2       // movq         %r12, %rdx
+	LONG $0xffee30e8; BYTE $0xff   // callq        _advance_ns, $-4560(%rip)
+	WORD $0xc084                   // testb        %al, %al
+	LONG $0x0348840f; WORD $0x0000 // je           LBB23_2, $840(%rip)
+	LONG $0xfffe8349               // cmpq         $-1, %r14
+	LONG $0x0007850f; WORD $0x0000 // jne          LBB23_10, $7(%rip)
+	LONG $0x24348b4d               // movq         (%r12), %r14
+	WORD $0xff49; BYTE $0xce       // decq         %r14
+
+LBB23_10:
+	WORD $0xbe0f; BYTE $0xf0                   // movsbl       %al, %esi
+	WORD $0x8b49; BYTE $0x0f                   // movq         (%r15), %rcx
+	LONG $0xff518d48                           // leaq         $-1(%rcx), %rdx
+	LONG $0xcf3c8b41                           // movl         (%r15,%rcx,8), %edi
+	WORD $0xcfff                               // decl         %edi
+	WORD $0xff83; BYTE $0x05                   // cmpl         $5, %edi
+	LONG $0x0027870f; WORD $0x0000             // ja           LBB23_14, $39(%rip)
+	LONG $0x7b1d8d48; WORD $0x0004; BYTE $0x00 // leaq         $1147(%rip), %rbx  /* LJTI23_0(%rip) */
+	LONG $0xbb3c6348                           // movslq       (%rbx,%rdi,4), %rdi
+	WORD $0x0148; BYTE $0xdf                   // addq         %rbx, %rdi
+	JMP  DI
+
+LBB23_12:
+	WORD $0xfe83; BYTE $0x2c       // cmpl         $44, %esi
+	LONG $0x01a8840f; WORD $0x0000 // je           LBB23_35, $424(%rip)
+	WORD $0xfe83; BYTE $0x5d       // cmpl         $93, %esi
+	LONG $0x016c840f; WORD $0x0000 // je           LBB23_32, $364(%rip)
+	LONG $0x000310e9; BYTE $0x00   // jmp          LBB23_58, $784(%rip)
+
+LBB23_14:
+	WORD $0x8949; BYTE $0x17                   // movq         %rdx, (%r15)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	WORD $0xfe83; BYTE $0x7b                   // cmpl         $123, %esi
+	LONG $0x0099860f; WORD $0x0000             // jbe          LBB23_26, $153(%rip)
+	LONG $0x0002d7e9; BYTE $0x00               // jmp          LBB23_54, $727(%rip)
+
+LBB23_15:
+	WORD $0xfe83; BYTE $0x7d                   // cmpl         $125, %esi
+	LONG $0x0146840f; WORD $0x0000             // je           LBB23_32, $326(%rip)
+	WORD $0xfe83; BYTE $0x2c                   // cmpl         $44, %esi
+	LONG $0x02e6850f; WORD $0x0000             // jne          LBB23_58, $742(%rip)
+	LONG $0x000003b8; BYTE $0x00               // movl         $3, %eax
+	LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq         $4095, %rcx
+	LONG $0xff3b8e0f; WORD $0xffff             // jle          LBB23_4, $-197(%rip)
+	LONG $0x0002dbe9; BYTE $0x00               // jmp          LBB23_62, $731(%rip)
+
+LBB23_18:
+	WORD $0x223c                   // cmpb         $34, %al
+	LONG $0x02c7850f; WORD $0x0000 // jne          LBB23_58, $711(%rip)
+	QUAD $0x00000004cf04c749       // movq         $4, (%r15,%rcx,8)
+	LONG $0x241c8b49               // movq         (%r12), %rbx
+	WORD $0x894c; BYTE $0xef       // movq         %r13, %rdi
+
+LBB23_20:
+	WORD $0x8948; BYTE $0xde       // movq         %rbx, %rsi
+	LONG $0xc0558d48               // leaq         $-64(%rbp), %rdx
+	LONG $0xb84d8b48               // movq         $-72(%rbp), %rcx
+	LONG $0xfff08fe8; BYTE $0xff   // callq        _advance_string, $-3953(%rip)
+	WORD $0x8949; BYTE $0xc5       // movq         %rax, %r13
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0107890f; WORD $0x0000 // jns          LBB23_33, $263(%rip)
+	LONG $0xc0458b48               // movq         $-64(%rbp), %rax
+	LONG $0x000107e9; BYTE $0x00   // jmp          LBB23_34, $263(%rip)
+
+LBB23_22:
+	WORD $0x3a3c                   // cmpb         $58, %al
+	LONG $0x028b850f; WORD $0x0000 // jne          LBB23_58, $651(%rip)
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0xfffef5e9; BYTE $0xff   // jmp          LBB23_5, $-267(%rip)
+
+LBB23_24:
+	WORD $0x5d3c                               // cmpb         $93, %al
+	LONG $0x00d3840f; WORD $0x0000             // je           LBB23_32, $211(%rip)
+	QUAD $0x00000001cf04c749                   // movq         $1, (%r15,%rcx,8)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	WORD $0xfe83; BYTE $0x7b                   // cmpl         $123, %esi
+	LONG $0x0243870f; WORD $0x0000             // ja           LBB23_54, $579(%rip)
+
+LBB23_26:
+	WORD $0xf189                               // movl         %esi, %ecx
+	LONG $0xbe158d48; WORD $0x0003; BYTE $0x00 // leaq         $958(%rip), %rdx  /* LJTI23_1(%rip) */
+	LONG $0x8a0c6348                           // movslq       (%rdx,%rcx,4), %rcx
+	WORD $0x0148; BYTE $0xd1                   // addq         %rdx, %rcx
+	LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r13
+	JMP  CX
+
+LBB23_27:
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	WORD $0x8b48; BYTE $0x18                   // movq         (%rax), %rbx
+	LONG $0xff6b8d4c                           // leaq         $-1(%rbx), %r13
+	LONG $0xd0458b48                           // movq         $-48(%rbp), %rax
+	WORD $0x8b48; BYTE $0x38                   // movq         (%rax), %rdi
+	WORD $0x014c; BYTE $0xef                   // addq         %r13, %rdi
+	LONG $0x08708b48                           // movq         $8(%rax), %rsi
+	WORD $0x294c; BYTE $0xee                   // subq         %r13, %rsi
+	LONG $0x0006d1e8; BYTE $0x00               // callq        _do_skip_number, $1745(%rip)
+	LONG $0xff488d48                           // leaq         $-1(%rax), %rcx
+	LONG $0xfec2c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rdx
+	WORD $0x2948; BYTE $0xc2                   // subq         %rax, %rdx
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0xd1490f48                           // cmovnsq      %rcx, %rdx
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	LONG $0xe8480f4c                           // cmovsq       %rax, %r13
+	WORD $0x0148; BYTE $0xda                   // addq         %rbx, %rdx
+	LONG $0xc8658b4c                           // movq         $-56(%rbp), %r12
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	WORD $0x854d; BYTE $0xed                   // testq        %r13, %r13
+	LONG $0xfe6c890f; WORD $0xffff             // jns          LBB23_6, $-404(%rip)
+	LONG $0x0001dfe9; BYTE $0x00               // jmp          LBB23_55, $479(%rip)
+
+LBB23_28:
+	WORD $0xfe83; BYTE $0x7d       // cmpl         $125, %esi
+	LONG $0x003f840f; WORD $0x0000 // je           LBB23_32, $63(%rip)
+	WORD $0xfe83; BYTE $0x22       // cmpl         $34, %esi
+	LONG $0x01df850f; WORD $0x0000 // jne          LBB23_58, $479(%rip)
+	QUAD $0x00000002cf04c749       // movq         $2, (%r15,%rcx,8)
+	LONG $0x241c8b49               // movq         (%r12), %rbx
+	WORD $0x894c; BYTE $0xef       // movq         %r13, %rdi
+	WORD $0x8948; BYTE $0xde       // movq         %rbx, %rsi
+	LONG $0xc0558d48               // leaq         $-64(%rbp), %rdx
+	LONG $0xb84d8b48               // movq         $-72(%rbp), %rcx
+	LONG $0xffefa7e8; BYTE $0xff   // callq        _advance_string, $-4185(%rip)
+	WORD $0x8949; BYTE $0xc5       // movq         %rax, %r13
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0052890f; WORD $0x0000 // jns          LBB23_37, $82(%rip)
+	LONG $0xc0458b48               // movq         $-64(%rbp), %rax
+	LONG $0x000052e9; BYTE $0x00   // jmp          LBB23_38, $82(%rip)
+	WORD $0x9090                   // .p2align 4, 0x90
+
+LBB23_32:
+	WORD $0x8949; BYTE $0x17       // movq         %rdx, (%r15)
+	WORD $0x894d; BYTE $0xf5       // movq         %r14, %r13
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0xfe1d850f; WORD $0xffff // jne          LBB23_7, $-483(%rip)
+	LONG $0x000183e9; BYTE $0x00   // jmp          LBB23_55, $387(%rip)
+
+LBB23_33:
+	WORD $0xff48; BYTE $0xcb // decq         %rbx
+	WORD $0x894c; BYTE $0xe8 // movq         %r13, %rax
+	WORD $0x8949; BYTE $0xdd // movq         %rbx, %r13
+
+LBB23_34:
+	LONG $0xc8658b4c               // movq         $-56(%rbp), %r12
+	LONG $0x24048949               // movq         %rax, (%r12)
+	WORD $0x854d; BYTE $0xed       // testq        %r13, %r13
+	LONG $0xfdf1890f; WORD $0xffff // jns          LBB23_6, $-527(%rip)
+	LONG $0x000164e9; BYTE $0x00   // jmp          LBB23_55, $356(%rip)
+
+LBB23_35:
+	LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq         $4095, %rcx
+	LONG $0x01758f0f; WORD $0x0000             // jg           LBB23_62, $373(%rip)
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0xfffdc9e9; BYTE $0xff               // jmp          LBB23_4, $-567(%rip)
+
+LBB23_37:
+	WORD $0xff48; BYTE $0xcb // decq         %rbx
+	WORD $0x894c; BYTE $0xe8 // movq         %r13, %rax
+	WORD $0x8949; BYTE $0xdd // movq         %rbx, %r13
+
+LBB23_38:
+	LONG $0xc8658b4c                           // movq         $-56(%rbp), %r12
+	LONG $0x24048949                           // movq         %rax, (%r12)
+	WORD $0x854d; BYTE $0xed                   // testq        %r13, %r13
+	LONG $0x0136880f; WORD $0x0000             // js           LBB23_55, $310(%rip)
+	WORD $0x8b49; BYTE $0x0f                   // movq         (%r15), %rcx
+	LONG $0x000004b8; BYTE $0x00               // movl         $4, %eax
+	LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq         $4095, %rcx
+	LONG $0xfd9a8e0f; WORD $0xffff             // jle          LBB23_4, $-614(%rip)
+	LONG $0x00013ae9; BYTE $0x00               // jmp          LBB23_62, $314(%rip)
+
+LBB23_40:
+	LONG $0x241c8b49             // movq         (%r12), %rbx
+	LONG $0xd07d8b48             // movq         $-48(%rbp), %rdi
+	LONG $0xfffe69e9; BYTE $0xff // jmp          LBB23_20, $-407(%rip)
+
+LBB23_41:
+	LONG $0x242c8b4d               // movq         (%r12), %r13
+	LONG $0xd0458b48               // movq         $-48(%rbp), %rax
+	WORD $0x8b48; BYTE $0x38       // movq         (%rax), %rdi
+	WORD $0x014c; BYTE $0xef       // addq         %r13, %rdi
+	LONG $0x08708b48               // movq         $8(%rax), %rsi
+	WORD $0x294c; BYTE $0xee       // subq         %r13, %rsi
+	LONG $0x0005aee8; BYTE $0x00   // callq        _do_skip_number, $1454(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0126880f; WORD $0x0000 // js           LBB23_66, $294(%rip)
+	WORD $0x014c; BYTE $0xe8       // addq         %r13, %rax
+	LONG $0x24048949               // movq         %rax, (%r12)
+	WORD $0x854d; BYTE $0xed       // testq        %r13, %r13
+	LONG $0xfd648f0f; WORD $0xffff // jg           LBB23_6, $-668(%rip)
+	LONG $0x000127e9; BYTE $0x00   // jmp          LBB23_68, $295(%rip)
+
+LBB23_43:
+	WORD $0x8b49; BYTE $0x0f                   // movq         (%r15), %rcx
+	LONG $0x000005b8; BYTE $0x00               // movl         $5, %eax
+	LONG $0xfff98148; WORD $0x000f; BYTE $0x00 // cmpq         $4095, %rcx
+	LONG $0xfd3b8e0f; WORD $0xffff             // jle          LBB23_4, $-709(%rip)
+	LONG $0x0000dbe9; BYTE $0x00               // jmp          LBB23_62, $219(%rip)
+
+LBB23_44:
+	LONG $0x24048b49               // movq         (%r12), %rax
+	LONG $0xd0758b48               // movq         $-48(%rbp), %rsi
+	LONG $0x084e8b48               // movq         $8(%rsi), %rcx
+	LONG $0xfc518d48               // leaq         $-4(%rcx), %rdx
+	WORD $0x3948; BYTE $0xd0       // cmpq         %rdx, %rax
+	LONG $0x00ce870f; WORD $0x0000 // ja           LBB23_64, $206(%rip)
+	WORD $0x8b48; BYTE $0x0e       // movq         (%rsi), %rcx
+	WORD $0x148b; BYTE $0x01       // movl         (%rcx,%rax), %edx
+	LONG $0x6c61fa81; WORD $0x6573 // cmpl         $1702063201, %edx
+	LONG $0x0198850f; WORD $0x0000 // jne          LBB23_78, $408(%rip)
+	LONG $0x04488d48               // leaq         $4(%rax), %rcx
+	LONG $0x240c8949               // movq         %rcx, (%r12)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0xfd098f0f; WORD $0xffff // jg           LBB23_6, $-759(%rip)
+	LONG $0x00006ae9; BYTE $0x00   // jmp          LBB23_52, $106(%rip)
+
+LBB23_47:
+	LONG $0x24048b49               // movq         (%r12), %rax
+	LONG $0xd0758b48               // movq         $-48(%rbp), %rsi
+	LONG $0x084e8b48               // movq         $8(%rsi), %rcx
+	LONG $0xfd518d48               // leaq         $-3(%rcx), %rdx
+	WORD $0x3948; BYTE $0xd0       // cmpq         %rdx, %rax
+	LONG $0x008d870f; WORD $0x0000 // ja           LBB23_64, $141(%rip)
+	WORD $0x8b48; BYTE $0x0e       // movq         (%rsi), %rcx
+	QUAD $0x6c6c756eff017c81       // cmpl         $1819047278, $-1(%rcx,%rax)
+	LONG $0x002f840f; WORD $0x0000 // je           LBB23_51, $47(%rip)
+	LONG $0x0000a5e9; BYTE $0x00   // jmp          LBB23_69, $165(%rip)
+
+LBB23_49:
+	LONG $0x24048b49               // movq         (%r12), %rax
+	LONG $0xd0758b48               // movq         $-48(%rbp), %rsi
+	LONG $0x084e8b48               // movq         $8(%rsi), %rcx
+	LONG $0xfd518d48               // leaq         $-3(%rcx), %rdx
+	WORD $0x3948; BYTE $0xd0       // cmpq         %rdx, %rax
+	LONG $0x005e870f; WORD $0x0000 // ja           LBB23_64, $94(%rip)
+	WORD $0x8b48; BYTE $0x0e       // movq         (%rsi), %rcx
+	QUAD $0x65757274ff017c81       // cmpl         $1702195828, $-1(%rcx,%rax)
+	LONG $0x00ce850f; WORD $0x0000 // jne          LBB23_73, $206(%rip)
+
+LBB23_51:
+	LONG $0x03488d48               // leaq         $3(%rax), %rcx
+	LONG $0x240c8949               // movq         %rcx, (%r12)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0xfc9a8f0f; WORD $0xffff // jg           LBB23_6, $-870(%rip)
+
+LBB23_52:
+	WORD $0xff48; BYTE $0xc8 // decq         %rax
+
+LBB23_54:
+	WORD $0x8949; BYTE $0xc5     // movq         %rax, %r13
+	LONG $0x000007e9; BYTE $0x00 // jmp          LBB23_55, $7(%rip)
+
+LBB23_2:
+	LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r13
+
+LBB23_55:
+	WORD $0x894c; BYTE $0xe8 // movq         %r13, %rax
+	LONG $0x28c48348         // addq         $40, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB23_58:
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+	LONG $0xffffe2e9; BYTE $0xff               // jmp          LBB23_55, $-30(%rip)
+
+LBB23_62:
+	LONG $0xf9c5c749; WORD $0xffff; BYTE $0xff // movq         $-7, %r13
+	LONG $0xffffd6e9; BYTE $0xff               // jmp          LBB23_55, $-42(%rip)
+
+LBB23_64:
+	LONG $0x240c8949                           // movq         %rcx, (%r12)
+	LONG $0xffc5c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r13
+	LONG $0xffffc6e9; BYTE $0xff               // jmp          LBB23_55, $-58(%rip)
+
+LBB23_66:
+	WORD $0xf748; BYTE $0xd0                   // notq         %rax
+	WORD $0x0149; BYTE $0xc5                   // addq         %rax, %r13
+	LONG $0x242c894d                           // movq         %r13, (%r12)
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+	LONG $0xffffb0e9; BYTE $0xff               // jmp          LBB23_55, $-80(%rip)
+
+LBB23_68:
+	WORD $0xff49; BYTE $0xcd     // decq         %r13
+	LONG $0xffffa8e9; BYTE $0xff // jmp          LBB23_55, $-88(%rip)
+
+LBB23_69:
+	LONG $0xff508d48                           // leaq         $-1(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+	LONG $0xff017c80; BYTE $0x6e               // cmpb         $110, $-1(%rcx,%rax)
+	LONG $0xff8e850f; WORD $0xffff             // jne          LBB23_55, $-114(%rip)
+	LONG $0x24048949                           // movq         %rax, (%r12)
+	LONG $0x75013c80                           // cmpb         $117, (%rcx,%rax)
+	LONG $0xff80850f; WORD $0xffff             // jne          LBB23_55, $-128(%rip)
+	LONG $0x01508d48                           // leaq         $1(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0x01017c80; BYTE $0x6c               // cmpb         $108, $1(%rcx,%rax)
+	LONG $0xff6d850f; WORD $0xffff             // jne          LBB23_55, $-147(%rip)
+	LONG $0x02508d48                           // leaq         $2(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0x02017c80; BYTE $0x6c               // cmpb         $108, $2(%rcx,%rax)
+	LONG $0xff5a850f; WORD $0xffff             // jne          LBB23_55, $-166(%rip)
+	LONG $0x00004ee9; BYTE $0x00               // jmp          LBB23_77, $78(%rip)
+
+LBB23_73:
+	LONG $0xff508d48                           // leaq         $-1(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+	LONG $0xff017c80; BYTE $0x74               // cmpb         $116, $-1(%rcx,%rax)
+	LONG $0xff3b850f; WORD $0xffff             // jne          LBB23_55, $-197(%rip)
+	LONG $0x24048949                           // movq         %rax, (%r12)
+	LONG $0x72013c80                           // cmpb         $114, (%rcx,%rax)
+	LONG $0xff2d850f; WORD $0xffff             // jne          LBB23_55, $-211(%rip)
+	LONG $0x01508d48                           // leaq         $1(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0x01017c80; BYTE $0x75               // cmpb         $117, $1(%rcx,%rax)
+	LONG $0xff1a850f; WORD $0xffff             // jne          LBB23_55, $-230(%rip)
+	LONG $0x02508d48                           // leaq         $2(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0x02017c80; BYTE $0x65               // cmpb         $101, $2(%rcx,%rax)
+	LONG $0xff07850f; WORD $0xffff             // jne          LBB23_55, $-249(%rip)
+
+LBB23_77:
+	LONG $0x03c08348             // addq         $3, %rax
+	LONG $0x24048949             // movq         %rax, (%r12)
+	LONG $0xfffefae9; BYTE $0xff // jmp          LBB23_55, $-262(%rip)
+
+LBB23_78:
+	LONG $0xfec5c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r13
+	WORD $0xfa80; BYTE $0x61                   // cmpb         $97, %dl
+	LONG $0xfeea850f; WORD $0xffff             // jne          LBB23_55, $-278(%rip)
+	LONG $0x01508d48                           // leaq         $1(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0x01017c80; BYTE $0x6c               // cmpb         $108, $1(%rcx,%rax)
+	LONG $0xfed7850f; WORD $0xffff             // jne          LBB23_55, $-297(%rip)
+	LONG $0x02508d48                           // leaq         $2(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0x02017c80; BYTE $0x73               // cmpb         $115, $2(%rcx,%rax)
+	LONG $0xfec4850f; WORD $0xffff             // jne          LBB23_55, $-316(%rip)
+	LONG $0x03508d48                           // leaq         $3(%rax), %rdx
+	LONG $0x24148949                           // movq         %rdx, (%r12)
+	LONG $0x03017c80; BYTE $0x65               // cmpb         $101, $3(%rcx,%rax)
+	LONG $0xfeb1850f; WORD $0xffff             // jne          LBB23_55, $-335(%rip)
+	LONG $0x04c08348                           // addq         $4, %rax
+	LONG $0x24048949                           // movq         %rax, (%r12)
+	LONG $0xfffea4e9; BYTE $0xff               // jmp          LBB23_55, $-348(%rip)
+	BYTE $0x90                                 // .p2align 2, 0x90
+
+	// .set L23_0_set_12, LBB23_12-LJTI23_0
+	// .set L23_0_set_15, LBB23_15-LJTI23_0
+	// .set L23_0_set_18, LBB23_18-LJTI23_0
+	// .set L23_0_set_22, LBB23_22-LJTI23_0
+	// .set L23_0_set_24, LBB23_24-LJTI23_0
+	// .set L23_0_set_28, LBB23_28-LJTI23_0
+LJTI23_0:
+	LONG $0xfffffb8e // .long L23_0_set_12
+	LONG $0xfffffbbd // .long L23_0_set_15
+	LONG $0xfffffbe6 // .long L23_0_set_18
+	LONG $0xfffffc22 // .long L23_0_set_22
+	LONG $0xfffffc31 // .long L23_0_set_24
+	LONG $0xfffffcc4 // .long L23_0_set_28
+
+	// .set L23_1_set_55, LBB23_55-LJTI23_1
+	// .set L23_1_set_54, LBB23_54-LJTI23_1
+	// .set L23_1_set_40, LBB23_40-LJTI23_1
+	// .set L23_1_set_41, LBB23_41-LJTI23_1
+	// .set L23_1_set_27, LBB23_27-LJTI23_1
+	// .set L23_1_set_43, LBB23_43-LJTI23_1
+	// .set L23_1_set_44, LBB23_44-LJTI23_1
+	// .set L23_1_set_47, LBB23_47-LJTI23_1
+	// .set L23_1_set_49, LBB23_49-LJTI23_1
+	// .set L23_1_set_3, LBB23_3-LJTI23_1
+LJTI23_1:
+	LONG $0xfffffe8b // .long L23_1_set_55
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffd6f // .long L23_1_set_40
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffd7c // .long L23_1_set_41
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffc52 // .long L23_1_set_27
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffdb4 // .long L23_1_set_43
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffdce // .long L23_1_set_44
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe0f // .long L23_1_set_47
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe3e // .long L23_1_set_49
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffe7c // .long L23_1_set_54
+	LONG $0xfffffaed // .long L23_1_set_3
+	LONG $0x00000000 // .p2align 4, 0x00
+
+LCPI24_0:
+	QUAD $0x0000000000000001 // .quad 1
+	QUAD $0x0000000000000006 // .quad 6
+
+	// .p2align 4, 0x90
+_skip_object:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x8948; BYTE $0xd0                   // movq         %rdx, %rax
+	WORD $0x8948; BYTE $0xf2                   // movq         %rsi, %rdx
+	WORD $0x8948; BYTE $0xfe                   // movq         %rdi, %rsi
+	LONG $0xdc05280f; WORD $0xffff; BYTE $0xff // movaps       $-36(%rip), %xmm0  /* LCPI24_0(%rip) */
+	WORD $0x110f; BYTE $0x00                   // movups       %xmm0, (%rax)
+	WORD $0x8948; BYTE $0xc7                   // movq         %rax, %rdi
+	BYTE $0x5d                                 // popq         %rbp
+	LONG $0xfff890e9; BYTE $0xff               // jmp          _fsm_exec, $-1904(%rip)
+
+	// .p2align 4, 0x90
+_skip_string:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5641                   // pushq        %r14
+	BYTE $0x53                     // pushq        %rbx
+	LONG $0x10ec8348               // subq         $16, %rsp
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	WORD $0x8949; BYTE $0xf6       // movq         %rsi, %r14
+	WORD $0x8b48; BYTE $0x1e       // movq         (%rsi), %rbx
+	LONG $0xe8558d48               // leaq         $-24(%rbp), %rdx
+	WORD $0x8948; BYTE $0xde       // movq         %rbx, %rsi
+	LONG $0xffea40e8; BYTE $0xff   // callq        _advance_string, $-5568(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0009890f; WORD $0x0000 // jns          LBB25_1, $9(%rip)
+	LONG $0xe84d8b48               // movq         $-24(%rbp), %rcx
+	LONG $0x000009e9; BYTE $0x00   // jmp          LBB25_3, $9(%rip)
+
+LBB25_1:
+	WORD $0xff48; BYTE $0xcb // decq         %rbx
+	WORD $0x8948; BYTE $0xc1 // movq         %rax, %rcx
+	WORD $0x8948; BYTE $0xd8 // movq         %rbx, %rax
+
+LBB25_3:
+	WORD $0x8949; BYTE $0x0e             // movq         %rcx, (%r14)
+	LONG $0x10c48348                     // addq         $16, %rsp
+	BYTE $0x5b                           // popq         %rbx
+	WORD $0x5e41                         // popq         %r14
+	BYTE $0x5d                           // popq         %rbp
+	BYTE $0xc3                           // retq
+	QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90
+
+_skip_negative:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5641                   // pushq        %r14
+	BYTE $0x53                     // pushq        %rbx
+	WORD $0x8949; BYTE $0xf6       // movq         %rsi, %r14
+	WORD $0x8b48; BYTE $0x1e       // movq         (%rsi), %rbx
+	WORD $0x8b48; BYTE $0x07       // movq         (%rdi), %rax
+	WORD $0x0148; BYTE $0xd8       // addq         %rbx, %rax
+	LONG $0x08778b48               // movq         $8(%rdi), %rsi
+	WORD $0x2948; BYTE $0xde       // subq         %rbx, %rsi
+	WORD $0x8948; BYTE $0xc7       // movq         %rax, %rdi
+	LONG $0x0000aee8; BYTE $0x00   // callq        _do_skip_number, $174(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x000e880f; WORD $0x0000 // js           LBB26_1, $14(%rip)
+	WORD $0x0148; BYTE $0xd8       // addq         %rbx, %rax
+	WORD $0x8949; BYTE $0x06       // movq         %rax, (%r14)
+	WORD $0xff48; BYTE $0xcb       // decq         %rbx
+	LONG $0x000010e9; BYTE $0x00   // jmp          LBB26_3, $16(%rip)
+
+LBB26_1:
+	WORD $0xf748; BYTE $0xd0                   // notq         %rax
+	WORD $0x0148; BYTE $0xc3                   // addq         %rax, %rbx
+	WORD $0x8949; BYTE $0x1e                   // movq         %rbx, (%r14)
+	LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rbx
+
+LBB26_3:
+	WORD $0x8948; BYTE $0xd8                                             // movq         %rbx, %rax
+	BYTE $0x5b                                                           // popq         %rbx
+	WORD $0x5e41                                                         // popq         %r14
+	BYTE $0x5d                                                           // popq         %rbp
+	BYTE $0xc3                                                           // retq
+	QUAD $0x0000000000000000; LONG $0x00000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00
+
+LCPI27_0:
+	QUAD $0x2b2b2b2b2b2b2b2b; QUAD $0x2b2b2b2b2b2b2b2b // .space 16, '++++++++++++++++'
+
+LCPI27_1:
+	QUAD $0x2d2d2d2d2d2d2d2d; QUAD $0x2d2d2d2d2d2d2d2d // .space 16, '----------------'
+
+LCPI27_2:
+	QUAD $0xd0d0d0d0d0d0d0d0; QUAD $0xd0d0d0d0d0d0d0d0 // .space 16, '\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0\xd0'
+
+LCPI27_3:
+	QUAD $0x0909090909090909; QUAD $0x0909090909090909 // .space 16, '\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t'
+
+LCPI27_4:
+	QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
+
+LCPI27_5:
+	QUAD $0x2e2e2e2e2e2e2e2e; QUAD $0x2e2e2e2e2e2e2e2e // .space 16, '................'
+
+LCPI27_6:
+	QUAD $0x4545454545454545; QUAD $0x4545454545454545 // .space 16, 'EEEEEEEEEEEEEEEE'
+
+	// .p2align 4, 0x90
+_do_skip_number:
+	BYTE $0x55                             // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5               // movq         %rsp, %rbp
+	WORD $0x5741                           // pushq        %r15
+	WORD $0x5641                           // pushq        %r14
+	BYTE $0x53                             // pushq        %rbx
+	WORD $0x8548; BYTE $0xf6               // testq        %rsi, %rsi
+	LONG $0x0255840f; WORD $0x0000         // je           LBB27_1, $597(%rip)
+	WORD $0x3f80; BYTE $0x30               // cmpb         $48, (%rdi)
+	LONG $0x0033850f; WORD $0x0000         // jne          LBB27_6, $51(%rip)
+	LONG $0x000001b8; BYTE $0x00           // movl         $1, %eax
+	LONG $0x01fe8348                       // cmpq         $1, %rsi
+	LONG $0x02d8840f; WORD $0x0000         // je           LBB27_55, $728(%rip)
+	LONG $0x014fb60f                       // movzbl       $1(%rdi), %ecx
+	WORD $0xc183; BYTE $0xd2               // addl         $-46, %ecx
+	WORD $0xf983; BYTE $0x37               // cmpl         $55, %ecx
+	LONG $0x02c8870f; WORD $0x0000         // ja           LBB27_55, $712(%rip)
+	QUAD $0x000000800001ba48; WORD $0x0080 // movabsq      $36028797027352577, %rdx
+	LONG $0xcaa30f48                       // btq          %rcx, %rdx
+	LONG $0x02b4830f; WORD $0x0000         // jae          LBB27_55, $692(%rip)
+
+LBB27_6:
+	LONG $0x10fe8348                           // cmpq         $16, %rsi
+	LONG $0x0313820f; WORD $0x0000             // jb           LBB27_7, $787(%rip)
+	LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r10
+	WORD $0xc031                               // xorl         %eax, %eax
+	QUAD $0xffff26056f0f4466; BYTE $0xff       // movdqa       $-218(%rip), %xmm8  /* LCPI27_0(%rip) */
+	QUAD $0xffff2d0d6f0f4466; BYTE $0xff       // movdqa       $-211(%rip), %xmm9  /* LCPI27_1(%rip) */
+	QUAD $0xffff34156f0f4466; BYTE $0xff       // movdqa       $-204(%rip), %xmm10  /* LCPI27_2(%rip) */
+	QUAD $0xffffff3c1d6f0f66                   // movdqa       $-196(%rip), %xmm3  /* LCPI27_3(%rip) */
+	QUAD $0xffffff44256f0f66                   // movdqa       $-188(%rip), %xmm4  /* LCPI27_4(%rip) */
+	QUAD $0xffffff4c2d6f0f66                   // movdqa       $-180(%rip), %xmm5  /* LCPI27_5(%rip) */
+	QUAD $0xffffff54356f0f66                   // movdqa       $-172(%rip), %xmm6  /* LCPI27_6(%rip) */
+	LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r9
+	LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r8
+	WORD $0x8949; BYTE $0xf6                   // movq         %rsi, %r14
+	WORD $0x9090; BYTE $0x90                   // .p2align 4, 0x90
+
+LBB27_9:
+	LONG $0x3c6f0ff3; BYTE $0x07   // movdqu       (%rdi,%rax), %xmm7
+	LONG $0xc76f0f66               // movdqa       %xmm7, %xmm0
+	LONG $0x740f4166; BYTE $0xc0   // pcmpeqb      %xmm8, %xmm0
+	LONG $0xcf6f0f66               // movdqa       %xmm7, %xmm1
+	LONG $0x740f4166; BYTE $0xc9   // pcmpeqb      %xmm9, %xmm1
+	LONG $0xc8eb0f66               // por          %xmm0, %xmm1
+	LONG $0xc76f0f66               // movdqa       %xmm7, %xmm0
+	LONG $0xfc0f4166; BYTE $0xc2   // paddb        %xmm10, %xmm0
+	LONG $0xd06f0f66               // movdqa       %xmm0, %xmm2
+	LONG $0xd3da0f66               // pminub       %xmm3, %xmm2
+	LONG $0xd0740f66               // pcmpeqb      %xmm0, %xmm2
+	LONG $0xc76f0f66               // movdqa       %xmm7, %xmm0
+	LONG $0xc4db0f66               // pand         %xmm4, %xmm0
+	LONG $0xc6740f66               // pcmpeqb      %xmm6, %xmm0
+	LONG $0xfd740f66               // pcmpeqb      %xmm5, %xmm7
+	LONG $0xd7d70f66               // pmovmskb     %xmm7, %edx
+	LONG $0xd70f4466; BYTE $0xf8   // pmovmskb     %xmm0, %r15d
+	LONG $0xd70f4466; BYTE $0xd9   // pmovmskb     %xmm1, %r11d
+	LONG $0xf8eb0f66               // por          %xmm0, %xmm7
+	LONG $0xf9eb0f66               // por          %xmm1, %xmm7
+	LONG $0xfaeb0f66               // por          %xmm2, %xmm7
+	LONG $0xcfd70f66               // pmovmskb     %xmm7, %ecx
+	WORD $0xd1f7                   // notl         %ecx
+	WORD $0xbc0f; BYTE $0xc9       // bsfl         %ecx, %ecx
+	WORD $0xf983; BYTE $0x10       // cmpl         $16, %ecx
+	LONG $0x0014840f; WORD $0x0000 // je           LBB27_11, $20(%rip)
+	LONG $0xffffffbb; BYTE $0xff   // movl         $-1, %ebx
+	WORD $0xe3d3                   // shll         %cl, %ebx
+	WORD $0xd3f7                   // notl         %ebx
+	WORD $0xda21                   // andl         %ebx, %edx
+	WORD $0x2141; BYTE $0xdf       // andl         %ebx, %r15d
+	WORD $0x2144; BYTE $0xdb       // andl         %r11d, %ebx
+	WORD $0x8941; BYTE $0xdb       // movl         %ebx, %r11d
+
+LBB27_11:
+	WORD $0x5a8d; BYTE $0xff       // leal         $-1(%rdx), %ebx
+	WORD $0xd321                   // andl         %edx, %ebx
+	LONG $0x020d850f; WORD $0x0000 // jne          LBB27_12, $525(%rip)
+	LONG $0xff5f8d41               // leal         $-1(%r15), %ebx
+	WORD $0x2144; BYTE $0xfb       // andl         %r15d, %ebx
+	LONG $0x0200850f; WORD $0x0000 // jne          LBB27_12, $512(%rip)
+	LONG $0xff5b8d41               // leal         $-1(%r11), %ebx
+	WORD $0x2144; BYTE $0xdb       // andl         %r11d, %ebx
+	LONG $0x01f3850f; WORD $0x0000 // jne          LBB27_12, $499(%rip)
+	WORD $0xd285                   // testl        %edx, %edx
+	LONG $0x0013840f; WORD $0x0000 // je           LBB27_19, $19(%rip)
+	WORD $0xbc0f; BYTE $0xd2       // bsfl         %edx, %edx
+	LONG $0xfff88349               // cmpq         $-1, %r8
+	LONG $0x01f4850f; WORD $0x0000 // jne          LBB27_56, $500(%rip)
+	WORD $0x0148; BYTE $0xc2       // addq         %rax, %rdx
+	WORD $0x8949; BYTE $0xd0       // movq         %rdx, %r8
+
+LBB27_19:
+	WORD $0x8545; BYTE $0xff       // testl        %r15d, %r15d
+	LONG $0x0014840f; WORD $0x0000 // je           LBB27_22, $20(%rip)
+	LONG $0xd7bc0f41               // bsfl         %r15d, %edx
+	LONG $0xfff98349               // cmpq         $-1, %r9
+	LONG $0x01d7850f; WORD $0x0000 // jne          LBB27_56, $471(%rip)
+	WORD $0x0148; BYTE $0xc2       // addq         %rax, %rdx
+	WORD $0x8949; BYTE $0xd1       // movq         %rdx, %r9
+
+LBB27_22:
+	WORD $0x8545; BYTE $0xdb       // testl        %r11d, %r11d
+	LONG $0x0014840f; WORD $0x0000 // je           LBB27_25, $20(%rip)
+	LONG $0xd3bc0f41               // bsfl         %r11d, %edx
+	LONG $0xfffa8349               // cmpq         $-1, %r10
+	LONG $0x01ba850f; WORD $0x0000 // jne          LBB27_56, $442(%rip)
+	WORD $0x0148; BYTE $0xc2       // addq         %rax, %rdx
+	WORD $0x8949; BYTE $0xd2       // movq         %rdx, %r10
+
+LBB27_25:
+	WORD $0xf983; BYTE $0x10       // cmpl         $16, %ecx
+	LONG $0x00c0850f; WORD $0x0000 // jne          LBB27_57, $192(%rip)
+	LONG $0xf0c68349               // addq         $-16, %r14
+	LONG $0x10c08348               // addq         $16, %rax
+	LONG $0x0ffe8349               // cmpq         $15, %r14
+	LONG $0xfeeb870f; WORD $0xffff // ja           LBB27_9, $-277(%rip)
+	LONG $0x070c8d48               // leaq         (%rdi,%rax), %rcx
+	WORD $0x8949; BYTE $0xcb       // movq         %rcx, %r11
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0x00a7840f; WORD $0x0000 // je           LBB27_41, $167(%rip)
+
+LBB27_28:
+	LONG $0x311c8d4e                           // leaq         (%rcx,%r14), %r11
+	WORD $0x8948; BYTE $0xce                   // movq         %rcx, %rsi
+	WORD $0x2948; BYTE $0xfe                   // subq         %rdi, %rsi
+	WORD $0xc031                               // xorl         %eax, %eax
+	LONG $0xa43d8d4c; WORD $0x0001; BYTE $0x00 // leaq         $420(%rip), %r15  /* LJTI27_0(%rip) */
+	LONG $0x00002fe9; BYTE $0x00               // jmp          LBB27_29, $47(%rip)
+
+LBB27_31:
+	WORD $0xfa83; BYTE $0x65       // cmpl         $101, %edx
+	LONG $0x009b850f; WORD $0x0000 // jne          LBB27_40, $155(%rip)
+
+LBB27_32:
+	LONG $0xfff98349                           // cmpq         $-1, %r9
+	LONG $0x0150850f; WORD $0x0000             // jne          LBB27_58, $336(%rip)
+	LONG $0x060c8d4c                           // leaq         (%rsi,%rax), %r9
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+LBB27_39:
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3949; BYTE $0xc6       // cmpq         %rax, %r14
+	LONG $0x0060840f; WORD $0x0000 // je           LBB27_41, $96(%rip)
+
+LBB27_29:
+	LONG $0x0114be0f               // movsbl       (%rcx,%rax), %edx
+	WORD $0x5a8d; BYTE $0xd0       // leal         $-48(%rdx), %ebx
+	WORD $0xfb83; BYTE $0x0a       // cmpl         $10, %ebx
+	LONG $0xffe4820f; WORD $0xffff // jb           LBB27_39, $-28(%rip)
+	WORD $0x5a8d; BYTE $0xd5       // leal         $-43(%rdx), %ebx
+	WORD $0xfb83; BYTE $0x1a       // cmpl         $26, %ebx
+	LONG $0xffb5870f; WORD $0xffff // ja           LBB27_31, $-75(%rip)
+	LONG $0x9f146349               // movslq       (%r15,%rbx,4), %rdx
+	WORD $0x014c; BYTE $0xfa       // addq         %r15, %rdx
+	JMP  DX
+
+LBB27_37:
+	LONG $0xfffa8349               // cmpq         $-1, %r10
+	LONG $0x0105850f; WORD $0x0000 // jne          LBB27_58, $261(%rip)
+	LONG $0x06148d4c               // leaq         (%rsi,%rax), %r10
+	LONG $0xffffbce9; BYTE $0xff   // jmp          LBB27_39, $-68(%rip)
+
+LBB27_35:
+	LONG $0xfff88349               // cmpq         $-1, %r8
+	LONG $0x00f2850f; WORD $0x0000 // jne          LBB27_58, $242(%rip)
+	LONG $0x06048d4c               // leaq         (%rsi,%rax), %r8
+	LONG $0xffffa9e9; BYTE $0xff   // jmp          LBB27_39, $-87(%rip)
+
+LBB27_1:
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0x00008fe9; BYTE $0x00               // jmp          LBB27_55, $143(%rip)
+
+LBB27_57:
+	WORD $0x8941; BYTE $0xcb // movl         %ecx, %r11d
+	WORD $0x0149; BYTE $0xfb // addq         %rdi, %r11
+	WORD $0x0149; BYTE $0xc3 // addq         %rax, %r11
+
+LBB27_41:
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x854d; BYTE $0xc0                   // testq        %r8, %r8
+	LONG $0x001b850f; WORD $0x0000             // jne          LBB27_42, $27(%rip)
+	LONG $0x000071e9; BYTE $0x00               // jmp          LBB27_55, $113(%rip)
+
+LBB27_40:
+	WORD $0x0148; BYTE $0xc1                   // addq         %rax, %rcx
+	WORD $0x8949; BYTE $0xcb                   // movq         %rcx, %r11
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x854d; BYTE $0xc0                   // testq        %r8, %r8
+	LONG $0x005b840f; WORD $0x0000             // je           LBB27_55, $91(%rip)
+
+LBB27_42:
+	WORD $0x854d; BYTE $0xd2       // testq        %r10, %r10
+	LONG $0x0052840f; WORD $0x0000 // je           LBB27_55, $82(%rip)
+	WORD $0x854d; BYTE $0xc9       // testq        %r9, %r9
+	LONG $0x0049840f; WORD $0x0000 // je           LBB27_55, $73(%rip)
+	WORD $0x2949; BYTE $0xfb       // subq         %rdi, %r11
+	LONG $0xff438d49               // leaq         $-1(%r11), %rax
+	WORD $0x3949; BYTE $0xc0       // cmpq         %rax, %r8
+	LONG $0x0033840f; WORD $0x0000 // je           LBB27_47, $51(%rip)
+	WORD $0x3949; BYTE $0xc2       // cmpq         %rax, %r10
+	LONG $0x002a840f; WORD $0x0000 // je           LBB27_47, $42(%rip)
+	WORD $0x3949; BYTE $0xc1       // cmpq         %rax, %r9
+	LONG $0x0021840f; WORD $0x0000 // je           LBB27_47, $33(%rip)
+	WORD $0x854d; BYTE $0xd2       // testq        %r10, %r10
+	LONG $0x00258e0f; WORD $0x0000 // jle          LBB27_51, $37(%rip)
+	LONG $0xff428d49               // leaq         $-1(%r10), %rax
+	WORD $0x3949; BYTE $0xc1       // cmpq         %rax, %r9
+	LONG $0x0018840f; WORD $0x0000 // je           LBB27_51, $24(%rip)
+	WORD $0xf749; BYTE $0xd2       // notq         %r10
+	WORD $0x894c; BYTE $0xd0       // movq         %r10, %rax
+	LONG $0x000006e9; BYTE $0x00   // jmp          LBB27_55, $6(%rip)
+
+LBB27_47:
+	WORD $0xf749; BYTE $0xdb // negq         %r11
+	WORD $0x894c; BYTE $0xd8 // movq         %r11, %rax
+
+LBB27_55:
+	BYTE $0x5b   // popq         %rbx
+	WORD $0x5e41 // popq         %r14
+	WORD $0x5f41 // popq         %r15
+	BYTE $0x5d   // popq         %rbp
+	BYTE $0xc3   // retq
+
+LBB27_51:
+	WORD $0x894c; BYTE $0xc0       // movq         %r8, %rax
+	WORD $0x094c; BYTE $0xc8       // orq          %r9, %rax
+	WORD $0x990f; BYTE $0xc0       // setns        %al
+	LONG $0x0014880f; WORD $0x0000 // js           LBB27_54, $20(%rip)
+	WORD $0x394d; BYTE $0xc8       // cmpq         %r9, %r8
+	LONG $0x000b8c0f; WORD $0x0000 // jl           LBB27_54, $11(%rip)
+	WORD $0xf749; BYTE $0xd0       // notq         %r8
+	WORD $0x894c; BYTE $0xc0       // movq         %r8, %rax
+	LONG $0xffffd6e9; BYTE $0xff   // jmp          LBB27_55, $-42(%rip)
+
+LBB27_54:
+	LONG $0xff498d49             // leaq         $-1(%r9), %rcx
+	WORD $0x3949; BYTE $0xc8     // cmpq         %rcx, %r8
+	WORD $0xf749; BYTE $0xd1     // notq         %r9
+	LONG $0xcb450f4d             // cmovneq      %r11, %r9
+	WORD $0xc084                 // testb        %al, %al
+	LONG $0xcb440f4d             // cmoveq       %r11, %r9
+	WORD $0x894c; BYTE $0xc8     // movq         %r9, %rax
+	LONG $0xffffbae9; BYTE $0xff // jmp          LBB27_55, $-70(%rip)
+
+LBB27_12:
+	WORD $0xbc0f; BYTE $0xcb     // bsfl         %ebx, %ecx
+	LONG $0x000010e9; BYTE $0x00 // jmp          LBB27_13, $16(%rip)
+
+LBB27_58:
+	WORD $0x2948; BYTE $0xcf     // subq         %rcx, %rdi
+	WORD $0xf748; BYTE $0xd0     // notq         %rax
+	WORD $0x0148; BYTE $0xf8     // addq         %rdi, %rax
+	LONG $0xffffa4e9; BYTE $0xff // jmp          LBB27_55, $-92(%rip)
+
+LBB27_56:
+	WORD $0xd189 // movl         %edx, %ecx
+
+LBB27_13:
+	WORD $0xf748; BYTE $0xd0     // notq         %rax
+	WORD $0x2948; BYTE $0xc8     // subq         %rcx, %rax
+	LONG $0xffff97e9; BYTE $0xff // jmp          LBB27_55, $-105(%rip)
+
+LBB27_7:
+	LONG $0xffc0c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r8
+	WORD $0x8948; BYTE $0xf9                   // movq         %rdi, %rcx
+	WORD $0x8949; BYTE $0xf6                   // movq         %rsi, %r14
+	LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r9
+	LONG $0xffc2c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r10
+	LONG $0xfffe4ae9; BYTE $0xff               // jmp          LBB27_28, $-438(%rip)
+	BYTE $0x90                                 // .p2align 2, 0x90
+
+	// .set L27_0_set_37, LBB27_37-LJTI27_0
+	// .set L27_0_set_40, LBB27_40-LJTI27_0
+	// .set L27_0_set_35, LBB27_35-LJTI27_0
+	// .set L27_0_set_32, LBB27_32-LJTI27_0
+LJTI27_0:
+	LONG $0xfffffeb5         // .long L27_0_set_37
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xfffffeb5         // .long L27_0_set_37
+	LONG $0xfffffec8         // .long L27_0_set_35
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xffffff05         // .long L27_0_set_40
+	LONG $0xfffffe6a         // .long L27_0_set_32
+	QUAD $0x9090909090909090 // .p2align 4, 0x90
+
+_skip_positive:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	BYTE $0x53                                 // pushq        %rbx
+	BYTE $0x50                                 // pushq        %rax
+	WORD $0x8949; BYTE $0xf6                   // movq         %rsi, %r14
+	WORD $0x8b4c; BYTE $0x3e                   // movq         (%rsi), %r15
+	LONG $0xff5f8d49                           // leaq         $-1(%r15), %rbx
+	WORD $0x8b48; BYTE $0x07                   // movq         (%rdi), %rax
+	WORD $0x0148; BYTE $0xd8                   // addq         %rbx, %rax
+	LONG $0x08778b48                           // movq         $8(%rdi), %rsi
+	WORD $0x2948; BYTE $0xde                   // subq         %rbx, %rsi
+	WORD $0x8948; BYTE $0xc7                   // movq         %rax, %rdi
+	LONG $0xfffbd7e8; BYTE $0xff               // callq        _do_skip_number, $-1065(%rip)
+	LONG $0xff508d48                           // leaq         $-1(%rax), %rdx
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0xfec6c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rsi
+	WORD $0x2948; BYTE $0xc6                   // subq         %rax, %rsi
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0xf2490f48                           // cmovnsq      %rdx, %rsi
+	LONG $0xcb490f48                           // cmovnsq      %rbx, %rcx
+	WORD $0x014c; BYTE $0xfe                   // addq         %r15, %rsi
+	WORD $0x8949; BYTE $0x36                   // movq         %rsi, (%r14)
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	LONG $0x08c48348                           // addq         $8, %rsp
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5e41                               // popq         %r14
+	WORD $0x5f41                               // popq         %r15
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+	WORD $0x9090; BYTE $0x90                   // .p2align 4, 0x90
+
+_skip_number:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5741                   // pushq        %r15
+	WORD $0x5641                   // pushq        %r14
+	WORD $0x5441                   // pushq        %r12
+	BYTE $0x53                     // pushq        %rbx
+	WORD $0x8949; BYTE $0xf6       // movq         %rsi, %r14
+	WORD $0x8b4c; BYTE $0x27       // movq         (%rdi), %r12
+	LONG $0x08778b48               // movq         $8(%rdi), %rsi
+	WORD $0x8b4d; BYTE $0x3e       // movq         (%r14), %r15
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x3c3c8043; BYTE $0x2d   // cmpb         $45, (%r12,%r15)
+	LONG $0x3c1c8d4b               // leaq         (%r12,%r15), %rbx
+	WORD $0x940f; BYTE $0xc0       // sete         %al
+	WORD $0x0148; BYTE $0xc3       // addq         %rax, %rbx
+	WORD $0x2948; BYTE $0xc6       // subq         %rax, %rsi
+	LONG $0x003c840f; WORD $0x0000 // je           LBB29_6, $60(%rip)
+	WORD $0x3949; BYTE $0xf7       // cmpq         %rsi, %r15
+	LONG $0x000d830f; WORD $0x0000 // jae          LBB29_3, $13(%rip)
+	WORD $0xb60f; BYTE $0x03       // movzbl       (%rbx), %eax
+	WORD $0xc604                   // addb         $-58, %al
+	WORD $0xf63c                   // cmpb         $-10, %al
+	LONG $0x0038820f; WORD $0x0000 // jb           LBB29_8, $56(%rip)
+
+LBB29_3:
+	WORD $0x8948; BYTE $0xdf       // movq         %rbx, %rdi
+	LONG $0xfffb50e8; BYTE $0xff   // callq        _do_skip_number, $-1200(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0021880f; WORD $0x0000 // js           LBB29_7, $33(%rip)
+	WORD $0x0148; BYTE $0xc3       // addq         %rax, %rbx
+
+LBB29_5:
+	WORD $0x294c; BYTE $0xe3 // subq         %r12, %rbx
+	WORD $0x8949; BYTE $0x1e // movq         %rbx, (%r14)
+	WORD $0x894c; BYTE $0xf8 // movq         %r15, %rax
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB29_6:
+	LONG $0xffc7c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r15
+	LONG $0xffffe2e9; BYTE $0xff               // jmp          LBB29_5, $-30(%rip)
+
+LBB29_7:
+	WORD $0xf748; BYTE $0xd0 // notq         %rax
+	WORD $0x0148; BYTE $0xc3 // addq         %rax, %rbx
+
+LBB29_8:
+	LONG $0xfec7c749; WORD $0xffff; BYTE $0xff // movq         $-2, %r15
+	LONG $0xffffd0e9; BYTE $0xff               // jmp          LBB29_5, $-48(%rip)
+	LONG $0x00000000                           // .p2align 4, 0x00
+
+LCPI30_0:
+	LONG $0x00000001 // .long 1
+	LONG $0x00000000 // .long 0
+	LONG $0x00000000 // .long 0
+	LONG $0x00000000 // .long 0
+
+	// .p2align 4, 0x90
+_skip_one:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x8948; BYTE $0xd0                   // movq         %rdx, %rax
+	WORD $0x8948; BYTE $0xf2                   // movq         %rsi, %rdx
+	WORD $0x8948; BYTE $0xfe                   // movq         %rdi, %rsi
+	LONG $0xdc05280f; WORD $0xffff; BYTE $0xff // movaps       $-36(%rip), %xmm0  /* LCPI30_0(%rip) */
+	WORD $0x110f; BYTE $0x00                   // movups       %xmm0, (%rax)
+	WORD $0x8948; BYTE $0xc7                   // movq         %rax, %rdi
+	BYTE $0x5d                                 // popq         %rbp
+	LONG $0xfff250e9; BYTE $0xff               // jmp          _fsm_exec, $-3504(%rip)
+
+	// .p2align 4, 0x00
+LCPI31_0:
+	LONG $0x00000001 // .long 1
+	LONG $0x00000000 // .long 0
+	LONG $0x00000000 // .long 0
+	LONG $0x00000000 // .long 0
+
+	// .p2align 4, 0x90
+_validate_one:
+	BYTE $0x55                                         // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                           // movq         %rsp, %rbp
+	WORD $0x8948; BYTE $0xd0                           // movq         %rdx, %rax
+	WORD $0x8948; BYTE $0xf2                           // movq         %rsi, %rdx
+	WORD $0x8948; BYTE $0xfe                           // movq         %rdi, %rsi
+	LONG $0xdc05280f; WORD $0xffff; BYTE $0xff         // movaps       $-36(%rip), %xmm0  /* LCPI31_0(%rip) */
+	WORD $0x110f; BYTE $0x00                           // movups       %xmm0, (%rax)
+	LONG $0x000020b9; BYTE $0x00                       // movl         $32, %ecx
+	WORD $0x8948; BYTE $0xc7                           // movq         %rax, %rdi
+	BYTE $0x5d                                         // popq         %rbp
+	LONG $0xfff21be9; BYTE $0xff                       // jmp          _fsm_exec, $-3557(%rip)
+	QUAD $0x0000000000000000; WORD $0x0000; BYTE $0x00 // .p2align 4, 0x00
+
+LCPI32_0:
+	QUAD $0x2c2c2c2c2c2c2c2c; QUAD $0x2c2c2c2c2c2c2c2c // .space 16, ',,,,,,,,,,,,,,,,'
+
+LCPI32_1:
+	QUAD $0xdfdfdfdfdfdfdfdf; QUAD $0xdfdfdfdfdfdfdfdf // .space 16, '\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf\xdf'
+
+LCPI32_2:
+	QUAD $0x5d5d5d5d5d5d5d5d; QUAD $0x5d5d5d5d5d5d5d5d // .space 16, ']]]]]]]]]]]]]]]]'
+
+LCPI32_3:
+	QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
+
+LCPI32_4:
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+
+LCPI32_5:
+	QUAD $0x7b7b7b7b7b7b7b7b; QUAD $0x7b7b7b7b7b7b7b7b // .space 16, '{{{{{{{{{{{{{{{{'
+
+LCPI32_6:
+	QUAD $0x7d7d7d7d7d7d7d7d; QUAD $0x7d7d7d7d7d7d7d7d // .space 16, '}}}}}}}}}}}}}}}}'
+
+LCPI32_7:
+	QUAD $0x5b5b5b5b5b5b5b5b; QUAD $0x5b5b5b5b5b5b5b5b // .space 16, '[[[[[[[[[[[[[[[['
+
+	// .p2align 4, 0x90
+_skip_one_fast:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x68ec8348                           // subq         $104, %rsp
+	WORD $0x8949; BYTE $0xf5                   // movq         %rsi, %r13
+	WORD $0x8949; BYTE $0xfe                   // movq         %rdi, %r14
+	WORD $0x8b48; BYTE $0x3f                   // movq         (%rdi), %rdi
+	LONG $0x08768b49                           // movq         $8(%r14), %rsi
+	WORD $0x894c; BYTE $0xea                   // movq         %r13, %rdx
+	LONG $0xffe01ae8; BYTE $0xff               // callq        _advance_ns, $-8166(%rip)
+	LONG $0x00558b49                           // movq         (%r13), %rdx
+	LONG $0xff428d4c                           // leaq         $-1(%rdx), %r8
+	WORD $0xbe0f; BYTE $0xc8                   // movsbl       %al, %ecx
+	WORD $0xf983; BYTE $0x7b                   // cmpl         $123, %ecx
+	LONG $0x0119870f; WORD $0x0000             // ja           LBB32_19, $281(%rip)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0x80358d48; WORD $0x000b; BYTE $0x00 // leaq         $2944(%rip), %rsi  /* LJTI32_0(%rip) */
+	LONG $0x8e0c6348                           // movslq       (%rsi,%rcx,4), %rcx
+	WORD $0x0148; BYTE $0xf1                   // addq         %rsi, %rcx
+	JMP  CX
+
+LBB32_2:
+	WORD $0x8b49; BYTE $0x06               // movq         (%r14), %rax
+	LONG $0x084e8b49                       // movq         $8(%r14), %rcx
+	WORD $0x8948; BYTE $0xce               // movq         %rcx, %rsi
+	WORD $0x2948; BYTE $0xd6               // subq         %rdx, %rsi
+	LONG $0x10fe8348                       // cmpq         $16, %rsi
+	LONG $0x0ab0820f; WORD $0x0000         // jb           LBB32_84, $2736(%rip)
+	WORD $0x8948; BYTE $0xd6               // movq         %rdx, %rsi
+	WORD $0xf748; BYTE $0xde               // negq         %rsi
+	QUAD $0xffffff0a056f0f66               // movdqa       $-246(%rip), %xmm0  /* LCPI32_0(%rip) */
+	QUAD $0xffffff120d6f0f66               // movdqa       $-238(%rip), %xmm1  /* LCPI32_1(%rip) */
+	QUAD $0xffffff1a156f0f66               // movdqa       $-230(%rip), %xmm2  /* LCPI32_2(%rip) */
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB32_4:
+	LONG $0x1c6f0ff3; BYTE $0x10   // movdqu       (%rax,%rdx), %xmm3
+	LONG $0xe36f0f66               // movdqa       %xmm3, %xmm4
+	LONG $0xe0740f66               // pcmpeqb      %xmm0, %xmm4
+	LONG $0xd9db0f66               // pand         %xmm1, %xmm3
+	LONG $0xda740f66               // pcmpeqb      %xmm2, %xmm3
+	LONG $0xdceb0f66               // por          %xmm4, %xmm3
+	LONG $0xfbd70f66               // pmovmskb     %xmm3, %edi
+	WORD $0xff85                   // testl        %edi, %edi
+	LONG $0x006b850f; WORD $0x0000 // jne          LBB32_14, $107(%rip)
+	LONG $0x10c28348               // addq         $16, %rdx
+	LONG $0x313c8d48               // leaq         (%rcx,%rsi), %rdi
+	LONG $0xf0c78348               // addq         $-16, %rdi
+	LONG $0xf0c68348               // addq         $-16, %rsi
+	LONG $0x0fff8348               // cmpq         $15, %rdi
+	LONG $0xffc1870f; WORD $0xffff // ja           LBB32_4, $-63(%rip)
+	WORD $0x8948; BYTE $0xc2       // movq         %rax, %rdx
+	WORD $0x2948; BYTE $0xf2       // subq         %rsi, %rdx
+	WORD $0x0148; BYTE $0xf1       // addq         %rsi, %rcx
+	WORD $0x8948; BYTE $0xce       // movq         %rcx, %rsi
+	WORD $0x8548; BYTE $0xf6       // testq        %rsi, %rsi
+	LONG $0x0034840f; WORD $0x0000 // je           LBB32_13, $52(%rip)
+
+LBB32_7:
+	LONG $0x323c8d48 // leaq         (%rdx,%rsi), %rdi
+	WORD $0xc931     // xorl         %ecx, %ecx
+
+LBB32_8:
+	LONG $0x0a1cb60f               // movzbl       (%rdx,%rcx), %ebx
+	WORD $0xfb83; BYTE $0x2c       // cmpl         $44, %ebx
+	LONG $0x09f5840f; WORD $0x0000 // je           LBB32_82, $2549(%rip)
+	WORD $0xfb83; BYTE $0x7d       // cmpl         $125, %ebx
+	LONG $0x09ec840f; WORD $0x0000 // je           LBB32_82, $2540(%rip)
+	WORD $0xfb83; BYTE $0x5d       // cmpl         $93, %ebx
+	LONG $0x09e3840f; WORD $0x0000 // je           LBB32_82, $2531(%rip)
+	WORD $0xff48; BYTE $0xc1       // incq         %rcx
+	WORD $0x3948; BYTE $0xce       // cmpq         %rcx, %rsi
+	LONG $0xffd5850f; WORD $0xffff // jne          LBB32_8, $-43(%rip)
+	WORD $0x8948; BYTE $0xfa       // movq         %rdi, %rdx
+
+LBB32_13:
+	WORD $0x2948; BYTE $0xc2     // subq         %rax, %rdx
+	LONG $0x0009d2e9; BYTE $0x00 // jmp          LBB32_83, $2514(%rip)
+
+LBB32_14:
+	LONG $0xc7bc0f66         // bsfw         %di, %ax
+	WORD $0xb70f; BYTE $0xc0 // movzwl       %ax, %eax
+	WORD $0x2948; BYTE $0xf0 // subq         %rsi, %rax
+
+LBB32_15:
+	LONG $0x00458949 // movq         %rax, (%r13)
+
+LBB32_16:
+	WORD $0x894c; BYTE $0xc0 // movq         %r8, %rax
+
+LBB32_17:
+	LONG $0x68c48348 // addq         $104, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5d41     // popq         %r13
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB32_18:
+	LONG $0x03c28348               // addq         $3, %rdx
+	LONG $0x08563b49               // cmpq         $8(%r14), %rdx
+	LONG $0xffe3830f; WORD $0xffff // jae          LBB32_17, $-29(%rip)
+	LONG $0x00099fe9; BYTE $0x00   // jmp          LBB32_83, $2463(%rip)
+
+LBB32_19:
+	LONG $0x0045894d                           // movq         %r8, (%r13)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+	LONG $0xffffcee9; BYTE $0xff               // jmp          LBB32_17, $-50(%rip)
+
+LBB32_20:
+	WORD $0x8b49; BYTE $0x0e       // movq         (%r14), %rcx
+	LONG $0x084e8b4d               // movq         $8(%r14), %r9
+	LONG $0xd04d8948               // movq         %rcx, $-48(%rbp)
+	LONG $0x11148d4c               // leaq         (%rcx,%rdx), %r10
+	WORD $0x2949; BYTE $0xd1       // subq         %rdx, %r9
+	LONG $0x20f98349               // cmpq         $32, %r9
+	LONG $0x098b820f; WORD $0x0000 // jb           LBB32_28, $2443(%rip)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	QUAD $0xfffffe26056f0f66       // movdqa       $-474(%rip), %xmm0  /* LCPI32_3(%rip) */
+	QUAD $0xfffffe2e0d6f0f66       // movdqa       $-466(%rip), %xmm1  /* LCPI32_4(%rip) */
+	WORD $0x3145; BYTE $0xe4       // xorl         %r12d, %r12d
+	WORD $0x3145; BYTE $0xdb       // xorl         %r11d, %r11d
+	LONG $0x000029e9; BYTE $0x00   // jmp          LBB32_22, $41(%rip)
+	WORD $0x9090; BYTE $0x90       // .p2align 4, 0x90
+
+LBB32_24:
+	WORD $0x3145; BYTE $0xdb       // xorl         %r11d, %r11d
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x00a5850f; WORD $0x0000 // jne          LBB32_81, $165(%rip)
+
+LBB32_25:
+	LONG $0x20c48349               // addq         $32, %r12
+	LONG $0x310c8d4b               // leaq         (%r9,%r14), %rcx
+	LONG $0xe0c18348               // addq         $-32, %rcx
+	LONG $0xe0c68349               // addq         $-32, %r14
+	LONG $0x1ff98348               // cmpq         $31, %rcx
+	LONG $0x0935860f; WORD $0x0000 // jbe          LBB32_26, $2357(%rip)
+
+LBB32_22:
+	LONG $0x6f0f43f3; WORD $0x2214             // movdqu       (%r10,%r12), %xmm2
+	LONG $0x6f0f43f3; WORD $0x225c; BYTE $0x10 // movdqu       $16(%r10,%r12), %xmm3
+	LONG $0xe26f0f66                           // movdqa       %xmm2, %xmm4
+	LONG $0xe0740f66                           // pcmpeqb      %xmm0, %xmm4
+	LONG $0xfcd70f66                           // pmovmskb     %xmm4, %edi
+	LONG $0xe36f0f66                           // movdqa       %xmm3, %xmm4
+	LONG $0xe0740f66                           // pcmpeqb      %xmm0, %xmm4
+	LONG $0xccd70f66                           // pmovmskb     %xmm4, %ecx
+	LONG $0x10e1c148                           // shlq         $16, %rcx
+	WORD $0x0948; BYTE $0xf9                   // orq          %rdi, %rcx
+	LONG $0xd1740f66                           // pcmpeqb      %xmm1, %xmm2
+	LONG $0xf2d70f66                           // pmovmskb     %xmm2, %esi
+	LONG $0xd9740f66                           // pcmpeqb      %xmm1, %xmm3
+	LONG $0xfbd70f66                           // pmovmskb     %xmm3, %edi
+	LONG $0x10e7c148                           // shlq         $16, %rdi
+	WORD $0x0948; BYTE $0xf7                   // orq          %rsi, %rdi
+	WORD $0x8948; BYTE $0xfe                   // movq         %rdi, %rsi
+	WORD $0x094c; BYTE $0xde                   // orq          %r11, %rsi
+	LONG $0xff8b840f; WORD $0xffff             // je           LBB32_24, $-117(%rip)
+	WORD $0x8944; BYTE $0xde                   // movl         %r11d, %esi
+	WORD $0xd6f7                               // notl         %esi
+	WORD $0xfe21                               // andl         %edi, %esi
+	LONG $0x363c8d44                           // leal         (%rsi,%rsi), %r15d
+	WORD $0x0945; BYTE $0xdf                   // orl          %r11d, %r15d
+	WORD $0x8944; BYTE $0xfb                   // movl         %r15d, %ebx
+	WORD $0xd3f7                               // notl         %ebx
+	WORD $0xfb21                               // andl         %edi, %ebx
+	LONG $0xaaaae381; WORD $0xaaaa             // andl         $-1431655766, %ebx
+	WORD $0x3145; BYTE $0xdb                   // xorl         %r11d, %r11d
+	WORD $0xf301                               // addl         %esi, %ebx
+	LONG $0xc3920f41                           // setb         %r11b
+	WORD $0xdb01                               // addl         %ebx, %ebx
+	LONG $0x5555f381; WORD $0x5555             // xorl         $1431655765, %ebx
+	WORD $0x2144; BYTE $0xfb                   // andl         %r15d, %ebx
+	WORD $0xd3f7                               // notl         %ebx
+	WORD $0xd921                               // andl         %ebx, %ecx
+	WORD $0x8548; BYTE $0xc9                   // testq        %rcx, %rcx
+	LONG $0xff5b840f; WORD $0xffff             // je           LBB32_25, $-165(%rip)
+
+LBB32_81:
+	WORD $0xbc0f; BYTE $0xc1     // bsfl         %ecx, %eax
+	WORD $0x0148; BYTE $0xd0     // addq         %rdx, %rax
+	WORD $0x014c; BYTE $0xe0     // addq         %r12, %rax
+	WORD $0xff48; BYTE $0xc0     // incq         %rax
+	LONG $0xfffec8e9; BYTE $0xff // jmp          LBB32_15, $-312(%rip)
+
+LBB32_29:
+	LONG $0xb845894c                       // movq         %r8, $-72(%rbp)
+	LONG $0xc86d894c                       // movq         %r13, $-56(%rbp)
+	LONG $0x084e8b49                       // movq         $8(%r14), %rcx
+	WORD $0x2948; BYTE $0xd1               // subq         %rdx, %rcx
+	WORD $0x0349; BYTE $0x16               // addq         (%r14), %rdx
+	QUAD $0x555555555555bb49; WORD $0x5555 // movabsq      $6148914691236517205, %r11
+	WORD $0x3145; BYTE $0xe4               // xorl         %r12d, %r12d
+	QUAD $0xfffd36156f0f4466; BYTE $0xff   // movdqa       $-714(%rip), %xmm10  /* LCPI32_4(%rip) */
+	QUAD $0xfffffd1e0d6f0f66               // movdqa       $-738(%rip), %xmm1  /* LCPI32_3(%rip) */
+	LONG $0x760f4566; BYTE $0xc9           // pcmpeqd      %xmm9, %xmm9
+	QUAD $0xfffffd511d6f0f66               // movdqa       $-687(%rip), %xmm3  /* LCPI32_7(%rip) */
+	QUAD $0xfffffcf9256f0f66               // movdqa       $-775(%rip), %xmm4  /* LCPI32_2(%rip) */
+	QUAD $0x333333333333bf49; WORD $0x3333 // movabsq      $3689348814741910323, %r15
+	LONG $0xc0570f45                       // xorps        %xmm8, %xmm8
+	WORD $0x3145; BYTE $0xd2               // xorl         %r10d, %r10d
+	WORD $0x3145; BYTE $0xed               // xorl         %r13d, %r13d
+	WORD $0x3145; BYTE $0xc9               // xorl         %r9d, %r9d
+	LONG $0x40f98348                       // cmpq         $64, %rcx
+	LONG $0xd04d8948                       // movq         %rcx, $-48(%rbp)
+	LONG $0x02748c0f; WORD $0x0000         // jl           LBB32_38, $628(%rip)
+
+LBB32_32:
+	LONG $0x026f0ff3                           // movdqu       (%rdx), %xmm0
+	LONG $0x6a6f0ff3; BYTE $0x10               // movdqu       $16(%rdx), %xmm5
+	LONG $0x7a6f0ff3; BYTE $0x20               // movdqu       $32(%rdx), %xmm7
+	LONG $0x726f0ff3; BYTE $0x30               // movdqu       $48(%rdx), %xmm6
+	LONG $0xd06f0f66                           // movdqa       %xmm0, %xmm2
+	LONG $0x740f4166; BYTE $0xd2               // pcmpeqb      %xmm10, %xmm2
+	LONG $0xfad70f66                           // pmovmskb     %xmm2, %edi
+	LONG $0xd56f0f66                           // movdqa       %xmm5, %xmm2
+	LONG $0x740f4166; BYTE $0xd2               // pcmpeqb      %xmm10, %xmm2
+	LONG $0xf2d70f66                           // pmovmskb     %xmm2, %esi
+	LONG $0xd76f0f66                           // movdqa       %xmm7, %xmm2
+	LONG $0x740f4166; BYTE $0xd2               // pcmpeqb      %xmm10, %xmm2
+	LONG $0xcad70f66                           // pmovmskb     %xmm2, %ecx
+	LONG $0xd66f0f66                           // movdqa       %xmm6, %xmm2
+	LONG $0x740f4166; BYTE $0xd2               // pcmpeqb      %xmm10, %xmm2
+	LONG $0xdad70f66                           // pmovmskb     %xmm2, %ebx
+	LONG $0x30e3c148                           // shlq         $48, %rbx
+	LONG $0x20e1c148                           // shlq         $32, %rcx
+	WORD $0x0948; BYTE $0xd9                   // orq          %rbx, %rcx
+	LONG $0x10e6c148                           // shlq         $16, %rsi
+	WORD $0x0948; BYTE $0xce                   // orq          %rcx, %rsi
+	WORD $0x0948; BYTE $0xf7                   // orq          %rsi, %rdi
+	WORD $0x8948; BYTE $0xf9                   // movq         %rdi, %rcx
+	WORD $0x094c; BYTE $0xd1                   // orq          %r10, %rcx
+	LONG $0x0012850f; WORD $0x0000             // jne          LBB32_34, $18(%rip)
+	LONG $0xffc7c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rdi
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0xc04d8948                           // movq         %rcx, $-64(%rbp)
+	LONG $0x00003fe9; BYTE $0x00               // jmp          LBB32_35, $63(%rip)
+
+LBB32_34:
+	WORD $0x894c; BYTE $0xd1               // movq         %r10, %rcx
+	WORD $0xf748; BYTE $0xd1               // notq         %rcx
+	WORD $0x2148; BYTE $0xf9               // andq         %rdi, %rcx
+	LONG $0x09048d4c                       // leaq         (%rcx,%rcx), %r8
+	WORD $0x094d; BYTE $0xd0               // orq          %r10, %r8
+	WORD $0x894c; BYTE $0xc6               // movq         %r8, %rsi
+	WORD $0xf748; BYTE $0xd6               // notq         %rsi
+	QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq      $-6148914691236517206, %rbx
+	WORD $0x2148; BYTE $0xdf               // andq         %rbx, %rdi
+	WORD $0x2148; BYTE $0xf7               // andq         %rsi, %rdi
+	WORD $0xf631                           // xorl         %esi, %esi
+	WORD $0x0148; BYTE $0xcf               // addq         %rcx, %rdi
+	LONG $0xc6920f40                       // setb         %sil
+	LONG $0xc0758948                       // movq         %rsi, $-64(%rbp)
+	WORD $0x0148; BYTE $0xff               // addq         %rdi, %rdi
+	WORD $0x314c; BYTE $0xdf               // xorq         %r11, %rdi
+	WORD $0x214c; BYTE $0xc7               // andq         %r8, %rdi
+	WORD $0xf748; BYTE $0xd7               // notq         %rdi
+
+LBB32_35:
+	LONG $0xd66f0f66                           // movdqa       %xmm6, %xmm2
+	LONG $0xd1740f66                           // pcmpeqb      %xmm1, %xmm2
+	LONG $0xcad70f66                           // pmovmskb     %xmm2, %ecx
+	LONG $0x30e1c148                           // shlq         $48, %rcx
+	LONG $0xd76f0f66                           // movdqa       %xmm7, %xmm2
+	LONG $0xd1740f66                           // pcmpeqb      %xmm1, %xmm2
+	LONG $0xf2d70f66                           // pmovmskb     %xmm2, %esi
+	LONG $0x20e6c148                           // shlq         $32, %rsi
+	WORD $0x0948; BYTE $0xce                   // orq          %rcx, %rsi
+	LONG $0xd56f0f66                           // movdqa       %xmm5, %xmm2
+	LONG $0xd1740f66                           // pcmpeqb      %xmm1, %xmm2
+	LONG $0xcad70f66                           // pmovmskb     %xmm2, %ecx
+	LONG $0x10e1c148                           // shlq         $16, %rcx
+	WORD $0x0948; BYTE $0xf1                   // orq          %rsi, %rcx
+	LONG $0xd06f0f66                           // movdqa       %xmm0, %xmm2
+	LONG $0xd1740f66                           // pcmpeqb      %xmm1, %xmm2
+	LONG $0xf2d70f66                           // pmovmskb     %xmm2, %esi
+	WORD $0x0948; BYTE $0xce                   // orq          %rcx, %rsi
+	WORD $0x2148; BYTE $0xfe                   // andq         %rdi, %rsi
+	LONG $0x6e0f4866; BYTE $0xd6               // movq         %rsi, %xmm2
+	LONG $0x3a0f4166; WORD $0xd144; BYTE $0x00 // pclmulqdq    $0, %xmm9, %xmm2
+	LONG $0x7e0f4966; BYTE $0xd0               // movq         %xmm2, %r8
+	WORD $0x314d; BYTE $0xe0                   // xorq         %r12, %r8
+	LONG $0xd06f0f66                           // movdqa       %xmm0, %xmm2
+	LONG $0xd3740f66                           // pcmpeqb      %xmm3, %xmm2
+	LONG $0xd70f4466; BYTE $0xd2               // pmovmskb     %xmm2, %r10d
+	LONG $0xd56f0f66                           // movdqa       %xmm5, %xmm2
+	LONG $0xd3740f66                           // pcmpeqb      %xmm3, %xmm2
+	LONG $0xcad70f66                           // pmovmskb     %xmm2, %ecx
+	LONG $0xd76f0f66                           // movdqa       %xmm7, %xmm2
+	LONG $0xd3740f66                           // pcmpeqb      %xmm3, %xmm2
+	LONG $0xf2d70f66                           // pmovmskb     %xmm2, %esi
+	LONG $0xd66f0f66                           // movdqa       %xmm6, %xmm2
+	LONG $0xd3740f66                           // pcmpeqb      %xmm3, %xmm2
+	LONG $0xfad70f66                           // pmovmskb     %xmm2, %edi
+	LONG $0x30e7c148                           // shlq         $48, %rdi
+	LONG $0x20e6c148                           // shlq         $32, %rsi
+	WORD $0x0948; BYTE $0xfe                   // orq          %rdi, %rsi
+	LONG $0x10e1c148                           // shlq         $16, %rcx
+	WORD $0x0948; BYTE $0xf1                   // orq          %rsi, %rcx
+	WORD $0x0949; BYTE $0xca                   // orq          %rcx, %r10
+	WORD $0x894d; BYTE $0xc4                   // movq         %r8, %r12
+	WORD $0xf749; BYTE $0xd4                   // notq         %r12
+	WORD $0x214d; BYTE $0xe2                   // andq         %r12, %r10
+	LONG $0xc4740f66                           // pcmpeqb      %xmm4, %xmm0
+	LONG $0xf8d70f66                           // pmovmskb     %xmm0, %edi
+	LONG $0xec740f66                           // pcmpeqb      %xmm4, %xmm5
+	LONG $0xcdd70f66                           // pmovmskb     %xmm5, %ecx
+	LONG $0xfc740f66                           // pcmpeqb      %xmm4, %xmm7
+	LONG $0xdfd70f66                           // pmovmskb     %xmm7, %ebx
+	LONG $0xf4740f66                           // pcmpeqb      %xmm4, %xmm6
+	LONG $0xf6d70f66                           // pmovmskb     %xmm6, %esi
+	LONG $0x30e6c148                           // shlq         $48, %rsi
+	LONG $0x20e3c148                           // shlq         $32, %rbx
+	WORD $0x0948; BYTE $0xf3                   // orq          %rsi, %rbx
+	LONG $0x10e1c148                           // shlq         $16, %rcx
+	WORD $0x0948; BYTE $0xd9                   // orq          %rbx, %rcx
+	WORD $0x0948; BYTE $0xcf                   // orq          %rcx, %rdi
+	QUAD $0x0f0f0f0f0f0fbb48; WORD $0x0f0f     // movabsq      $1085102592571150095, %rbx
+	WORD $0x214c; BYTE $0xe7                   // andq         %r12, %rdi
+	LONG $0x0065840f; WORD $0x0000             // je           LBB32_30, $101(%rip)
+	QUAD $0x9090909090909090                   // .p2align 4, 0x90
+
+LBB32_36:
+	LONG $0xff678d4c                       // leaq         $-1(%rdi), %r12
+	WORD $0x894c; BYTE $0xe1               // movq         %r12, %rcx
+	WORD $0x214c; BYTE $0xd1               // andq         %r10, %rcx
+	WORD $0x8948; BYTE $0xce               // movq         %rcx, %rsi
+	WORD $0xd148; BYTE $0xee               // shrq         %rsi
+	WORD $0x214c; BYTE $0xde               // andq         %r11, %rsi
+	WORD $0x2948; BYTE $0xf1               // subq         %rsi, %rcx
+	WORD $0x8948; BYTE $0xce               // movq         %rcx, %rsi
+	WORD $0x214c; BYTE $0xfe               // andq         %r15, %rsi
+	LONG $0x02e9c148                       // shrq         $2, %rcx
+	WORD $0x214c; BYTE $0xf9               // andq         %r15, %rcx
+	WORD $0x0148; BYTE $0xf1               // addq         %rsi, %rcx
+	WORD $0x8948; BYTE $0xce               // movq         %rcx, %rsi
+	LONG $0x04eec148                       // shrq         $4, %rsi
+	WORD $0x0148; BYTE $0xce               // addq         %rcx, %rsi
+	WORD $0x2148; BYTE $0xde               // andq         %rbx, %rsi
+	QUAD $0x010101010101b948; WORD $0x0101 // movabsq      $72340172838076673, %rcx
+	LONG $0xf1af0f48                       // imulq        %rcx, %rsi
+	LONG $0x38eec148                       // shrq         $56, %rsi
+	WORD $0x014c; BYTE $0xee               // addq         %r13, %rsi
+	WORD $0x394c; BYTE $0xce               // cmpq         %r9, %rsi
+	LONG $0x05dd860f; WORD $0x0000         // jbe          LBB32_80, $1501(%rip)
+	WORD $0xff49; BYTE $0xc1               // incq         %r9
+	WORD $0x214c; BYTE $0xe7               // andq         %r12, %rdi
+	LONG $0xffa3850f; WORD $0xffff         // jne          LBB32_36, $-93(%rip)
+
+LBB32_30:
+	LONG $0x3ff8c149                       // sarq         $63, %r8
+	WORD $0x894c; BYTE $0xd1               // movq         %r10, %rcx
+	WORD $0xd148; BYTE $0xe9               // shrq         %rcx
+	WORD $0x214c; BYTE $0xd9               // andq         %r11, %rcx
+	WORD $0x2949; BYTE $0xca               // subq         %rcx, %r10
+	WORD $0x894c; BYTE $0xd1               // movq         %r10, %rcx
+	WORD $0x214c; BYTE $0xf9               // andq         %r15, %rcx
+	LONG $0x02eac149                       // shrq         $2, %r10
+	WORD $0x214d; BYTE $0xfa               // andq         %r15, %r10
+	WORD $0x0149; BYTE $0xca               // addq         %rcx, %r10
+	WORD $0x894c; BYTE $0xd1               // movq         %r10, %rcx
+	LONG $0x04e9c148                       // shrq         $4, %rcx
+	WORD $0x014c; BYTE $0xd1               // addq         %r10, %rcx
+	WORD $0x2148; BYTE $0xd9               // andq         %rbx, %rcx
+	QUAD $0x010101010101be48; WORD $0x0101 // movabsq      $72340172838076673, %rsi
+	LONG $0xceaf0f48                       // imulq        %rsi, %rcx
+	LONG $0x38e9c148                       // shrq         $56, %rcx
+	WORD $0x0149; BYTE $0xcd               // addq         %rcx, %r13
+	LONG $0x40c28348                       // addq         $64, %rdx
+	LONG $0xd04d8b48                       // movq         $-48(%rbp), %rcx
+	LONG $0xc0c18348                       // addq         $-64, %rcx
+	WORD $0x894d; BYTE $0xc4               // movq         %r8, %r12
+	LONG $0xc0558b4c                       // movq         $-64(%rbp), %r10
+	LONG $0x40f98348                       // cmpq         $64, %rcx
+	LONG $0xd04d8948                       // movq         %rcx, $-48(%rbp)
+	LONG $0xfd8c8d0f; WORD $0xffff         // jge          LBB32_32, $-628(%rip)
+
+LBB32_38:
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x05e08e0f; WORD $0x0000 // jle          LBB32_85, $1504(%rip)
+	WORD $0x894c; BYTE $0xd7       // movq         %r10, %rdi
+	LONG $0x45110f44; BYTE $0xa0   // movups       %xmm8, $-96(%rbp)
+	LONG $0x45110f44; BYTE $0x90   // movups       %xmm8, $-112(%rbp)
+	LONG $0x45110f44; BYTE $0x80   // movups       %xmm8, $-128(%rbp)
+	QUAD $0xffffff7085110f44       // movups       %xmm8, $-144(%rbp)
+	WORD $0xd189                   // movl         %edx, %ecx
+	LONG $0x0fffe181; WORD $0x0000 // andl         $4095, %ecx
+	LONG $0x0fc1f981; WORD $0x0000 // cmpl         $4033, %ecx
+	LONG $0x0036820f; WORD $0x0000 // jb           LBB32_42, $54(%rip)
+	LONG $0xd07d8348; BYTE $0x20   // cmpq         $32, $-48(%rbp)
+	LONG $0x0033820f; WORD $0x0000 // jb           LBB32_43, $51(%rip)
+	LONG $0x026f0ff3               // movdqu       (%rdx), %xmm0
+	LONG $0x526f0ff3; BYTE $0x10   // movdqu       $16(%rdx), %xmm2
+	QUAD $0xffffff70857f0ff3       // movdqu       %xmm0, $-144(%rbp)
+	LONG $0x557f0ff3; BYTE $0x80   // movdqu       %xmm2, $-128(%rbp)
+	LONG $0x20c28348               // addq         $32, %rdx
+	LONG $0xd04d8b48               // movq         $-48(%rbp), %rcx
+	LONG $0xe0518d4c               // leaq         $-32(%rcx), %r10
+	LONG $0x90458d4c               // leaq         $-112(%rbp), %r8
+	LONG $0x000013e9; BYTE $0x00   // jmp          LBB32_44, $19(%rip)
+
+LBB32_42:
+	WORD $0x8949; BYTE $0xfa     // movq         %rdi, %r10
+	LONG $0xfffd17e9; BYTE $0xff // jmp          LBB32_32, $-745(%rip)
+
+LBB32_43:
+	LONG $0x70858d4c; WORD $0xffff; BYTE $0xff // leaq         $-144(%rbp), %r8
+	LONG $0xd0558b4c                           // movq         $-48(%rbp), %r10
+
+LBB32_44:
+	LONG $0x10fa8349               // cmpq         $16, %r10
+	LONG $0x0049820f; WORD $0x0000 // jb           LBB32_45, $73(%rip)
+	LONG $0x026f0ff3               // movdqu       (%rdx), %xmm0
+	LONG $0x7f0f41f3; BYTE $0x00   // movdqu       %xmm0, (%r8)
+	LONG $0x10c28348               // addq         $16, %rdx
+	LONG $0x10c08349               // addq         $16, %r8
+	LONG $0xf0c28349               // addq         $-16, %r10
+	LONG $0x08fa8349               // cmpq         $8, %r10
+	LONG $0x0034830f; WORD $0x0000 // jae          LBB32_52, $52(%rip)
+
+LBB32_46:
+	LONG $0x04fa8349               // cmpq         $4, %r10
+	LONG $0x0046820f; WORD $0x0000 // jb           LBB32_47, $70(%rip)
+
+LBB32_53:
+	WORD $0x0a8b                   // movl         (%rdx), %ecx
+	WORD $0x8941; BYTE $0x08       // movl         %ecx, (%r8)
+	LONG $0x04c28348               // addq         $4, %rdx
+	LONG $0x04c08349               // addq         $4, %r8
+	LONG $0xfcc28349               // addq         $-4, %r10
+	LONG $0x02fa8349               // cmpq         $2, %r10
+	LONG $0x0035830f; WORD $0x0000 // jae          LBB32_48, $53(%rip)
+	LONG $0x000043e9; BYTE $0x00   // jmp          LBB32_49, $67(%rip)
+
+LBB32_45:
+	LONG $0x08fa8349               // cmpq         $8, %r10
+	LONG $0xffcc820f; WORD $0xffff // jb           LBB32_46, $-52(%rip)
+
+LBB32_52:
+	WORD $0x8b48; BYTE $0x0a       // movq         (%rdx), %rcx
+	WORD $0x8949; BYTE $0x08       // movq         %rcx, (%r8)
+	LONG $0x08c28348               // addq         $8, %rdx
+	LONG $0x08c08349               // addq         $8, %r8
+	LONG $0xf8c28349               // addq         $-8, %r10
+	LONG $0x04fa8349               // cmpq         $4, %r10
+	LONG $0xffba830f; WORD $0xffff // jae          LBB32_53, $-70(%rip)
+
+LBB32_47:
+	LONG $0x02fa8349               // cmpq         $2, %r10
+	LONG $0x0013820f; WORD $0x0000 // jb           LBB32_49, $19(%rip)
+
+LBB32_48:
+	WORD $0xb70f; BYTE $0x0a // movzwl       (%rdx), %ecx
+	LONG $0x08894166         // movw         %cx, (%r8)
+	LONG $0x02c28348         // addq         $2, %rdx
+	LONG $0x02c08349         // addq         $2, %r8
+	LONG $0xfec28349         // addq         $-2, %r10
+
+LBB32_49:
+	WORD $0x8948; BYTE $0xd6                   // movq         %rdx, %rsi
+	LONG $0x70958d48; WORD $0xffff; BYTE $0xff // leaq         $-144(%rbp), %rdx
+	WORD $0x854d; BYTE $0xd2                   // testq        %r10, %r10
+	WORD $0x8949; BYTE $0xfa                   // movq         %rdi, %r10
+	LONG $0xfc60840f; WORD $0xffff             // je           LBB32_32, $-928(%rip)
+	WORD $0xb60f; BYTE $0x0e                   // movzbl       (%rsi), %ecx
+	WORD $0x8841; BYTE $0x08                   // movb         %cl, (%r8)
+	LONG $0x70958d48; WORD $0xffff; BYTE $0xff // leaq         $-144(%rbp), %rdx
+	LONG $0xfffc4ee9; BYTE $0xff               // jmp          LBB32_32, $-946(%rip)
+
+LBB32_54:
+	LONG $0x04c28348               // addq         $4, %rdx
+	LONG $0x08563b49               // cmpq         $8(%r14), %rdx
+	LONG $0xfaa5830f; WORD $0xffff // jae          LBB32_17, $-1371(%rip)
+	LONG $0x000461e9; BYTE $0x00   // jmp          LBB32_83, $1121(%rip)
+
+LBB32_55:
+	LONG $0xb845894c                       // movq         %r8, $-72(%rbp)
+	LONG $0xc86d894c                       // movq         %r13, $-56(%rbp)
+	LONG $0x084e8b49                       // movq         $8(%r14), %rcx
+	WORD $0x2948; BYTE $0xd1               // subq         %rdx, %rcx
+	WORD $0x0349; BYTE $0x16               // addq         (%r14), %rdx
+	QUAD $0x555555555555bb49; WORD $0x5555 // movabsq      $6148914691236517205, %r11
+	WORD $0x3145; BYTE $0xe4               // xorl         %r12d, %r12d
+	QUAD $0xfff907156f0f4466; BYTE $0xff   // movdqa       $-1785(%rip), %xmm10  /* LCPI32_4(%rip) */
+	QUAD $0xfffff8ef0d6f0f66               // movdqa       $-1809(%rip), %xmm1  /* LCPI32_3(%rip) */
+	LONG $0x760f4566; BYTE $0xc9           // pcmpeqd      %xmm9, %xmm9
+	QUAD $0xfffff9021d6f0f66               // movdqa       $-1790(%rip), %xmm3  /* LCPI32_5(%rip) */
+	QUAD $0xfffff90a256f0f66               // movdqa       $-1782(%rip), %xmm4  /* LCPI32_6(%rip) */
+	QUAD $0x333333333333bf49; WORD $0x3333 // movabsq      $3689348814741910323, %r15
+	LONG $0xc0570f45                       // xorps        %xmm8, %xmm8
+	WORD $0x3145; BYTE $0xd2               // xorl         %r10d, %r10d
+	WORD $0x3145; BYTE $0xed               // xorl         %r13d, %r13d
+	WORD $0x3145; BYTE $0xc9               // xorl         %r9d, %r9d
+	LONG $0x40f98348                       // cmpq         $64, %rcx
+	LONG $0xd04d8948                       // movq         %rcx, $-48(%rbp)
+	LONG $0x02758c0f; WORD $0x0000         // jl           LBB32_64, $629(%rip)
+
+LBB32_58:
+	LONG $0x026f0ff3                           // movdqu       (%rdx), %xmm0
+	LONG $0x6a6f0ff3; BYTE $0x10               // movdqu       $16(%rdx), %xmm5
+	LONG $0x7a6f0ff3; BYTE $0x20               // movdqu       $32(%rdx), %xmm7
+	LONG $0x726f0ff3; BYTE $0x30               // movdqu       $48(%rdx), %xmm6
+	LONG $0xd06f0f66                           // movdqa       %xmm0, %xmm2
+	LONG $0x740f4166; BYTE $0xd2               // pcmpeqb      %xmm10, %xmm2
+	LONG $0xfad70f66                           // pmovmskb     %xmm2, %edi
+	LONG $0xd56f0f66                           // movdqa       %xmm5, %xmm2
+	LONG $0x740f4166; BYTE $0xd2               // pcmpeqb      %xmm10, %xmm2
+	LONG $0xf2d70f66                           // pmovmskb     %xmm2, %esi
+	LONG $0xd76f0f66                           // movdqa       %xmm7, %xmm2
+	LONG $0x740f4166; BYTE $0xd2               // pcmpeqb      %xmm10, %xmm2
+	LONG $0xdad70f66                           // pmovmskb     %xmm2, %ebx
+	LONG $0xd66f0f66                           // movdqa       %xmm6, %xmm2
+	LONG $0x740f4166; BYTE $0xd2               // pcmpeqb      %xmm10, %xmm2
+	LONG $0xcad70f66                           // pmovmskb     %xmm2, %ecx
+	LONG $0x30e1c148                           // shlq         $48, %rcx
+	LONG $0x20e3c148                           // shlq         $32, %rbx
+	WORD $0x0948; BYTE $0xcb                   // orq          %rcx, %rbx
+	LONG $0x10e6c148                           // shlq         $16, %rsi
+	WORD $0x0948; BYTE $0xde                   // orq          %rbx, %rsi
+	WORD $0x0948; BYTE $0xf7                   // orq          %rsi, %rdi
+	WORD $0x8948; BYTE $0xf9                   // movq         %rdi, %rcx
+	WORD $0x094c; BYTE $0xd1                   // orq          %r10, %rcx
+	LONG $0x0012850f; WORD $0x0000             // jne          LBB32_60, $18(%rip)
+	LONG $0xffc7c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rdi
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0xc04d8948                           // movq         %rcx, $-64(%rbp)
+	LONG $0x00003fe9; BYTE $0x00               // jmp          LBB32_61, $63(%rip)
+
+LBB32_60:
+	WORD $0x894c; BYTE $0xd1               // movq         %r10, %rcx
+	WORD $0xf748; BYTE $0xd1               // notq         %rcx
+	WORD $0x2148; BYTE $0xf9               // andq         %rdi, %rcx
+	LONG $0x09048d4c                       // leaq         (%rcx,%rcx), %r8
+	WORD $0x094d; BYTE $0xd0               // orq          %r10, %r8
+	WORD $0x894c; BYTE $0xc6               // movq         %r8, %rsi
+	WORD $0xf748; BYTE $0xd6               // notq         %rsi
+	QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq      $-6148914691236517206, %rbx
+	WORD $0x2148; BYTE $0xdf               // andq         %rbx, %rdi
+	WORD $0x2148; BYTE $0xf7               // andq         %rsi, %rdi
+	WORD $0xf631                           // xorl         %esi, %esi
+	WORD $0x0148; BYTE $0xcf               // addq         %rcx, %rdi
+	LONG $0xc6920f40                       // setb         %sil
+	LONG $0xc0758948                       // movq         %rsi, $-64(%rbp)
+	WORD $0x0148; BYTE $0xff               // addq         %rdi, %rdi
+	WORD $0x314c; BYTE $0xdf               // xorq         %r11, %rdi
+	WORD $0x214c; BYTE $0xc7               // andq         %r8, %rdi
+	WORD $0xf748; BYTE $0xd7               // notq         %rdi
+
+LBB32_61:
+	LONG $0xd66f0f66                           // movdqa       %xmm6, %xmm2
+	LONG $0xd1740f66                           // pcmpeqb      %xmm1, %xmm2
+	LONG $0xcad70f66                           // pmovmskb     %xmm2, %ecx
+	LONG $0x30e1c148                           // shlq         $48, %rcx
+	LONG $0xd76f0f66                           // movdqa       %xmm7, %xmm2
+	LONG $0xd1740f66                           // pcmpeqb      %xmm1, %xmm2
+	LONG $0xf2d70f66                           // pmovmskb     %xmm2, %esi
+	LONG $0x20e6c148                           // shlq         $32, %rsi
+	WORD $0x0948; BYTE $0xce                   // orq          %rcx, %rsi
+	LONG $0xd56f0f66                           // movdqa       %xmm5, %xmm2
+	LONG $0xd1740f66                           // pcmpeqb      %xmm1, %xmm2
+	LONG $0xcad70f66                           // pmovmskb     %xmm2, %ecx
+	LONG $0x10e1c148                           // shlq         $16, %rcx
+	WORD $0x0948; BYTE $0xf1                   // orq          %rsi, %rcx
+	LONG $0xd06f0f66                           // movdqa       %xmm0, %xmm2
+	LONG $0xd1740f66                           // pcmpeqb      %xmm1, %xmm2
+	LONG $0xf2d70f66                           // pmovmskb     %xmm2, %esi
+	WORD $0x0948; BYTE $0xce                   // orq          %rcx, %rsi
+	WORD $0x2148; BYTE $0xfe                   // andq         %rdi, %rsi
+	LONG $0x6e0f4866; BYTE $0xd6               // movq         %rsi, %xmm2
+	LONG $0x3a0f4166; WORD $0xd144; BYTE $0x00 // pclmulqdq    $0, %xmm9, %xmm2
+	LONG $0x7e0f4966; BYTE $0xd0               // movq         %xmm2, %r8
+	WORD $0x314d; BYTE $0xe0                   // xorq         %r12, %r8
+	LONG $0xd06f0f66                           // movdqa       %xmm0, %xmm2
+	LONG $0xd3740f66                           // pcmpeqb      %xmm3, %xmm2
+	LONG $0xd70f4466; BYTE $0xd2               // pmovmskb     %xmm2, %r10d
+	LONG $0xd56f0f66                           // movdqa       %xmm5, %xmm2
+	LONG $0xd3740f66                           // pcmpeqb      %xmm3, %xmm2
+	LONG $0xcad70f66                           // pmovmskb     %xmm2, %ecx
+	LONG $0xd76f0f66                           // movdqa       %xmm7, %xmm2
+	LONG $0xd3740f66                           // pcmpeqb      %xmm3, %xmm2
+	LONG $0xf2d70f66                           // pmovmskb     %xmm2, %esi
+	LONG $0xd66f0f66                           // movdqa       %xmm6, %xmm2
+	LONG $0xd3740f66                           // pcmpeqb      %xmm3, %xmm2
+	LONG $0xfad70f66                           // pmovmskb     %xmm2, %edi
+	LONG $0x30e7c148                           // shlq         $48, %rdi
+	LONG $0x20e6c148                           // shlq         $32, %rsi
+	WORD $0x0948; BYTE $0xfe                   // orq          %rdi, %rsi
+	LONG $0x10e1c148                           // shlq         $16, %rcx
+	WORD $0x0948; BYTE $0xf1                   // orq          %rsi, %rcx
+	WORD $0x0949; BYTE $0xca                   // orq          %rcx, %r10
+	WORD $0x894d; BYTE $0xc4                   // movq         %r8, %r12
+	WORD $0xf749; BYTE $0xd4                   // notq         %r12
+	WORD $0x214d; BYTE $0xe2                   // andq         %r12, %r10
+	LONG $0xc4740f66                           // pcmpeqb      %xmm4, %xmm0
+	LONG $0xf8d70f66                           // pmovmskb     %xmm0, %edi
+	LONG $0xec740f66                           // pcmpeqb      %xmm4, %xmm5
+	LONG $0xcdd70f66                           // pmovmskb     %xmm5, %ecx
+	LONG $0xfc740f66                           // pcmpeqb      %xmm4, %xmm7
+	LONG $0xdfd70f66                           // pmovmskb     %xmm7, %ebx
+	LONG $0xf4740f66                           // pcmpeqb      %xmm4, %xmm6
+	LONG $0xf6d70f66                           // pmovmskb     %xmm6, %esi
+	LONG $0x30e6c148                           // shlq         $48, %rsi
+	LONG $0x20e3c148                           // shlq         $32, %rbx
+	WORD $0x0948; BYTE $0xf3                   // orq          %rsi, %rbx
+	LONG $0x10e1c148                           // shlq         $16, %rcx
+	WORD $0x0948; BYTE $0xd9                   // orq          %rbx, %rcx
+	WORD $0x0948; BYTE $0xcf                   // orq          %rcx, %rdi
+	QUAD $0x0f0f0f0f0f0fbb48; WORD $0x0f0f     // movabsq      $1085102592571150095, %rbx
+	WORD $0x214c; BYTE $0xe7                   // andq         %r12, %rdi
+	LONG $0x0066840f; WORD $0x0000             // je           LBB32_56, $102(%rip)
+	QUAD $0x9090909090909090; BYTE $0x90       // .p2align 4, 0x90
+
+LBB32_62:
+	LONG $0xff678d4c                       // leaq         $-1(%rdi), %r12
+	WORD $0x894c; BYTE $0xe1               // movq         %r12, %rcx
+	WORD $0x214c; BYTE $0xd1               // andq         %r10, %rcx
+	WORD $0x8948; BYTE $0xce               // movq         %rcx, %rsi
+	WORD $0xd148; BYTE $0xee               // shrq         %rsi
+	WORD $0x214c; BYTE $0xde               // andq         %r11, %rsi
+	WORD $0x2948; BYTE $0xf1               // subq         %rsi, %rcx
+	WORD $0x8948; BYTE $0xce               // movq         %rcx, %rsi
+	WORD $0x214c; BYTE $0xfe               // andq         %r15, %rsi
+	LONG $0x02e9c148                       // shrq         $2, %rcx
+	WORD $0x214c; BYTE $0xf9               // andq         %r15, %rcx
+	WORD $0x0148; BYTE $0xf1               // addq         %rsi, %rcx
+	WORD $0x8948; BYTE $0xce               // movq         %rcx, %rsi
+	LONG $0x04eec148                       // shrq         $4, %rsi
+	WORD $0x0148; BYTE $0xce               // addq         %rcx, %rsi
+	WORD $0x2148; BYTE $0xde               // andq         %rbx, %rsi
+	QUAD $0x010101010101b948; WORD $0x0101 // movabsq      $72340172838076673, %rcx
+	LONG $0xf1af0f48                       // imulq        %rcx, %rsi
+	LONG $0x38eec148                       // shrq         $56, %rsi
+	WORD $0x014c; BYTE $0xee               // addq         %r13, %rsi
+	WORD $0x394c; BYTE $0xce               // cmpq         %r9, %rsi
+	LONG $0x01ad860f; WORD $0x0000         // jbe          LBB32_80, $429(%rip)
+	WORD $0xff49; BYTE $0xc1               // incq         %r9
+	WORD $0x214c; BYTE $0xe7               // andq         %r12, %rdi
+	LONG $0xffa3850f; WORD $0xffff         // jne          LBB32_62, $-93(%rip)
+
+LBB32_56:
+	LONG $0x3ff8c149                       // sarq         $63, %r8
+	WORD $0x894c; BYTE $0xd1               // movq         %r10, %rcx
+	WORD $0xd148; BYTE $0xe9               // shrq         %rcx
+	WORD $0x214c; BYTE $0xd9               // andq         %r11, %rcx
+	WORD $0x2949; BYTE $0xca               // subq         %rcx, %r10
+	WORD $0x894c; BYTE $0xd1               // movq         %r10, %rcx
+	WORD $0x214c; BYTE $0xf9               // andq         %r15, %rcx
+	LONG $0x02eac149                       // shrq         $2, %r10
+	WORD $0x214d; BYTE $0xfa               // andq         %r15, %r10
+	WORD $0x0149; BYTE $0xca               // addq         %rcx, %r10
+	WORD $0x894c; BYTE $0xd1               // movq         %r10, %rcx
+	LONG $0x04e9c148                       // shrq         $4, %rcx
+	WORD $0x014c; BYTE $0xd1               // addq         %r10, %rcx
+	WORD $0x2148; BYTE $0xd9               // andq         %rbx, %rcx
+	QUAD $0x010101010101be48; WORD $0x0101 // movabsq      $72340172838076673, %rsi
+	LONG $0xceaf0f48                       // imulq        %rsi, %rcx
+	LONG $0x38e9c148                       // shrq         $56, %rcx
+	WORD $0x0149; BYTE $0xcd               // addq         %rcx, %r13
+	LONG $0x40c28348                       // addq         $64, %rdx
+	LONG $0xd04d8b48                       // movq         $-48(%rbp), %rcx
+	LONG $0xc0c18348                       // addq         $-64, %rcx
+	WORD $0x894d; BYTE $0xc4               // movq         %r8, %r12
+	LONG $0xc0558b4c                       // movq         $-64(%rbp), %r10
+	LONG $0x40f98348                       // cmpq         $64, %rcx
+	LONG $0xd04d8948                       // movq         %rcx, $-48(%rbp)
+	LONG $0xfd8b8d0f; WORD $0xffff         // jge          LBB32_58, $-629(%rip)
+
+LBB32_64:
+	WORD $0x8548; BYTE $0xc9       // testq        %rcx, %rcx
+	LONG $0x01b08e0f; WORD $0x0000 // jle          LBB32_85, $432(%rip)
+	WORD $0x894c; BYTE $0xd7       // movq         %r10, %rdi
+	LONG $0x45110f44; BYTE $0xa0   // movups       %xmm8, $-96(%rbp)
+	LONG $0x45110f44; BYTE $0x90   // movups       %xmm8, $-112(%rbp)
+	LONG $0x45110f44; BYTE $0x80   // movups       %xmm8, $-128(%rbp)
+	QUAD $0xffffff7085110f44       // movups       %xmm8, $-144(%rbp)
+	WORD $0xd189                   // movl         %edx, %ecx
+	LONG $0x0fffe181; WORD $0x0000 // andl         $4095, %ecx
+	LONG $0x0fc1f981; WORD $0x0000 // cmpl         $4033, %ecx
+	LONG $0x0036820f; WORD $0x0000 // jb           LBB32_68, $54(%rip)
+	LONG $0xd07d8348; BYTE $0x20   // cmpq         $32, $-48(%rbp)
+	LONG $0x0033820f; WORD $0x0000 // jb           LBB32_69, $51(%rip)
+	LONG $0x026f0ff3               // movdqu       (%rdx), %xmm0
+	LONG $0x526f0ff3; BYTE $0x10   // movdqu       $16(%rdx), %xmm2
+	QUAD $0xffffff70857f0ff3       // movdqu       %xmm0, $-144(%rbp)
+	LONG $0x557f0ff3; BYTE $0x80   // movdqu       %xmm2, $-128(%rbp)
+	LONG $0x20c28348               // addq         $32, %rdx
+	LONG $0xd04d8b48               // movq         $-48(%rbp), %rcx
+	LONG $0xe0518d4c               // leaq         $-32(%rcx), %r10
+	LONG $0x90458d4c               // leaq         $-112(%rbp), %r8
+	LONG $0x000013e9; BYTE $0x00   // jmp          LBB32_70, $19(%rip)
+
+LBB32_68:
+	WORD $0x8949; BYTE $0xfa     // movq         %rdi, %r10
+	LONG $0xfffd16e9; BYTE $0xff // jmp          LBB32_58, $-746(%rip)
+
+LBB32_69:
+	LONG $0x70858d4c; WORD $0xffff; BYTE $0xff // leaq         $-144(%rbp), %r8
+	LONG $0xd0558b4c                           // movq         $-48(%rbp), %r10
+
+LBB32_70:
+	LONG $0x10fa8349               // cmpq         $16, %r10
+	LONG $0x0049820f; WORD $0x0000 // jb           LBB32_71, $73(%rip)
+	LONG $0x026f0ff3               // movdqu       (%rdx), %xmm0
+	LONG $0x7f0f41f3; BYTE $0x00   // movdqu       %xmm0, (%r8)
+	LONG $0x10c28348               // addq         $16, %rdx
+	LONG $0x10c08349               // addq         $16, %r8
+	LONG $0xf0c28349               // addq         $-16, %r10
+	LONG $0x08fa8349               // cmpq         $8, %r10
+	LONG $0x0034830f; WORD $0x0000 // jae          LBB32_78, $52(%rip)
+
+LBB32_72:
+	LONG $0x04fa8349               // cmpq         $4, %r10
+	LONG $0x0046820f; WORD $0x0000 // jb           LBB32_73, $70(%rip)
+
+LBB32_79:
+	WORD $0x0a8b                   // movl         (%rdx), %ecx
+	WORD $0x8941; BYTE $0x08       // movl         %ecx, (%r8)
+	LONG $0x04c28348               // addq         $4, %rdx
+	LONG $0x04c08349               // addq         $4, %r8
+	LONG $0xfcc28349               // addq         $-4, %r10
+	LONG $0x02fa8349               // cmpq         $2, %r10
+	LONG $0x0035830f; WORD $0x0000 // jae          LBB32_74, $53(%rip)
+	LONG $0x000043e9; BYTE $0x00   // jmp          LBB32_75, $67(%rip)
+
+LBB32_71:
+	LONG $0x08fa8349               // cmpq         $8, %r10
+	LONG $0xffcc820f; WORD $0xffff // jb           LBB32_72, $-52(%rip)
+
+LBB32_78:
+	WORD $0x8b48; BYTE $0x0a       // movq         (%rdx), %rcx
+	WORD $0x8949; BYTE $0x08       // movq         %rcx, (%r8)
+	LONG $0x08c28348               // addq         $8, %rdx
+	LONG $0x08c08349               // addq         $8, %r8
+	LONG $0xf8c28349               // addq         $-8, %r10
+	LONG $0x04fa8349               // cmpq         $4, %r10
+	LONG $0xffba830f; WORD $0xffff // jae          LBB32_79, $-70(%rip)
+
+LBB32_73:
+	LONG $0x02fa8349               // cmpq         $2, %r10
+	LONG $0x0013820f; WORD $0x0000 // jb           LBB32_75, $19(%rip)
+
+LBB32_74:
+	WORD $0xb70f; BYTE $0x0a // movzwl       (%rdx), %ecx
+	LONG $0x08894166         // movw         %cx, (%r8)
+	LONG $0x02c28348         // addq         $2, %rdx
+	LONG $0x02c08349         // addq         $2, %r8
+	LONG $0xfec28349         // addq         $-2, %r10
+
+LBB32_75:
+	WORD $0x8948; BYTE $0xd6                   // movq         %rdx, %rsi
+	LONG $0x70958d48; WORD $0xffff; BYTE $0xff // leaq         $-144(%rbp), %rdx
+	WORD $0x854d; BYTE $0xd2                   // testq        %r10, %r10
+	WORD $0x8949; BYTE $0xfa                   // movq         %rdi, %r10
+	LONG $0xfc5f840f; WORD $0xffff             // je           LBB32_58, $-929(%rip)
+	WORD $0xb60f; BYTE $0x0e                   // movzbl       (%rsi), %ecx
+	WORD $0x8841; BYTE $0x08                   // movb         %cl, (%r8)
+	LONG $0x70958d48; WORD $0xffff; BYTE $0xff // leaq         $-144(%rbp), %rdx
+	LONG $0xfffc4de9; BYTE $0xff               // jmp          LBB32_58, $-947(%rip)
+
+LBB32_80:
+	LONG $0x08468b49                           // movq         $8(%r14), %rax
+	LONG $0xcfbc0f48                           // bsfq         %rdi, %rcx
+	LONG $0xd04d2b48                           // subq         $-48(%rbp), %rcx
+	WORD $0x0148; BYTE $0xc8                   // addq         %rcx, %rax
+	WORD $0xff48; BYTE $0xc0                   // incq         %rax
+	LONG $0xc8558b48                           // movq         $-56(%rbp), %rdx
+	WORD $0x8948; BYTE $0x02                   // movq         %rax, (%rdx)
+	LONG $0x084e8b49                           // movq         $8(%r14), %rcx
+	WORD $0x3948; BYTE $0xc8                   // cmpq         %rcx, %rax
+	LONG $0xc8420f48                           // cmovbq       %rax, %rcx
+	WORD $0x8948; BYTE $0x0a                   // movq         %rcx, (%rdx)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xb84d8b48                           // movq         $-72(%rbp), %rcx
+	LONG $0xc8470f48                           // cmovaq       %rax, %rcx
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	LONG $0xfff645e9; BYTE $0xff               // jmp          LBB32_17, $-2491(%rip)
+
+LBB32_82:
+	WORD $0x2948; BYTE $0xc2 // subq         %rax, %rdx
+	WORD $0x0148; BYTE $0xca // addq         %rcx, %rdx
+
+LBB32_83:
+	LONG $0x00558949             // movq         %rdx, (%r13)
+	LONG $0xfff633e9; BYTE $0xff // jmp          LBB32_16, $-2509(%rip)
+
+LBB32_26:
+	WORD $0x854d; BYTE $0xdb       // testq        %r11, %r11
+	LONG $0x0035850f; WORD $0x0000 // jne          LBB32_86, $53(%rip)
+	WORD $0x014d; BYTE $0xe2       // addq         %r12, %r10
+	WORD $0x014d; BYTE $0xf1       // addq         %r14, %r9
+
+LBB32_28:
+	WORD $0x854d; BYTE $0xc9       // testq        %r9, %r9
+	LONG $0x0068850f; WORD $0x0000 // jne          LBB32_90, $104(%rip)
+	LONG $0xfff619e9; BYTE $0xff   // jmp          LBB32_17, $-2535(%rip)
+
+LBB32_84:
+	WORD $0x0148; BYTE $0xc2       // addq         %rax, %rdx
+	WORD $0x8548; BYTE $0xf6       // testq        %rsi, %rsi
+	LONG $0xf5c0850f; WORD $0xffff // jne          LBB32_7, $-2624(%rip)
+	LONG $0xfff5efe9; BYTE $0xff   // jmp          LBB32_13, $-2577(%rip)
+
+LBB32_85:
+	LONG $0x084e8b49             // movq         $8(%r14), %rcx
+	LONG $0xc8558b48             // movq         $-56(%rbp), %rdx
+	WORD $0x8948; BYTE $0x0a     // movq         %rcx, (%rdx)
+	LONG $0xfff5f8e9; BYTE $0xff // jmp          LBB32_17, $-2568(%rip)
+
+LBB32_86:
+	WORD $0x394d; BYTE $0xe1       // cmpq         %r12, %r9
+	LONG $0xf5ef840f; WORD $0xffff // je           LBB32_17, $-2577(%rip)
+	WORD $0x014d; BYTE $0xe2       // addq         %r12, %r10
+	WORD $0xff49; BYTE $0xc2       // incq         %r10
+	WORD $0xf749; BYTE $0xd4       // notq         %r12
+	WORD $0x014d; BYTE $0xe1       // addq         %r12, %r9
+	WORD $0x854d; BYTE $0xc9       // testq        %r9, %r9
+	LONG $0x0024850f; WORD $0x0000 // jne          LBB32_90, $36(%rip)
+	LONG $0xfff5d5e9; BYTE $0xff   // jmp          LBB32_17, $-2603(%rip)
+
+LBB32_88:
+	LONG $0xfec1c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rcx
+	LONG $0x000002b8; BYTE $0x00               // movl         $2, %eax
+	WORD $0x0149; BYTE $0xc2                   // addq         %rax, %r10
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x0149; BYTE $0xc9                   // addq         %rcx, %r9
+	LONG $0xf5b6840f; WORD $0xffff             // je           LBB32_17, $-2634(%rip)
+
+LBB32_90:
+	LONG $0x02b60f41                           // movzbl       (%r10), %eax
+	WORD $0xf883; BYTE $0x5c                   // cmpl         $92, %eax
+	LONG $0xffd4840f; WORD $0xffff             // je           LBB32_88, $-44(%rip)
+	WORD $0xf883; BYTE $0x22                   // cmpl         $34, %eax
+	LONG $0x0024840f; WORD $0x0000             // je           LBB32_93, $36(%rip)
+	LONG $0xffc1c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rcx
+	LONG $0x000001b8; BYTE $0x00               // movl         $1, %eax
+	WORD $0x0149; BYTE $0xc2                   // addq         %rax, %r10
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0x0149; BYTE $0xc9                   // addq         %rcx, %r9
+	LONG $0xffcb850f; WORD $0xffff             // jne          LBB32_90, $-53(%rip)
+	LONG $0xfff57ce9; BYTE $0xff               // jmp          LBB32_17, $-2692(%rip)
+
+LBB32_93:
+	LONG $0xd0552b4c             // subq         $-48(%rbp), %r10
+	WORD $0xff49; BYTE $0xc2     // incq         %r10
+	LONG $0x0055894d             // movq         %r10, (%r13)
+	LONG $0xfff569e9; BYTE $0xff // jmp          LBB32_16, $-2711(%rip)
+	WORD $0x9090; BYTE $0x90     // .p2align 2, 0x90
+
+	// .set L32_0_set_17, LBB32_17-LJTI32_0
+	// .set L32_0_set_19, LBB32_19-LJTI32_0
+	// .set L32_0_set_20, LBB32_20-LJTI32_0
+	// .set L32_0_set_2, LBB32_2-LJTI32_0
+	// .set L32_0_set_29, LBB32_29-LJTI32_0
+	// .set L32_0_set_54, LBB32_54-LJTI32_0
+	// .set L32_0_set_18, LBB32_18-LJTI32_0
+	// .set L32_0_set_55, LBB32_55-LJTI32_0
+LJTI32_0:
+	LONG $0xfffff569         // .long L32_0_set_17
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff59b         // .long L32_0_set_20
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff489         // .long L32_0_set_2
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff489         // .long L32_0_set_2
+	LONG $0xfffff489         // .long L32_0_set_2
+	LONG $0xfffff489         // .long L32_0_set_2
+	LONG $0xfffff489         // .long L32_0_set_2
+	LONG $0xfffff489         // .long L32_0_set_2
+	LONG $0xfffff489         // .long L32_0_set_2
+	LONG $0xfffff489         // .long L32_0_set_2
+	LONG $0xfffff489         // .long L32_0_set_2
+	LONG $0xfffff489         // .long L32_0_set_2
+	LONG $0xfffff489         // .long L32_0_set_2
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff69a         // .long L32_0_set_29
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffffab6         // .long L32_0_set_54
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff578         // .long L32_0_set_18
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff578         // .long L32_0_set_18
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffff58b         // .long L32_0_set_19
+	LONG $0xfffffac9         // .long L32_0_set_55
+	QUAD $0x9090909090909090 // .p2align 4, 0x90
+
+_get_by_path:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5741                   // pushq        %r15
+	WORD $0x5641                   // pushq        %r14
+	WORD $0x5541                   // pushq        %r13
+	WORD $0x5441                   // pushq        %r12
+	BYTE $0x53                     // pushq        %rbx
+	LONG $0x38ec8348               // subq         $56, %rsp
+	WORD $0x8949; BYTE $0xf4       // movq         %rsi, %r12
+	WORD $0x8949; BYTE $0xfe       // movq         %rdi, %r14
+	LONG $0x08428b48               // movq         $8(%rdx), %rax
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x037d840f; WORD $0x0000 // je           LBB33_53, $893(%rip)
+	WORD $0x8b4c; BYTE $0x3a       // movq         (%rdx), %r15
+	LONG $0x04e0c148               // shlq         $4, %rax
+	WORD $0x014c; BYTE $0xf8       // addq         %r15, %rax
+	LONG $0xa0458948               // movq         %rax, $-96(%rbp)
+
+LBB33_2:
+	WORD $0x8b49; BYTE $0x3e                   // movq         (%r14), %rdi
+	LONG $0x08768b49                           // movq         $8(%r14), %rsi
+	WORD $0x894c; BYTE $0xe2                   // movq         %r12, %rdx
+	LONG $0xffd23fe8; BYTE $0xff               // callq        _advance_ns, $-11713(%rip)
+	WORD $0x8b49; BYTE $0x0f                   // movq         (%r15), %rcx
+	LONG $0x1749b60f                           // movzbl       $23(%rcx), %ecx
+	WORD $0xe180; BYTE $0x1f                   // andb         $31, %cl
+	WORD $0xf980; BYTE $0x18                   // cmpb         $24, %cl
+	LONG $0x02dc850f; WORD $0x0000             // jne          LBB33_47, $732(%rip)
+	WORD $0x7b3c                               // cmpb         $123, %al
+	LONG $0xc865894c                           // movq         %r12, $-56(%rbp)
+	LONG $0xd07d894c                           // movq         %r15, $-48(%rbp)
+	LONG $0x034d850f; WORD $0x0000             // jne          LBB33_54, $845(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+LBB33_4:
+	WORD $0x8b49; BYTE $0x3e       // movq         (%r14), %rdi
+	LONG $0x08768b49               // movq         $8(%r14), %rsi
+	WORD $0x894c; BYTE $0xe2       // movq         %r12, %rdx
+	LONG $0xffd201e8; BYTE $0xff   // callq        _advance_ns, $-11775(%rip)
+	WORD $0x223c                   // cmpb         $34, %al
+	LONG $0x032a850f; WORD $0x0000 // jne          LBB33_54, $810(%rip)
+	LONG $0x08478b49               // movq         $8(%r15), %rax
+	WORD $0x8b4c; BYTE $0x28       // movq         (%rax), %r13
+	LONG $0x08788b4c               // movq         $8(%rax), %r15
+	QUAD $0xffffffffb045c748       // movq         $-1, $-80(%rbp)
+	WORD $0x894c; BYTE $0xe3       // movq         %r12, %rbx
+	LONG $0x24248b4d               // movq         (%r12), %r12
+	WORD $0x894c; BYTE $0xf7       // movq         %r14, %rdi
+	WORD $0x894c; BYTE $0xe6       // movq         %r12, %rsi
+	LONG $0xb0558d48               // leaq         $-80(%rbp), %rdx
+	LONG $0x001aa0e8; BYTE $0x00   // callq        _advance_string_default, $6816(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0312880f; WORD $0x0000 // js           LBB33_56, $786(%rip)
+	WORD $0x8948; BYTE $0x03       // movq         %rax, (%rbx)
+	LONG $0xb04d8b48               // movq         $-80(%rbp), %rcx
+	LONG $0xfff98348               // cmpq         $-1, %rcx
+	LONG $0x0009840f; WORD $0x0000 // je           LBB33_8, $9(%rip)
+	WORD $0x3948; BYTE $0xc1       // cmpq         %rax, %rcx
+	LONG $0x01478e0f; WORD $0x0000 // jle          LBB33_27, $327(%rip)
+
+LBB33_8:
+	WORD $0x894c; BYTE $0xe1       // movq         %r12, %rcx
+	WORD $0xf748; BYTE $0xd1       // notq         %rcx
+	WORD $0x0148; BYTE $0xc8       // addq         %rcx, %rax
+	WORD $0x394c; BYTE $0xf8       // cmpq         %r15, %rax
+	LONG $0x0047850f; WORD $0x0000 // jne          LBB33_12, $71(%rip)
+	WORD $0x034d; BYTE $0x26       // addq         (%r14), %r12
+	WORD $0x894c; BYTE $0xe9       // movq         %r13, %rcx
+	WORD $0x894c; BYTE $0xe0       // movq         %r12, %rax
+	WORD $0x9090                   // .p2align 4, 0x90
+
+LBB33_10:
+	LONG $0x10ff8349               // cmpq         $16, %r15
+	LONG $0x0086820f; WORD $0x0000 // jb           LBB33_17, $134(%rip)
+	LONG $0x006f0ff3               // movdqu       (%rax), %xmm0
+	LONG $0x6f0f41f3; WORD $0x004d // movdqu       (%r13), %xmm1
+	LONG $0xc8740f66               // pcmpeqb      %xmm0, %xmm1
+	LONG $0xd1d70f66               // pmovmskb     %xmm1, %edx
+	LONG $0x10c08348               // addq         $16, %rax
+	LONG $0x10c58349               // addq         $16, %r13
+	LONG $0xf0c78349               // addq         $-16, %r15
+	LONG $0x10c18348               // addq         $16, %rcx
+	LONG $0x10c48349               // addq         $16, %r12
+	LONG $0xfffffa81; WORD $0x0000 // cmpl         $65535, %edx
+	LONG $0xffc4840f; WORD $0xffff // je           LBB33_10, $-60(%rip)
+
+LBB33_12:
+	WORD $0xdb31 // xorl         %ebx, %ebx
+
+LBB33_13:
+	LONG $0xc8658b4c // movq         $-56(%rbp), %r12
+
+LBB33_14:
+	LONG $0xd07d8b4c               // movq         $-48(%rbp), %r15
+	WORD $0x8b49; BYTE $0x3e       // movq         (%r14), %rdi
+	LONG $0x08768b49               // movq         $8(%r14), %rsi
+	WORD $0x894c; BYTE $0xe2       // movq         %r12, %rdx
+	LONG $0xffd13be8; BYTE $0xff   // callq        _advance_ns, $-11973(%rip)
+	WORD $0x3a3c                   // cmpb         $58, %al
+	LONG $0x0264850f; WORD $0x0000 // jne          LBB33_54, $612(%rip)
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x023a850f; WORD $0x0000 // jne          LBB33_52, $570(%rip)
+	WORD $0x894c; BYTE $0xf7       // movq         %r14, %rdi
+	WORD $0x894c; BYTE $0xe6       // movq         %r12, %rsi
+	LONG $0xfff0dfe8; BYTE $0xff   // callq        _skip_one_fast, $-3873(%rip)
+	WORD $0x8b49; BYTE $0x3e       // movq         (%r14), %rdi
+	LONG $0x08768b49               // movq         $8(%r14), %rsi
+	WORD $0x894c; BYTE $0xe2       // movq         %r12, %rdx
+	LONG $0xffd110e8; BYTE $0xff   // callq        _advance_ns, $-12016(%rip)
+	WORD $0x2c3c                   // cmpb         $44, %al
+	LONG $0xfef8840f; WORD $0xffff // je           LBB33_4, $-264(%rip)
+	LONG $0x000234e9; BYTE $0x00   // jmp          LBB33_54, $564(%rip)
+	WORD $0x9090; BYTE $0x90       // .p2align 4, 0x90
+
+LBB33_17:
+	LONG $0xffe48141; WORD $0x000f; BYTE $0x00 // andl         $4095, %r12d
+	LONG $0xf0fc8141; WORD $0x000f; BYTE $0x00 // cmpl         $4080, %r12d
+	LONG $0x0048870f; WORD $0x0000             // ja           LBB33_21, $72(%rip)
+	LONG $0x0fffe181; WORD $0x0000             // andl         $4095, %ecx
+	LONG $0x0ff1f981; WORD $0x0000             // cmpl         $4081, %ecx
+	LONG $0x0036830f; WORD $0x0000             // jae          LBB33_21, $54(%rip)
+	LONG $0x006f0ff3                           // movdqu       (%rax), %xmm0
+	LONG $0x6f0f41f3; WORD $0x004d             // movdqu       (%r13), %xmm1
+	LONG $0xc8740f66                           // pcmpeqb      %xmm0, %xmm1
+	LONG $0xc1d70f66                           // pmovmskb     %xmm1, %eax
+	LONG $0xfff88366                           // cmpw         $-1, %ax
+	LONG $0xc8658b4c                           // movq         $-56(%rbp), %r12
+	LONG $0x004a840f; WORD $0x0000             // je           LBB33_25, $74(%rip)
+	WORD $0xd0f7                               // notl         %eax
+	LONG $0xc0bc0f66                           // bsfw         %ax, %ax
+	WORD $0xb70f; BYTE $0xc0                   // movzwl       %ax, %eax
+	WORD $0xdb31                               // xorl         %ebx, %ebx
+	WORD $0x3949; BYTE $0xc7                   // cmpq         %rax, %r15
+	WORD $0x960f; BYTE $0xc3                   // setbe        %bl
+	LONG $0xffff56e9; BYTE $0xff               // jmp          LBB33_14, $-170(%rip)
+
+LBB33_21:
+	LONG $0x000001bb; BYTE $0x00   // movl         $1, %ebx
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0xc8658b4c               // movq         $-56(%rbp), %r12
+	LONG $0xff44840f; WORD $0xffff // je           LBB33_14, $-188(%rip)
+	WORD $0xc931                   // xorl         %ecx, %ecx
+
+	// .p2align 4, 0x90
+LBB33_23:
+	LONG $0x0814b60f               // movzbl       (%rax,%rcx), %edx
+	LONG $0x0d543a41; BYTE $0x00   // cmpb         (%r13,%rcx), %dl
+	LONG $0x011d850f; WORD $0x0000 // jne          LBB33_26, $285(%rip)
+	WORD $0xff48; BYTE $0xc1       // incq         %rcx
+	WORD $0x3949; BYTE $0xcf       // cmpq         %rcx, %r15
+	LONG $0xffe5850f; WORD $0xffff // jne          LBB33_23, $-27(%rip)
+	LONG $0xffff22e9; BYTE $0xff   // jmp          LBB33_14, $-222(%rip)
+
+LBB33_25:
+	LONG $0x000001bb; BYTE $0x00 // movl         $1, %ebx
+	LONG $0xffff18e9; BYTE $0xff // jmp          LBB33_14, $-232(%rip)
+
+LBB33_27:
+	QUAD $0x00000000b845c748       // movq         $0, $-72(%rbp)
+	WORD $0x8b49; BYTE $0x0e       // movq         (%r14), %rcx
+	WORD $0x0149; BYTE $0xcc       // addq         %rcx, %r12
+	LONG $0xc065894c               // movq         %r12, $-64(%rbp)
+	LONG $0x01348d48               // leaq         (%rcx,%rax), %rsi
+	WORD $0xff48; BYTE $0xce       // decq         %rsi
+	LONG $0x2f3c8d4b               // leaq         (%r15,%r13), %rdi
+	WORD $0x3949; BYTE $0xf4       // cmpq         %rsi, %r12
+	LONG $0x00c9830f; WORD $0x0000 // jae          LBB33_44, $201(%rip)
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x00c08e0f; WORD $0x0000 // jle          LBB33_44, $192(%rip)
+	LONG $0xb8558d48               // leaq         $-72(%rbp), %rdx
+	LONG $0xa8758948               // movq         %rsi, $-88(%rbp)
+
+LBB33_30:
+	LONG $0x04b60f41; BYTE $0x24   // movzbl       (%r12), %eax
+	WORD $0x5c3c                   // cmpb         $92, %al
+	LONG $0x0069850f; WORD $0x0000 // jne          LBB33_37, $105(%rip)
+	WORD $0x8948; BYTE $0xfb       // movq         %rdi, %rbx
+	LONG $0xc07d8d48               // leaq         $-64(%rbp), %rdi
+	WORD $0x8949; BYTE $0xd7       // movq         %rdx, %r15
+	LONG $0x001c93e8; BYTE $0x00   // callq        _unescape, $7315(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	LONG $0x0168880f; WORD $0x0000 // js           LBB33_57, $360(%rip)
+	LONG $0x280c8d48               // leaq         (%rax,%rbp), %rcx
+	LONG $0xb8c18348               // addq         $-72, %rcx
+	WORD $0x8948; BYTE $0xdf       // movq         %rbx, %rdi
+	WORD $0x3949; BYTE $0xdd       // cmpq         %rbx, %r13
+	LONG $0xc8658b4c               // movq         $-56(%rbp), %r12
+	LONG $0x0052830f; WORD $0x0000 // jae          LBB33_39, $82(%rip)
+	WORD $0x8548; BYTE $0xc0       // testq        %rax, %rax
+	WORD $0x894c; BYTE $0xfa       // movq         %r15, %rdx
+	WORD $0x894c; BYTE $0xf8       // movq         %r15, %rax
+	LONG $0x0049840f; WORD $0x0000 // je           LBB33_40, $73(%rip)
+
+LBB33_34:
+	LONG $0x5db60f41; BYTE $0x00   // movzbl       (%r13), %ebx
+	WORD $0x183a                   // cmpb         (%rax), %bl
+	LONG $0x003c850f; WORD $0x0000 // jne          LBB33_40, $60(%rip)
+	WORD $0xff49; BYTE $0xc5       // incq         %r13
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x3949; BYTE $0xfd       // cmpq         %rdi, %r13
+	LONG $0x002d830f; WORD $0x0000 // jae          LBB33_40, $45(%rip)
+	WORD $0x3948; BYTE $0xc8       // cmpq         %rcx, %rax
+	LONG $0xffdb820f; WORD $0xffff // jb           LBB33_34, $-37(%rip)
+	LONG $0x00001fe9; BYTE $0x00   // jmp          LBB33_40, $31(%rip)
+
+LBB33_37:
+	LONG $0x00453a41               // cmpb         (%r13), %al
+	LONG $0xfe5b850f; WORD $0xffff // jne          LBB33_12, $-421(%rip)
+	WORD $0xff49; BYTE $0xc4       // incq         %r12
+	LONG $0xc065894c               // movq         %r12, $-64(%rbp)
+	WORD $0xff49; BYTE $0xc5       // incq         %r13
+	LONG $0x000017e9; BYTE $0x00   // jmp          LBB33_42, $23(%rip)
+
+LBB33_39:
+	WORD $0x894c; BYTE $0xfa // movq         %r15, %rdx
+	WORD $0x894c; BYTE $0xf8 // movq         %r15, %rax
+
+LBB33_40:
+	WORD $0x3948; BYTE $0xc8       // cmpq         %rcx, %rax
+	LONG $0x002d850f; WORD $0x0000 // jne          LBB33_26, $45(%rip)
+	LONG $0xc0658b4c               // movq         $-64(%rbp), %r12
+	LONG $0xa8758b48               // movq         $-88(%rbp), %rsi
+
+LBB33_42:
+	WORD $0x3949; BYTE $0xf4       // cmpq         %rsi, %r12
+	LONG $0x0009830f; WORD $0x0000 // jae          LBB33_44, $9(%rip)
+	WORD $0x3949; BYTE $0xfd       // cmpq         %rdi, %r13
+	LONG $0xff48820f; WORD $0xffff // jb           LBB33_30, $-184(%rip)
+
+LBB33_44:
+	WORD $0x3149; BYTE $0xf4     // xorq         %rsi, %r12
+	WORD $0x3149; BYTE $0xfd     // xorq         %rdi, %r13
+	WORD $0xdb31                 // xorl         %ebx, %ebx
+	WORD $0x094d; BYTE $0xe5     // orq          %r12, %r13
+	WORD $0x940f; BYTE $0xc3     // sete         %bl
+	LONG $0xfffe12e9; BYTE $0xff // jmp          LBB33_13, $-494(%rip)
+
+LBB33_26:
+	WORD $0xdb31                                           // xorl         %ebx, %ebx
+	LONG $0xfffe0fe9; BYTE $0xff                           // jmp          LBB33_14, $-497(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB33_47:
+	WORD $0xf980; BYTE $0x02       // cmpb         $2, %cl
+	LONG $0x0078850f; WORD $0x0000 // jne          LBB33_54, $120(%rip)
+	WORD $0x5b3c                   // cmpb         $91, %al
+	LONG $0x0070850f; WORD $0x0000 // jne          LBB33_54, $112(%rip)
+	LONG $0x08478b49               // movq         $8(%r15), %rax
+	WORD $0x8b48; BYTE $0x18       // movq         (%rax), %rbx
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	LONG $0x90909090; BYTE $0x90   // .p2align 4, 0x90
+
+LBB33_50:
+	WORD $0xff48; BYTE $0xcb                               // decq         %rbx
+	WORD $0x8548; BYTE $0xdb                               // testq        %rbx, %rbx
+	LONG $0x00348e0f; WORD $0x0000                         // jle          LBB33_52, $52(%rip)
+	WORD $0x894c; BYTE $0xf7                               // movq         %r14, %rdi
+	WORD $0x894c; BYTE $0xe6                               // movq         %r12, %rsi
+	LONG $0xffeed9e8; BYTE $0xff                           // callq        _skip_one_fast, $-4391(%rip)
+	WORD $0x8b49; BYTE $0x3e                               // movq         (%r14), %rdi
+	LONG $0x08768b49                                       // movq         $8(%r14), %rsi
+	WORD $0x894c; BYTE $0xe2                               // movq         %r12, %rdx
+	LONG $0xffcf0ae8; BYTE $0xff                           // callq        _advance_ns, $-12534(%rip)
+	WORD $0x2c3c                                           // cmpb         $44, %al
+	LONG $0xffd2840f; WORD $0xffff                         // je           LBB33_50, $-46(%rip)
+	LONG $0x00002ee9; BYTE $0x00                           // jmp          LBB33_54, $46(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB33_52:
+	LONG $0x10c78349               // addq         $16, %r15
+	LONG $0xa0458b48               // movq         $-96(%rbp), %rax
+	WORD $0x3949; BYTE $0xc7       // cmpq         %rax, %r15
+	LONG $0xfc91850f; WORD $0xffff // jne          LBB33_2, $-879(%rip)
+
+LBB33_53:
+	WORD $0x894c; BYTE $0xf7     // movq         %r14, %rdi
+	WORD $0x894c; BYTE $0xe6     // movq         %r12, %rsi
+	LONG $0xffee94e8; BYTE $0xff // callq        _skip_one_fast, $-4460(%rip)
+	LONG $0x00000be9; BYTE $0x00 // jmp          LBB33_55, $11(%rip)
+
+LBB33_54:
+	LONG $0x240cff49                           // decq         (%r12)
+	LONG $0xfec0c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rax
+
+LBB33_55:
+	LONG $0x38c48348 // addq         $56, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5d41     // popq         %r13
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB33_56:
+	LONG $0x08468b49                           // movq         $8(%r14), %rax
+	WORD $0x8948; BYTE $0x03                   // movq         %rax, (%rbx)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xffffdee9; BYTE $0xff               // jmp          LBB33_55, $-34(%rip)
+
+LBB33_57:
+	LONG $0xc04d8b48                                                     // movq         $-64(%rbp), %rcx
+	WORD $0x2b49; BYTE $0x0e                                             // subq         (%r14), %rcx
+	LONG $0xc8558b48                                                     // movq         $-56(%rbp), %rdx
+	WORD $0x8948; BYTE $0x0a                                             // movq         %rcx, (%rdx)
+	LONG $0xffffcbe9; BYTE $0xff                                         // jmp          LBB33_55, $-53(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+_validate_utf8:
+	BYTE $0x55                             // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5               // movq         %rsp, %rbp
+	WORD $0x5741                           // pushq        %r15
+	WORD $0x5641                           // pushq        %r14
+	WORD $0x5441                           // pushq        %r12
+	BYTE $0x53                             // pushq        %rbx
+	BYTE $0x50                             // pushq        %rax
+	WORD $0x8b4c; BYTE $0x17               // movq         (%rdi), %r10
+	LONG $0x085f8b4c                       // movq         $8(%rdi), %r11
+	WORD $0x8b48; BYTE $0x0e               // movq         (%rsi), %rcx
+	WORD $0x014c; BYTE $0xd1               // addq         %r10, %rcx
+	LONG $0x1a048d4f                       // leaq         (%r10,%r11), %r8
+	LONG $0xfdc08349                       // addq         $-3, %r8
+	LONG $0x00000de9; BYTE $0x00           // jmp          LBB34_1, $13(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB34_19:
+	WORD $0x0148; BYTE $0xd9 // addq         %rbx, %rcx
+
+LBB34_1:
+	WORD $0x394c; BYTE $0xc1                                             // cmpq         %r8, %rcx
+	LONG $0x00e1830f; WORD $0x0000                                       // jae          LBB34_2, $225(%rip)
+	LONG $0x000001bb; BYTE $0x00                                         // movl         $1, %ebx
+	WORD $0x3980; BYTE $0x00                                             // cmpb         $0, (%rcx)
+	LONG $0xffe6890f; WORD $0xffff                                       // jns          LBB34_19, $-26(%rip)
+	WORD $0x018b                                                         // movl         (%rcx), %eax
+	WORD $0xc789                                                         // movl         %eax, %edi
+	LONG $0xc0f0e781; WORD $0x00c0                                       // andl         $12632304, %edi
+	LONG $0x80e0ff81; WORD $0x0080                                       // cmpl         $8421600, %edi
+	LONG $0x0030850f; WORD $0x0000                                       // jne          LBB34_10, $48(%rip)
+	WORD $0xc789                                                         // movl         %eax, %edi
+	LONG $0x200fe781; WORD $0x0000                                       // andl         $8207, %edi
+	LONG $0x200dff81; WORD $0x0000                                       // cmpl         $8205, %edi
+	LONG $0x001c840f; WORD $0x0000                                       // je           LBB34_10, $28(%rip)
+	LONG $0x000003bb; BYTE $0x00                                         // movl         $3, %ebx
+	WORD $0xff85                                                         // testl        %edi, %edi
+	LONG $0xffaf850f; WORD $0xffff                                       // jne          LBB34_19, $-81(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB34_10:
+	WORD $0xc789                   // movl         %eax, %edi
+	LONG $0xc0e0e781; WORD $0x0000 // andl         $49376, %edi
+	LONG $0x80c0ff81; WORD $0x0000 // cmpl         $32960, %edi
+	LONG $0x0010850f; WORD $0x0000 // jne          LBB34_12, $16(%rip)
+	WORD $0xc789                   // movl         %eax, %edi
+	LONG $0x000002bb; BYTE $0x00   // movl         $2, %ebx
+	WORD $0xe783; BYTE $0x1e       // andl         $30, %edi
+	LONG $0xff7c850f; WORD $0xffff // jne          LBB34_19, $-132(%rip)
+
+LBB34_12:
+	WORD $0xc789                   // movl         %eax, %edi
+	LONG $0xc0f8e781; WORD $0xc0c0 // andl         $-1061109512, %edi
+	LONG $0x80f0ff81; WORD $0x8080 // cmpl         $-2139062032, %edi
+	LONG $0x0026850f; WORD $0x0000 // jne          LBB34_16, $38(%rip)
+	WORD $0xc789                   // movl         %eax, %edi
+	LONG $0x3007e781; WORD $0x0000 // andl         $12295, %edi
+	LONG $0x0018840f; WORD $0x0000 // je           LBB34_16, $24(%rip)
+	LONG $0x000004bb; BYTE $0x00   // movl         $4, %ebx
+	WORD $0x04a8                   // testb        $4, %al
+	LONG $0xff4d840f; WORD $0xffff // je           LBB34_19, $-179(%rip)
+	LONG $0x00300325; BYTE $0x00   // andl         $12291, %eax
+	LONG $0xff42840f; WORD $0xffff // je           LBB34_19, $-190(%rip)
+
+LBB34_16:
+	WORD $0x8948; BYTE $0xcf                   // movq         %rcx, %rdi
+	WORD $0x294c; BYTE $0xd7                   // subq         %r10, %rdi
+	WORD $0x8b48; BYTE $0x1a                   // movq         (%rdx), %rbx
+	LONG $0x00fb8148; WORD $0x0010; BYTE $0x00 // cmpq         $4096, %rbx
+	LONG $0x0187830f; WORD $0x0000             // jae          LBB34_17, $391(%rip)
+	WORD $0x6348; BYTE $0xc7                   // movslq       %edi, %rax
+	LONG $0x017b8d48                           // leaq         $1(%rbx), %rdi
+	WORD $0x8948; BYTE $0x3a                   // movq         %rdi, (%rdx)
+	LONG $0xda448948; BYTE $0x08               // movq         %rax, $8(%rdx,%rbx,8)
+	LONG $0x000001bb; BYTE $0x00               // movl         $1, %ebx
+	LONG $0xffff13e9; BYTE $0xff               // jmp          LBB34_19, $-237(%rip)
+
+LBB34_2:
+	WORD $0x014d; BYTE $0xd3               // addq         %r10, %r11
+	WORD $0x394c; BYTE $0xd9               // cmpq         %r11, %rcx
+	LONG $0x013e830f; WORD $0x0000         // jae          LBB34_36, $318(%rip)
+	LONG $0xdc458d4c                       // leaq         $-36(%rbp), %r8
+	LONG $0xda4d8d4c                       // leaq         $-38(%rbp), %r9
+	LONG $0x000016e9; BYTE $0x00           // jmp          LBB34_4, $22(%rip)
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB34_5:
+	WORD $0xff48; BYTE $0xc1       // incq         %rcx
+	WORD $0x394c; BYTE $0xd9       // cmpq         %r11, %rcx
+	LONG $0x011b830f; WORD $0x0000 // jae          LBB34_36, $283(%rip)
+
+LBB34_4:
+	WORD $0x3980; BYTE $0x00       // cmpb         $0, (%rcx)
+	LONG $0xffeb890f; WORD $0xffff // jns          LBB34_5, $-21(%rip)
+	LONG $0x00dc45c6               // movb         $0, $-36(%rbp)
+	LONG $0x00da45c6               // movb         $0, $-38(%rbp)
+	WORD $0x894c; BYTE $0xdb       // movq         %r11, %rbx
+	WORD $0x2948; BYTE $0xcb       // subq         %rcx, %rbx
+	LONG $0x02fb8348               // cmpq         $2, %rbx
+	LONG $0x0035820f; WORD $0x0000 // jb           LBB34_21, $53(%rip)
+	LONG $0x21b60f44               // movzbl       (%rcx), %r12d
+	LONG $0x71b60f44; BYTE $0x01   // movzbl       $1(%rcx), %r14d
+	LONG $0xdc658844               // movb         %r12b, $-36(%rbp)
+	LONG $0x02798d4c               // leaq         $2(%rcx), %r15
+	LONG $0xfec38348               // addq         $-2, %rbx
+	WORD $0x894c; BYTE $0xcf       // movq         %r9, %rdi
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0x0029840f; WORD $0x0000 // je           LBB34_24, $41(%rip)
+
+LBB34_25:
+	LONG $0x07b60f41             // movzbl       (%r15), %eax
+	WORD $0x0788                 // movb         %al, (%rdi)
+	LONG $0x65b60f44; BYTE $0xdc // movzbl       $-36(%rbp), %r12d
+	LONG $0xda7db60f             // movzbl       $-38(%rbp), %edi
+	LONG $0x000017e9; BYTE $0x00 // jmp          LBB34_26, $23(%rip)
+
+LBB34_21:
+	WORD $0x3145; BYTE $0xe4       // xorl         %r12d, %r12d
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	WORD $0x894c; BYTE $0xc7       // movq         %r8, %rdi
+	WORD $0x8949; BYTE $0xcf       // movq         %rcx, %r15
+	WORD $0x8548; BYTE $0xdb       // testq        %rbx, %rbx
+	LONG $0xffd7850f; WORD $0xffff // jne          LBB34_25, $-41(%rip)
+
+LBB34_24:
+	WORD $0xff31 // xorl         %edi, %edi
+
+LBB34_26:
+	LONG $0xc7b60f40               // movzbl       %dil, %eax
+	WORD $0xe0c1; BYTE $0x10       // shll         $16, %eax
+	LONG $0xdeb60f41               // movzbl       %r14b, %ebx
+	WORD $0xe3c1; BYTE $0x08       // shll         $8, %ebx
+	WORD $0xc309                   // orl          %eax, %ebx
+	LONG $0xfcb60f41               // movzbl       %r12b, %edi
+	WORD $0xdf09                   // orl          %ebx, %edi
+	WORD $0xf889                   // movl         %edi, %eax
+	LONG $0xc0c0f025; BYTE $0x00   // andl         $12632304, %eax
+	LONG $0x8080e03d; BYTE $0x00   // cmpl         $8421600, %eax
+	LONG $0x001f850f; WORD $0x0000 // jne          LBB34_29, $31(%rip)
+	WORD $0xf889                   // movl         %edi, %eax
+	LONG $0x00200f25; BYTE $0x00   // andl         $8207, %eax
+	LONG $0x00200d3d; BYTE $0x00   // cmpl         $8205, %eax
+	LONG $0x000d840f; WORD $0x0000 // je           LBB34_29, $13(%rip)
+	LONG $0x000003bb; BYTE $0x00   // movl         $3, %ebx
+	WORD $0xc085                   // testl        %eax, %eax
+	LONG $0x0021850f; WORD $0x0000 // jne          LBB34_34, $33(%rip)
+
+	// .p2align 4, 0x90
+LBB34_29:
+	LONG $0x1ec4f641               // testb        $30, %r12b
+	LONG $0x0028840f; WORD $0x0000 // je           LBB34_31, $40(%rip)
+	LONG $0xc0e0e781; WORD $0x0000 // andl         $49376, %edi
+	LONG $0x000002bb; BYTE $0x00   // movl         $2, %ebx
+	LONG $0x80c0ff81; WORD $0x0000 // cmpl         $32960, %edi
+	LONG $0x0011850f; WORD $0x0000 // jne          LBB34_31, $17(%rip)
+
+LBB34_34:
+	WORD $0x0148; BYTE $0xd9       // addq         %rbx, %rcx
+	WORD $0x394c; BYTE $0xd9       // cmpq         %r11, %rcx
+	LONG $0xff1f820f; WORD $0xffff // jb           LBB34_4, $-225(%rip)
+	LONG $0x000035e9; BYTE $0x00   // jmp          LBB34_36, $53(%rip)
+
+LBB34_31:
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	WORD $0x294c; BYTE $0xd0                   // subq         %r10, %rax
+	WORD $0x8b48; BYTE $0x3a                   // movq         (%rdx), %rdi
+	LONG $0x00ff8148; WORD $0x0010; BYTE $0x00 // cmpq         $4096, %rdi
+	LONG $0x0034830f; WORD $0x0000             // jae          LBB34_32, $52(%rip)
+	WORD $0x9848                               // cltq
+	LONG $0x015f8d48                           // leaq         $1(%rdi), %rbx
+	WORD $0x8948; BYTE $0x1a                   // movq         %rbx, (%rdx)
+	LONG $0xfa448948; BYTE $0x08               // movq         %rax, $8(%rdx,%rdi,8)
+	LONG $0x000001bb; BYTE $0x00               // movl         $1, %ebx
+	WORD $0x0148; BYTE $0xd9                   // addq         %rbx, %rcx
+	WORD $0x394c; BYTE $0xd9                   // cmpq         %r11, %rcx
+	LONG $0xfee5820f; WORD $0xffff             // jb           LBB34_4, $-283(%rip)
+
+LBB34_36:
+	WORD $0x294c; BYTE $0xd1 // subq         %r10, %rcx
+	WORD $0x8948; BYTE $0x0e // movq         %rcx, (%rsi)
+	WORD $0xc031             // xorl         %eax, %eax
+
+LBB34_37:
+	LONG $0x08c48348 // addq         $8, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB34_32:
+	WORD $0x8948; BYTE $0x06                   // movq         %rax, (%rsi)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xffffe4e9; BYTE $0xff               // jmp          LBB34_37, $-28(%rip)
+
+LBB34_17:
+	WORD $0x8948; BYTE $0x3e                   // movq         %rdi, (%rsi)
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xffffd5e9; BYTE $0xff               // jmp          LBB34_37, $-43(%rip)
+	LONG $0x90909090; WORD $0x9090             // .p2align 4, 0x90
+
+_validate_utf8_fast:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	BYTE $0x53                                 // pushq        %rbx
+	BYTE $0x50                                 // pushq        %rax
+	WORD $0x8b4c; BYTE $0x17                   // movq         (%rdi), %r10
+	LONG $0x085f8b4c                           // movq         $8(%rdi), %r11
+	LONG $0x1a348d4b                           // leaq         (%r10,%r11), %rsi
+	LONG $0xfdc68348                           // addq         $-3, %rsi
+	WORD $0x894c; BYTE $0xd0                   // movq         %r10, %rax
+	WORD $0x394c; BYTE $0xd6                   // cmpq         %r10, %rsi
+	LONG $0x00dd860f; WORD $0x0000             // jbe          LBB35_14, $221(%rip)
+	WORD $0x894c; BYTE $0xd0                   // movq         %r10, %rax
+	LONG $0x000013e9; BYTE $0x00               // jmp          LBB35_3, $19(%rip)
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB35_2:
+	WORD $0x0148; BYTE $0xd0       // addq         %rdx, %rax
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0x00c2830f; WORD $0x0000 // jae          LBB35_14, $194(%rip)
+
+LBB35_3:
+	LONG $0x000001ba; BYTE $0x00                                         // movl         $1, %edx
+	WORD $0x3880; BYTE $0x00                                             // cmpb         $0, (%rax)
+	LONG $0xffe6890f; WORD $0xffff                                       // jns          LBB35_2, $-26(%rip)
+	WORD $0x388b                                                         // movl         (%rax), %edi
+	WORD $0xf989                                                         // movl         %edi, %ecx
+	LONG $0xc0f0e181; WORD $0x00c0                                       // andl         $12632304, %ecx
+	LONG $0x80e0f981; WORD $0x0080                                       // cmpl         $8421600, %ecx
+	LONG $0x0030850f; WORD $0x0000                                       // jne          LBB35_7, $48(%rip)
+	WORD $0xf989                                                         // movl         %edi, %ecx
+	LONG $0x200fe181; WORD $0x0000                                       // andl         $8207, %ecx
+	LONG $0x200df981; WORD $0x0000                                       // cmpl         $8205, %ecx
+	LONG $0x001c840f; WORD $0x0000                                       // je           LBB35_7, $28(%rip)
+	LONG $0x000003ba; BYTE $0x00                                         // movl         $3, %edx
+	WORD $0xc985                                                         // testl        %ecx, %ecx
+	LONG $0xffaf850f; WORD $0xffff                                       // jne          LBB35_2, $-81(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB35_7:
+	WORD $0xf989                   // movl         %edi, %ecx
+	LONG $0xc0e0e181; WORD $0x0000 // andl         $49376, %ecx
+	LONG $0x80c0f981; WORD $0x0000 // cmpl         $32960, %ecx
+	LONG $0x0010850f; WORD $0x0000 // jne          LBB35_9, $16(%rip)
+	WORD $0xf989                   // movl         %edi, %ecx
+	LONG $0x000002ba; BYTE $0x00   // movl         $2, %edx
+	WORD $0xe183; BYTE $0x1e       // andl         $30, %ecx
+	LONG $0xff7c850f; WORD $0xffff // jne          LBB35_2, $-132(%rip)
+
+LBB35_9:
+	WORD $0xf989                   // movl         %edi, %ecx
+	LONG $0xc0f8e181; WORD $0xc0c0 // andl         $-1061109512, %ecx
+	LONG $0x80f0f981; WORD $0x8080 // cmpl         $-2139062032, %ecx
+	LONG $0x0029850f; WORD $0x0000 // jne          LBB35_13, $41(%rip)
+	WORD $0xf989                   // movl         %edi, %ecx
+	LONG $0x3007e181; WORD $0x0000 // andl         $12295, %ecx
+	LONG $0x001b840f; WORD $0x0000 // je           LBB35_13, $27(%rip)
+	LONG $0x000004ba; BYTE $0x00   // movl         $4, %edx
+	LONG $0x04c7f640               // testb        $4, %dil
+	LONG $0xff4b840f; WORD $0xffff // je           LBB35_2, $-181(%rip)
+	LONG $0x3003e781; WORD $0x0000 // andl         $12291, %edi
+	LONG $0xff3f840f; WORD $0xffff // je           LBB35_2, $-193(%rip)
+
+LBB35_13:
+	WORD $0xf748; BYTE $0xd0 // notq         %rax
+	WORD $0x014c; BYTE $0xd0 // addq         %r10, %rax
+	LONG $0x08c48348         // addq         $8, %rsp
+	BYTE $0x5b               // popq         %rbx
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB35_14:
+	WORD $0x014d; BYTE $0xd3             // addq         %r10, %r11
+	WORD $0x394c; BYTE $0xd8             // cmpq         %r11, %rax
+	LONG $0x0103830f; WORD $0x0000       // jae          LBB35_30, $259(%rip)
+	LONG $0xf4458d4c                     // leaq         $-12(%rbp), %r8
+	LONG $0xf24d8d4c                     // leaq         $-14(%rbp), %r9
+	LONG $0x000015e9; BYTE $0x00         // jmp          LBB35_17, $21(%rip)
+	QUAD $0x9090909090909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB35_16:
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x394c; BYTE $0xd8       // cmpq         %r11, %rax
+	LONG $0x00e1830f; WORD $0x0000 // jae          LBB35_30, $225(%rip)
+
+LBB35_17:
+	WORD $0x3880; BYTE $0x00       // cmpb         $0, (%rax)
+	LONG $0xffeb890f; WORD $0xffff // jns          LBB35_16, $-21(%rip)
+	LONG $0x00f445c6               // movb         $0, $-12(%rbp)
+	LONG $0x00f245c6               // movb         $0, $-14(%rbp)
+	WORD $0x894c; BYTE $0xda       // movq         %r11, %rdx
+	WORD $0x2948; BYTE $0xc2       // subq         %rax, %rdx
+	LONG $0x02fa8348               // cmpq         $2, %rdx
+	LONG $0x0031820f; WORD $0x0000 // jb           LBB35_21, $49(%rip)
+	WORD $0xb60f; BYTE $0x30       // movzbl       (%rax), %esi
+	LONG $0x0178b60f               // movzbl       $1(%rax), %edi
+	LONG $0xf4758840               // movb         %sil, $-12(%rbp)
+	LONG $0x02488d48               // leaq         $2(%rax), %rcx
+	LONG $0xfec28348               // addq         $-2, %rdx
+	WORD $0x894c; BYTE $0xcb       // movq         %r9, %rbx
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0x0025840f; WORD $0x0000 // je           LBB35_22, $37(%rip)
+
+LBB35_20:
+	WORD $0xb60f; BYTE $0x09     // movzbl       (%rcx), %ecx
+	WORD $0x0b88                 // movb         %cl, (%rbx)
+	LONG $0xf475b60f             // movzbl       $-12(%rbp), %esi
+	LONG $0xf24db60f             // movzbl       $-14(%rbp), %ecx
+	LONG $0x000015e9; BYTE $0x00 // jmp          LBB35_23, $21(%rip)
+
+LBB35_21:
+	WORD $0xf631                   // xorl         %esi, %esi
+	WORD $0xff31                   // xorl         %edi, %edi
+	WORD $0x894c; BYTE $0xc3       // movq         %r8, %rbx
+	WORD $0x8948; BYTE $0xc1       // movq         %rax, %rcx
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0xffdb850f; WORD $0xffff // jne          LBB35_20, $-37(%rip)
+
+LBB35_22:
+	WORD $0xc931 // xorl         %ecx, %ecx
+
+LBB35_23:
+	WORD $0xb60f; BYTE $0xc9       // movzbl       %cl, %ecx
+	WORD $0xe1c1; BYTE $0x10       // shll         $16, %ecx
+	LONG $0xffb60f40               // movzbl       %dil, %edi
+	WORD $0xe7c1; BYTE $0x08       // shll         $8, %edi
+	WORD $0xcf09                   // orl          %ecx, %edi
+	LONG $0xd6b60f40               // movzbl       %sil, %edx
+	WORD $0xfa09                   // orl          %edi, %edx
+	WORD $0xd189                   // movl         %edx, %ecx
+	LONG $0xc0f0e181; WORD $0x00c0 // andl         $12632304, %ecx
+	LONG $0x80e0f981; WORD $0x0080 // cmpl         $8421600, %ecx
+	LONG $0x0024850f; WORD $0x0000 // jne          LBB35_26, $36(%rip)
+	WORD $0xd789                   // movl         %edx, %edi
+	LONG $0x200fe781; WORD $0x0000 // andl         $8207, %edi
+	LONG $0x200dff81; WORD $0x0000 // cmpl         $8205, %edi
+	LONG $0x0010840f; WORD $0x0000 // je           LBB35_26, $16(%rip)
+	LONG $0x000003b9; BYTE $0x00   // movl         $3, %ecx
+	WORD $0xff85                   // testl        %edi, %edi
+	LONG $0x0024850f; WORD $0x0000 // jne          LBB35_28, $36(%rip)
+	WORD $0x9090; BYTE $0x90       // .p2align 4, 0x90
+
+LBB35_26:
+	LONG $0x1ec6f640               // testb        $30, %sil
+	LONG $0xff07840f; WORD $0xffff // je           LBB35_13, $-249(%rip)
+	LONG $0xc0e0e281; WORD $0x0000 // andl         $49376, %edx
+	LONG $0x000002b9; BYTE $0x00   // movl         $2, %ecx
+	LONG $0x80c0fa81; WORD $0x0000 // cmpl         $32960, %edx
+	LONG $0xfef0850f; WORD $0xffff // jne          LBB35_13, $-272(%rip)
+
+LBB35_28:
+	WORD $0x0148; BYTE $0xc8       // addq         %rcx, %rax
+	WORD $0x394c; BYTE $0xd8       // cmpq         %r11, %rax
+	LONG $0xff1f820f; WORD $0xffff // jb           LBB35_17, $-225(%rip)
+
+LBB35_30:
+	WORD $0xc031                           // xorl         %eax, %eax
+	LONG $0x08c48348                       // addq         $8, %rsp
+	BYTE $0x5b                             // popq         %rbx
+	BYTE $0x5d                             // popq         %rbp
+	BYTE $0xc3                             // retq
+	QUAD $0x0000000000000000; WORD $0x0000 // .p2align 4, 0x00
+
+LCPI36_0:
+	QUAD $0x3030303030303030; QUAD $0x3030303030303030 // .space 16, '0000000000000000'
+
+	// .p2align 4, 0x90
+_f32toa:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	BYTE $0x50                                 // pushq        %rax
+	LONG $0xc07e0f66                           // movd         %xmm0, %eax
+	WORD $0xc189                               // movl         %eax, %ecx
+	WORD $0xe9c1; BYTE $0x17                   // shrl         $23, %ecx
+	WORD $0xb60f; BYTE $0xd1                   // movzbl       %cl, %edx
+	LONG $0x00fffa81; WORD $0x0000             // cmpl         $255, %edx
+	LONG $0x0c90840f; WORD $0x0000             // je           LBB36_1, $3216(%rip)
+	WORD $0x07c6; BYTE $0x2d                   // movb         $45, (%rdi)
+	WORD $0x8941; BYTE $0xc5                   // movl         %eax, %r13d
+	LONG $0x1fedc141                           // shrl         $31, %r13d
+	LONG $0x2f0c8d4e                           // leaq         (%rdi,%r13), %r9
+	LONG $0xffffffa9; BYTE $0x7f               // testl        $2147483647, %eax
+	LONG $0x0191840f; WORD $0x0000             // je           LBB36_3, $401(%rip)
+	LONG $0x7fffff25; BYTE $0x00               // andl         $8388607, %eax
+	WORD $0xd285                               // testl        %edx, %edx
+	LONG $0x0c71840f; WORD $0x0000             // je           LBB36_5, $3185(%rip)
+	LONG $0x00b88d44; WORD $0x8000; BYTE $0x00 // leal         $8388608(%rax), %r15d
+	LONG $0x6a828d44; WORD $0xffff; BYTE $0xff // leal         $-150(%rdx), %r8d
+	WORD $0x4a8d; BYTE $0x81                   // leal         $-127(%rdx), %ecx
+	WORD $0xf983; BYTE $0x17                   // cmpl         $23, %ecx
+	LONG $0x001c870f; WORD $0x0000             // ja           LBB36_6, $28(%rip)
+	LONG $0x000096b9; BYTE $0x00               // movl         $150, %ecx
+	WORD $0xd129                               // subl         %edx, %ecx
+	LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rbx
+	WORD $0xd348; BYTE $0xe3                   // shlq         %cl, %rbx
+	WORD $0xd3f7                               // notl         %ebx
+	WORD $0x8544; BYTE $0xfb                   // testl        %r15d, %ebx
+	LONG $0x0303840f; WORD $0x0000             // je           LBB36_11, $771(%rip)
+
+LBB36_6:
+	WORD $0x8945; BYTE $0xfe                   // movl         %r15d, %r14d
+	LONG $0x01e68341                           // andl         $1, %r14d
+	WORD $0xc085                               // testl        %eax, %eax
+	WORD $0x940f; BYTE $0xc0                   // sete         %al
+	WORD $0xfa83; BYTE $0x02                   // cmpl         $2, %edx
+	WORD $0x930f; BYTE $0xc1                   // setae        %cl
+	WORD $0xc120                               // andb         %al, %cl
+	WORD $0xb60f; BYTE $0xc9                   // movzbl       %cl, %ecx
+	WORD $0x8945; BYTE $0xfa                   // movl         %r15d, %r10d
+	LONG $0x02e2c141                           // shll         $2, %r10d
+	LONG $0xb9048d42                           // leal         (%rcx,%r15,4), %eax
+	WORD $0xc083; BYTE $0xfe                   // addl         $-2, %eax
+	LONG $0x13d06941; WORD $0x1344; BYTE $0x00 // imull        $1262611, %r8d, %edx
+	LONG $0x019a8d44; WORD $0xf801; BYTE $0xff // leal         $-524031(%rdx), %r11d
+	WORD $0xc984                               // testb        %cl, %cl
+	LONG $0xda440f44                           // cmovel       %edx, %r11d
+	LONG $0x16fbc141                           // sarl         $22, %r11d
+	LONG $0xb1cb6941; WORD $0xe56c; BYTE $0xff // imull        $-1741647, %r11d, %ecx
+	WORD $0xe9c1; BYTE $0x13                   // shrl         $19, %ecx
+	WORD $0x0144; BYTE $0xc1                   // addl         %r8d, %ecx
+	LONG $0x00001fba; BYTE $0x00               // movl         $31, %edx
+	WORD $0x2944; BYTE $0xda                   // subl         %r11d, %edx
+	LONG $0x65358d48; WORD $0x00b7; BYTE $0x00 // leaq         $46949(%rip), %rsi  /* _pow10_ceil_sig_f32.g(%rip) */
+	WORD $0xc1fe                               // incb         %cl
+	WORD $0xe0d3                               // shll         %cl, %eax
+	LONG $0xd6248b4c                           // movq         (%rsi,%rdx,8), %r12
+	WORD $0xf749; BYTE $0xe4                   // mulq         %r12
+	QUAD $0x00000002bd048d46                   // leal         $2(,%r15,4), %r8d
+	WORD $0xf631                               // xorl         %esi, %esi
+	LONG $0x21e8c148                           // shrq         $33, %rax
+	LONG $0xc6950f40                           // setne        %sil
+	WORD $0xd609                               // orl          %edx, %esi
+	WORD $0xd341; BYTE $0xe2                   // shll         %cl, %r10d
+	WORD $0x894c; BYTE $0xd0                   // movq         %r10, %rax
+	WORD $0xf749; BYTE $0xe4                   // mulq         %r12
+	WORD $0x8949; BYTE $0xd2                   // movq         %rdx, %r10
+	WORD $0x3145; BYTE $0xff                   // xorl         %r15d, %r15d
+	LONG $0x21e8c148                           // shrq         $33, %rax
+	LONG $0xc7950f41                           // setne        %r15b
+	WORD $0x0945; BYTE $0xd7                   // orl          %r10d, %r15d
+	WORD $0xd341; BYTE $0xe0                   // shll         %cl, %r8d
+	WORD $0x894c; BYTE $0xc0                   // movq         %r8, %rax
+	WORD $0xf749; BYTE $0xe4                   // mulq         %r12
+	WORD $0xc931                               // xorl         %ecx, %ecx
+	LONG $0x21e8c148                           // shrq         $33, %rax
+	WORD $0x950f; BYTE $0xc1                   // setne        %cl
+	WORD $0xd109                               // orl          %edx, %ecx
+	WORD $0x0144; BYTE $0xf6                   // addl         %r14d, %esi
+	WORD $0x2944; BYTE $0xf1                   // subl         %r14d, %ecx
+	LONG $0x28ff8341                           // cmpl         $40, %r15d
+	LONG $0x0042820f; WORD $0x0000             // jb           LBB36_26, $66(%rip)
+	WORD $0x8944; BYTE $0xd0                   // movl         %r10d, %eax
+	LONG $0xcccccdba; BYTE $0xcc               // movl         $3435973837, %edx
+	LONG $0xd0af0f48                           // imulq        %rax, %rdx
+	LONG $0x25eac148                           // shrq         $37, %rdx
+	WORD $0x8941; BYTE $0xf0                   // movl         %esi, %r8d
+	QUAD $0x00000000d51c8d48                   // leaq         (,%rdx,8), %rbx
+	LONG $0x9b048d48                           // leaq         (%rbx,%rbx,4), %rax
+	WORD $0x394c; BYTE $0xc0                   // cmpq         %r8, %rax
+	LONG $0xc6920f41                           // setb         %r14b
+	LONG $0x9b048d4c                           // leaq         (%rbx,%rbx,4), %r8
+	LONG $0x28c08349                           // addq         $40, %r8
+	WORD $0xcb89                               // movl         %ecx, %ebx
+	WORD $0xc031                               // xorl         %eax, %eax
+	WORD $0x3949; BYTE $0xd8                   // cmpq         %rbx, %r8
+	LONG $0xc0960f41                           // setbe        %r8b
+	WORD $0x3845; BYTE $0xc6                   // cmpb         %r8b, %r14b
+	LONG $0x00b3840f; WORD $0x0000             // je           LBB36_8, $179(%rip)
+
+LBB36_26:
+	WORD $0x8945; BYTE $0xd0       // movl         %r10d, %r8d
+	LONG $0x02e8c141               // shrl         $2, %r8d
+	WORD $0x8944; BYTE $0xd2       // movl         %r10d, %edx
+	WORD $0xe283; BYTE $0xfc       // andl         $-4, %edx
+	WORD $0xd639                   // cmpl         %edx, %esi
+	LONG $0xc6970f40               // seta         %sil
+	WORD $0x428d; BYTE $0x04       // leal         $4(%rdx), %eax
+	WORD $0xc839                   // cmpl         %ecx, %eax
+	WORD $0x960f; BYTE $0xc3       // setbe        %bl
+	WORD $0x3040; BYTE $0xf3       // xorb         %sil, %bl
+	LONG $0x0044840f; WORD $0x0000 // je           LBB36_27, $68(%rip)
+	WORD $0xca83; BYTE $0x02       // orl          $2, %edx
+	LONG $0x000001b8; BYTE $0x00   // movl         $1, %eax
+	WORD $0x3941; BYTE $0xd7       // cmpl         %edx, %r15d
+	LONG $0x000e870f; WORD $0x0000 // ja           LBB36_30, $14(%rip)
+	WORD $0x940f; BYTE $0xc0       // sete         %al
+	LONG $0x02eac041               // shrb         $2, %r10b
+	WORD $0x2041; BYTE $0xc2       // andb         %al, %r10b
+	LONG $0xc2b60f41               // movzbl       %r10b, %eax
+
+LBB36_30:
+	WORD $0x0144; BYTE $0xc0       // addl         %r8d, %eax
+	LONG $0x0186a03d; BYTE $0x00   // cmpl         $100000, %eax
+	LONG $0x002b830f; WORD $0x0000 // jae          LBB36_32, $43(%rip)
+	LONG $0x000070e9; BYTE $0x00   // jmp          LBB36_35, $112(%rip)
+
+LBB36_3:
+	LONG $0x3001c641             // movb         $48, (%r9)
+	WORD $0x2941; BYTE $0xf9     // subl         %edi, %r9d
+	WORD $0xff41; BYTE $0xc1     // incl         %r9d
+	WORD $0x8944; BYTE $0xc8     // movl         %r9d, %eax
+	LONG $0x0006b3e9; BYTE $0x00 // jmp          LBB36_147, $1715(%rip)
+
+LBB36_27:
+	WORD $0xc139                   // cmpl         %eax, %ecx
+	LONG $0xffd88341               // sbbl         $-1, %r8d
+	WORD $0x8944; BYTE $0xc0       // movl         %r8d, %eax
+	LONG $0x0186a03d; BYTE $0x00   // cmpl         $100000, %eax
+	LONG $0x004a820f; WORD $0x0000 // jb           LBB36_35, $74(%rip)
+
+LBB36_32:
+	LONG $0x0006be41; WORD $0x0000 // movl         $6, %r14d
+	LONG $0x0f42403d; BYTE $0x00   // cmpl         $1000000, %eax
+	LONG $0x0078820f; WORD $0x0000 // jb           LBB36_39, $120(%rip)
+	LONG $0x0007be41; WORD $0x0000 // movl         $7, %r14d
+	LONG $0x9896803d; BYTE $0x00   // cmpl         $10000000, %eax
+	LONG $0x0067820f; WORD $0x0000 // jb           LBB36_39, $103(%rip)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	LONG $0xf5e1003d; BYTE $0x05   // cmpl         $100000000, %eax
+	LONG $0xc6920f41               // setb         %r14b
+	LONG $0x09f68341               // xorl         $9, %r14d
+	LONG $0x000052e9; BYTE $0x00   // jmp          LBB36_39, $82(%rip)
+
+LBB36_8:
+	WORD $0x8844; BYTE $0xc0       // movb         %r8b, %al
+	WORD $0xd001                   // addl         %edx, %eax
+	WORD $0xff41; BYTE $0xc3       // incl         %r11d
+	LONG $0x0186a03d; BYTE $0x00   // cmpl         $100000, %eax
+	LONG $0xffb6830f; WORD $0xffff // jae          LBB36_32, $-74(%rip)
+
+LBB36_35:
+	LONG $0x0001be41; WORD $0x0000 // movl         $1, %r14d
+	WORD $0xf883; BYTE $0x0a       // cmpl         $10, %eax
+	LONG $0x0030820f; WORD $0x0000 // jb           LBB36_39, $48(%rip)
+	LONG $0x0002be41; WORD $0x0000 // movl         $2, %r14d
+	WORD $0xf883; BYTE $0x64       // cmpl         $100, %eax
+	LONG $0x0021820f; WORD $0x0000 // jb           LBB36_39, $33(%rip)
+	LONG $0x0003be41; WORD $0x0000 // movl         $3, %r14d
+	LONG $0x0003e83d; BYTE $0x00   // cmpl         $1000, %eax
+	LONG $0x0010820f; WORD $0x0000 // jb           LBB36_39, $16(%rip)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	LONG $0x0027103d; BYTE $0x00   // cmpl         $10000, %eax
+	LONG $0xc6920f41               // setb         %r14b
+	LONG $0x05f68341               // xorl         $5, %r14d
+
+LBB36_39:
+	LONG $0x1e148d47                           // leal         (%r14,%r11), %r10d
+	LONG $0x1e0c8d43                           // leal         (%r14,%r11), %ecx
+	WORD $0xc183; BYTE $0xea                   // addl         $-22, %ecx
+	WORD $0xf983; BYTE $0xe4                   // cmpl         $-28, %ecx
+	LONG $0x0069870f; WORD $0x0000             // ja           LBB36_64, $105(%rip)
+	WORD $0x8945; BYTE $0xf6                   // movl         %r14d, %r14d
+	LONG $0x31148d4b                           // leaq         (%r9,%r14), %rdx
+	WORD $0xff48; BYTE $0xc2                   // incq         %rdx
+	LONG $0x0027103d; BYTE $0x00               // cmpl         $10000, %eax
+	LONG $0x00c8820f; WORD $0x0000             // jb           LBB36_41, $200(%rip)
+	WORD $0xc389                               // movl         %eax, %ebx
+	LONG $0xb71759b9; BYTE $0xd1               // movl         $3518437209, %ecx
+	LONG $0xcbaf0f48                           // imulq        %rbx, %rcx
+	LONG $0x2de9c148                           // shrq         $45, %rcx
+	LONG $0xf0c16944; WORD $0xffd8; BYTE $0xff // imull        $-10000, %ecx, %r8d
+	WORD $0x0141; BYTE $0xc0                   // addl         %eax, %r8d
+	LONG $0x02f8840f; WORD $0x0000             // je           LBB36_43, $760(%rip)
+	WORD $0x8944; BYTE $0xc0                   // movl         %r8d, %eax
+	LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xd86b; BYTE $0x64                   // imull        $100, %eax, %ebx
+	WORD $0x2941; BYTE $0xd8                   // subl         %ebx, %r8d
+	LONG $0xde1d8d4c; WORD $0x0041; BYTE $0x00 // leaq         $16862(%rip), %r11  /* _Digits(%rip) */
+	LONG $0x1cb70f43; BYTE $0x43               // movzwl       (%r11,%r8,2), %ebx
+	LONG $0xfe5a8966                           // movw         %bx, $-2(%rdx)
+	LONG $0x04b70f41; BYTE $0x43               // movzwl       (%r11,%rax,2), %eax
+	LONG $0xfc428966                           // movw         %ax, $-4(%rdx)
+	WORD $0x3145; BYTE $0xc0                   // xorl         %r8d, %r8d
+	LONG $0x0002c9e9; BYTE $0x00               // jmp          LBB36_45, $713(%rip)
+
+LBB36_64:
+	WORD $0x8945; BYTE $0xf4                   // movl         %r14d, %r12d
+	WORD $0x8545; BYTE $0xdb                   // testl        %r11d, %r11d
+	LONG $0x0109880f; WORD $0x0000             // js           LBB36_65, $265(%rip)
+	LONG $0x213c8d4f                           // leaq         (%r9,%r12), %r15
+	LONG $0x0027103d; BYTE $0x00               // cmpl         $10000, %eax
+	LONG $0x0136820f; WORD $0x0000             // jb           LBB36_118, $310(%rip)
+	WORD $0xc189                               // movl         %eax, %ecx
+	LONG $0xb71759ba; BYTE $0xd1               // movl         $3518437209, %edx
+	LONG $0xd1af0f48                           // imulq        %rcx, %rdx
+	LONG $0x2deac148                           // shrq         $45, %rdx
+	LONG $0xd8f0ca69; WORD $0xffff             // imull        $-10000, %edx, %ecx
+	WORD $0xc101                               // addl         %eax, %ecx
+	LONG $0x1fc16948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rcx, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xd86b; BYTE $0x64                   // imull        $100, %eax, %ebx
+	WORD $0xd929                               // subl         %ebx, %ecx
+	LONG $0x7b1d8d48; WORD $0x0041; BYTE $0x00 // leaq         $16763(%rip), %rbx  /* _Digits(%rip) */
+	LONG $0x4b0cb70f                           // movzwl       (%rbx,%rcx,2), %ecx
+	LONG $0x4f894166; BYTE $0xfe               // movw         %cx, $-2(%r15)
+	LONG $0xfc4f8d49                           // leaq         $-4(%r15), %rcx
+	LONG $0x4304b70f                           // movzwl       (%rbx,%rax,2), %eax
+	LONG $0x47894166; BYTE $0xfc               // movw         %ax, $-4(%r15)
+	WORD $0xd089                               // movl         %edx, %eax
+	WORD $0x8945; BYTE $0xd3                   // movl         %r10d, %r11d
+	WORD $0xf883; BYTE $0x64                   // cmpl         $100, %eax
+	LONG $0x00f3830f; WORD $0x0000             // jae          LBB36_122, $243(%rip)
+
+LBB36_121:
+	WORD $0xc289                 // movl         %eax, %edx
+	LONG $0x00012ee9; BYTE $0x00 // jmp          LBB36_124, $302(%rip)
+
+LBB36_41:
+	WORD $0x3145; BYTE $0xc0       // xorl         %r8d, %r8d
+	WORD $0xc189                   // movl         %eax, %ecx
+	WORD $0xf983; BYTE $0x64       // cmpl         $100, %ecx
+	LONG $0x0254830f; WORD $0x0000 // jae          LBB36_48, $596(%rip)
+
+LBB36_47:
+	WORD $0xc889                 // movl         %ecx, %eax
+	LONG $0x00028ae9; BYTE $0x00 // jmp          LBB36_50, $650(%rip)
+
+LBB36_11:
+	WORD $0xd341; BYTE $0xef                   // shrl         %cl, %r15d
+	LONG $0xa0ff8141; WORD $0x0186; BYTE $0x00 // cmpl         $100000, %r15d
+	LONG $0x017d820f; WORD $0x0000             // jb           LBB36_14, $381(%rip)
+	LONG $0x80ff8141; WORD $0x9896; BYTE $0x00 // cmpl         $10000000, %r15d
+	LONG $0x000008b8; BYTE $0x00               // movl         $8, %eax
+	LONG $0x00d88348                           // sbbq         $0, %rax
+	LONG $0x40ff8141; WORD $0x0f42; BYTE $0x00 // cmpl         $1000000, %r15d
+	LONG $0x000006b9; BYTE $0x00               // movl         $6, %ecx
+	LONG $0xc8430f48                           // cmovaeq      %rax, %rcx
+	WORD $0x014c; BYTE $0xc9                   // addq         %r9, %rcx
+
+LBB36_13:
+	WORD $0x8944; BYTE $0xf8                   // movl         %r15d, %eax
+	LONG $0xb71759ba; BYTE $0xd1               // movl         $3518437209, %edx
+	LONG $0xd0af0f48                           // imulq        %rax, %rdx
+	LONG $0x2deac148                           // shrq         $45, %rdx
+	LONG $0xd8f0c269; WORD $0xffff             // imull        $-10000, %edx, %eax
+	WORD $0x0144; BYTE $0xf8                   // addl         %r15d, %eax
+	LONG $0x1ff06948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rsi
+	LONG $0x25eec148                           // shrq         $37, %rsi
+	WORD $0xde6b; BYTE $0x64                   // imull        $100, %esi, %ebx
+	WORD $0xd829                               // subl         %ebx, %eax
+	LONG $0xd81d8d48; WORD $0x0040; BYTE $0x00 // leaq         $16600(%rip), %rbx  /* _Digits(%rip) */
+	LONG $0x4304b70f                           // movzwl       (%rbx,%rax,2), %eax
+	LONG $0xfe418966                           // movw         %ax, $-2(%rcx)
+	LONG $0x7304b70f                           // movzwl       (%rbx,%rsi,2), %eax
+	LONG $0xfc418966                           // movw         %ax, $-4(%rcx)
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	LONG $0xfcc18348                           // addq         $-4, %rcx
+	WORD $0x8941; BYTE $0xd7                   // movl         %edx, %r15d
+	LONG $0x64ff8341                           // cmpl         $100, %r15d
+	LONG $0x0146830f; WORD $0x0000             // jae          LBB36_21, $326(%rip)
+	LONG $0x000181e9; BYTE $0x00               // jmp          LBB36_23, $385(%rip)
+
+LBB36_65:
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0x05458f0f; WORD $0x0000 // jg           LBB36_79, $1349(%rip)
+	LONG $0x01c74166; WORD $0x2e30 // movw         $11824, (%r9)
+	LONG $0x02c18349               // addq         $2, %r9
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0x0532890f; WORD $0x0000 // jns          LBB36_79, $1330(%rip)
+	WORD $0x894c; BYTE $0xe3       // movq         %r12, %rbx
+	WORD $0x8945; BYTE $0xf4       // movl         %r14d, %r12d
+	WORD $0xf741; BYTE $0xd4       // notl         %r12d
+	WORD $0x2945; BYTE $0xdc       // subl         %r11d, %r12d
+	WORD $0xc931                   // xorl         %ecx, %ecx
+	LONG $0x1ffc8341               // cmpl         $31, %r12d
+	LONG $0x0402830f; WORD $0x0000 // jae          LBB36_69, $1026(%rip)
+	WORD $0x8949; BYTE $0xdc       // movq         %rbx, %r12
+	LONG $0x0004f2e9; BYTE $0x00   // jmp          LBB36_77, $1266(%rip)
+
+LBB36_118:
+	WORD $0x894c; BYTE $0xf9       // movq         %r15, %rcx
+	WORD $0x8945; BYTE $0xd3       // movl         %r10d, %r11d
+	WORD $0xf883; BYTE $0x64       // cmpl         $100, %eax
+	LONG $0xff0d820f; WORD $0xffff // jb           LBB36_121, $-243(%rip)
+
+LBB36_122:
+	WORD $0xff48; BYTE $0xc9                   // decq         %rcx
+	LONG $0x5a058d4c; WORD $0x0040; BYTE $0x00 // leaq         $16474(%rip), %r8  /* _Digits(%rip) */
+	QUAD $0x9090909090909090; WORD $0x9090     // .p2align 4, 0x90
+
+LBB36_123:
+	WORD $0xc289                               // movl         %eax, %edx
+	LONG $0x1fd26948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rdx, %rdx
+	LONG $0x25eac148                           // shrq         $37, %rdx
+	WORD $0xda6b; BYTE $0x64                   // imull        $100, %edx, %ebx
+	WORD $0xc689                               // movl         %eax, %esi
+	WORD $0xde29                               // subl         %ebx, %esi
+	LONG $0x34b70f41; BYTE $0x70               // movzwl       (%r8,%rsi,2), %esi
+	LONG $0xff718966                           // movw         %si, $-1(%rcx)
+	LONG $0xfec18348                           // addq         $-2, %rcx
+	LONG $0x00270f3d; BYTE $0x00               // cmpl         $9999, %eax
+	WORD $0xd089                               // movl         %edx, %eax
+	LONG $0xffd2870f; WORD $0xffff             // ja           LBB36_123, $-46(%rip)
+
+LBB36_124:
+	WORD $0xfa83; BYTE $0x0a                   // cmpl         $10, %edx
+	LONG $0x0022820f; WORD $0x0000             // jb           LBB36_126, $34(%rip)
+	WORD $0xd089                               // movl         %edx, %eax
+	LONG $0x100d8d48; WORD $0x0040; BYTE $0x00 // leaq         $16400(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	LONG $0x01894166                           // movw         %ax, (%r9)
+	WORD $0x014d; BYTE $0xd9                   // addq         %r11, %r9
+	WORD $0x3945; BYTE $0xd6                   // cmpl         %r10d, %r14d
+	LONG $0x0017820f; WORD $0x0000             // jb           LBB36_128, $23(%rip)
+	LONG $0x0003c7e9; BYTE $0x00               // jmp          LBB36_145, $967(%rip)
+
+LBB36_126:
+	WORD $0xc280; BYTE $0x30       // addb         $48, %dl
+	WORD $0x8841; BYTE $0x11       // movb         %dl, (%r9)
+	WORD $0x014d; BYTE $0xd9       // addq         %r11, %r9
+	WORD $0x3945; BYTE $0xd6       // cmpl         %r10d, %r14d
+	LONG $0x03b5830f; WORD $0x0000 // jae          LBB36_145, $949(%rip)
+
+LBB36_128:
+	LONG $0x2f048d4a               // leaq         (%rdi,%r13), %rax
+	LONG $0x040c8d49               // leaq         (%r12,%rax), %rcx
+	WORD $0xff48; BYTE $0xc1       // incq         %rcx
+	WORD $0x0149; BYTE $0xc3       // addq         %rax, %r11
+	WORD $0x394c; BYTE $0xd9       // cmpq         %r11, %rcx
+	LONG $0xd9470f4c               // cmovaq       %rcx, %r11
+	WORD $0x014c; BYTE $0xe0       // addq         %r12, %rax
+	WORD $0x2949; BYTE $0xc3       // subq         %rax, %r11
+	LONG $0x08fb8349               // cmpq         $8, %r11
+	LONG $0x0380820f; WORD $0x0000 // jb           LBB36_144, $896(%rip)
+	LONG $0x20fb8349               // cmpq         $32, %r11
+	LONG $0x01e5830f; WORD $0x0000 // jae          LBB36_134, $485(%rip)
+	WORD $0x3145; BYTE $0xd2       // xorl         %r10d, %r10d
+	LONG $0x0002c9e9; BYTE $0x00   // jmp          LBB36_131, $713(%rip)
+
+LBB36_14:
+	LONG $0x000001b8; BYTE $0x00               // movl         $1, %eax
+	LONG $0x0aff8341                           // cmpl         $10, %r15d
+	LONG $0x0021820f; WORD $0x0000             // jb           LBB36_17, $33(%rip)
+	LONG $0x000002b8; BYTE $0x00               // movl         $2, %eax
+	LONG $0x64ff8341                           // cmpl         $100, %r15d
+	LONG $0x0012820f; WORD $0x0000             // jb           LBB36_17, $18(%rip)
+	LONG $0x000003b8; BYTE $0x00               // movl         $3, %eax
+	LONG $0xe7ff8141; WORD $0x0003; BYTE $0x00 // cmpl         $999, %r15d
+	LONG $0x02de870f; WORD $0x0000             // ja           LBB36_19, $734(%rip)
+
+LBB36_17:
+	WORD $0x014c; BYTE $0xc8       // addq         %r9, %rax
+	WORD $0x8948; BYTE $0xc1       // movq         %rax, %rcx
+	LONG $0x64ff8341               // cmpl         $100, %r15d
+	LONG $0x0040820f; WORD $0x0000 // jb           LBB36_23, $64(%rip)
+
+LBB36_21:
+	WORD $0xff48; BYTE $0xc9                   // decq         %rcx
+	LONG $0x64058d4c; WORD $0x003f; BYTE $0x00 // leaq         $16228(%rip), %r8  /* _Digits(%rip) */
+	LONG $0x90909090                           // .p2align 4, 0x90
+
+LBB36_22:
+	WORD $0x8944; BYTE $0xfb                   // movl         %r15d, %ebx
+	WORD $0x8944; BYTE $0xfe                   // movl         %r15d, %esi
+	LONG $0x1ffe694c; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rsi, %r15
+	LONG $0x25efc149                           // shrq         $37, %r15
+	LONG $0x64d76b41                           // imull        $100, %r15d, %edx
+	WORD $0xde89                               // movl         %ebx, %esi
+	WORD $0xd629                               // subl         %edx, %esi
+	LONG $0x14b70f41; BYTE $0x70               // movzwl       (%r8,%rsi,2), %edx
+	LONG $0xff518966                           // movw         %dx, $-1(%rcx)
+	LONG $0xfec18348                           // addq         $-2, %rcx
+	LONG $0x270ffb81; WORD $0x0000             // cmpl         $9999, %ebx
+	LONG $0xffce870f; WORD $0xffff             // ja           LBB36_22, $-50(%rip)
+
+LBB36_23:
+	LONG $0x0aff8341                           // cmpl         $10, %r15d
+	LONG $0x0017820f; WORD $0x0000             // jb           LBB36_25, $23(%rip)
+	WORD $0x8944; BYTE $0xf9                   // movl         %r15d, %ecx
+	LONG $0x1a158d48; WORD $0x003f; BYTE $0x00 // leaq         $16154(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x4a0cb70f                           // movzwl       (%rdx,%rcx,2), %ecx
+	LONG $0x09894166                           // movw         %cx, (%r9)
+	LONG $0x0002e0e9; BYTE $0x00               // jmp          LBB36_146, $736(%rip)
+
+LBB36_25:
+	LONG $0x30c78041             // addb         $48, %r15b
+	WORD $0x8845; BYTE $0x39     // movb         %r15b, (%r9)
+	LONG $0x0002d4e9; BYTE $0x00 // jmp          LBB36_146, $724(%rip)
+
+LBB36_43:
+	LONG $0x0004b841; WORD $0x0000 // movl         $4, %r8d
+
+LBB36_45:
+	LONG $0xfcc28348               // addq         $-4, %rdx
+	WORD $0xf983; BYTE $0x64       // cmpl         $100, %ecx
+	LONG $0xfdac820f; WORD $0xffff // jb           LBB36_47, $-596(%rip)
+
+LBB36_48:
+	WORD $0xff48; BYTE $0xca                   // decq         %rdx
+	LONG $0xe41d8d4c; WORD $0x003e; BYTE $0x00 // leaq         $16100(%rip), %r11  /* _Digits(%rip) */
+	LONG $0x90909090                           // .p2align 4, 0x90
+
+LBB36_49:
+	WORD $0xc889                               // movl         %ecx, %eax
+	LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xd86b; BYTE $0x64                   // imull        $100, %eax, %ebx
+	WORD $0xce89                               // movl         %ecx, %esi
+	WORD $0xde29                               // subl         %ebx, %esi
+	LONG $0x34b70f41; BYTE $0x73               // movzwl       (%r11,%rsi,2), %esi
+	LONG $0xff728966                           // movw         %si, $-1(%rdx)
+	LONG $0xfec28348                           // addq         $-2, %rdx
+	LONG $0x270ff981; WORD $0x0000             // cmpl         $9999, %ecx
+	WORD $0xc189                               // movl         %eax, %ecx
+	LONG $0xffd1870f; WORD $0xffff             // ja           LBB36_49, $-47(%rip)
+
+LBB36_50:
+	LONG $0x01518d49                           // leaq         $1(%r9), %rdx
+	WORD $0xf883; BYTE $0x0a                   // cmpl         $10, %eax
+	LONG $0x001f820f; WORD $0x0000             // jb           LBB36_52, $31(%rip)
+	WORD $0xc189                               // movl         %eax, %ecx
+	LONG $0x9b358d48; WORD $0x003e; BYTE $0x00 // leaq         $16027(%rip), %rsi  /* _Digits(%rip) */
+	LONG $0x4e04b60f                           // movzbl       (%rsi,%rcx,2), %eax
+	LONG $0x4e4cb60f; BYTE $0x01               // movzbl       $1(%rsi,%rcx,2), %ecx
+	LONG $0x01418841                           // movb         %al, $1(%r9)
+	LONG $0x02498841                           // movb         %cl, $2(%r9)
+	LONG $0x000004e9; BYTE $0x00               // jmp          LBB36_53, $4(%rip)
+
+LBB36_52:
+	WORD $0x3004 // addb         $48, %al
+	WORD $0x0288 // movb         %al, (%rdx)
+
+LBB36_53:
+	WORD $0x294d; BYTE $0xc5     // subq         %r8, %r13
+	WORD $0x0149; BYTE $0xfd     // addq         %rdi, %r13
+	LONG $0x000001be; BYTE $0x00 // movl         $1, %esi
+	WORD $0x294c; BYTE $0xc6     // subq         %r8, %rsi
+	WORD $0x9090; BYTE $0x90     // .p2align 4, 0x90
+
+LBB36_54:
+	WORD $0xff48; BYTE $0xce       // decq         %rsi
+	LONG $0x357c8043; WORD $0x3000 // cmpb         $48, (%r13,%r14)
+	LONG $0xff6d8d4d               // leaq         $-1(%r13), %r13
+	LONG $0xffed840f; WORD $0xffff // je           LBB36_54, $-19(%rip)
+	WORD $0x8841; BYTE $0x01       // movb         %al, (%r9)
+	WORD $0x014c; BYTE $0xf6       // addq         %r14, %rsi
+	LONG $0x02fe8348               // cmpq         $2, %rsi
+	LONG $0x00458c0f; WORD $0x0000 // jl           LBB36_56, $69(%rip)
+	LONG $0x2e048d4b               // leaq         (%r14,%r13), %rax
+	LONG $0x02c08348               // addq         $2, %rax
+	WORD $0x02c6; BYTE $0x2e       // movb         $46, (%rdx)
+	WORD $0x00c6; BYTE $0x65       // movb         $101, (%rax)
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0x00418e0f; WORD $0x0000 // jle          LBB36_59, $65(%rip)
+
+LBB36_60:
+	WORD $0xff41; BYTE $0xca       // decl         %r10d
+	LONG $0x2b0140c6               // movb         $43, $1(%rax)
+	WORD $0x8944; BYTE $0xd1       // movl         %r10d, %ecx
+	WORD $0xf983; BYTE $0x0a       // cmpl         $10, %ecx
+	LONG $0x0043820f; WORD $0x0000 // jb           LBB36_63, $67(%rip)
+
+LBB36_62:
+	WORD $0x6348; BYTE $0xc9                   // movslq       %ecx, %rcx
+	LONG $0x19158d48; WORD $0x003e; BYTE $0x00 // leaq         $15897(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x4a0cb70f                           // movzwl       (%rdx,%rcx,2), %ecx
+	LONG $0x02488966                           // movw         %cx, $2(%rax)
+	LONG $0x04c08348                           // addq         $4, %rax
+	LONG $0x0001dbe9; BYTE $0x00               // jmp          LBB36_146, $475(%rip)
+
+LBB36_56:
+	LONG $0x2e048d4b               // leaq         (%r14,%r13), %rax
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x00c6; BYTE $0x65       // movb         $101, (%rax)
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0xffbf8f0f; WORD $0xffff // jg           LBB36_60, $-65(%rip)
+
+LBB36_59:
+	LONG $0x2d0140c6               // movb         $45, $1(%rax)
+	LONG $0x000001b9; BYTE $0x00   // movl         $1, %ecx
+	WORD $0x2944; BYTE $0xd1       // subl         %r10d, %ecx
+	WORD $0xf983; BYTE $0x0a       // cmpl         $10, %ecx
+	LONG $0xffbd830f; WORD $0xffff // jae          LBB36_62, $-67(%rip)
+
+LBB36_63:
+	WORD $0xc180; BYTE $0x30     // addb         $48, %cl
+	WORD $0x4888; BYTE $0x02     // movb         %cl, $2(%rax)
+	LONG $0x03c08348             // addq         $3, %rax
+	LONG $0x0001a4e9; BYTE $0x00 // jmp          LBB36_146, $420(%rip)
+
+LBB36_134:
+	WORD $0x894d; BYTE $0xda       // movq         %r11, %r10
+	LONG $0xe0e28349               // andq         $-32, %r10
+	LONG $0xe0428d49               // leaq         $-32(%r10), %rax
+	WORD $0x8948; BYTE $0xc1       // movq         %rax, %rcx
+	LONG $0x05e9c148               // shrq         $5, %rcx
+	WORD $0xff48; BYTE $0xc1       // incq         %rcx
+	WORD $0x8941; BYTE $0xc8       // movl         %ecx, %r8d
+	LONG $0x03e08341               // andl         $3, %r8d
+	LONG $0x60f88348               // cmpq         $96, %rax
+	LONG $0x0007830f; WORD $0x0000 // jae          LBB36_136, $7(%rip)
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x000061e9; BYTE $0x00   // jmp          LBB36_138, $97(%rip)
+
+LBB36_136:
+	LONG $0xfce18348                       // andq         $-4, %rcx
+	LONG $0x2c048d4b                       // leaq         (%r12,%r13), %rax
+	LONG $0x07148d48                       // leaq         (%rdi,%rax), %rdx
+	LONG $0x70c28348                       // addq         $112, %rdx
+	WORD $0xc031                           // xorl         %eax, %eax
+	QUAD $0xfffff8ba056f0f66               // movdqa       $-1862(%rip), %xmm0  /* LCPI36_0(%rip) */
+	QUAD $0x9090909090909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB36_137:
+	LONG $0x447f0ff3; WORD $0x9002 // movdqu       %xmm0, $-112(%rdx,%rax)
+	LONG $0x447f0ff3; WORD $0xa002 // movdqu       %xmm0, $-96(%rdx,%rax)
+	LONG $0x447f0ff3; WORD $0xb002 // movdqu       %xmm0, $-80(%rdx,%rax)
+	LONG $0x447f0ff3; WORD $0xc002 // movdqu       %xmm0, $-64(%rdx,%rax)
+	LONG $0x447f0ff3; WORD $0xd002 // movdqu       %xmm0, $-48(%rdx,%rax)
+	LONG $0x447f0ff3; WORD $0xe002 // movdqu       %xmm0, $-32(%rdx,%rax)
+	LONG $0x447f0ff3; WORD $0xf002 // movdqu       %xmm0, $-16(%rdx,%rax)
+	LONG $0x047f0ff3; BYTE $0x02   // movdqu       %xmm0, (%rdx,%rax)
+	LONG $0x80e88348               // subq         $-128, %rax
+	LONG $0xfcc18348               // addq         $-4, %rcx
+	LONG $0xffc3850f; WORD $0xffff // jne          LBB36_137, $-61(%rip)
+
+LBB36_138:
+	WORD $0x854d; BYTE $0xc0                                             // testq        %r8, %r8
+	LONG $0x0042840f; WORD $0x0000                                       // je           LBB36_141, $66(%rip)
+	WORD $0x014c; BYTE $0xe8                                             // addq         %r13, %rax
+	WORD $0x014c; BYTE $0xe0                                             // addq         %r12, %rax
+	WORD $0x0148; BYTE $0xf8                                             // addq         %rdi, %rax
+	LONG $0x10c08348                                                     // addq         $16, %rax
+	LONG $0x05e0c149                                                     // shlq         $5, %r8
+	WORD $0xc931                                                         // xorl         %ecx, %ecx
+	QUAD $0xfffff84f056f0f66                                             // movdqa       $-1969(%rip), %xmm0  /* LCPI36_0(%rip) */
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB36_140:
+	LONG $0x447f0ff3; WORD $0xf008 // movdqu       %xmm0, $-16(%rax,%rcx)
+	LONG $0x047f0ff3; BYTE $0x08   // movdqu       %xmm0, (%rax,%rcx)
+	LONG $0x20c18348               // addq         $32, %rcx
+	WORD $0x3949; BYTE $0xc8       // cmpq         %rcx, %r8
+	LONG $0xffe8850f; WORD $0xffff // jne          LBB36_140, $-24(%rip)
+
+LBB36_141:
+	WORD $0x394d; BYTE $0xd3       // cmpq         %r10, %r11
+	LONG $0x00bf840f; WORD $0x0000 // je           LBB36_145, $191(%rip)
+	LONG $0x18c3f641               // testb        $24, %r11b
+	LONG $0x009c840f; WORD $0x0000 // je           LBB36_143, $156(%rip)
+
+LBB36_131:
+	WORD $0x894d; BYTE $0xd8               // movq         %r11, %r8
+	LONG $0xf8e08349                       // andq         $-8, %r8
+	WORD $0x014d; BYTE $0xc7               // addq         %r8, %r15
+	WORD $0x014d; BYTE $0xd5               // addq         %r10, %r13
+	WORD $0x014d; BYTE $0xe5               // addq         %r12, %r13
+	WORD $0x0149; BYTE $0xfd               // addq         %rdi, %r13
+	WORD $0x894c; BYTE $0xc1               // movq         %r8, %rcx
+	WORD $0x294c; BYTE $0xd1               // subq         %r10, %rcx
+	WORD $0xd231                           // xorl         %edx, %edx
+	QUAD $0x303030303030b848; WORD $0x3030 // movabsq      $3472328296227680304, %rax
+
+	// .p2align 4, 0x90
+LBB36_132:
+	LONG $0x15448949; BYTE $0x00   // movq         %rax, (%r13,%rdx)
+	LONG $0x08c28348               // addq         $8, %rdx
+	WORD $0x3948; BYTE $0xd1       // cmpq         %rdx, %rcx
+	LONG $0xffee850f; WORD $0xffff // jne          LBB36_132, $-18(%rip)
+	WORD $0x394d; BYTE $0xc3       // cmpq         %r8, %r11
+	LONG $0x0065850f; WORD $0x0000 // jne          LBB36_144, $101(%rip)
+	LONG $0x000070e9; BYTE $0x00   // jmp          LBB36_145, $112(%rip)
+
+LBB36_19:
+	LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl         $10000, %r15d
+	WORD $0x894c; BYTE $0xc9                   // movq         %r9, %rcx
+	LONG $0x00d98348                           // sbbq         $0, %rcx
+	LONG $0x05c18348                           // addq         $5, %rcx
+	LONG $0x10ff8141; WORD $0x0027; BYTE $0x00 // cmpl         $10000, %r15d
+	LONG $0xfb79830f; WORD $0xffff             // jae          LBB36_13, $-1159(%rip)
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	LONG $0xfffd0be9; BYTE $0xff               // jmp          LBB36_21, $-757(%rip)
+
+LBB36_69:
+	WORD $0xff49; BYTE $0xc4       // incq         %r12
+	WORD $0x894c; BYTE $0xe1       // movq         %r12, %rcx
+	LONG $0xe0e18348               // andq         $-32, %rcx
+	LONG $0xe0518d48               // leaq         $-32(%rcx), %rdx
+	WORD $0x8949; BYTE $0xd0       // movq         %rdx, %r8
+	LONG $0x05e8c149               // shrq         $5, %r8
+	WORD $0xff49; BYTE $0xc0       // incq         %r8
+	WORD $0x8945; BYTE $0xc7       // movl         %r8d, %r15d
+	LONG $0x03e78341               // andl         $3, %r15d
+	LONG $0x60fa8348               // cmpq         $96, %rdx
+	LONG $0x0034830f; WORD $0x0000 // jae          LBB36_71, $52(%rip)
+	WORD $0xd231                   // xorl         %edx, %edx
+	LONG $0x000080e9; BYTE $0x00   // jmp          LBB36_73, $128(%rip)
+
+LBB36_143:
+	WORD $0x014d; BYTE $0xd7       // addq         %r10, %r15
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB36_144:
+	LONG $0x3007c641               // movb         $48, (%r15)
+	WORD $0xff49; BYTE $0xc7       // incq         %r15
+	WORD $0x394d; BYTE $0xcf       // cmpq         %r9, %r15
+	LONG $0xfff0820f; WORD $0xffff // jb           LBB36_144, $-16(%rip)
+
+LBB36_145:
+	WORD $0x894c; BYTE $0xc8 // movq         %r9, %rax
+
+LBB36_146:
+	WORD $0xf829 // subl         %edi, %eax
+
+LBB36_147:
+	LONG $0x08c48348 // addq         $8, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5d41     // popq         %r13
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB36_71:
+	LONG $0xfce08349         // andq         $-4, %r8
+	LONG $0x2f348d4a         // leaq         (%rdi,%r13), %rsi
+	LONG $0x72c68348         // addq         $114, %rsi
+	WORD $0xd231             // xorl         %edx, %edx
+	QUAD $0xfffff736056f0f66 // movdqa       $-2250(%rip), %xmm0  /* LCPI36_0(%rip) */
+
+LBB36_72:
+	LONG $0x447f0ff3; WORD $0x9016 // movdqu       %xmm0, $-112(%rsi,%rdx)
+	LONG $0x447f0ff3; WORD $0xa016 // movdqu       %xmm0, $-96(%rsi,%rdx)
+	LONG $0x447f0ff3; WORD $0xb016 // movdqu       %xmm0, $-80(%rsi,%rdx)
+	LONG $0x447f0ff3; WORD $0xc016 // movdqu       %xmm0, $-64(%rsi,%rdx)
+	LONG $0x447f0ff3; WORD $0xd016 // movdqu       %xmm0, $-48(%rsi,%rdx)
+	LONG $0x447f0ff3; WORD $0xe016 // movdqu       %xmm0, $-32(%rsi,%rdx)
+	LONG $0x447f0ff3; WORD $0xf016 // movdqu       %xmm0, $-16(%rsi,%rdx)
+	LONG $0x047f0ff3; BYTE $0x16   // movdqu       %xmm0, (%rsi,%rdx)
+	LONG $0x80ea8348               // subq         $-128, %rdx
+	LONG $0xfcc08349               // addq         $-4, %r8
+	LONG $0xffc3850f; WORD $0xffff // jne          LBB36_72, $-61(%rip)
+
+LBB36_73:
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x0030840f; WORD $0x0000 // je           LBB36_76, $48(%rip)
+	WORD $0x014c; BYTE $0xea       // addq         %r13, %rdx
+	WORD $0x0148; BYTE $0xfa       // addq         %rdi, %rdx
+	LONG $0x12c28348               // addq         $18, %rdx
+	LONG $0x05e7c149               // shlq         $5, %r15
+	WORD $0xf631                   // xorl         %esi, %esi
+	QUAD $0xfffff6d8056f0f66       // movdqa       $-2344(%rip), %xmm0  /* LCPI36_0(%rip) */
+
+LBB36_75:
+	LONG $0x447f0ff3; WORD $0xf032 // movdqu       %xmm0, $-16(%rdx,%rsi)
+	LONG $0x047f0ff3; BYTE $0x32   // movdqu       %xmm0, (%rdx,%rsi)
+	LONG $0x20c68348               // addq         $32, %rsi
+	WORD $0x3949; BYTE $0xf7       // cmpq         %rsi, %r15
+	LONG $0xffe8850f; WORD $0xffff // jne          LBB36_75, $-24(%rip)
+
+LBB36_76:
+	WORD $0x0149; BYTE $0xc9       // addq         %rcx, %r9
+	WORD $0x3949; BYTE $0xcc       // cmpq         %rcx, %r12
+	WORD $0x8949; BYTE $0xdc       // movq         %rbx, %r12
+	LONG $0x0020840f; WORD $0x0000 // je           LBB36_79, $32(%rip)
+
+LBB36_77:
+	WORD $0x0144; BYTE $0xd1                   // addl         %r10d, %ecx
+	WORD $0xd9f7                               // negl         %ecx
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+LBB36_78:
+	LONG $0x3001c641               // movb         $48, (%r9)
+	WORD $0xff49; BYTE $0xc1       // incq         %r9
+	WORD $0xc9ff                   // decl         %ecx
+	LONG $0xfff1850f; WORD $0xffff // jne          LBB36_78, $-15(%rip)
+
+LBB36_79:
+	WORD $0x894d; BYTE $0xe5                   // movq         %r12, %r13
+	LONG $0x213c8d4f                           // leaq         (%r9,%r12), %r15
+	LONG $0x0027103d; BYTE $0x00               // cmpl         $10000, %eax
+	LONG $0x0052820f; WORD $0x0000             // jb           LBB36_80, $82(%rip)
+	WORD $0xc289                               // movl         %eax, %edx
+	LONG $0x1759bc41; WORD $0xd1b7             // movl         $3518437209, %r12d
+	LONG $0xe2af0f4c                           // imulq        %rdx, %r12
+	LONG $0x2decc149                           // shrq         $45, %r12
+	LONG $0xf0d46941; WORD $0xffd8; BYTE $0xff // imull        $-10000, %r12d, %edx
+	WORD $0xc201                               // addl         %eax, %edx
+	LONG $0x004e840f; WORD $0x0000             // je           LBB36_82, $78(%rip)
+	WORD $0xd089                               // movl         %edx, %eax
+	LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xf06b; BYTE $0x64                   // imull        $100, %eax, %esi
+	WORD $0xf229                               // subl         %esi, %edx
+	LONG $0x17358d48; WORD $0x003b; BYTE $0x00 // leaq         $15127(%rip), %rsi  /* _Digits(%rip) */
+	LONG $0x5614b70f                           // movzwl       (%rsi,%rdx,2), %edx
+	LONG $0x57894166; BYTE $0xfe               // movw         %dx, $-2(%r15)
+	LONG $0x4604b70f                           // movzwl       (%rsi,%rax,2), %eax
+	LONG $0x47894166; BYTE $0xfc               // movw         %ax, $-4(%r15)
+	WORD $0x3145; BYTE $0xc0                   // xorl         %r8d, %r8d
+	LONG $0x000021e9; BYTE $0x00               // jmp          LBB36_84, $33(%rip)
+
+LBB36_80:
+	WORD $0x3145; BYTE $0xc0       // xorl         %r8d, %r8d
+	WORD $0x894c; BYTE $0xfe       // movq         %r15, %rsi
+	WORD $0x8941; BYTE $0xc4       // movl         %eax, %r12d
+	LONG $0x64fc8341               // cmpl         $100, %r12d
+	LONG $0x001c830f; WORD $0x0000 // jae          LBB36_87, $28(%rip)
+
+LBB36_86:
+	WORD $0x8944; BYTE $0xe0     // movl         %r12d, %eax
+	LONG $0x000054e9; BYTE $0x00 // jmp          LBB36_89, $84(%rip)
+
+LBB36_82:
+	LONG $0x0004b841; WORD $0x0000 // movl         $4, %r8d
+
+LBB36_84:
+	LONG $0xfc778d49               // leaq         $-4(%r15), %rsi
+	LONG $0x64fc8341               // cmpl         $100, %r12d
+	LONG $0xffe4820f; WORD $0xffff // jb           LBB36_86, $-28(%rip)
+
+LBB36_87:
+	WORD $0xff48; BYTE $0xce                   // decq         %rsi
+	LONG $0xc4158d48; WORD $0x003a; BYTE $0x00 // leaq         $15044(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x90909090                           // .p2align 4, 0x90
+
+LBB36_88:
+	WORD $0x8944; BYTE $0xe0                   // movl         %r12d, %eax
+	LONG $0x1fc06948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rax
+	LONG $0x25e8c148                           // shrq         $37, %rax
+	WORD $0xd86b; BYTE $0x64                   // imull        $100, %eax, %ebx
+	WORD $0x8944; BYTE $0xe1                   // movl         %r12d, %ecx
+	WORD $0xd929                               // subl         %ebx, %ecx
+	LONG $0x4a0cb70f                           // movzwl       (%rdx,%rcx,2), %ecx
+	LONG $0xff4e8966                           // movw         %cx, $-1(%rsi)
+	LONG $0xfec68348                           // addq         $-2, %rsi
+	LONG $0x0ffc8141; WORD $0x0027; BYTE $0x00 // cmpl         $9999, %r12d
+	WORD $0x8941; BYTE $0xc4                   // movl         %eax, %r12d
+	LONG $0xffce870f; WORD $0xffff             // ja           LBB36_88, $-50(%rip)
+
+LBB36_89:
+	WORD $0xf883; BYTE $0x0a                   // cmpl         $10, %eax
+	LONG $0x0016820f; WORD $0x0000             // jb           LBB36_91, $22(%rip)
+	WORD $0xc089                               // movl         %eax, %eax
+	LONG $0x7c0d8d48; WORD $0x003a; BYTE $0x00 // leaq         $14972(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	LONG $0x01894166                           // movw         %ax, (%r9)
+	LONG $0x000005e9; BYTE $0x00               // jmp          LBB36_92, $5(%rip)
+
+LBB36_91:
+	WORD $0x3004             // addb         $48, %al
+	WORD $0x8841; BYTE $0x01 // movb         %al, (%r9)
+
+LBB36_92:
+	WORD $0x294d; BYTE $0xc7 // subq         %r8, %r15
+	WORD $0x294d; BYTE $0xc5 // subq         %r8, %r13
+	WORD $0xff49; BYTE $0xc5 // incq         %r13
+	LONG $0xd06d894c         // movq         %r13, $-48(%rbp)
+	LONG $0x18048d43         // leal         (%r8,%r11), %eax
+	WORD $0xd8f6             // negb         %al
+	LONG $0x03248d47         // leal         (%r11,%r8), %r12d
+	WORD $0xf741; BYTE $0xdc // negl         %r12d
+	LONG $0x032c8d47         // leal         (%r11,%r8), %r13d
+	WORD $0xff41; BYTE $0xcd // decl         %r13d
+	LONG $0x03348d43         // leal         (%r11,%r8), %esi
+	WORD $0xc683; BYTE $0xfe // addl         $-2, %esi
+	WORD $0xc931             // xorl         %ecx, %ecx
+
+	// .p2align 4, 0x90
+LBB36_93:
+	WORD $0xc389                   // movl         %eax, %ebx
+	WORD $0x438d; BYTE $0x03       // leal         $3(%rbx), %eax
+	WORD $0xc6ff                   // incl         %esi
+	LONG $0x0f7c8041; WORD $0x30ff // cmpb         $48, $-1(%r15,%rcx)
+	LONG $0xff498d48               // leaq         $-1(%rcx), %rcx
+	LONG $0xffe9840f; WORD $0xffff // je           LBB36_93, $-23(%rip)
+	LONG $0x0f048d49               // leaq         (%r15,%rcx), %rax
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0xfdec8e0f; WORD $0xffff // jle          LBB36_146, $-532(%rip)
+	WORD $0x2945; BYTE $0xc6       // subl         %r8d, %r14d
+	LONG $0x0e148d41               // leal         (%r14,%rcx), %edx
+	WORD $0xc2ff                   // incl         %edx
+	WORD $0x3941; BYTE $0xd2       // cmpl         %edx, %r10d
+	LONG $0x002b8d0f; WORD $0x0000 // jge          LBB36_96, $43(%rip)
+	WORD $0x6349; BYTE $0xc4       // movslq       %r12d, %rax
+	LONG $0x081c8d4c               // leaq         (%rax,%rcx), %r11
+	WORD $0xff49; BYTE $0xc3       // incq         %r11
+	WORD $0x8545; BYTE $0xdb       // testl        %r11d, %r11d
+	LONG $0x00ec8e0f; WORD $0x0000 // jle          LBB36_114, $236(%rip)
+	WORD $0x8945; BYTE $0xd8       // movl         %r11d, %r8d
+	LONG $0xff508d49               // leaq         $-1(%r8), %rdx
+	LONG $0x03fa8348               // cmpq         $3, %rdx
+	LONG $0x0073830f; WORD $0x0000 // jae          LBB36_115, $115(%rip)
+	WORD $0xd231                   // xorl         %edx, %edx
+	LONG $0x000098e9; BYTE $0x00   // jmp          LBB36_111, $152(%rip)
+
+LBB36_96:
+	WORD $0x8945; BYTE $0xea       // movl         %r13d, %r10d
+	WORD $0x2949; BYTE $0xca       // subq         %rcx, %r10
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0xfda08e0f; WORD $0xffff // jle          LBB36_146, $-608(%rip)
+	LONG $0x031c8d43               // leal         (%r11,%r8), %ebx
+	WORD $0xc383; BYTE $0xfe       // addl         $-2, %ebx
+	WORD $0x2948; BYTE $0xcb       // subq         %rcx, %rbx
+	WORD $0xd231                   // xorl         %edx, %edx
+	WORD $0xfb83; BYTE $0x1f       // cmpl         $31, %ebx
+	LONG $0x0198820f; WORD $0x0000 // jb           LBB36_106, $408(%rip)
+	LONG $0x03348d47               // leal         (%r11,%r8), %r14d
+	LONG $0xfec68341               // addl         $-2, %r14d
+	WORD $0x2949; BYTE $0xce       // subq         %rcx, %r14
+	WORD $0x8941; BYTE $0xdb       // movl         %ebx, %r11d
+	WORD $0xff49; BYTE $0xc3       // incq         %r11
+	WORD $0x894c; BYTE $0xda       // movq         %r11, %rdx
+	LONG $0xe0e28348               // andq         $-32, %rdx
+	LONG $0xd04d034c               // addq         $-48(%rbp), %r9
+	WORD $0xf089                   // movl         %esi, %eax
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	LONG $0xe0e08348               // andq         $-32, %rax
+	WORD $0x014c; BYTE $0xc8       // addq         %r9, %rax
+	LONG $0xe0728d48               // leaq         $-32(%rdx), %rsi
+	WORD $0x8949; BYTE $0xf0       // movq         %rsi, %r8
+	LONG $0x05e8c149               // shrq         $5, %r8
+	WORD $0xff49; BYTE $0xc0       // incq         %r8
+	LONG $0x60fe8348               // cmpq         $96, %rsi
+	LONG $0x0085830f; WORD $0x0000 // jae          LBB36_100, $133(%rip)
+	WORD $0x3145; BYTE $0xc9       // xorl         %r9d, %r9d
+	LONG $0x0000e3e9; BYTE $0x00   // jmp          LBB36_102, $227(%rip)
+
+LBB36_115:
+	LONG $0xfce38341                           // andl         $-4, %r11d
+	WORD $0xf749; BYTE $0xdb                   // negq         %r11
+	WORD $0xd231                               // xorl         %edx, %edx
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB36_116:
+	LONG $0x17048d49               // leaq         (%r15,%rdx), %rax
+	LONG $0xfd01748b               // movl         $-3(%rcx,%rax), %esi
+	LONG $0xfe017489               // movl         %esi, $-2(%rcx,%rax)
+	LONG $0xfcc28348               // addq         $-4, %rdx
+	WORD $0x3949; BYTE $0xd3       // cmpq         %rdx, %r11
+	LONG $0xffe7850f; WORD $0xffff // jne          LBB36_116, $-25(%rip)
+	WORD $0xf748; BYTE $0xda       // negq         %rdx
+
+LBB36_111:
+	LONG $0x03c0f641                           // testb        $3, %r8b
+	LONG $0x0032840f; WORD $0x0000             // je           LBB36_114, $50(%rip)
+	LONG $0xc3b60f44                           // movzbl       %bl, %r8d
+	LONG $0x03e08341                           // andl         $3, %r8d
+	WORD $0xf749; BYTE $0xd8                   // negq         %r8
+	WORD $0x894c; BYTE $0xfe                   // movq         %r15, %rsi
+	WORD $0x2948; BYTE $0xd6                   // subq         %rdx, %rsi
+	WORD $0xd231                               // xorl         %edx, %edx
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB36_113:
+	LONG $0x161c8d48               // leaq         (%rsi,%rdx), %rbx
+	LONG $0x1904b60f               // movzbl       (%rcx,%rbx), %eax
+	LONG $0x01194488               // movb         %al, $1(%rcx,%rbx)
+	WORD $0xff48; BYTE $0xca       // decq         %rdx
+	WORD $0x3949; BYTE $0xd0       // cmpq         %rdx, %r8
+	LONG $0xffe8850f; WORD $0xffff // jne          LBB36_113, $-24(%rip)
+
+LBB36_114:
+	WORD $0x8944; BYTE $0xd0     // movl         %r10d, %eax
+	LONG $0x0104c641; BYTE $0x2e // movb         $46, (%r9,%rax)
+	LONG $0x0f048d49             // leaq         (%r15,%rcx), %rax
+	LONG $0x02c08348             // addq         $2, %rax
+	LONG $0xfffcc6e9; BYTE $0xff // jmp          LBB36_146, $-826(%rip)
+
+LBB36_100:
+	WORD $0x8944; BYTE $0xf3 // movl         %r14d, %ebx
+	WORD $0xff48; BYTE $0xc3 // incq         %rbx
+	LONG $0xe0e38348         // andq         $-32, %rbx
+	LONG $0xe0c38348         // addq         $-32, %rbx
+	LONG $0x05ebc148         // shrq         $5, %rbx
+	WORD $0xff48; BYTE $0xc3 // incq         %rbx
+	LONG $0xfce38348         // andq         $-4, %rbx
+	WORD $0x3145; BYTE $0xc9 // xorl         %r9d, %r9d
+	QUAD $0xfffff3ff056f0f66 // movdqa       $-3073(%rip), %xmm0  /* LCPI36_0(%rip) */
+
+LBB36_101:
+	LONG $0x0f348d4b               // leaq         (%r15,%r9), %rsi
+	LONG $0x447f0ff3; WORD $0x0131 // movdqu       %xmm0, $1(%rcx,%rsi)
+	LONG $0x447f0ff3; WORD $0x1131 // movdqu       %xmm0, $17(%rcx,%rsi)
+	LONG $0x447f0ff3; WORD $0x2131 // movdqu       %xmm0, $33(%rcx,%rsi)
+	LONG $0x447f0ff3; WORD $0x3131 // movdqu       %xmm0, $49(%rcx,%rsi)
+	LONG $0x447f0ff3; WORD $0x4131 // movdqu       %xmm0, $65(%rcx,%rsi)
+	LONG $0x447f0ff3; WORD $0x5131 // movdqu       %xmm0, $81(%rcx,%rsi)
+	LONG $0x447f0ff3; WORD $0x6131 // movdqu       %xmm0, $97(%rcx,%rsi)
+	LONG $0x447f0ff3; WORD $0x7131 // movdqu       %xmm0, $113(%rcx,%rsi)
+	LONG $0x80e98349               // subq         $-128, %r9
+	LONG $0xfcc38348               // addq         $-4, %rbx
+	LONG $0xffbe850f; WORD $0xffff // jne          LBB36_101, $-66(%rip)
+
+LBB36_102:
+	WORD $0x0148; BYTE $0xc8       // addq         %rcx, %rax
+	LONG $0x03c0f641               // testb        $3, %r8b
+	LONG $0x004b840f; WORD $0x0000 // je           LBB36_105, $75(%rip)
+	WORD $0xfe41; BYTE $0xc6       // incb         %r14b
+	LONG $0x60e68041               // andb         $96, %r14b
+	LONG $0xe0c68041               // addb         $-32, %r14b
+	LONG $0x05eec041               // shrb         $5, %r14b
+	WORD $0xfe41; BYTE $0xc6       // incb         %r14b
+	LONG $0xc6b60f45               // movzbl       %r14b, %r8d
+	LONG $0x03e08341               // andl         $3, %r8d
+	LONG $0x05e0c149               // shlq         $5, %r8
+	WORD $0x014d; BYTE $0xf9       // addq         %r15, %r9
+	LONG $0x11c18349               // addq         $17, %r9
+	WORD $0xdb31                   // xorl         %ebx, %ebx
+	QUAD $0xfffff381056f0f66       // movdqa       $-3199(%rip), %xmm0  /* LCPI36_0(%rip) */
+
+LBB36_104:
+	LONG $0x19348d49               // leaq         (%r9,%rbx), %rsi
+	LONG $0x447f0ff3; WORD $0xf031 // movdqu       %xmm0, $-16(%rcx,%rsi)
+	LONG $0x047f0ff3; BYTE $0x31   // movdqu       %xmm0, (%rcx,%rsi)
+	LONG $0x20c38348               // addq         $32, %rbx
+	WORD $0x3949; BYTE $0xd8       // cmpq         %rbx, %r8
+	LONG $0xffe4850f; WORD $0xffff // jne          LBB36_104, $-28(%rip)
+
+LBB36_105:
+	WORD $0x3949; BYTE $0xd3                   // cmpq         %rdx, %r11
+	LONG $0xfbff840f; WORD $0xffff             // je           LBB36_146, $-1025(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+LBB36_106:
+	WORD $0x00c6; BYTE $0x30       // movb         $48, (%rax)
+	WORD $0xff48; BYTE $0xc0       // incq         %rax
+	WORD $0xc2ff                   // incl         %edx
+	WORD $0x3944; BYTE $0xd2       // cmpl         %r10d, %edx
+	LONG $0xffef8c0f; WORD $0xffff // jl           LBB36_106, $-17(%rip)
+	LONG $0xfffbdde9; BYTE $0xff   // jmp          LBB36_146, $-1059(%rip)
+
+LBB36_1:
+	WORD $0xc031                 // xorl         %eax, %eax
+	LONG $0xfffbd8e9; BYTE $0xff // jmp          LBB36_147, $-1064(%rip)
+
+LBB36_5:
+	LONG $0xff6bb841; WORD $0xffff // movl         $-149, %r8d
+	WORD $0x8941; BYTE $0xc7       // movl         %eax, %r15d
+	LONG $0xfff3b7e9; BYTE $0xff   // jmp          LBB36_6, $-3145(%rip)
+	LONG $0x90909090; BYTE $0x90   // .p2align 4, 0x90
+
+_format_significand:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	WORD $0x5641                   // pushq        %r14
+	BYTE $0x53                     // pushq        %rbx
+	WORD $0x8941; BYTE $0xd0       // movl         %edx, %r8d
+	WORD $0x0149; BYTE $0xf0       // addq         %rsi, %r8
+	WORD $0x8948; BYTE $0xf8       // movq         %rdi, %rax
+	LONG $0x20e8c148               // shrq         $32, %rax
+	LONG $0x001c850f; WORD $0x0000 // jne          LBB37_2, $28(%rip)
+	WORD $0x3145; BYTE $0xc9       // xorl         %r9d, %r9d
+	WORD $0x894d; BYTE $0xc6       // movq         %r8, %r14
+	WORD $0x8948; BYTE $0xfa       // movq         %rdi, %rdx
+	LONG $0x2710fa81; WORD $0x0000 // cmpl         $10000, %edx
+	LONG $0x00e3830f; WORD $0x0000 // jae          LBB37_8, $227(%rip)
+
+LBB37_7:
+	WORD $0xd789                 // movl         %edx, %edi
+	LONG $0x000132e9; BYTE $0x00 // jmp          LBB37_10, $306(%rip)
+
+LBB37_2:
+	QUAD $0x77118461cefdb948; WORD $0xabcc     // movabsq      $-6067343680855748867, %rcx
+	WORD $0x8948; BYTE $0xf8                   // movq         %rdi, %rax
+	WORD $0xf748; BYTE $0xe1                   // mulq         %rcx
+	LONG $0x1aeac148                           // shrq         $26, %rdx
+	LONG $0x1f00ca69; WORD $0xfa0a             // imull        $-100000000, %edx, %ecx
+	WORD $0xf901                               // addl         %edi, %ecx
+	LONG $0x00a4840f; WORD $0x0000             // je           LBB37_3, $164(%rip)
+	WORD $0xc889                               // movl         %ecx, %eax
+	LONG $0x1759b941; WORD $0xd1b7             // movl         $3518437209, %r9d
+	LONG $0xc1af0f49                           // imulq        %r9, %rax
+	LONG $0x2de8c148                           // shrq         $45, %rax
+	LONG $0x2710f869; WORD $0x0000             // imull        $10000, %eax, %edi
+	WORD $0xf929                               // subl         %edi, %ecx
+	WORD $0x8948; BYTE $0xc7                   // movq         %rax, %rdi
+	LONG $0xf9af0f49                           // imulq        %r9, %rdi
+	LONG $0x2defc148                           // shrq         $45, %rdi
+	LONG $0x2710ff69; WORD $0x0000             // imull        $10000, %edi, %edi
+	WORD $0xf829                               // subl         %edi, %eax
+	WORD $0xb70f; BYTE $0xf9                   // movzwl       %cx, %edi
+	WORD $0xefc1; BYTE $0x02                   // shrl         $2, %edi
+	LONG $0x7bcf6944; WORD $0x0014; BYTE $0x00 // imull        $5243, %edi, %r9d
+	LONG $0x11e9c141                           // shrl         $17, %r9d
+	LONG $0x64f96b41                           // imull        $100, %r9d, %edi
+	WORD $0xf929                               // subl         %edi, %ecx
+	LONG $0xd1b70f44                           // movzwl       %cx, %r10d
+	WORD $0xb70f; BYTE $0xf8                   // movzwl       %ax, %edi
+	WORD $0xefc1; BYTE $0x02                   // shrl         $2, %edi
+	LONG $0x147bff69; WORD $0x0000             // imull        $5243, %edi, %edi
+	WORD $0xefc1; BYTE $0x11                   // shrl         $17, %edi
+	WORD $0xcf6b; BYTE $0x64                   // imull        $100, %edi, %ecx
+	WORD $0xc829                               // subl         %ecx, %eax
+	LONG $0xd8b70f44                           // movzwl       %ax, %r11d
+	LONG $0x330d8d48; WORD $0x0037; BYTE $0x00 // leaq         $14131(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x04b70f42; BYTE $0x51               // movzwl       (%rcx,%r10,2), %eax
+	LONG $0x40894166; BYTE $0xfe               // movw         %ax, $-2(%r8)
+	LONG $0x04b70f42; BYTE $0x49               // movzwl       (%rcx,%r9,2), %eax
+	LONG $0x40894166; BYTE $0xfc               // movw         %ax, $-4(%r8)
+	LONG $0x04b70f42; BYTE $0x59               // movzwl       (%rcx,%r11,2), %eax
+	LONG $0x40894166; BYTE $0xfa               // movw         %ax, $-6(%r8)
+	LONG $0x7904b70f                           // movzwl       (%rcx,%rdi,2), %eax
+	LONG $0x40894166; BYTE $0xf8               // movw         %ax, $-8(%r8)
+	WORD $0x3145; BYTE $0xc9                   // xorl         %r9d, %r9d
+	LONG $0xf8708d4d                           // leaq         $-8(%r8), %r14
+	LONG $0x2710fa81; WORD $0x0000             // cmpl         $10000, %edx
+	LONG $0xff38820f; WORD $0xffff             // jb           LBB37_7, $-200(%rip)
+	LONG $0x000016e9; BYTE $0x00               // jmp          LBB37_8, $22(%rip)
+
+LBB37_3:
+	LONG $0x0008b941; WORD $0x0000 // movl         $8, %r9d
+	LONG $0xf8708d4d               // leaq         $-8(%r8), %r14
+	LONG $0x2710fa81; WORD $0x0000 // cmpl         $10000, %edx
+	LONG $0xff1d820f; WORD $0xffff // jb           LBB37_7, $-227(%rip)
+
+LBB37_8:
+	LONG $0x1759ba41; WORD $0xd1b7             // movl         $3518437209, %r10d
+	LONG $0xd11d8d4c; WORD $0x0036; BYTE $0x00 // leaq         $14033(%rip), %r11  /* _Digits(%rip) */
+	BYTE $0x90                                 // .p2align 4, 0x90
+
+LBB37_9:
+	WORD $0xd789                               // movl         %edx, %edi
+	LONG $0xfaaf0f49                           // imulq        %r10, %rdi
+	LONG $0x2defc148                           // shrq         $45, %rdi
+	LONG $0xd8f0c769; WORD $0xffff             // imull        $-10000, %edi, %eax
+	WORD $0xd001                               // addl         %edx, %eax
+	LONG $0x1fd86948; WORD $0xeb85; BYTE $0x51 // imulq        $1374389535, %rax, %rbx
+	LONG $0x25ebc148                           // shrq         $37, %rbx
+	WORD $0xcb6b; BYTE $0x64                   // imull        $100, %ebx, %ecx
+	WORD $0xc829                               // subl         %ecx, %eax
+	LONG $0x04b70f41; BYTE $0x43               // movzwl       (%r11,%rax,2), %eax
+	LONG $0x46894166; BYTE $0xfe               // movw         %ax, $-2(%r14)
+	LONG $0x04b70f41; BYTE $0x5b               // movzwl       (%r11,%rbx,2), %eax
+	LONG $0x46894166; BYTE $0xfc               // movw         %ax, $-4(%r14)
+	LONG $0xfcc68349                           // addq         $-4, %r14
+	LONG $0xe0fffa81; WORD $0x05f5             // cmpl         $99999999, %edx
+	WORD $0xfa89                               // movl         %edi, %edx
+	LONG $0xffb8870f; WORD $0xffff             // ja           LBB37_9, $-72(%rip)
+
+LBB37_10:
+	WORD $0xff83; BYTE $0x64       // cmpl         $100, %edi
+	LONG $0x0020830f; WORD $0x0000 // jae          LBB37_11, $32(%rip)
+	WORD $0xff83; BYTE $0x0a       // cmpl         $10, %edi
+	LONG $0x004d820f; WORD $0x0000 // jb           LBB37_14, $77(%rip)
+
+LBB37_13:
+	WORD $0xf889                               // movl         %edi, %eax
+	LONG $0x6d0d8d48; WORD $0x0036; BYTE $0x00 // leaq         $13933(%rip), %rcx  /* _Digits(%rip) */
+	LONG $0x4104b70f                           // movzwl       (%rcx,%rax,2), %eax
+	LONG $0x46894166; BYTE $0xfe               // movw         %ax, $-2(%r14)
+	LONG $0x00003de9; BYTE $0x00               // jmp          LBB37_15, $61(%rip)
+
+LBB37_11:
+	WORD $0xb70f; BYTE $0xc7                   // movzwl       %di, %eax
+	WORD $0xe8c1; BYTE $0x02                   // shrl         $2, %eax
+	LONG $0x147bc069; WORD $0x0000             // imull        $5243, %eax, %eax
+	WORD $0xe8c1; BYTE $0x11                   // shrl         $17, %eax
+	WORD $0xc86b; BYTE $0x64                   // imull        $100, %eax, %ecx
+	WORD $0xcf29                               // subl         %ecx, %edi
+	WORD $0xb70f; BYTE $0xcf                   // movzwl       %di, %ecx
+	LONG $0x41158d48; WORD $0x0036; BYTE $0x00 // leaq         $13889(%rip), %rdx  /* _Digits(%rip) */
+	LONG $0x4a0cb70f                           // movzwl       (%rdx,%rcx,2), %ecx
+	LONG $0x4e894166; BYTE $0xfe               // movw         %cx, $-2(%r14)
+	LONG $0xfec68349                           // addq         $-2, %r14
+	WORD $0xc789                               // movl         %eax, %edi
+	WORD $0xff83; BYTE $0x0a                   // cmpl         $10, %edi
+	LONG $0xffb3830f; WORD $0xffff             // jae          LBB37_13, $-77(%rip)
+
+LBB37_14:
+	LONG $0x30c78040         // addb         $48, %dil
+	WORD $0x8840; BYTE $0x3e // movb         %dil, (%rsi)
+
+LBB37_15:
+	WORD $0x294d; BYTE $0xc8                   // subq         %r9, %r8
+	WORD $0x894c; BYTE $0xc0                   // movq         %r8, %rax
+	BYTE $0x5b                                 // popq         %rbx
+	WORD $0x5e41                               // popq         %r14
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+_left_shift:
+	BYTE $0x55                                             // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                               // movq         %rsp, %rbp
+	WORD $0x5741                                           // pushq        %r15
+	WORD $0x5641                                           // pushq        %r14
+	BYTE $0x53                                             // pushq        %rbx
+	WORD $0xf189                                           // movl         %esi, %ecx
+	LONG $0x68c16b48                                       // imulq        $104, %rcx, %rax
+	LONG $0xea158d48; WORD $0x008f; BYTE $0x00             // leaq         $36842(%rip), %rdx  /* _LSHIFT_TAB(%rip) */
+	LONG $0x10048b44                                       // movl         (%rax,%rdx), %r8d
+	WORD $0x8b4c; BYTE $0x0f                               // movq         (%rdi), %r9
+	WORD $0x0148; BYTE $0xc2                               // addq         %rax, %rdx
+	LONG $0x04c28348                                       // addq         $4, %rdx
+	LONG $0x10476348                                       // movslq       $16(%rdi), %rax
+	WORD $0xf631                                           // xorl         %esi, %esi
+	WORD $0x8548; BYTE $0xc0                               // testq        %rax, %rax
+	LONG $0x0031840f; WORD $0x0000                         // je           LBB38_6, $49(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB38_1:
+	LONG $0x321cb60f               // movzbl       (%rdx,%rsi), %ebx
+	WORD $0xdb84                   // testb        %bl, %bl
+	LONG $0x0025840f; WORD $0x0000 // je           LBB38_8, $37(%rip)
+	LONG $0x311c3841               // cmpb         %bl, (%r9,%rsi)
+	LONG $0x0189850f; WORD $0x0000 // jne          LBB38_3, $393(%rip)
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0x3948; BYTE $0xf0       // cmpq         %rsi, %rax
+	LONG $0xffde850f; WORD $0xffff // jne          LBB38_1, $-34(%rip)
+	WORD $0xc689                   // movl         %eax, %esi
+
+LBB38_6:
+	LONG $0x00323c80               // cmpb         $0, (%rdx,%rsi)
+	LONG $0x0003840f; WORD $0x0000 // je           LBB38_8, $3(%rip)
+
+LBB38_7:
+	WORD $0xff41; BYTE $0xc8 // decl         %r8d
+
+LBB38_8:
+	WORD $0xc085                               // testl        %eax, %eax
+	LONG $0x00968e0f; WORD $0x0000             // jle          LBB38_22, $150(%rip)
+	LONG $0x001c8d45                           // leal         (%r8,%rax), %r11d
+	WORD $0xc389                               // movl         %eax, %ebx
+	WORD $0x634d; BYTE $0xf3                   // movslq       %r11d, %r14
+	WORD $0xff49; BYTE $0xce                   // decq         %r14
+	WORD $0xff48; BYTE $0xc3                   // incq         %rbx
+	WORD $0xd231                               // xorl         %edx, %edx
+	QUAD $0xcccccccccccdba49; WORD $0xcccc     // movabsq      $-3689348814741910323, %r10
+	LONG $0x000023e9; BYTE $0x00               // jmp          LBB38_10, $35(%rip)
+	LONG $0x90909090; WORD $0x9090; BYTE $0x90 // .p2align 4, 0x90
+
+LBB38_11:
+	WORD $0x3004             // addb         $48, %al
+	LONG $0x31048843         // movb         %al, (%r9,%r14)
+	WORD $0x8b4c; BYTE $0x0f // movq         (%rdi), %r9
+
+LBB38_18:
+	WORD $0xff41; BYTE $0xcb       // decl         %r11d
+	WORD $0xff49; BYTE $0xce       // decq         %r14
+	WORD $0xff48; BYTE $0xcb       // decq         %rbx
+	LONG $0x01fb8348               // cmpq         $1, %rbx
+	LONG $0x0049860f; WORD $0x0000 // jbe          LBB38_12, $73(%rip)
+
+LBB38_10:
+	WORD $0x438d; BYTE $0xfe                   // leal         $-2(%rbx), %eax
+	LONG $0x34be0f49; BYTE $0x01               // movsbq       (%r9,%rax), %rsi
+	LONG $0xd0c68348                           // addq         $-48, %rsi
+	WORD $0xd348; BYTE $0xe6                   // shlq         %cl, %rsi
+	WORD $0x0148; BYTE $0xd6                   // addq         %rdx, %rsi
+	WORD $0x8948; BYTE $0xf0                   // movq         %rsi, %rax
+	WORD $0xf749; BYTE $0xe2                   // mulq         %r10
+	LONG $0x03eac148                           // shrq         $3, %rdx
+	LONG $0x12048d48                           // leaq         (%rdx,%rdx), %rax
+	LONG $0x803c8d4c                           // leaq         (%rax,%rax,4), %r15
+	WORD $0x8948; BYTE $0xf0                   // movq         %rsi, %rax
+	WORD $0x294c; BYTE $0xf8                   // subq         %r15, %rax
+	LONG $0x0877394c                           // cmpq         %r14, $8(%rdi)
+	LONG $0xffb0870f; WORD $0xffff             // ja           LBB38_11, $-80(%rip)
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0xffb0840f; WORD $0xffff             // je           LBB38_18, $-80(%rip)
+	LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl         $1, $28(%rdi)
+	LONG $0xffffa4e9; BYTE $0xff               // jmp          LBB38_18, $-92(%rip)
+
+LBB38_12:
+	LONG $0x0afe8348               // cmpq         $10, %rsi
+	LONG $0x0070830f; WORD $0x0000 // jae          LBB38_13, $112(%rip)
+
+LBB38_22:
+	LONG $0x10476348               // movslq       $16(%rdi), %rax
+	WORD $0x6349; BYTE $0xc8       // movslq       %r8d, %rcx
+	WORD $0x0148; BYTE $0xc1       // addq         %rax, %rcx
+	WORD $0x4f89; BYTE $0x10       // movl         %ecx, $16(%rdi)
+	LONG $0x08478b48               // movq         $8(%rdi), %rax
+	WORD $0x3948; BYTE $0xc8       // cmpq         %rcx, %rax
+	LONG $0x0005870f; WORD $0x0000 // ja           LBB38_24, $5(%rip)
+	WORD $0x4789; BYTE $0x10       // movl         %eax, $16(%rdi)
+	WORD $0xc189                   // movl         %eax, %ecx
+
+LBB38_24:
+	LONG $0x14470144               // addl         %r8d, $20(%rdi)
+	WORD $0xc985                   // testl        %ecx, %ecx
+	LONG $0x00318e0f; WORD $0x0000 // jle          LBB38_28, $49(%rip)
+	WORD $0x8b48; BYTE $0x07       // movq         (%rdi), %rax
+	WORD $0xc989                   // movl         %ecx, %ecx
+	BYTE $0x90                     // .p2align 4, 0x90
+
+LBB38_26:
+	LONG $0xff518d48               // leaq         $-1(%rcx), %rdx
+	WORD $0xd689                   // movl         %edx, %esi
+	LONG $0x30303c80               // cmpb         $48, (%rax,%rsi)
+	LONG $0x0028850f; WORD $0x0000 // jne          LBB38_30, $40(%rip)
+	WORD $0xc9ff                   // decl         %ecx
+	WORD $0x4f89; BYTE $0x10       // movl         %ecx, $16(%rdi)
+	LONG $0x01728d48               // leaq         $1(%rdx), %rsi
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	LONG $0x01fe8348               // cmpq         $1, %rsi
+	LONG $0xffda870f; WORD $0xffff // ja           LBB38_26, $-38(%rip)
+	LONG $0x000006e9; BYTE $0x00   // jmp          LBB38_29, $6(%rip)
+
+LBB38_28:
+	LONG $0x0007850f; WORD $0x0000 // jne          LBB38_30, $7(%rip)
+
+LBB38_29:
+	LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl         $0, $20(%rdi)
+
+LBB38_30:
+	BYTE $0x5b   // popq         %rbx
+	WORD $0x5e41 // popq         %r14
+	WORD $0x5f41 // popq         %r15
+	BYTE $0x5d   // popq         %rbp
+	BYTE $0xc3   // retq
+
+LBB38_13:
+	WORD $0x6349; BYTE $0xf3       // movslq       %r11d, %rsi
+	WORD $0xff48; BYTE $0xce       // decq         %rsi
+	LONG $0x00001be9; BYTE $0x00   // jmp          LBB38_14, $27(%rip)
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB38_15:
+	WORD $0x3004             // addb         $48, %al
+	WORD $0x8b48; BYTE $0x1f // movq         (%rdi), %rbx
+	WORD $0x0488; BYTE $0x33 // movb         %al, (%rbx,%rsi)
+
+LBB38_21:
+	WORD $0xff48; BYTE $0xce       // decq         %rsi
+	LONG $0x09f98348               // cmpq         $9, %rcx
+	LONG $0xff6a860f; WORD $0xffff // jbe          LBB38_22, $-150(%rip)
+
+LBB38_14:
+	WORD $0x8948; BYTE $0xd1                   // movq         %rdx, %rcx
+	WORD $0x8948; BYTE $0xd0                   // movq         %rdx, %rax
+	WORD $0xf749; BYTE $0xe2                   // mulq         %r10
+	LONG $0x03eac148                           // shrq         $3, %rdx
+	LONG $0x12048d48                           // leaq         (%rdx,%rdx), %rax
+	LONG $0x801c8d48                           // leaq         (%rax,%rax,4), %rbx
+	WORD $0x8948; BYTE $0xc8                   // movq         %rcx, %rax
+	WORD $0x2948; BYTE $0xd8                   // subq         %rbx, %rax
+	LONG $0x08773948                           // cmpq         %rsi, $8(%rdi)
+	LONG $0xffc6870f; WORD $0xffff             // ja           LBB38_15, $-58(%rip)
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0xffc5840f; WORD $0xffff             // je           LBB38_21, $-59(%rip)
+	LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl         $1, $28(%rdi)
+	LONG $0xffffb9e9; BYTE $0xff               // jmp          LBB38_21, $-71(%rip)
+
+LBB38_3:
+	LONG $0xfe898c0f; WORD $0xffff // jl           LBB38_7, $-375(%rip)
+	LONG $0xfffe87e9; BYTE $0xff   // jmp          LBB38_8, $-377(%rip)
+	LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+_right_shift:
+	BYTE $0x55                     // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5       // movq         %rsp, %rbp
+	BYTE $0x53                     // pushq        %rbx
+	WORD $0xf189                   // movl         %esi, %ecx
+	LONG $0x10478b44               // movl         $16(%rdi), %r8d
+	WORD $0xd231                   // xorl         %edx, %edx
+	WORD $0x8545; BYTE $0xc0       // testl        %r8d, %r8d
+	LONG $0x0000bb41; WORD $0x0000 // movl         $0, %r11d
+	LONG $0xd84f0f45               // cmovgl       %r8d, %r11d
+	WORD $0xc031                   // xorl         %eax, %eax
+	LONG $0x90909090               // .p2align 4, 0x90
+
+LBB39_1:
+	WORD $0x3949; BYTE $0xd3       // cmpq         %rdx, %r11
+	LONG $0x0132840f; WORD $0x0000 // je           LBB39_2, $306(%rip)
+	LONG $0x80048d48               // leaq         (%rax,%rax,4), %rax
+	WORD $0x8b48; BYTE $0x37       // movq         (%rdi), %rsi
+	LONG $0x34be0f48; BYTE $0x16   // movsbq       (%rsi,%rdx), %rsi
+	LONG $0x46048d48               // leaq         (%rsi,%rax,2), %rax
+	LONG $0xd0c08348               // addq         $-48, %rax
+	WORD $0xff48; BYTE $0xc2       // incq         %rdx
+	WORD $0x8948; BYTE $0xc6       // movq         %rax, %rsi
+	WORD $0xd348; BYTE $0xee       // shrq         %cl, %rsi
+	WORD $0x8548; BYTE $0xf6       // testq        %rsi, %rsi
+	LONG $0xffd1840f; WORD $0xffff // je           LBB39_1, $-47(%rip)
+	WORD $0x8941; BYTE $0xd3       // movl         %edx, %r11d
+
+LBB39_7:
+	WORD $0x578b; BYTE $0x14                   // movl         $20(%rdi), %edx
+	WORD $0x2944; BYTE $0xda                   // subl         %r11d, %edx
+	WORD $0xc2ff                               // incl         %edx
+	LONG $0xffc1c749; WORD $0xffff; BYTE $0xff // movq         $-1, %r9
+	WORD $0xd349; BYTE $0xe1                   // shlq         %cl, %r9
+	WORD $0x5789; BYTE $0x14                   // movl         %edx, $20(%rdi)
+	WORD $0xf749; BYTE $0xd1                   // notq         %r9
+	WORD $0x3145; BYTE $0xd2                   // xorl         %r10d, %r10d
+	WORD $0x3945; BYTE $0xc3                   // cmpl         %r8d, %r11d
+	LONG $0x00718d0f; WORD $0x0000             // jge          LBB39_10, $113(%rip)
+	WORD $0x634d; BYTE $0xc3                   // movslq       %r11d, %r8
+	WORD $0x8b48; BYTE $0x37                   // movq         (%rdi), %rsi
+	WORD $0x3145; BYTE $0xd2                   // xorl         %r10d, %r10d
+	BYTE $0x90                                 // .p2align 4, 0x90
+
+LBB39_9:
+	WORD $0x8948; BYTE $0xc2                                 // movq         %rax, %rdx
+	WORD $0xd348; BYTE $0xea                                 // shrq         %cl, %rdx
+	WORD $0x214c; BYTE $0xc8                                 // andq         %r9, %rax
+	WORD $0xc280; BYTE $0x30                                 // addb         $48, %dl
+	LONG $0x16148842                                         // movb         %dl, (%rsi,%r10)
+	WORD $0x8b48; BYTE $0x37                                 // movq         (%rdi), %rsi
+	LONG $0x06148d4a                                         // leaq         (%rsi,%r8), %rdx
+	LONG $0x1cbe0f4d; BYTE $0x12                             // movsbq       (%r10,%rdx), %r11
+	LONG $0x105c8d4b; BYTE $0x01                             // leaq         $1(%r8,%r10), %rbx
+	WORD $0xff49; BYTE $0xc2                                 // incq         %r10
+	LONG $0x80048d48                                         // leaq         (%rax,%rax,4), %rax
+	LONG $0x43048d49                                         // leaq         (%r11,%rax,2), %rax
+	LONG $0xd0c08348                                         // addq         $-48, %rax
+	LONG $0x10576348                                         // movslq       $16(%rdi), %rdx
+	WORD $0x3948; BYTE $0xd3                                 // cmpq         %rdx, %rbx
+	LONG $0xffc38c0f; WORD $0xffff                           // jl           LBB39_9, $-61(%rip)
+	LONG $0x000025e9; BYTE $0x00                             // jmp          LBB39_10, $37(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090; WORD $0x9090 // .p2align 4, 0x90
+
+LBB39_12:
+	LONG $0x30c68040         // addb         $48, %sil
+	WORD $0x8b48; BYTE $0x1f // movq         (%rdi), %rbx
+	LONG $0x13348840         // movb         %sil, (%rbx,%rdx)
+	WORD $0xc2ff             // incl         %edx
+	WORD $0x8941; BYTE $0xd2 // movl         %edx, %r10d
+
+LBB39_15:
+	WORD $0x0148; BYTE $0xc0 // addq         %rax, %rax
+	LONG $0x80048d48         // leaq         (%rax,%rax,4), %rax
+
+LBB39_10:
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0x002b840f; WORD $0x0000             // je           LBB39_16, $43(%rip)
+	WORD $0x8948; BYTE $0xc6                   // movq         %rax, %rsi
+	WORD $0xd348; BYTE $0xee                   // shrq         %cl, %rsi
+	WORD $0x214c; BYTE $0xc8                   // andq         %r9, %rax
+	WORD $0x6349; BYTE $0xd2                   // movslq       %r10d, %rdx
+	LONG $0x08573948                           // cmpq         %rdx, $8(%rdi)
+	LONG $0xffca870f; WORD $0xffff             // ja           LBB39_12, $-54(%rip)
+	WORD $0x8548; BYTE $0xf6                   // testq        %rsi, %rsi
+	LONG $0xffd1840f; WORD $0xffff             // je           LBB39_15, $-47(%rip)
+	LONG $0x011c47c7; WORD $0x0000; BYTE $0x00 // movl         $1, $28(%rdi)
+	LONG $0xffffc5e9; BYTE $0xff               // jmp          LBB39_15, $-59(%rip)
+
+LBB39_16:
+	LONG $0x10578944               // movl         %r10d, $16(%rdi)
+	WORD $0x8545; BYTE $0xd2       // testl        %r10d, %r10d
+	LONG $0x00758e0f; WORD $0x0000 // jle          LBB39_20, $117(%rip)
+	WORD $0x8b48; BYTE $0x07       // movq         (%rdi), %rax
+	WORD $0x8944; BYTE $0xd1       // movl         %r10d, %ecx
+	WORD $0x9090                   // .p2align 4, 0x90
+
+LBB39_18:
+	LONG $0xff518d48               // leaq         $-1(%rcx), %rdx
+	WORD $0xd689                   // movl         %edx, %esi
+	LONG $0x30303c80               // cmpb         $48, (%rax,%rsi)
+	LONG $0x0063850f; WORD $0x0000 // jne          LBB39_22, $99(%rip)
+	WORD $0xc9ff                   // decl         %ecx
+	WORD $0x4f89; BYTE $0x10       // movl         %ecx, $16(%rdi)
+	LONG $0x01728d48               // leaq         $1(%rdx), %rsi
+	WORD $0x8948; BYTE $0xd1       // movq         %rdx, %rcx
+	LONG $0x01fe8348               // cmpq         $1, %rsi
+	LONG $0xffda870f; WORD $0xffff // ja           LBB39_18, $-38(%rip)
+	LONG $0x00004be9; BYTE $0x00   // jmp          LBB39_21, $75(%rip)
+
+LBB39_2:
+	WORD $0x8548; BYTE $0xc0                   // testq        %rax, %rax
+	LONG $0x004c840f; WORD $0x0000             // je           LBB39_23, $76(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+	WORD $0x8948; BYTE $0xc2                   // movq         %rax, %rdx
+	WORD $0xd348; BYTE $0xea                   // shrq         %cl, %rdx
+	WORD $0x8548; BYTE $0xd2                   // testq        %rdx, %rdx
+	LONG $0xfed3850f; WORD $0xffff             // jne          LBB39_7, $-301(%rip)
+
+LBB39_4:
+	WORD $0x0148; BYTE $0xc0       // addq         %rax, %rax
+	LONG $0x80048d48               // leaq         (%rax,%rax,4), %rax
+	WORD $0xff41; BYTE $0xc3       // incl         %r11d
+	WORD $0x8948; BYTE $0xc2       // movq         %rax, %rdx
+	WORD $0xd348; BYTE $0xea       // shrq         %cl, %rdx
+	WORD $0x8548; BYTE $0xd2       // testq        %rdx, %rdx
+	LONG $0xffe7840f; WORD $0xffff // je           LBB39_4, $-25(%rip)
+	LONG $0xfffeb5e9; BYTE $0xff   // jmp          LBB39_7, $-331(%rip)
+
+LBB39_20:
+	LONG $0x0003840f; WORD $0x0000 // je           LBB39_21, $3(%rip)
+
+LBB39_22:
+	BYTE $0x5b // popq         %rbx
+	BYTE $0x5d // popq         %rbp
+	BYTE $0xc3 // retq
+
+LBB39_21:
+	LONG $0x001447c7; WORD $0x0000; BYTE $0x00 // movl         $0, $20(%rdi)
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+
+LBB39_23:
+	LONG $0x001047c7; WORD $0x0000; BYTE $0x00 // movl         $0, $16(%rdi)
+	BYTE $0x5b                                 // popq         %rbx
+	BYTE $0x5d                                 // popq         %rbp
+	BYTE $0xc3                                 // retq
+	LONG $0x00000000; WORD $0x0000             // .p2align 4, 0x00
+
+LCPI40_0:
+	QUAD $0x2222222222222222; QUAD $0x2222222222222222 // .space 16, '""""""""""""""""'
+
+LCPI40_1:
+	QUAD $0x5c5c5c5c5c5c5c5c; QUAD $0x5c5c5c5c5c5c5c5c // .space 16, '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+
+	// .p2align 4, 0x90
+_advance_string_default:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	BYTE $0x50                                 // pushq        %rax
+	LONG $0x087f8b4c                           // movq         $8(%rdi), %r15
+	WORD $0x2949; BYTE $0xf7                   // subq         %rsi, %r15
+	LONG $0x037d840f; WORD $0x0000             // je           LBB40_17, $893(%rip)
+	WORD $0x8b4c; BYTE $0x0f                   // movq         (%rdi), %r9
+	LONG $0xff02c748; WORD $0xffff; BYTE $0xff // movq         $-1, (%rdx)
+	LONG $0x40ff8349                           // cmpq         $64, %r15
+	LONG $0x01f7820f; WORD $0x0000             // jb           LBB40_18, $503(%rip)
+	WORD $0x8948; BYTE $0xf7                   // movq         %rsi, %rdi
+	WORD $0xf748; BYTE $0xd7                   // notq         %rdi
+	QUAD $0xffffffffd045c748                   // movq         $-1, $-48(%rbp)
+	WORD $0x3145; BYTE $0xf6                   // xorl         %r14d, %r14d
+	QUAD $0xffffff98056f0f66                   // movdqa       $-104(%rip), %xmm0  /* LCPI40_0(%rip) */
+	QUAD $0xffffffa00d6f0f66                   // movdqa       $-96(%rip), %xmm1  /* LCPI40_1(%rip) */
+
+	// .p2align 4, 0x90
+LBB40_3:
+	LONG $0x6f0f41f3; WORD $0x3114             // movdqu       (%r9,%rsi), %xmm2
+	LONG $0x6f0f41f3; WORD $0x315c; BYTE $0x10 // movdqu       $16(%r9,%rsi), %xmm3
+	LONG $0x6f0f41f3; WORD $0x3164; BYTE $0x20 // movdqu       $32(%r9,%rsi), %xmm4
+	LONG $0x6f0f41f3; WORD $0x316c; BYTE $0x30 // movdqu       $48(%r9,%rsi), %xmm5
+	LONG $0xf26f0f66                           // movdqa       %xmm2, %xmm6
+	LONG $0xf0740f66                           // pcmpeqb      %xmm0, %xmm6
+	LONG $0xd70f4466; BYTE $0xe6               // pmovmskb     %xmm6, %r12d
+	LONG $0xf36f0f66                           // movdqa       %xmm3, %xmm6
+	LONG $0xf0740f66                           // pcmpeqb      %xmm0, %xmm6
+	LONG $0xded70f66                           // pmovmskb     %xmm6, %ebx
+	LONG $0xf46f0f66                           // movdqa       %xmm4, %xmm6
+	LONG $0xf0740f66                           // pcmpeqb      %xmm0, %xmm6
+	LONG $0xd70f4466; BYTE $0xc6               // pmovmskb     %xmm6, %r8d
+	LONG $0xf56f0f66                           // movdqa       %xmm5, %xmm6
+	LONG $0xf0740f66                           // pcmpeqb      %xmm0, %xmm6
+	LONG $0xd70f4466; BYTE $0xd6               // pmovmskb     %xmm6, %r10d
+	LONG $0xd1740f66                           // pcmpeqb      %xmm1, %xmm2
+	LONG $0xd70f4466; BYTE $0xea               // pmovmskb     %xmm2, %r13d
+	LONG $0xd9740f66                           // pcmpeqb      %xmm1, %xmm3
+	LONG $0xcbd70f66                           // pmovmskb     %xmm3, %ecx
+	LONG $0xe1740f66                           // pcmpeqb      %xmm1, %xmm4
+	LONG $0xc4d70f66                           // pmovmskb     %xmm4, %eax
+	LONG $0xe9740f66                           // pcmpeqb      %xmm1, %xmm5
+	LONG $0xd70f4466; BYTE $0xdd               // pmovmskb     %xmm5, %r11d
+	LONG $0x30e2c149                           // shlq         $48, %r10
+	LONG $0x20e0c149                           // shlq         $32, %r8
+	WORD $0x094d; BYTE $0xd0                   // orq          %r10, %r8
+	LONG $0x10e3c148                           // shlq         $16, %rbx
+	WORD $0x094c; BYTE $0xc3                   // orq          %r8, %rbx
+	WORD $0x0949; BYTE $0xdc                   // orq          %rbx, %r12
+	LONG $0x30e3c149                           // shlq         $48, %r11
+	LONG $0x20e0c148                           // shlq         $32, %rax
+	WORD $0x094c; BYTE $0xd8                   // orq          %r11, %rax
+	LONG $0x10e1c148                           // shlq         $16, %rcx
+	WORD $0x0948; BYTE $0xc1                   // orq          %rax, %rcx
+	WORD $0x0949; BYTE $0xcd                   // orq          %rcx, %r13
+	LONG $0x0030850f; WORD $0x0000             // jne          LBB40_7, $48(%rip)
+	WORD $0x854d; BYTE $0xf6                   // testq        %r14, %r14
+	LONG $0x0040850f; WORD $0x0000             // jne          LBB40_9, $64(%rip)
+	WORD $0x3145; BYTE $0xf6                   // xorl         %r14d, %r14d
+	WORD $0x854d; BYTE $0xe4                   // testq        %r12, %r12
+	LONG $0x0086850f; WORD $0x0000             // jne          LBB40_10, $134(%rip)
+
+LBB40_6:
+	LONG $0xc0c78349               // addq         $-64, %r15
+	LONG $0xc0c78348               // addq         $-64, %rdi
+	LONG $0x40c68348               // addq         $64, %rsi
+	LONG $0x3fff8349               // cmpq         $63, %r15
+	LONG $0xff35870f; WORD $0xffff // ja           LBB40_3, $-203(%rip)
+	LONG $0x000081e9; BYTE $0x00   // jmp          LBB40_12, $129(%rip)
+
+LBB40_7:
+	LONG $0xd07d8348; BYTE $0xff   // cmpq         $-1, $-48(%rbp)
+	LONG $0x000e850f; WORD $0x0000 // jne          LBB40_9, $14(%rip)
+	LONG $0xc5bc0f49               // bsfq         %r13, %rax
+	WORD $0x0148; BYTE $0xf0       // addq         %rsi, %rax
+	LONG $0xd0458948               // movq         %rax, $-48(%rbp)
+	WORD $0x8948; BYTE $0x02       // movq         %rax, (%rdx)
+
+LBB40_9:
+	WORD $0x894c; BYTE $0xf0               // movq         %r14, %rax
+	WORD $0xf748; BYTE $0xd0               // notq         %rax
+	WORD $0x214c; BYTE $0xe8               // andq         %r13, %rax
+	LONG $0x00048d4c                       // leaq         (%rax,%rax), %r8
+	WORD $0x094d; BYTE $0xf0               // orq          %r14, %r8
+	WORD $0x894c; BYTE $0xc1               // movq         %r8, %rcx
+	WORD $0xf748; BYTE $0xd1               // notq         %rcx
+	WORD $0x214c; BYTE $0xe9               // andq         %r13, %rcx
+	QUAD $0xaaaaaaaaaaaabb48; WORD $0xaaaa // movabsq      $-6148914691236517206, %rbx
+	WORD $0x2148; BYTE $0xd9               // andq         %rbx, %rcx
+	WORD $0x3145; BYTE $0xf6               // xorl         %r14d, %r14d
+	WORD $0x0148; BYTE $0xc1               // addq         %rax, %rcx
+	LONG $0xc6920f41                       // setb         %r14b
+	WORD $0x0148; BYTE $0xc9               // addq         %rcx, %rcx
+	QUAD $0x555555555555b848; WORD $0x5555 // movabsq      $6148914691236517205, %rax
+	WORD $0x3148; BYTE $0xc1               // xorq         %rax, %rcx
+	WORD $0x214c; BYTE $0xc1               // andq         %r8, %rcx
+	WORD $0xf748; BYTE $0xd1               // notq         %rcx
+	WORD $0x2149; BYTE $0xcc               // andq         %rcx, %r12
+	WORD $0x854d; BYTE $0xe4               // testq        %r12, %r12
+	LONG $0xff7a840f; WORD $0xffff         // je           LBB40_6, $-134(%rip)
+
+LBB40_10:
+	LONG $0xc4bc0f49         // bsfq         %r12, %rax
+	WORD $0x2948; BYTE $0xf8 // subq         %rdi, %rax
+
+LBB40_11:
+	LONG $0x08c48348 // addq         $8, %rsp
+	BYTE $0x5b       // popq         %rbx
+	WORD $0x5c41     // popq         %r12
+	WORD $0x5d41     // popq         %r13
+	WORD $0x5e41     // popq         %r14
+	WORD $0x5f41     // popq         %r15
+	BYTE $0x5d       // popq         %rbp
+	BYTE $0xc3       // retq
+
+LBB40_12:
+	WORD $0x014c; BYTE $0xce       // addq         %r9, %rsi
+	LONG $0x20ff8349               // cmpq         $32, %r15
+	LONG $0x00f5820f; WORD $0x0000 // jb           LBB40_23, $245(%rip)
+
+LBB40_13:
+	LONG $0x066f0ff3               // movdqu       (%rsi), %xmm0
+	LONG $0x4e6f0ff3; BYTE $0x10   // movdqu       $16(%rsi), %xmm1
+	QUAD $0xfffffe21156f0f66       // movdqa       $-479(%rip), %xmm2  /* LCPI40_0(%rip) */
+	QUAD $0xfffffe291d6f0f66       // movdqa       $-471(%rip), %xmm3  /* LCPI40_1(%rip) */
+	LONG $0xe06f0f66               // movdqa       %xmm0, %xmm4
+	LONG $0xe2740f66               // pcmpeqb      %xmm2, %xmm4
+	LONG $0xfcd70f66               // pmovmskb     %xmm4, %edi
+	LONG $0xd1740f66               // pcmpeqb      %xmm1, %xmm2
+	LONG $0xcad70f66               // pmovmskb     %xmm2, %ecx
+	LONG $0xc3740f66               // pcmpeqb      %xmm3, %xmm0
+	LONG $0xc0d70f66               // pmovmskb     %xmm0, %eax
+	LONG $0xcb740f66               // pcmpeqb      %xmm3, %xmm1
+	LONG $0xd9d70f66               // pmovmskb     %xmm1, %ebx
+	LONG $0x10e1c148               // shlq         $16, %rcx
+	WORD $0x0948; BYTE $0xcf       // orq          %rcx, %rdi
+	LONG $0x10e3c148               // shlq         $16, %rbx
+	WORD $0x0948; BYTE $0xd8       // orq          %rbx, %rax
+	LONG $0x0044850f; WORD $0x0000 // jne          LBB40_19, $68(%rip)
+	WORD $0x854d; BYTE $0xf6       // testq        %r14, %r14
+	LONG $0x005a850f; WORD $0x0000 // jne          LBB40_21, $90(%rip)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0x0087840f; WORD $0x0000 // je           LBB40_22, $135(%rip)
+
+LBB40_16:
+	LONG $0xc7bc0f48             // bsfq         %rdi, %rax
+	WORD $0x294c; BYTE $0xce     // subq         %r9, %rsi
+	WORD $0x0148; BYTE $0xf0     // addq         %rsi, %rax
+	WORD $0xff48; BYTE $0xc0     // incq         %rax
+	LONG $0xffff6ce9; BYTE $0xff // jmp          LBB40_11, $-148(%rip)
+
+LBB40_18:
+	WORD $0x014c; BYTE $0xce       // addq         %r9, %rsi
+	QUAD $0xffffffffd045c748       // movq         $-1, $-48(%rbp)
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	LONG $0x20ff8349               // cmpq         $32, %r15
+	LONG $0xff70830f; WORD $0xffff // jae          LBB40_13, $-144(%rip)
+	LONG $0x000060e9; BYTE $0x00   // jmp          LBB40_23, $96(%rip)
+
+LBB40_19:
+	LONG $0xd07d8348; BYTE $0xff   // cmpq         $-1, $-48(%rbp)
+	LONG $0x0014850f; WORD $0x0000 // jne          LBB40_21, $20(%rip)
+	WORD $0x8948; BYTE $0xf1       // movq         %rsi, %rcx
+	WORD $0x294c; BYTE $0xc9       // subq         %r9, %rcx
+	LONG $0xd8bc0f48               // bsfq         %rax, %rbx
+	WORD $0x0148; BYTE $0xcb       // addq         %rcx, %rbx
+	LONG $0xd05d8948               // movq         %rbx, $-48(%rbp)
+	WORD $0x8948; BYTE $0x1a       // movq         %rbx, (%rdx)
+
+LBB40_21:
+	WORD $0x8944; BYTE $0xf1       // movl         %r14d, %ecx
+	WORD $0xd1f7                   // notl         %ecx
+	WORD $0xc121                   // andl         %eax, %ecx
+	WORD $0x1c8d; BYTE $0x09       // leal         (%rcx,%rcx), %ebx
+	LONG $0x4e048d45               // leal         (%r14,%rcx,2), %r8d
+	WORD $0xd3f7                   // notl         %ebx
+	WORD $0xc321                   // andl         %eax, %ebx
+	LONG $0xaaaae381; WORD $0xaaaa // andl         $-1431655766, %ebx
+	WORD $0x3145; BYTE $0xf6       // xorl         %r14d, %r14d
+	WORD $0xcb01                   // addl         %ecx, %ebx
+	LONG $0xc6920f41               // setb         %r14b
+	WORD $0xdb01                   // addl         %ebx, %ebx
+	LONG $0x5555f381; WORD $0x5555 // xorl         $1431655765, %ebx
+	WORD $0x2144; BYTE $0xc3       // andl         %r8d, %ebx
+	WORD $0xd3f7                   // notl         %ebx
+	WORD $0xdf21                   // andl         %ebx, %edi
+	WORD $0x8548; BYTE $0xff       // testq        %rdi, %rdi
+	LONG $0xff79850f; WORD $0xffff // jne          LBB40_16, $-135(%rip)
+
+LBB40_22:
+	LONG $0x20c68348 // addq         $32, %rsi
+	LONG $0xe0c78349 // addq         $-32, %r15
+
+LBB40_23:
+	WORD $0x854d; BYTE $0xf6       // testq        %r14, %r14
+	LONG $0x00b4850f; WORD $0x0000 // jne          LBB40_38, $180(%rip)
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x0088840f; WORD $0x0000 // je           LBB40_35, $136(%rip)
+
+LBB40_25:
+	WORD $0x894c; BYTE $0xcf                   // movq         %r9, %rdi
+	WORD $0xf748; BYTE $0xdf                   // negq         %rdi
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+
+LBB40_26:
+	WORD $0xdb31 // xorl         %ebx, %ebx
+
+LBB40_27:
+	LONG $0x1e0cb60f               // movzbl       (%rsi,%rbx), %ecx
+	WORD $0xf983; BYTE $0x22       // cmpl         $34, %ecx
+	LONG $0x0066840f; WORD $0x0000 // je           LBB40_34, $102(%rip)
+	WORD $0xf983; BYTE $0x5c       // cmpl         $92, %ecx
+	LONG $0x0011840f; WORD $0x0000 // je           LBB40_30, $17(%rip)
+	WORD $0xff48; BYTE $0xc3       // incq         %rbx
+	WORD $0x3949; BYTE $0xdf       // cmpq         %rbx, %r15
+	LONG $0xffde850f; WORD $0xffff // jne          LBB40_27, $-34(%rip)
+	LONG $0x00005de9; BYTE $0x00   // jmp          LBB40_36, $93(%rip)
+
+LBB40_30:
+	LONG $0xff4f8d49               // leaq         $-1(%r15), %rcx
+	WORD $0x3948; BYTE $0xd9       // cmpq         %rbx, %rcx
+	LONG $0xfe9a840f; WORD $0xffff // je           LBB40_11, $-358(%rip)
+	LONG $0xd07d8348; BYTE $0xff   // cmpq         $-1, $-48(%rbp)
+	LONG $0x000e850f; WORD $0x0000 // jne          LBB40_33, $14(%rip)
+	LONG $0x370c8d48               // leaq         (%rdi,%rsi), %rcx
+	WORD $0x0148; BYTE $0xd9       // addq         %rbx, %rcx
+	LONG $0xd04d8948               // movq         %rcx, $-48(%rbp)
+	WORD $0x8948; BYTE $0x0a       // movq         %rcx, (%rdx)
+
+LBB40_33:
+	WORD $0x0148; BYTE $0xde       // addq         %rbx, %rsi
+	LONG $0x02c68348               // addq         $2, %rsi
+	WORD $0x894c; BYTE $0xf9       // movq         %r15, %rcx
+	WORD $0x2948; BYTE $0xd9       // subq         %rbx, %rcx
+	LONG $0xfec18348               // addq         $-2, %rcx
+	LONG $0xfec78349               // addq         $-2, %r15
+	WORD $0x3949; BYTE $0xdf       // cmpq         %rbx, %r15
+	WORD $0x8949; BYTE $0xcf       // movq         %rcx, %r15
+	LONG $0xff90850f; WORD $0xffff // jne          LBB40_26, $-112(%rip)
+	LONG $0xfffe5be9; BYTE $0xff   // jmp          LBB40_11, $-421(%rip)
+
+LBB40_34:
+	WORD $0x0148; BYTE $0xde // addq         %rbx, %rsi
+	WORD $0xff48; BYTE $0xc6 // incq         %rsi
+
+LBB40_35:
+	WORD $0x294c; BYTE $0xce     // subq         %r9, %rsi
+	WORD $0x8948; BYTE $0xf0     // movq         %rsi, %rax
+	LONG $0xfffe4ae9; BYTE $0xff // jmp          LBB40_11, $-438(%rip)
+
+LBB40_36:
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	WORD $0xf980; BYTE $0x22                   // cmpb         $34, %cl
+	LONG $0xfe3a850f; WORD $0xffff             // jne          LBB40_11, $-454(%rip)
+	WORD $0x0148; BYTE $0xde                   // addq         %rbx, %rsi
+	LONG $0xffffdde9; BYTE $0xff               // jmp          LBB40_35, $-35(%rip)
+
+LBB40_38:
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0x002f840f; WORD $0x0000 // je           LBB40_17, $47(%rip)
+	LONG $0xd07d8348; BYTE $0xff   // cmpq         $-1, $-48(%rbp)
+	LONG $0x0010850f; WORD $0x0000 // jne          LBB40_41, $16(%rip)
+	WORD $0x894c; BYTE $0xc8       // movq         %r9, %rax
+	WORD $0xf748; BYTE $0xd0       // notq         %rax
+	WORD $0x0148; BYTE $0xf0       // addq         %rsi, %rax
+	LONG $0xd0458948               // movq         %rax, $-48(%rbp)
+	WORD $0x8948; BYTE $0x02       // movq         %rax, (%rdx)
+
+LBB40_41:
+	WORD $0xff48; BYTE $0xc6       // incq         %rsi
+	WORD $0xff49; BYTE $0xcf       // decq         %r15
+	WORD $0x854d; BYTE $0xff       // testq        %r15, %r15
+	LONG $0xff22850f; WORD $0xffff // jne          LBB40_25, $-222(%rip)
+	LONG $0xffffa5e9; BYTE $0xff   // jmp          LBB40_35, $-91(%rip)
+
+LBB40_17:
+	LONG $0xffc0c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rax
+	LONG $0xfffdeee9; BYTE $0xff               // jmp          LBB40_11, $-530(%rip)
+	QUAD $0x9090909090909090; LONG $0x90909090 // .p2align 4, 0x90
+
+_unescape:
+	BYTE $0x55                                 // pushq        %rbp
+	WORD $0x8948; BYTE $0xe5                   // movq         %rsp, %rbp
+	WORD $0x5741                               // pushq        %r15
+	WORD $0x5641                               // pushq        %r14
+	WORD $0x5541                               // pushq        %r13
+	WORD $0x5441                               // pushq        %r12
+	BYTE $0x53                                 // pushq        %rbx
+	LONG $0x18ec8348                           // subq         $24, %rsp
+	WORD $0x8b4c; BYTE $0x2f                   // movq         (%rdi), %r13
+	WORD $0x294c; BYTE $0xee                   // subq         %r13, %rsi
+	LONG $0xffc3c748; WORD $0xffff; BYTE $0xff // movq         $-1, %rbx
+	WORD $0x8548; BYTE $0xf6                   // testq        %rsi, %rsi
+	LONG $0x00d38e0f; WORD $0x0000             // jle          LBB41_13, $211(%rip)
+	WORD $0x8949; BYTE $0xd6                   // movq         %rdx, %r14
+	WORD $0x8949; BYTE $0xff                   // movq         %rdi, %r15
+	LONG $0x01458d49                           // leaq         $1(%r13), %rax
+	LONG $0x4db60f41; BYTE $0x01               // movzbl       $1(%r13), %ecx
+	LONG $0x43158d48; WORD $0x0077; BYTE $0x00 // leaq         $30531(%rip), %rdx  /* __UnquoteTab(%rip) */
+	LONG $0x110cb60f                           // movzbl       (%rcx,%rdx), %ecx
+	LONG $0x00fff981; WORD $0x0000             // cmpl         $255, %ecx
+	LONG $0x0017840f; WORD $0x0000             // je           LBB41_4, $23(%rip)
+	WORD $0xc985                               // testl        %ecx, %ecx
+	LONG $0x0021850f; WORD $0x0000             // jne          LBB41_6, $33(%rip)
+	WORD $0x8949; BYTE $0x07                   // movq         %rax, (%r15)
+	LONG $0xfdc3c748; WORD $0xffff; BYTE $0xff // movq         $-3, %rbx
+	LONG $0x000096e9; BYTE $0x00               // jmp          LBB41_13, $150(%rip)
+
+LBB41_4:
+	LONG $0x03fe8348               // cmpq         $3, %rsi
+	LONG $0x0019870f; WORD $0x0000 // ja           LBB41_7, $25(%rip)
+	WORD $0x8949; BYTE $0x07       // movq         %rax, (%r15)
+	LONG $0x000084e9; BYTE $0x00   // jmp          LBB41_13, $132(%rip)
+
+LBB41_6:
+	WORD $0x8841; BYTE $0x0e     // movb         %cl, (%r14)
+	LONG $0x02078349             // addq         $2, (%r15)
+	LONG $0x000001bb; BYTE $0x00 // movl         $1, %ebx
+	LONG $0x000073e9; BYTE $0x00 // jmp          LBB41_13, $115(%rip)
+
+LBB41_7:
+	LONG $0x024d8b41               // movl         $2(%r13), %ecx
+	WORD $0xc889                   // movl         %ecx, %eax
+	WORD $0xd0f7                   // notl         %eax
+	LONG $0xcfd0918d; WORD $0xcfcf // leal         $-808464432(%rcx), %edx
+	LONG $0x80808025; BYTE $0x80   // andl         $-2139062144, %eax
+	WORD $0xd085                   // testl        %edx, %eax
+	LONG $0x004a850f; WORD $0x0000 // jne          LBB41_11, $74(%rip)
+	LONG $0x1919918d; WORD $0x1919 // leal         $421075225(%rcx), %edx
+	WORD $0xca09                   // orl          %ecx, %edx
+	LONG $0x8080c2f7; WORD $0x8080 // testl        $-2139062144, %edx
+	LONG $0x0036850f; WORD $0x0000 // jne          LBB41_11, $54(%rip)
+	WORD $0xca89                   // movl         %ecx, %edx
+	LONG $0x7f7fe281; WORD $0x7f7f // andl         $2139062143, %edx
+	LONG $0xc0c0c0bf; BYTE $0xc0   // movl         $-1061109568, %edi
+	WORD $0xd729                   // subl         %edx, %edi
+	LONG $0x46469a8d; WORD $0x4646 // leal         $1179010630(%rdx), %ebx
+	WORD $0xc721                   // andl         %eax, %edi
+	WORD $0xdf85                   // testl        %ebx, %edi
+	LONG $0x0017850f; WORD $0x0000 // jne          LBB41_11, $23(%rip)
+	LONG $0xe0e0e0bf; BYTE $0xe0   // movl         $-522133280, %edi
+	WORD $0xd729                   // subl         %edx, %edi
+	LONG $0x3939c281; WORD $0x3939 // addl         $960051513, %edx
+	WORD $0xf821                   // andl         %edi, %eax
+	WORD $0xd085                   // testl        %edx, %eax
+	LONG $0x0020840f; WORD $0x0000 // je           LBB41_14, $32(%rip)
+
+LBB41_11:
+	LONG $0x02c58349         // addq         $2, %r13
+	WORD $0x894d; BYTE $0x2f // movq         %r13, (%r15)
+
+LBB41_12:
+	LONG $0xfec3c748; WORD $0xffff; BYTE $0xff // movq         $-2, %rbx
+
+LBB41_13:
+	WORD $0x8948; BYTE $0xd8 // movq         %rbx, %rax
+	LONG $0x18c48348         // addq         $24, %rsp
+	BYTE $0x5b               // popq         %rbx
+	WORD $0x5c41             // popq         %r12
+	WORD $0x5d41             // popq         %r13
+	WORD $0x5e41             // popq         %r14
+	WORD $0x5f41             // popq         %r15
+	BYTE $0x5d               // popq         %rbp
+	BYTE $0xc3               // retq
+
+LBB41_14:
+	WORD $0xc90f                               // bswapl       %ecx
+	WORD $0xc889                               // movl         %ecx, %eax
+	WORD $0xd0f7                               // notl         %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	LONG $0x01010125; BYTE $0x01               // andl         $16843009, %eax
+	WORD $0x048d; BYTE $0xc0                   // leal         (%rax,%rax,8), %eax
+	LONG $0x0f0fe181; WORD $0x0f0f             // andl         $252645135, %ecx
+	WORD $0xc101                               // addl         %eax, %ecx
+	WORD $0xc889                               // movl         %ecx, %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	WORD $0xc809                               // orl          %ecx, %eax
+	WORD $0xc189                               // movl         %eax, %ecx
+	WORD $0xe9c1; BYTE $0x08                   // shrl         $8, %ecx
+	LONG $0xff00e181; WORD $0x0000             // andl         $65280, %ecx
+	LONG $0xe0b60f44                           // movzbl       %al, %r12d
+	WORD $0x0941; BYTE $0xcc                   // orl          %ecx, %r12d
+	LONG $0x06558d49                           // leaq         $6(%r13), %rdx
+	WORD $0x8949; BYTE $0x17                   // movq         %rdx, (%r15)
+	LONG $0x7ffc8341                           // cmpl         $127, %r12d
+	LONG $0x004c860f; WORD $0x0000             // jbe          LBB41_18, $76(%rip)
+	LONG $0xfffc8141; WORD $0x0007; BYTE $0x00 // cmpl         $2047, %r12d
+	LONG $0x004c860f; WORD $0x0000             // jbe          LBB41_19, $76(%rip)
+	QUAD $0xffff200024bc8d41                   // leal         $-57344(%r12), %edi
+	LONG $0xf7ffff81; WORD $0xffff             // cmpl         $-2049, %edi
+	LONG $0x0055870f; WORD $0x0000             // ja           LBB41_20, $85(%rip)
+	WORD $0xe9c1; BYTE $0x0c                   // shrl         $12, %ecx
+	WORD $0xc980; BYTE $0xe0                   // orb          $-32, %cl
+	WORD $0x8841; BYTE $0x0e                   // movb         %cl, (%r14)
+	LONG $0x06ecc141                           // shrl         $6, %r12d
+	LONG $0x3fe48041                           // andb         $63, %r12b
+	LONG $0x80cc8041                           // orb          $-128, %r12b
+	LONG $0x01668845                           // movb         %r12b, $1(%r14)
+	WORD $0x3f24                               // andb         $63, %al
+	WORD $0x800c                               // orb          $-128, %al
+	LONG $0x02468841                           // movb         %al, $2(%r14)
+	LONG $0x000003bb; BYTE $0x00               // movl         $3, %ebx
+	LONG $0xffff5fe9; BYTE $0xff               // jmp          LBB41_13, $-161(%rip)
+
+LBB41_18:
+	WORD $0x8841; BYTE $0x06     // movb         %al, (%r14)
+	LONG $0x000001bb; BYTE $0x00 // movl         $1, %ebx
+	LONG $0xffff52e9; BYTE $0xff // jmp          LBB41_13, $-174(%rip)
+
+LBB41_19:
+	LONG $0x06ecc141             // shrl         $6, %r12d
+	LONG $0xc0cc8041             // orb          $-64, %r12b
+	WORD $0x8845; BYTE $0x26     // movb         %r12b, (%r14)
+	WORD $0x3f24                 // andb         $63, %al
+	WORD $0x800c                 // orb          $-128, %al
+	LONG $0x01468841             // movb         %al, $1(%r14)
+	LONG $0x000002bb; BYTE $0x00 // movl         $2, %ebx
+	LONG $0xffff35e9; BYTE $0xff // jmp          LBB41_13, $-203(%rip)
+
+LBB41_20:
+	LONG $0xfcc3c748; WORD $0xffff; BYTE $0xff // movq         $-4, %rbx
+	LONG $0x06fe8348                           // cmpq         $6, %rsi
+	LONG $0xff24820f; WORD $0xffff             // jb           LBB41_13, $-220(%rip)
+	LONG $0xfffc8141; WORD $0x00db; BYTE $0x00 // cmpl         $56319, %r12d
+	LONG $0xff17870f; WORD $0xffff             // ja           LBB41_13, $-233(%rip)
+	WORD $0x3a80; BYTE $0x5c                   // cmpb         $92, (%rdx)
+	LONG $0xff0e850f; WORD $0xffff             // jne          LBB41_13, $-242(%rip)
+	LONG $0x077d8041; BYTE $0x75               // cmpb         $117, $7(%r13)
+	LONG $0xff03850f; WORD $0xffff             // jne          LBB41_13, $-253(%rip)
+	LONG $0x08458d49                           // leaq         $8(%r13), %rax
+	LONG $0xc8458948                           // movq         %rax, $-56(%rbp)
+	LONG $0x087d8b41                           // movl         $8(%r13), %edi
+	WORD $0x7d89; BYTE $0xd4                   // movl         %edi, $-44(%rbp)
+	LONG $0xff9c65e8; BYTE $0xff               // callq        _unhex16_is, $-25499(%rip)
+	WORD $0xc084                               // testb        %al, %al
+	LONG $0x0050840f; WORD $0x0000             // je           LBB41_27, $80(%rip)
+	WORD $0x558b; BYTE $0xd4                   // movl         $-44(%rbp), %edx
+	WORD $0xca0f                               // bswapl       %edx
+	WORD $0xd089                               // movl         %edx, %eax
+	WORD $0xd0f7                               // notl         %eax
+	WORD $0xe8c1; BYTE $0x04                   // shrl         $4, %eax
+	LONG $0x01010125; BYTE $0x01               // andl         $16843009, %eax
+	WORD $0x048d; BYTE $0xc0                   // leal         (%rax,%rax,8), %eax
+	LONG $0x0f0fe281; WORD $0x0f0f             // andl         $252645135, %edx
+	WORD $0xc201                               // addl         %eax, %edx
+	WORD $0xd189                               // movl         %edx, %ecx
+	WORD $0xe9c1; BYTE $0x04                   // shrl         $4, %ecx
+	WORD $0xd109                               // orl          %edx, %ecx
+	WORD $0xb60f; BYTE $0xc1                   // movzbl       %cl, %eax
+	WORD $0xe9c1; BYTE $0x08                   // shrl         $8, %ecx
+	LONG $0xff00e181; WORD $0x0000             // andl         $65280, %ecx
+	WORD $0x148d; BYTE $0x01                   // leal         (%rcx,%rax), %edx
+	LONG $0x2000c281; WORD $0xffff             // addl         $-57344, %edx
+	LONG $0xfbfffa81; WORD $0xffff             // cmpl         $-1025, %edx
+	LONG $0x0018870f; WORD $0x0000             // ja           LBB41_28, $24(%rip)
+	LONG $0xc8458b48                           // movq         $-56(%rbp), %rax
+	WORD $0x8949; BYTE $0x07                   // movq         %rax, (%r15)
+	LONG $0xfffe97e9; BYTE $0xff               // jmp          LBB41_13, $-361(%rip)
+
+LBB41_27:
+	LONG $0xc8458b48             // movq         $-56(%rbp), %rax
+	WORD $0x8949; BYTE $0x07     // movq         %rax, (%r15)
+	LONG $0xfffe84e9; BYTE $0xff // jmp          LBB41_12, $-380(%rip)
+
+LBB41_28:
+	WORD $0xc109                                           // orl          %eax, %ecx
+	LONG $0x0ae4c141                                       // shll         $10, %r12d
+	WORD $0xc889                                           // movl         %ecx, %eax
+	WORD $0x0144; BYTE $0xe0                               // addl         %r12d, %eax
+	WORD $0x0144; BYTE $0xe1                               // addl         %r12d, %ecx
+	LONG $0x2400c181; WORD $0xfca0                         // addl         $-56613888, %ecx
+	WORD $0xca89                                           // movl         %ecx, %edx
+	WORD $0xeac1; BYTE $0x12                               // shrl         $18, %edx
+	WORD $0xca80; BYTE $0xf0                               // orb          $-16, %dl
+	WORD $0x8841; BYTE $0x16                               // movb         %dl, (%r14)
+	WORD $0xca89                                           // movl         %ecx, %edx
+	WORD $0xeac1; BYTE $0x0c                               // shrl         $12, %edx
+	WORD $0xe280; BYTE $0x3f                               // andb         $63, %dl
+	WORD $0xca80; BYTE $0x80                               // orb          $-128, %dl
+	LONG $0x01568841                                       // movb         %dl, $1(%r14)
+	WORD $0xe9c1; BYTE $0x06                               // shrl         $6, %ecx
+	WORD $0xe180; BYTE $0x3f                               // andb         $63, %cl
+	WORD $0xc980; BYTE $0x80                               // orb          $-128, %cl
+	LONG $0x024e8841                                       // movb         %cl, $2(%r14)
+	WORD $0x3f24                                           // andb         $63, %al
+	WORD $0x800c                                           // orb          $-128, %al
+	LONG $0x03468841                                       // movb         %al, $3(%r14)
+	LONG $0x0cc58349                                       // addq         $12, %r13
+	WORD $0x894d; BYTE $0x2f                               // movq         %r13, (%r15)
+	LONG $0x000004bb; BYTE $0x00                           // movl         $4, %ebx
+	LONG $0xfffe37e9; BYTE $0xff                           // jmp          LBB41_13, $-457(%rip)
+	QUAD $0x0000000000000000; LONG $0x00000000; BYTE $0x00 // .p2align 4, 0x00
+
+_POW10_M128_TAB:
+	QUAD $0x1732c869cd60e453                           // .quad 1671618768450675795
+	QUAD $0xfa8fd5a0081c0288                           // .quad -391859759250406776
+	QUAD $0x0e7fbd42205c8eb4                           // .quad 1044761730281672372
+	QUAD $0x9c99e58405118195                           // .quad -7162441377172586091
+	QUAD $0x521fac92a873b261                           // .quad 5917638181279478369
+	QUAD $0xc3c05ee50655e1fa                           // .quad -4341365703038344710
+	QUAD $0xe6a797b752909ef9                           // .quad -1826324310255427847
+	QUAD $0xf4b0769e47eb5a78                           // .quad -815021110370542984
+	QUAD $0x9028bed2939a635c                           // .quad -8058981721550724260
+	QUAD $0x98ee4a22ecf3188b                           // .quad -7426917221622671221
+	QUAD $0x7432ee873880fc33                           // .quad 8373016921771146291
+	QUAD $0xbf29dcaba82fdeae                           // .quad -4671960508600951122
+	QUAD $0x113faa2906a13b3f                           // .quad 1242899115359157055
+	QUAD $0xeef453d6923bd65a                           // .quad -1228264617323800998
+	QUAD $0x4ac7ca59a424c507                           // .quad 5388497965526861063
+	QUAD $0x9558b4661b6565f8                           // .quad -7685194413468457480
+	QUAD $0x5d79bcf00d2df649                           // .quad 6735622456908576329
+	QUAD $0xbaaee17fa23ebf76                           // .quad -4994806998408183946
+	QUAD $0xf4d82c2c107973dc                           // .quad -803843965719055396
+	QUAD $0xe95a99df8ace6f53                           // .quad -1631822729582842029
+	QUAD $0x79071b9b8a4be869                           // .quad 8720969558280366185
+	QUAD $0x91d8a02bb6c10594                           // .quad -7937418233630358124
+	QUAD $0x9748e2826cdee284                           // .quad -7545532125859093884
+	QUAD $0xb64ec836a47146f9                           // .quad -5310086773610559751
+	QUAD $0xfd1b1b2308169b25                           // .quad -208543120469091547
+	QUAD $0xe3e27a444d8d98b7                           // .quad -2025922448585811785
+	QUAD $0xfe30f0f5e50e20f7                           // .quad -130339450293182217
+	QUAD $0x8e6d8c6ab0787f72                           // .quad -8183730558007214222
+	QUAD $0xbdbd2d335e51a935                           // .quad -4774610331293865675
+	QUAD $0xb208ef855c969f4f                           // .quad -5617977179081629873
+	QUAD $0xad2c788035e61382                           // .quad -5968262914117332094
+	QUAD $0xde8b2b66b3bc4723                           // .quad -2410785455424649437
+	QUAD $0x4c3bcb5021afcc31                           // .quad 5493207715531443249
+	QUAD $0x8b16fb203055ac76                           // .quad -8424269937281487754
+	QUAD $0xdf4abe242a1bbf3d                           // .quad -2356862392440471747
+	QUAD $0xaddcb9e83c6b1793                           // .quad -5918651403174471789
+	QUAD $0xd71d6dad34a2af0d                           // .quad -2946077990550589683
+	QUAD $0xd953e8624b85dd78                           // .quad -2786628235540701832
+	QUAD $0x8672648c40e5ad68                           // .quad -8758827771735200408
+	QUAD $0x87d4713d6f33aa6b                           // .quad -8659171674854020501
+	QUAD $0x680efdaf511f18c2                           // .quad 7498209359040551106
+	QUAD $0xa9c98d8ccb009506                           // .quad -6212278575140137722
+	QUAD $0x0212bd1b2566def2                           // .quad 149389661945913074
+	QUAD $0xd43bf0effdc0ba48                           // .quad -3153662200497784248
+	QUAD $0x014bb630f7604b57                           // .quad 93368538716195671
+	QUAD $0x84a57695fe98746d                           // .quad -8888567902952197011
+	QUAD $0x419ea3bd35385e2d                           // .quad 4728396691822632493
+	QUAD $0xa5ced43b7e3e9188                           // .quad -6499023860262858360
+	QUAD $0x52064cac828675b9                           // .quad 5910495864778290617
+	QUAD $0xcf42894a5dce35ea                           // .quad -3512093806901185046
+	QUAD $0x7343efebd1940993                           // .quad 8305745933913819539
+	QUAD $0x818995ce7aa0e1b2                           // .quad -9112587656954322510
+	QUAD $0x1014ebe6c5f90bf8                           // .quad 1158810380537498616
+	QUAD $0xa1ebfb4219491a1f                           // .quad -6779048552765515233
+	QUAD $0xd41a26e077774ef6                           // .quad -3163173042755514634
+	QUAD $0xca66fa129f9b60a6                           // .quad -3862124672529506138
+	QUAD $0x8920b098955522b4                           // .quad -8565652321871781196
+	QUAD $0xfd00b897478238d0                           // .quad -215969822234494768
+	QUAD $0x55b46e5f5d5535b0                           // .quad 6175682344898606512
+	QUAD $0x9e20735e8cb16382                           // .quad -7052510166537641086
+	QUAD $0xeb2189f734aa831d                           // .quad -1503769105731517667
+	QUAD $0xc5a890362fddbc62                           // .quad -4203951689744663454
+	QUAD $0xa5e9ec7501d523e4                           // .quad -6491397400591784988
+	QUAD $0xf712b443bbd52b7b                           // .quad -643253593753441413
+	QUAD $0x47b233c92125366e                           // .quad 5166248661484910190
+	QUAD $0x9a6bb0aa55653b2d                           // .quad -7319562523736982739
+	QUAD $0x999ec0bb696e840a                           // .quad -7377247228426025974
+	QUAD $0xc1069cd4eabe89f8                           // .quad -4537767136243840520
+	QUAD $0xc00670ea43ca250d                           // .quad -4609873017105144563
+	QUAD $0xf148440a256e2c76                           // .quad -1060522901877412746
+	QUAD $0x380406926a5e5728                           // .quad 4036358391950366504
+	QUAD $0x96cd2a865764dbca                           // .quad -7580355841314464822
+	QUAD $0xc605083704f5ecf2                           // .quad -4177924046916817678
+	QUAD $0xbc807527ed3e12bc                           // .quad -4863758783215693124
+	QUAD $0xf7864a44c633682e                           // .quad -610719040218634194
+	QUAD $0xeba09271e88d976b                           // .quad -1468012460592228501
+	QUAD $0x7ab3ee6afbe0211d                           // .quad 8841672636718129437
+	QUAD $0x93445b8731587ea3                           // .quad -7835036815511224669
+	QUAD $0x5960ea05bad82964                           // .quad 6440404777470273892
+	QUAD $0xb8157268fdae9e4c                           // .quad -5182110000961642932
+	QUAD $0x6fb92487298e33bd                           // .quad 8050505971837842365
+	QUAD $0xe61acf033d1a45df                           // .quad -1865951482774665761
+	QUAD $0xa5d3b6d479f8e056                           // .quad -6497648813669818282
+	QUAD $0x8fd0c16206306bab                           // .quad -8083748704375247957
+	QUAD $0x8f48a4899877186c                           // .quad -8122061017087272852
+	QUAD $0xb3c4f1ba87bc8696                           // .quad -5492999862041672042
+	QUAD $0x331acdabfe94de87                           // .quad 3682481783923072647
+	QUAD $0xe0b62e2929aba83c                           // .quad -2254563809124702148
+	QUAD $0x9ff0c08b7f1d0b14                           // .quad -6921820921902855404
+	QUAD $0x8c71dcd9ba0b4925                           // .quad -8326631408344020699
+	QUAD $0x07ecf0ae5ee44dd9                           // .quad 571095884476206553
+	QUAD $0xaf8e5410288e1b6f                           // .quad -5796603242002637969
+	QUAD $0xc9e82cd9f69d6150                           // .quad -3897816162832129712
+	QUAD $0xdb71e91432b1a24a                           // .quad -2634068034075909558
+	QUAD $0xbe311c083a225cd2                           // .quad -4741978110983775022
+	QUAD $0x892731ac9faf056e                           // .quad -8563821548938525330
+	QUAD $0x6dbd630a48aaf406                           // .quad 7907585416552444934
+	QUAD $0xab70fe17c79ac6ca                           // .quad -6093090917745768758
+	QUAD $0x092cbbccdad5b108                           // .quad 661109733835780360
+	QUAD $0xd64d3d9db981787d                           // .quad -3004677628754823043
+	QUAD $0x25bbf56008c58ea5                           // .quad 2719036592861056677
+	QUAD $0x85f0468293f0eb4e                           // .quad -8795452545612846258
+	QUAD $0xaf2af2b80af6f24e                           // .quad -5824576295778454962
+	QUAD $0xa76c582338ed2621                           // .quad -6382629663588669919
+	QUAD $0x1af5af660db4aee1                           // .quad 1942651667131707105
+	QUAD $0xd1476e2c07286faa                           // .quad -3366601061058449494
+	QUAD $0x50d98d9fc890ed4d                           // .quad 5825843310384704845
+	QUAD $0x82cca4db847945ca                           // .quad -9021654690802612790
+	QUAD $0xe50ff107bab528a0                           // .quad -1941067898873894752
+	QUAD $0xa37fce126597973c                           // .quad -6665382345075878084
+	QUAD $0x1e53ed49a96272c8                           // .quad 2185351144835019464
+	QUAD $0xcc5fc196fefd7d0c                           // .quad -3720041912917459700
+	QUAD $0x25e8e89c13bb0f7a                           // .quad 2731688931043774330
+	QUAD $0xff77b1fcbebcdc4f                           // .quad -38366372719436721
+	QUAD $0x77b191618c54e9ac                           // .quad 8624834609543440812
+	QUAD $0x9faacf3df73609b1                           // .quad -6941508010590729807
+	QUAD $0xd59df5b9ef6a2417                           // .quad -3054014793352862697
+	QUAD $0xc795830d75038c1d                           // .quad -4065198994811024355
+	QUAD $0x4b0573286b44ad1d                           // .quad 5405853545163697437
+	QUAD $0xf97ae3d0d2446f25                           // .quad -469812725086392539
+	QUAD $0x4ee367f9430aec32                           // .quad 5684501474941004850
+	QUAD $0x9becce62836ac577                           // .quad -7211161980820077193
+	QUAD $0x229c41f793cda73f                           // .quad 2493940825248868159
+	QUAD $0xc2e801fb244576d5                           // .quad -4402266457597708587
+	QUAD $0x6b43527578c1110f                           // .quad 7729112049988473103
+	QUAD $0xf3a20279ed56d48a                           // .quad -891147053569747830
+	QUAD $0x830a13896b78aaa9                           // .quad -9004363024039368023
+	QUAD $0x9845418c345644d6                           // .quad -7474495936122174250
+	QUAD $0x23cc986bc656d553                           // .quad 2579604275232953683
+	QUAD $0xbe5691ef416bd60c                           // .quad -4731433901725329908
+	QUAD $0x2cbfbe86b7ec8aa8                           // .quad 3224505344041192104
+	QUAD $0xedec366b11c6cb8f                           // .quad -1302606358729274481
+	QUAD $0x7bf7d71432f3d6a9                           // .quad 8932844867666826921
+	QUAD $0x94b3a202eb1c3f39                           // .quad -7731658001846878407
+	QUAD $0xdaf5ccd93fb0cc53                           // .quad -2669001970698630061
+	QUAD $0xb9e08a83a5e34f07                           // .quad -5052886483881210105
+	QUAD $0xd1b3400f8f9cff68                           // .quad -3336252463373287576
+	QUAD $0xe858ad248f5c22c9                           // .quad -1704422086424124727
+	QUAD $0x23100809b9c21fa1                           // .quad 2526528228819083169
+	QUAD $0x91376c36d99995be                           // .quad -7982792831656159810
+	QUAD $0xabd40a0c2832a78a                           // .quad -6065211750830921846
+	QUAD $0xb58547448ffffb2d                           // .quad -5366805021142811859
+	QUAD $0x16c90c8f323f516c                           // .quad 1641857348316123500
+	QUAD $0xe2e69915b3fff9f9                           // .quad -2096820258001126919
+	QUAD $0xae3da7d97f6792e3                           // .quad -5891368184943504669
+	QUAD $0x8dd01fad907ffc3b                           // .quad -8228041688891786181
+	QUAD $0x99cd11cfdf41779c                           // .quad -7364210231179380836
+	QUAD $0xb1442798f49ffb4a                           // .quad -5673366092687344822
+	QUAD $0x40405643d711d583                           // .quad 4629795266307937667
+	QUAD $0xdd95317f31c7fa1d                           // .quad -2480021597431793123
+	QUAD $0x482835ea666b2572                           // .quad 5199465050656154994
+	QUAD $0x8a7d3eef7f1cfc52                           // .quad -8467542526035952558
+	QUAD $0xda3243650005eecf                           // .quad -2724040723534582065
+	QUAD $0xad1c8eab5ee43b66                           // .quad -5972742139117552794
+	QUAD $0x90bed43e40076a82                           // .quad -8016736922845615486
+	QUAD $0xd863b256369d4a40                           // .quad -2854241655469553088
+	QUAD $0x5a7744a6e804a291                           // .quad 6518754469289960081
+	QUAD $0x873e4f75e2224e68                           // .quad -8701430062309552536
+	QUAD $0x711515d0a205cb36                           // .quad 8148443086612450102
+	QUAD $0xa90de3535aaae202                           // .quad -6265101559459552766
+	QUAD $0x0d5a5b44ca873e03                           // .quad 962181821410786819
+	QUAD $0xd3515c2831559a83                           // .quad -3219690930897053053
+	QUAD $0xe858790afe9486c2                           // .quad -1704479370831952190
+	QUAD $0x8412d9991ed58091                           // .quad -8929835859451740015
+	QUAD $0x626e974dbe39a872                           // .quad 7092772823314835570
+	QUAD $0xa5178fff668ae0b6                           // .quad -6550608805887287114
+	QUAD $0xfb0a3d212dc8128f                           // .quad -357406007711231345
+	QUAD $0xce5d73ff402d98e3                           // .quad -3576574988931720989
+	QUAD $0x7ce66634bc9d0b99                           // .quad 8999993282035256217
+	QUAD $0x80fa687f881c7f8e                           // .quad -9152888395723407474
+	QUAD $0x1c1fffc1ebc44e80                           // .quad 2026619565689294464
+	QUAD $0xa139029f6a239f72                           // .quad -6829424476226871438
+	QUAD $0xa327ffb266b56220                           // .quad -6690097579743157728
+	QUAD $0xc987434744ac874e                           // .quad -3925094576856201394
+	QUAD $0x4bf1ff9f0062baa8                           // .quad 5472436080603216552
+	QUAD $0xfbe9141915d7a922                           // .quad -294682202642863838
+	QUAD $0x6f773fc3603db4a9                           // .quad 8031958568804398249
+	QUAD $0x9d71ac8fada6c9b5                           // .quad -7101705404292871755
+	QUAD $0xcb550fb4384d21d3                           // .quad -3795109844276665901
+	QUAD $0xc4ce17b399107c22                           // .quad -4265445736938701790
+	QUAD $0x7e2a53a146606a48                           // .quad 9091170749936331336
+	QUAD $0xf6019da07f549b2b                           // .quad -720121152745989333
+	QUAD $0x2eda7444cbfc426d                           // .quad 3376138709496513133
+	QUAD $0x99c102844f94e0fb                           // .quad -7367604748107325189
+	QUAD $0xfa911155fefb5308                           // .quad -391512631556746488
+	QUAD $0xc0314325637a1939                           // .quad -4597819916706768583
+	QUAD $0x793555ab7eba27ca                           // .quad 8733981247408842698
+	QUAD $0xf03d93eebc589f88                           // .quad -1135588877456072824
+	QUAD $0x4bc1558b2f3458de                           // .quad 5458738279630526686
+	QUAD $0x96267c7535b763b5                           // .quad -7627272076051127371
+	QUAD $0x9eb1aaedfb016f16                           // .quad -7011635205744005354
+	QUAD $0xbbb01b9283253ca2                           // .quad -4922404076636521310
+	QUAD $0x465e15a979c1cadc                           // .quad 5070514048102157020
+	QUAD $0xea9c227723ee8bcb                           // .quad -1541319077368263733
+	QUAD $0x0bfacd89ec191ec9                           // .quad 863228270850154185
+	QUAD $0x92a1958a7675175f                           // .quad -7880853450996246689
+	QUAD $0xcef980ec671f667b                           // .quad -3532650679864695173
+	QUAD $0xb749faed14125d36                           // .quad -5239380795317920458
+	QUAD $0x82b7e12780e7401a                           // .quad -9027499368258256870
+	QUAD $0xe51c79a85916f484                           // .quad -1937539975720012668
+	QUAD $0xd1b2ecb8b0908810                           // .quad -3336344095947716592
+	QUAD $0x8f31cc0937ae58d2                           // .quad -8128491512466089774
+	QUAD $0x861fa7e6dcb4aa15                           // .quad -8782116138362033643
+	QUAD $0xb2fe3f0b8599ef07                           // .quad -5548928372155224313
+	QUAD $0x67a791e093e1d49a                           // .quad 7469098900757009562
+	QUAD $0xdfbdcece67006ac9                           // .quad -2324474446766642487
+	QUAD $0xe0c8bb2c5c6d24e0                           // .quad -2249342214667950880
+	QUAD $0x8bd6a141006042bd                           // .quad -8370325556870233411
+	QUAD $0x58fae9f773886e18                           // .quad 6411694268519837208
+	QUAD $0xaecc49914078536d                           // .quad -5851220927660403859
+	QUAD $0xaf39a475506a899e                           // .quad -5820440219632367202
+	QUAD $0xda7f5bf590966848                           // .quad -2702340141148116920
+	QUAD $0x6d8406c952429603                           // .quad 7891439908798240259
+	QUAD $0x888f99797a5e012d                           // .quad -8606491615858654931
+	QUAD $0xc8e5087ba6d33b83                           // .quad -3970758169284363389
+	QUAD $0xaab37fd7d8f58178                           // .quad -6146428501395930760
+	QUAD $0xfb1e4a9a90880a64                           // .quad -351761693178066332
+	QUAD $0xd5605fcdcf32e1d6                           // .quad -3071349608317525546
+	QUAD $0x5cf2eea09a55067f                           // .quad 6697677969404790399
+	QUAD $0x855c3be0a17fcd26                           // .quad -8837122532839535322
+	QUAD $0xf42faa48c0ea481e                           // .quad -851274575098787810
+	QUAD $0xa6b34ad8c9dfc06f                           // .quad -6434717147622031249
+	QUAD $0xf13b94daf124da26                           // .quad -1064093218873484762
+	QUAD $0xd0601d8efc57b08b                           // .quad -3431710416100151157
+	QUAD $0x76c53d08d6b70858                           // .quad 8558313775058847832
+	QUAD $0x823c12795db6ce57                           // .quad -9062348037703676329
+	QUAD $0x54768c4b0c64ca6e                           // .quad 6086206200396171886
+	QUAD $0xa2cb1717b52481ed                           // .quad -6716249028702207507
+	QUAD $0xa9942f5dcf7dfd09                           // .quad -6227300304786948855
+	QUAD $0xcb7ddcdda26da268                           // .quad -3783625267450371480
+	QUAD $0xd3f93b35435d7c4c                           // .quad -3172439362556298164
+	QUAD $0xfe5d54150b090b02                           // .quad -117845565885576446
+	QUAD $0xc47bc5014a1a6daf                           // .quad -4288617610811380305
+	QUAD $0x9efa548d26e5a6e1                           // .quad -6991182506319567135
+	QUAD $0x359ab6419ca1091b                           // .quad 3862600023340550427
+	QUAD $0xc6b8e9b0709f109a                           // .quad -4127292114472071014
+	QUAD $0xc30163d203c94b62                           // .quad -4395122007679087774
+	QUAD $0xf867241c8cc6d4c0                           // .quad -547429124662700864
+	QUAD $0x79e0de63425dcf1d                           // .quad 8782263791269039901
+	QUAD $0x9b407691d7fc44f8                           // .quad -7259672230555269896
+	QUAD $0x985915fc12f542e4                           // .quad -7468914334623251740
+	QUAD $0xc21094364dfb5636                           // .quad -4462904269766699466
+	QUAD $0x3e6f5b7b17b2939d                           // .quad 4498915137003099037
+	QUAD $0xf294b943e17a2bc4                           // .quad -966944318780986428
+	QUAD $0xa705992ceecf9c42                           // .quad -6411550076227838910
+	QUAD $0x979cf3ca6cec5b5a                           // .quad -7521869226879198374
+	QUAD $0x50c6ff782a838353                           // .quad 5820620459997365075
+	QUAD $0xbd8430bd08277231                           // .quad -4790650515171610063
+	QUAD $0xa4f8bf5635246428                           // .quad -6559282480285457368
+	QUAD $0xece53cec4a314ebd                           // .quad -1376627125537124675
+	QUAD $0x871b7795e136be99                           // .quad -8711237568605798759
+	QUAD $0x940f4613ae5ed136                           // .quad -7777920981101784778
+	QUAD $0x28e2557b59846e3f                           // .quad 2946011094524915263
+	QUAD $0xb913179899f68584                           // .quad -5110715207949843068
+	QUAD $0x331aeada2fe589cf                           // .quad 3682513868156144079
+	QUAD $0xe757dd7ec07426e5                           // .quad -1776707991509915931
+	QUAD $0x3ff0d2c85def7621                           // .quad 4607414176811284001
+	QUAD $0x9096ea6f3848984f                           // .quad -8027971522334779313
+	QUAD $0x0fed077a756b53a9                           // .quad 1147581702586717097
+	QUAD $0xb4bca50b065abe63                           // .quad -5423278384491086237
+	QUAD $0xd3e8495912c62894                           // .quad -3177208890193991532
+	QUAD $0xe1ebce4dc7f16dfb                           // .quad -2167411962186469893
+	QUAD $0x64712dd7abbbd95c                           // .quad 7237616480483531100
+	QUAD $0x8d3360f09cf6e4bd                           // .quad -8272161504007625539
+	QUAD $0xbd8d794d96aacfb3                           // .quad -4788037454677749837
+	QUAD $0xb080392cc4349dec                           // .quad -5728515861582144020
+	QUAD $0xecf0d7a0fc5583a0                           // .quad -1373360799919799392
+	QUAD $0xdca04777f541c567                           // .quad -2548958808550292121
+	QUAD $0xf41686c49db57244                           // .quad -858350499949874620
+	QUAD $0x89e42caaf9491b60                           // .quad -8510628282985014432
+	QUAD $0x311c2875c522ced5                           // .quad 3538747893490044629
+	QUAD $0xac5d37d5b79b6239                           // .quad -6026599335303880135
+	QUAD $0x7d633293366b828b                           // .quad 9035120885289943691
+	QUAD $0xd77485cb25823ac7                           // .quad -2921563150702462265
+	QUAD $0xae5dff9c02033197                           // .quad -5882264492762254953
+	QUAD $0x86a8d39ef77164bc                           // .quad -8743505996830120772
+	QUAD $0xd9f57f830283fdfc                           // .quad -2741144597525430788
+	QUAD $0xa8530886b54dbdeb                           // .quad -6317696477610263061
+	QUAD $0xd072df63c324fd7b                           // .quad -3426430746906788485
+	QUAD $0xd267caa862a12d66                           // .quad -3285434578585440922
+	QUAD $0x4247cb9e59f71e6d                           // .quad 4776009810824339053
+	QUAD $0x8380dea93da4bc60                           // .quad -8970925639256982432
+	QUAD $0x52d9be85f074e608                           // .quad 5970012263530423816
+	QUAD $0xa46116538d0deb78                           // .quad -6601971030643840136
+	QUAD $0x67902e276c921f8b                           // .quad 7462515329413029771
+	QUAD $0xcd795be870516656                           // .quad -3640777769877412266
+	QUAD $0x00ba1cd8a3db53b6                           // .quad 52386062455755702
+	QUAD $0x806bd9714632dff6                           // .quad -9193015133814464522
+	QUAD $0x80e8a40eccd228a4                           // .quad -9157889458785081180
+	QUAD $0xa086cfcd97bf97f3                           // .quad -6879582898840692749
+	QUAD $0x6122cd128006b2cd                           // .quad 6999382250228200141
+	QUAD $0xc8a883c0fdaf7df0                           // .quad -3987792605123478032
+	QUAD $0x796b805720085f81                           // .quad 8749227812785250177
+	QUAD $0xfad2a4b13d1b5d6c                           // .quad -373054737976959636
+	QUAD $0xcbe3303674053bb0                           // .quad -3755104653863994448
+	QUAD $0x9cc3a6eec6311a63                           // .quad -7150688238876681629
+	QUAD $0xbedbfc4411068a9c                           // .quad -4693880817329993060
+	QUAD $0xc3f490aa77bd60fc                           // .quad -4326674280168464132
+	QUAD $0xee92fb5515482d44                           // .quad -1255665003235103420
+	QUAD $0xf4f1b4d515acb93b                           // .quad -796656831783192261
+	QUAD $0x751bdd152d4d1c4a                           // .quad 8438581409832836170
+	QUAD $0x991711052d8bf3c5                           // .quad -7415439547505577019
+	QUAD $0xd262d45a78a0635d                           // .quad -3286831292991118499
+	QUAD $0xbf5cd54678eef0b6                           // .quad -4657613415954583370
+	QUAD $0x86fb897116c87c34                           // .quad -8720225134666286028
+	QUAD $0xef340a98172aace4                           // .quad -1210330751515841308
+	QUAD $0xd45d35e6ae3d4da0                           // .quad -3144297699952734816
+	QUAD $0x9580869f0e7aac0e                           // .quad -7673985747338482674
+	QUAD $0x8974836059cca109                           // .quad -8542058143368306423
+	QUAD $0xbae0a846d2195712                           // .quad -4980796165745715438
+	QUAD $0x2bd1a438703fc94b                           // .quad 3157485376071780683
+	QUAD $0xe998d258869facd7                           // .quad -1614309188754756393
+	QUAD $0x7b6306a34627ddcf                           // .quad 8890957387685944783
+	QUAD $0x91ff83775423cc06                           // .quad -7926472270612804602
+	QUAD $0x1a3bc84c17b1d542                           // .quad 1890324697752655170
+	QUAD $0xb67f6455292cbf08                           // .quad -5296404319838617848
+	QUAD $0x20caba5f1d9e4a93                           // .quad 2362905872190818963
+	QUAD $0xe41f3d6a7377eeca                           // .quad -2008819381370884406
+	QUAD $0x547eb47b7282ee9c                           // .quad 6088502188546649756
+	QUAD $0x8e938662882af53e                           // .quad -8173041140997884610
+	QUAD $0xe99e619a4f23aa43                           // .quad -1612744301171463613
+	QUAD $0xb23867fb2a35b28d                           // .quad -5604615407819967859
+	QUAD $0x6405fa00e2ec94d4                           // .quad 7207441660390446292
+	QUAD $0xdec681f9f4c31f31                           // .quad -2394083241347571919
+	QUAD $0xde83bc408dd3dd04                           // .quad -2412877989897052924
+	QUAD $0x8b3c113c38f9f37e                           // .quad -8413831053483314306
+	QUAD $0x9624ab50b148d445                           // .quad -7627783505798704059
+	QUAD $0xae0b158b4738705e                           // .quad -5905602798426754978
+	QUAD $0x3badd624dd9b0957                           // .quad 4300328673033783639
+	QUAD $0xd98ddaee19068c76                           // .quad -2770317479606055818
+	QUAD $0xe54ca5d70a80e5d6                           // .quad -1923980597781273130
+	QUAD $0x87f8a8d4cfa417c9                           // .quad -8648977452394866743
+	QUAD $0x5e9fcf4ccd211f4c                           // .quad 6818396289628184396
+	QUAD $0xa9f6d30a038d1dbc                           // .quad -6199535797066195524
+	QUAD $0x7647c3200069671f                           // .quad 8522995362035230495
+	QUAD $0xd47487cc8470652b                           // .quad -3137733727905356501
+	QUAD $0x29ecd9f40041e073                           // .quad 3021029092058325107
+	QUAD $0x84c8d4dfd2c63f3b                           // .quad -8878612607581929669
+	QUAD $0xf468107100525890                           // .quad -835399653354481520
+	QUAD $0xa5fb0a17c777cf09                           // .quad -6486579741050024183
+	QUAD $0x7182148d4066eeb4                           // .quad 8179122470161673908
+	QUAD $0xcf79cc9db955c2cc                           // .quad -3496538657885142324
+	QUAD $0xc6f14cd848405530                           // .quad -4111420493003729616
+	QUAD $0x81ac1fe293d599bf                           // .quad -9102865688819295809
+	QUAD $0xb8ada00e5a506a7c                           // .quad -5139275616254662020
+	QUAD $0xa21727db38cb002f                           // .quad -6766896092596731857
+	QUAD $0xa6d90811f0e4851c                           // .quad -6424094520318327524
+	QUAD $0xca9cf1d206fdc03b                           // .quad -3846934097318526917
+	QUAD $0x908f4a166d1da663                           // .quad -8030118150397909405
+	QUAD $0xfd442e4688bd304a                           // .quad -196981603220770742
+	QUAD $0x9a598e4e043287fe                           // .quad -7324666853212387330
+	QUAD $0x9e4a9cec15763e2e                           // .quad -7040642529654063570
+	QUAD $0x40eff1e1853f29fd                           // .quad 4679224488766679549
+	QUAD $0xc5dd44271ad3cdba                           // .quad -4189117143640191558
+	QUAD $0xd12bee59e68ef47c                           // .quad -3374341425896426372
+	QUAD $0xf7549530e188c128                           // .quad -624710411122851544
+	QUAD $0x82bb74f8301958ce                           // .quad -9026492418826348338
+	QUAD $0x9a94dd3e8cf578b9                           // .quad -7307973034592864071
+	QUAD $0xe36a52363c1faf01                           // .quad -2059743486678159615
+	QUAD $0xc13a148e3032d6e7                           // .quad -4523280274813692185
+	QUAD $0xdc44e6c3cb279ac1                           // .quad -2574679358347699519
+	QUAD $0xf18899b1bc3f8ca1                           // .quad -1042414325089727327
+	QUAD $0x29ab103a5ef8c0b9                           // .quad 3002511419460075705
+	QUAD $0x96f5600f15a7b7e5                           // .quad -7569037980822161435
+	QUAD $0x7415d448f6b6f0e7                           // .quad 8364825292752482535
+	QUAD $0xbcb2b812db11a5de                           // .quad -4849611457600313890
+	QUAD $0x111b495b3464ad21                           // .quad 1232659579085827361
+	QUAD $0xebdf661791d60f56                           // .quad -1450328303573004458
+	QUAD $0xcab10dd900beec34                           // .quad -3841273781498745804
+	QUAD $0x936b9fcebb25c995                           // .quad -7823984217374209643
+	QUAD $0x3d5d514f40eea742                           // .quad 4421779809981343554
+	QUAD $0xb84687c269ef3bfb                           // .quad -5168294253290374149
+	QUAD $0x0cb4a5a3112a5112                           // .quad 915538744049291538
+	QUAD $0xe65829b3046b0afa                           // .quad -1848681798185579782
+	QUAD $0x47f0e785eaba72ab                           // .quad 5183897733458195115
+	QUAD $0x8ff71a0fe2c2e6dc                           // .quad -8072955151507069220
+	QUAD $0x59ed216765690f56                           // .quad 6479872166822743894
+	QUAD $0xb3f4e093db73a093                           // .quad -5479507920956448621
+	QUAD $0x306869c13ec3532c                           // .quad 3488154190101041964
+	QUAD $0xe0f218b8d25088b8                           // .quad -2237698882768172872
+	QUAD $0x1e414218c73a13fb                           // .quad 2180096368813151227
+	QUAD $0x8c974f7383725573                           // .quad -8316090829371189901
+	QUAD $0xe5d1929ef90898fa                           // .quad -1886565557410948870
+	QUAD $0xafbd2350644eeacf                           // .quad -5783427518286599473
+	QUAD $0xdf45f746b74abf39                           // .quad -2358206946763686087
+	QUAD $0xdbac6c247d62a583                           // .quad -2617598379430861437
+	QUAD $0x6b8bba8c328eb783                           // .quad 7749492695127472003
+	QUAD $0x894bc396ce5da772                           // .quad -8553528014785370254
+	QUAD $0x066ea92f3f326564                           // .quad 463493832054564196
+	QUAD $0xab9eb47c81f5114f                           // .quad -6080224000054324913
+	QUAD $0xc80a537b0efefebd                           // .quad -4032318728359182659
+	QUAD $0xd686619ba27255a2                           // .quad -2988593981640518238
+	QUAD $0xbd06742ce95f5f36                           // .quad -4826042214438183114
+	QUAD $0x8613fd0145877585                           // .quad -8785400266166405755
+	QUAD $0x2c48113823b73704                           // .quad 3190819268807046916
+	QUAD $0xa798fc4196e952e7                           // .quad -6370064314280619289
+	QUAD $0xf75a15862ca504c5                           // .quad -623161932418579259
+	QUAD $0xd17f3b51fca3a7a0                           // .quad -3350894374423386208
+	QUAD $0x9a984d73dbe722fb                           // .quad -7307005235402693893
+	QUAD $0x82ef85133de648c4                           // .quad -9011838011655698236
+	QUAD $0xc13e60d0d2e0ebba                           // .quad -4522070525825979462
+	QUAD $0xa3ab66580d5fdaf5                           // .quad -6653111496142234891
+	QUAD $0x318df905079926a8                           // .quad 3570783879572301480
+	QUAD $0xcc963fee10b7d1b3                           // .quad -3704703351750405709
+	QUAD $0xfdf17746497f7052                           // .quad -148206168962011054
+	QUAD $0xffbbcfe994e5c61f                           // .quad -19193171260619233
+	QUAD $0xfeb6ea8bedefa633                           // .quad -92628855601256909
+	QUAD $0x9fd561f1fd0f9bd3                           // .quad -6929524759678968877
+	QUAD $0xfe64a52ee96b8fc0                           // .quad -115786069501571136
+	QUAD $0xc7caba6e7c5382c8                           // .quad -4050219931171323192
+	QUAD $0x3dfdce7aa3c673b0                           // .quad 4466953431550423984
+	QUAD $0xf9bd690a1b68637b                           // .quad -451088895536766085
+	QUAD $0x06bea10ca65c084e                           // .quad 486002885505321038
+	QUAD $0x9c1661a651213e2d                           // .quad -7199459587351560659
+	QUAD $0x486e494fcff30a62                           // .quad 5219189625309039202
+	QUAD $0xc31bfa0fe5698db8                           // .quad -4387638465762062920
+	QUAD $0x5a89dba3c3efccfa                           // .quad 6523987031636299002
+	QUAD $0xf3e2f893dec3f126                           // .quad -872862063775190746
+	QUAD $0xf89629465a75e01c                           // .quad -534194123654701028
+	QUAD $0x986ddb5c6b3a76b7                           // .quad -7463067817500576073
+	QUAD $0xf6bbb397f1135823                           // .quad -667742654568376285
+	QUAD $0xbe89523386091465                           // .quad -4717148753448332187
+	QUAD $0x746aa07ded582e2c                           // .quad 8388693718644305452
+	QUAD $0xee2ba6c0678b597f                           // .quad -1284749923383027329
+	QUAD $0xa8c2a44eb4571cdc                           // .quad -6286281471915778852
+	QUAD $0x94db483840b717ef                           // .quad -7720497729755473937
+	QUAD $0x92f34d62616ce413                           // .quad -7857851839894723565
+	QUAD $0xba121a4650e4ddeb                           // .quad -5038936143766954517
+	QUAD $0x77b020baf9c81d17                           // .quad 8624429273841147159
+	QUAD $0xe896a0d7e51e1566                           // .quad -1686984161281305242
+	QUAD $0x0ace1474dc1d122e                           // .quad 778582277723329070
+	QUAD $0x915e2486ef32cd60                           // .quad -7971894128441897632
+	QUAD $0x0d819992132456ba                           // .quad 973227847154161338
+	QUAD $0xb5b5ada8aaff80b8                           // .quad -5353181642124984136
+	QUAD $0x10e1fff697ed6c69                           // .quad 1216534808942701673
+	QUAD $0xe3231912d5bf60e6                           // .quad -2079791034228842266
+	QUAD $0xca8d3ffa1ef463c1                           // .quad -3851351762838199359
+	QUAD $0x8df5efabc5979c8f                           // .quad -8217398424034108273
+	QUAD $0xbd308ff8a6b17cb2                           // .quad -4814189703547749198
+	QUAD $0xb1736b96b6fd83b3                           // .quad -5660062011615247437
+	QUAD $0xac7cb3f6d05ddbde                           // .quad -6017737129434686498
+	QUAD $0xddd0467c64bce4a0                           // .quad -2463391496091671392
+	QUAD $0x6bcdf07a423aa96b                           // .quad 7768129340171790699
+	QUAD $0x8aa22c0dbef60ee4                           // .quad -8457148712698376476
+	QUAD $0x86c16c98d2c953c6                           // .quad -8736582398494813242
+	QUAD $0xad4ab7112eb3929d                           // .quad -5959749872445582691
+	QUAD $0xe871c7bf077ba8b7                           // .quad -1697355961263740745
+	QUAD $0xd89d64d57a607744                           // .quad -2838001322129590460
+	QUAD $0x11471cd764ad4972                           // .quad 1244995533423855986
+	QUAD $0x87625f056c7c4a8b                           // .quad -8691279853972075893
+	QUAD $0xd598e40d3dd89bcf                           // .quad -3055441601647567921
+	QUAD $0xa93af6c6c79b5d2d                           // .quad -6252413799037706963
+	QUAD $0x4aff1d108d4ec2c3                           // .quad 5404070034795315907
+	QUAD $0xd389b47879823479                           // .quad -3203831230369745799
+	QUAD $0xcedf722a585139ba                           // .quad -3539985255894009414
+	QUAD $0x843610cb4bf160cb                           // .quad -8919923546622172981
+	QUAD $0xc2974eb4ee658828                           // .quad -4424981569867511768
+	QUAD $0xa54394fe1eedb8fe                           // .quad -6538218414850328322
+	QUAD $0x733d226229feea32                           // .quad 8303831092947774002
+	QUAD $0xce947a3da6a9273e                           // .quad -3561087000135522498
+	QUAD $0x0806357d5a3f525f                           // .quad 578208414664970847
+	QUAD $0x811ccc668829b887                           // .quad -9143208402725783417
+	QUAD $0xca07c2dcb0cf26f7                           // .quad -3888925500096174345
+	QUAD $0xa163ff802a3426a8                           // .quad -6817324484979841368
+	QUAD $0xfc89b393dd02f0b5                           // .quad -249470856692830027
+	QUAD $0xc9bcff6034c13052                           // .quad -3909969587797413806
+	QUAD $0xbbac2078d443ace2                           // .quad -4923524589293425438
+	QUAD $0xfc2c3f3841f17c67                           // .quad -275775966319379353
+	QUAD $0xd54b944b84aa4c0d                           // .quad -3077202868308390899
+	QUAD $0x9d9ba7832936edc0                           // .quad -7089889006590693952
+	QUAD $0x0a9e795e65d4df11                           // .quad 765182433041899281
+	QUAD $0xc5029163f384a931                           // .quad -4250675239810979535
+	QUAD $0x4d4617b5ff4a16d5                           // .quad 5568164059729762005
+	QUAD $0xf64335bcf065d37d                           // .quad -701658031336336515
+	QUAD $0x504bced1bf8e4e45                           // .quad 5785945546544795205
+	QUAD $0x99ea0196163fa42e                           // .quad -7356065297226292178
+	QUAD $0xe45ec2862f71e1d6                           // .quad -1990940103673781802
+	QUAD $0xc06481fb9bcf8d39                           // .quad -4583395603105477319
+	QUAD $0x5d767327bb4e5a4c                           // .quad 6734696907262548556
+	QUAD $0xf07da27a82c37088                           // .quad -1117558485454458744
+	QUAD $0x3a6a07f8d510f86f                           // .quad 4209185567039092847
+	QUAD $0x964e858c91ba2655                           // .quad -7616003081050118571
+	QUAD $0x890489f70a55368b                           // .quad -8573576096483297653
+	QUAD $0xbbe226efb628afea                           // .quad -4908317832885260310
+	QUAD $0x2b45ac74ccea842e                           // .quad 3118087934678041646
+	QUAD $0xeadab0aba3b2dbe5                           // .quad -1523711272679187483
+	QUAD $0x3b0b8bc90012929d                           // .quad 4254647968387469981
+	QUAD $0x92c8ae6b464fc96f                           // .quad -7869848573065574033
+	QUAD $0x09ce6ebb40173744                           // .quad 706623942056949572
+	QUAD $0xb77ada0617e3bbcb                           // .quad -5225624697904579637
+	QUAD $0xcc420a6a101d0515                           // .quad -3728406090856200939
+	QUAD $0xe55990879ddcaabd                           // .quad -1920344853953336643
+	QUAD $0x9fa946824a12232d                           // .quad -6941939825212513491
+	QUAD $0x8f57fa54c2a9eab6                           // .quad -8117744561361917258
+	QUAD $0x47939822dc96abf9                           // .quad 5157633273766521849
+	QUAD $0xb32df8e9f3546564                           // .quad -5535494683275008668
+	QUAD $0x59787e2b93bc56f7                           // .quad 6447041592208152311
+	QUAD $0xdff9772470297ebd                           // .quad -2307682335666372931
+	QUAD $0x57eb4edb3c55b65a                           // .quad 6335244004343789146
+	QUAD $0x8bfbea76c619ef36                           // .quad -8359830487432564938
+	QUAD $0xede622920b6b23f1                           // .quad -1304317031425039375
+	QUAD $0xaefae51477a06b03                           // .quad -5838102090863318269
+	QUAD $0xe95fab368e45eced                           // .quad -1630396289281299219
+	QUAD $0xdab99e59958885c4                           // .quad -2685941595151759932
+	QUAD $0x11dbcb0218ebb414                           // .quad 1286845328412881940
+	QUAD $0x88b402f7fd75539b                           // .quad -8596242524610931813
+	QUAD $0xd652bdc29f26a119                           // .quad -3003129357911285479
+	QUAD $0xaae103b5fcd2a881                           // .quad -6133617137336276863
+	QUAD $0x4be76d3346f0495f                           // .quad 5469460339465668959
+	QUAD $0xd59944a37c0752a2                           // .quad -3055335403242958174
+	QUAD $0x6f70a4400c562ddb                           // .quad 8030098730593431003
+	QUAD $0x857fcae62d8493a5                           // .quad -8827113654667930715
+	QUAD $0xcb4ccd500f6bb952                           // .quad -3797434642040374958
+	QUAD $0xa6dfbd9fb8e5b88e                           // .quad -6422206049907525490
+	QUAD $0x7e2000a41346a7a7                           // .quad 9088264752731695015
+	QUAD $0xd097ad07a71f26b2                           // .quad -3416071543957018958
+	QUAD $0x8ed400668c0c28c8                           // .quad -8154892584824854328
+	QUAD $0x825ecc24c873782f                           // .quad -9052573742614218705
+	QUAD $0x728900802f0f32fa                           // .quad 8253128342678483706
+	QUAD $0xa2f67f2dfa90563b                           // .quad -6704031159840385477
+	QUAD $0x4f2b40a03ad2ffb9                           // .quad 5704724409920716729
+	QUAD $0xcbb41ef979346bca                           // .quad -3768352931373093942
+	QUAD $0xe2f610c84987bfa8                           // .quad -2092466524453879896
+	QUAD $0xfea126b7d78186bc                           // .quad -98755145788979524
+	QUAD $0x0dd9ca7d2df4d7c9                           // .quad 998051431430019017
+	QUAD $0x9f24b832e6b0f436                           // .quad -6979250993759194058
+	QUAD $0x91503d1c79720dbb                           // .quad -7975807747567252037
+	QUAD $0xc6ede63fa05d3143                           // .quad -4112377723771604669
+	QUAD $0x75a44c6397ce912a                           // .quad 8476984389250486570
+	QUAD $0xf8a95fcf88747d94                           // .quad -528786136287117932
+	QUAD $0xc986afbe3ee11aba                           // .quad -3925256793573221702
+	QUAD $0x9b69dbe1b548ce7c                           // .quad -7248020362820530564
+	QUAD $0xfbe85badce996168                           // .quad -294884973539139224
+	QUAD $0xc24452da229b021b                           // .quad -4448339435098275301
+	QUAD $0xfae27299423fb9c3                           // .quad -368606216923924029
+	QUAD $0xf2d56790ab41c2a2                           // .quad -948738275445456222
+	QUAD $0xdccd879fc967d41a                           // .quad -2536221894791146470
+	QUAD $0x97c560ba6b0919a5                           // .quad -7510490449794491995
+	QUAD $0x5400e987bbc1c920                           // .quad 6053094668365842720
+	QUAD $0xbdb6b8e905cb600f                           // .quad -4776427043815727089
+	QUAD $0x290123e9aab23b68                           // .quad 2954682317029915496
+	QUAD $0xed246723473e3813                           // .quad -1358847786342270957
+	QUAD $0xf9a0b6720aaf6521                           // .quad -459166561069996767
+	QUAD $0x9436c0760c86e30b                           // .quad -7766808894105001205
+	QUAD $0xf808e40e8d5b3e69                           // .quad -573958201337495959
+	QUAD $0xb94470938fa89bce                           // .quad -5096825099203863602
+	QUAD $0xb60b1d1230b20e04                           // .quad -5329133770099257852
+	QUAD $0xe7958cb87392c2c2                           // .quad -1759345355577441598
+	QUAD $0xb1c6f22b5e6f48c2                           // .quad -5636551615525730110
+	QUAD $0x90bd77f3483bb9b9                           // .quad -8017119874876982855
+	QUAD $0x1e38aeb6360b1af3                           // .quad 2177682517447613171
+	QUAD $0xb4ecd5f01a4aa828                           // .quad -5409713825168840664
+	QUAD $0x25c6da63c38de1b0                           // .quad 2722103146809516464
+	QUAD $0xe2280b6c20dd5232                           // .quad -2150456263033662926
+	QUAD $0x579c487e5a38ad0e                           // .quad 6313000485183335694
+	QUAD $0x8d590723948a535f                           // .quad -8261564192037121185
+	QUAD $0x2d835a9df0c6d851                           // .quad 3279564588051781713
+	QUAD $0xb0af48ec79ace837                           // .quad -5715269221619013577
+	QUAD $0xf8e431456cf88e65                           // .quad -512230283362660763
+	QUAD $0xdcdb1b2798182244                           // .quad -2532400508596379068
+	QUAD $0x1b8e9ecb641b58ff                           // .quad 1985699082112030975
+	QUAD $0x8a08f0f8bf0f156b                           // .quad -8500279345513818773
+	QUAD $0xe272467e3d222f3f                           // .quad -2129562165787349185
+	QUAD $0xac8b2d36eed2dac5                           // .quad -6013663163464885563
+	QUAD $0x5b0ed81dcc6abb0f                           // .quad 6561419329620589327
+	QUAD $0xd7adf884aa879177                           // .quad -2905392935903719049
+	QUAD $0x98e947129fc2b4e9                           // .quad -7428327965055601431
+	QUAD $0x86ccbb52ea94baea                           // .quad -8733399612580906262
+	QUAD $0x3f2398d747b36224                           // .quad 4549648098962661924
+	QUAD $0xa87fea27a539e9a5                           // .quad -6305063497298744923
+	QUAD $0x8eec7f0d19a03aad                           // .quad -8147997931578836307
+	QUAD $0xd29fe4b18e88640e                           // .quad -3269643353196043250
+	QUAD $0x1953cf68300424ac                           // .quad 1825030320404309164
+	QUAD $0x83a3eeeef9153e89                           // .quad -8961056123388608887
+	QUAD $0x5fa8c3423c052dd7                           // .quad 6892973918932774359
+	QUAD $0xa48ceaaab75a8e2b                           // .quad -6589634135808373205
+	QUAD $0x3792f412cb06794d                           // .quad 4004531380238580045
+	QUAD $0xcdb02555653131b6                           // .quad -3625356651333078602
+	QUAD $0xe2bbd88bbee40bd0                           // .quad -2108853905778275376
+	QUAD $0x808e17555f3ebf11                           // .quad -9183376934724255983
+	QUAD $0x5b6aceaeae9d0ec4                           // .quad 6587304654631931588
+	QUAD $0xa0b19d2ab70e6ed6                           // .quad -6867535149977932074
+	QUAD $0xf245825a5a445275                           // .quad -989241218564861323
+	QUAD $0xc8de047564d20a8b                           // .quad -3972732919045027189
+	QUAD $0xeed6e2f0f0d56712                           // .quad -1236551523206076654
+	QUAD $0xfb158592be068d2e                           // .quad -354230130378896082
+	QUAD $0x55464dd69685606b                           // .quad 6144684325637283947
+	QUAD $0x9ced737bb6c4183d                           // .quad -7138922859127891907
+	QUAD $0xaa97e14c3c26b886                           // .quad -6154202648235558778
+	QUAD $0xc428d05aa4751e4c                           // .quad -4311967555482476980
+	QUAD $0xd53dd99f4b3066a8                           // .quad -3081067291867060568
+	QUAD $0xf53304714d9265df                           // .quad -778273425925708321
+	QUAD $0xe546a8038efe4029                           // .quad -1925667057416912855
+	QUAD $0x993fe2c6d07b7fab                           // .quad -7403949918844649557
+	QUAD $0xde98520472bdd033                           // .quad -2407083821771141069
+	QUAD $0xbf8fdb78849a5f96                           // .quad -4643251380128424042
+	QUAD $0x963e66858f6d4440                           // .quad -7620540795641314240
+	QUAD $0xef73d256a5c0f77c                           // .quad -1192378206733142148
+	QUAD $0xdde7001379a44aa8                           // .quad -2456994988062127448
+	QUAD $0x95a8637627989aad                           // .quad -7662765406849295699
+	QUAD $0x5560c018580d5d52                           // .quad 6152128301777116498
+	QUAD $0xbb127c53b17ec159                           // .quad -4966770740134231719
+	QUAD $0xaab8f01e6e10b4a6                           // .quad -6144897678060768090
+	QUAD $0xe9d71b689dde71af                           // .quad -1596777406740401745
+	QUAD $0xcab3961304ca70e8                           // .quad -3840561048787980056
+	QUAD $0x9226712162ab070d                           // .quad -7915514906853832947
+	QUAD $0x3d607b97c5fd0d22                           // .quad 4422670725869800738
+	QUAD $0xb6b00d69bb55c8d1                           // .quad -5282707615139903279
+	QUAD $0x8cb89a7db77c506a                           // .quad -8306719647944912790
+	QUAD $0xe45c10c42a2b3b05                           // .quad -1991698500497491195
+	QUAD $0x77f3608e92adb242                           // .quad 8643358275316593218
+	QUAD $0x8eb98a7a9a5b04e3                           // .quad -8162340590452013853
+	QUAD $0x55f038b237591ed3                           // .quad 6192511825718353619
+	QUAD $0xb267ed1940f1c61c                           // .quad -5591239719637629412
+	QUAD $0x6b6c46dec52f6688                           // .quad 7740639782147942024
+	QUAD $0xdf01e85f912e37a3                           // .quad -2377363631119648861
+	QUAD $0x2323ac4b3b3da015                           // .quad 2532056854628769813
+	QUAD $0x8b61313bbabce2c6                           // .quad -8403381297090862394
+	QUAD $0xabec975e0a0d081a                           // .quad -6058300968568813542
+	QUAD $0xae397d8aa96c1b77                           // .quad -5892540602936190089
+	QUAD $0x96e7bd358c904a21                           // .quad -7572876210711016927
+	QUAD $0xd9c7dced53c72255                           // .quad -2753989735242849707
+	QUAD $0x7e50d64177da2e54                           // .quad 9102010423587778132
+	QUAD $0x881cea14545c7575                           // .quad -8638772612167862923
+	QUAD $0xdde50bd1d5d0b9e9                           // .quad -2457545025797441047
+	QUAD $0xaa242499697392d2                           // .quad -6186779746782440750
+	QUAD $0x955e4ec64b44e864                           // .quad -7683617300674189212
+	QUAD $0xd4ad2dbfc3d07787                           // .quad -3121788665050663033
+	QUAD $0xbd5af13bef0b113e                           // .quad -4802260812921368258
+	QUAD $0x84ec3c97da624ab4                           // .quad -8868646943297746252
+	QUAD $0xecb1ad8aeacdd58e                           // .quad -1391139997724322418
+	QUAD $0xa6274bbdd0fadd61                           // .quad -6474122660694794911
+	QUAD $0x67de18eda5814af2                           // .quad 7484447039699372786
+	QUAD $0xcfb11ead453994ba                           // .quad -3480967307441105734
+	QUAD $0x80eacf948770ced7                           // .quad -9157278655470055721
+	QUAD $0x81ceb32c4b43fcf4                           // .quad -9093133594791772940
+	QUAD $0xa1258379a94d028d                           // .quad -6834912300910181747
+	QUAD $0xa2425ff75e14fc31                           // .quad -6754730975062328271
+	QUAD $0x096ee45813a04330                           // .quad 679731660717048624
+	QUAD $0xcad2f7f5359a3b3e                           // .quad -3831727700400522434
+	QUAD $0x8bca9d6e188853fc                           // .quad -8373707460958465028
+	QUAD $0xfd87b5f28300ca0d                           // .quad -177973607073265139
+	QUAD $0x775ea264cf55347d                           // .quad 8601490892183123069
+	QUAD $0x9e74d1b791e07e48                           // .quad -7028762532061872568
+	QUAD $0x95364afe032a819d                           // .quad -7694880458480647779
+	QUAD $0xc612062576589dda                           // .quad -4174267146649952806
+	QUAD $0x3a83ddbd83f52204                           // .quad 4216457482181353988
+	QUAD $0xf79687aed3eec551                           // .quad -606147914885053103
+	QUAD $0xc4926a9672793542                           // .quad -4282243101277735614
+	QUAD $0x9abe14cd44753b52                           // .quad -7296371474444240046
+	QUAD $0x75b7053c0f178293                           // .quad 8482254178684994195
+	QUAD $0xc16d9a0095928a27                           // .quad -4508778324627912153
+	QUAD $0x5324c68b12dd6338                           // .quad 5991131704928854840
+	QUAD $0xf1c90080baf72cb1                           // .quad -1024286887357502287
+	QUAD $0xd3f6fc16ebca5e03                           // .quad -3173071712060547581
+	QUAD $0x971da05074da7bee                           // .quad -7557708332239520786
+	QUAD $0x88f4bb1ca6bcf584                           // .quad -8578025658503072380
+	QUAD $0xbce5086492111aea                           // .quad -4835449396872013078
+	QUAD $0x2b31e9e3d06c32e5                           // .quad 3112525982153323237
+	QUAD $0xec1e4a7db69561a5                           // .quad -1432625727662628443
+	QUAD $0x3aff322e62439fcf                           // .quad 4251171748059520975
+	QUAD $0x9392ee8e921d5d07                           // .quad -7812920107430224633
+	QUAD $0x09befeb9fad487c2                           // .quad 702278666647013314
+	QUAD $0xb877aa3236a4b449                           // .quad -5154464115860392887
+	QUAD $0x4c2ebe687989a9b3                           // .quad 5489534351736154547
+	QUAD $0xe69594bec44de15b                           // .quad -1831394126398103205
+	QUAD $0x0f9d37014bf60a10                           // .quad 1125115960621402640
+	QUAD $0x901d7cf73ab0acd9                           // .quad -8062150356639896359
+	QUAD $0x538484c19ef38c94                           // .quad 6018080969204141204
+	QUAD $0xb424dc35095cd80f                           // .quad -5466001927372482545
+	QUAD $0x2865a5f206b06fb9                           // .quad 2910915193077788601
+	QUAD $0xe12e13424bb40e13                           // .quad -2220816390788215277
+	QUAD $0xf93f87b7442e45d3                           // .quad -486521013540076077
+	QUAD $0x8cbccc096f5088cb                           // .quad -8305539271883716405
+	QUAD $0xf78f69a51539d748                           // .quad -608151266925095096
+	QUAD $0xafebff0bcb24aafe                           // .quad -5770238071427257602
+	QUAD $0xb573440e5a884d1b                           // .quad -5371875102083756773
+	QUAD $0xdbe6fecebdedd5be                           // .quad -2601111570856684098
+	QUAD $0x31680a88f8953030                           // .quad 3560107088838733872
+	QUAD $0x89705f4136b4a597                           // .quad -8543223759426509417
+	QUAD $0xfdc20d2b36ba7c3d                           // .quad -161552157378970563
+	QUAD $0xabcc77118461cefc                           // .quad -6067343680855748868
+	QUAD $0x3d32907604691b4c                           // .quad 4409745821703674700
+	QUAD $0xd6bf94d5e57a42bc                           // .quad -2972493582642298180
+	QUAD $0xa63f9a49c2c1b10f                           // .quad -6467280898289979121
+	QUAD $0x8637bd05af6c69b5                           // .quad -8775337516792518219
+	QUAD $0x0fcf80dc33721d53                           // .quad 1139270913992301907
+	QUAD $0xa7c5ac471b478423                           // .quad -6357485877563259869
+	QUAD $0xd3c36113404ea4a8                           // .quad -3187597375937010520
+	QUAD $0xd1b71758e219652b                           // .quad -3335171328526686933
+	QUAD $0x645a1cac083126e9                           // .quad 7231123676894144233
+	QUAD $0x83126e978d4fdf3b                           // .quad -9002011107970261189
+	QUAD $0x3d70a3d70a3d70a3                           // .quad 4427218577690292387
+	QUAD $0xa3d70a3d70a3d70a                           // .quad -6640827866535438582
+	QUAD $0xcccccccccccccccc; QUAD $0xcccccccccccccccc // .space 16, '\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc'
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x8000000000000000                           // .quad -9223372036854775808
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xa000000000000000                           // .quad -6917529027641081856
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xc800000000000000                           // .quad -4035225266123964416
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xfa00000000000000                           // .quad -432345564227567616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x9c40000000000000                           // .quad -7187745005283311616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xc350000000000000                           // .quad -4372995238176751616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xf424000000000000                           // .quad -854558029293551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x9896800000000000                           // .quad -7451627795949551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xbebc200000000000                           // .quad -4702848726509551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xee6b280000000000                           // .quad -1266874889709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x9502f90000000000                           // .quad -7709325833709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xba43b74000000000                           // .quad -5024971273709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xe8d4a51000000000                           // .quad -1669528073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x9184e72a00000000                           // .quad -7960984073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xb5e620f480000000                           // .quad -5339544073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xe35fa931a0000000                           // .quad -2062744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x8e1bc9bf04000000                           // .quad -8206744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xb1a2bc2ec5000000                           // .quad -5646744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xde0b6b3a76400000                           // .quad -2446744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x8ac7230489e80000                           // .quad -8446744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xad78ebc5ac620000                           // .quad -5946744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xd8d726b7177a8000                           // .quad -2821744073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x878678326eac9000                           // .quad -8681119073709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xa968163f0a57b400                           // .quad -6239712823709551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xd3c21bcecceda100                           // .quad -3187955011209551616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0x84595161401484a0                           // .quad -8910000909647051616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xa56fa5b99019a5c8                           // .quad -6525815118631426616
+	QUAD $0x0000000000000000                           // .quad 0
+	QUAD $0xcecb8f27f4200f3a                           // .quad -3545582879861895366
+	QUAD $0x4000000000000000                           // .quad 4611686018427387904
+	QUAD $0x813f3978f8940984                           // .quad -9133518327554766460
+	QUAD $0x5000000000000000                           // .quad 5764607523034234880
+	QUAD $0xa18f07d736b90be5                           // .quad -6805211891016070171
+	QUAD $0xa400000000000000                           // .quad -6629298651489370112
+	QUAD $0xc9f2c9cd04674ede                           // .quad -3894828845342699810
+	QUAD $0x4d00000000000000                           // .quad 5548434740920451072
+	QUAD $0xfc6f7c4045812296                           // .quad -256850038250986858
+	QUAD $0xf020000000000000                           // .quad -1143914305352105984
+	QUAD $0x9dc5ada82b70b59d                           // .quad -7078060301547948643
+	QUAD $0x6c28000000000000                           // .quad 7793479155164643328
+	QUAD $0xc5371912364ce305                           // .quad -4235889358507547899
+	QUAD $0xc732000000000000                           // .quad -4093209111326359552
+	QUAD $0xf684df56c3e01bc6                           // .quad -683175679707046970
+	QUAD $0x3c7f400000000000                           // .quad 4359273333062107136
+	QUAD $0x9a130b963a6c115c                           // .quad -7344513827457986212
+	QUAD $0x4b9f100000000000                           // .quad 5449091666327633920
+	QUAD $0xc097ce7bc90715b3                           // .quad -4568956265895094861
+	QUAD $0x1e86d40000000000                           // .quad 2199678564482154496
+	QUAD $0xf0bdc21abb48db20                           // .quad -1099509313941480672
+	QUAD $0x1314448000000000                           // .quad 1374799102801346560
+	QUAD $0x96769950b50d88f4                           // .quad -7604722348854507276
+	QUAD $0x17d955a000000000                           // .quad 1718498878501683200
+	QUAD $0xbc143fa4e250eb31                           // .quad -4894216917640746191
+	QUAD $0x5dcfab0800000000                           // .quad 6759809616554491904
+	QUAD $0xeb194f8e1ae525fd                           // .quad -1506085128623544835
+	QUAD $0x5aa1cae500000000                           // .quad 6530724019560251392
+	QUAD $0x92efd1b8d0cf37be                           // .quad -7858832233030797378
+	QUAD $0xf14a3d9e40000000                           // .quad -1059967012404461568
+	QUAD $0xb7abc627050305ad                           // .quad -5211854272861108819
+	QUAD $0x6d9ccd05d0000000                           // .quad 7898413271349198848
+	QUAD $0xe596b7b0c643c719                           // .quad -1903131822648998119
+	QUAD $0xe4820023a2000000                           // .quad -1981020733047832576
+	QUAD $0x8f7e32ce7bea5c6f                           // .quad -8106986416796705681
+	QUAD $0xdda2802c8a800000                           // .quad -2476275916309790720
+	QUAD $0xb35dbf821ae4f38b                           // .quad -5522047002568494197
+	QUAD $0xd50b2037ad200000                           // .quad -3095344895387238400
+	QUAD $0xe0352f62a19e306e                           // .quad -2290872734783229842
+	QUAD $0x4526f422cc340000                           // .quad 4982938468024057856
+	QUAD $0x8c213d9da502de45                           // .quad -8349324486880600507
+	QUAD $0x9670b12b7f410000                           // .quad -7606384970252091392
+	QUAD $0xaf298d050e4395d6                           // .quad -5824969590173362730
+	QUAD $0x3c0cdd765f114000                           // .quad 4327076842467049472
+	QUAD $0xdaf3f04651d47b4c                           // .quad -2669525969289315508
+	QUAD $0xa5880a69fb6ac800                           // .quad -6518949010312869888
+	QUAD $0x88d8762bf324cd0f                           // .quad -8585982758446904049
+	QUAD $0x8eea0d047a457a00                           // .quad -8148686262891087360
+	QUAD $0xab0e93b6efee0053                           // .quad -6120792429631242157
+	QUAD $0x72a4904598d6d880                           // .quad 8260886245095692416
+	QUAD $0xd5d238a4abe98068                           // .quad -3039304518611664792
+	QUAD $0x47a6da2b7f864750                           // .quad 5163053903184807760
+	QUAD $0x85a36366eb71f041                           // .quad -8817094351773372351
+	QUAD $0x999090b65f67d924                           // .quad -7381240676301154012
+	QUAD $0xa70c3c40a64e6c51                           // .quad -6409681921289327535
+	QUAD $0xfff4b4e3f741cf6d                           // .quad -3178808521666707
+	QUAD $0xd0cf4b50cfe20765                           // .quad -3400416383184271515
+	QUAD $0xbff8f10e7a8921a4                           // .quad -4613672773753429596
+	QUAD $0x82818f1281ed449f                           // .quad -9042789267131251553
+	QUAD $0xaff72d52192b6a0d                           // .quad -5767090967191786995
+	QUAD $0xa321f2d7226895c7                           // .quad -6691800565486676537
+	QUAD $0x9bf4f8a69f764490                           // .quad -7208863708989733744
+	QUAD $0xcbea6f8ceb02bb39                           // .quad -3753064688430957767
+	QUAD $0x02f236d04753d5b4                           // .quad 212292400617608628
+	QUAD $0xfee50b7025c36a08                           // .quad -79644842111309304
+	QUAD $0x01d762422c946590                           // .quad 132682750386005392
+	QUAD $0x9f4f2726179a2245                           // .quad -6967307053960650171
+	QUAD $0x424d3ad2b7b97ef5                           // .quad 4777539456409894645
+	QUAD $0xc722f0ef9d80aad6                           // .quad -4097447799023424810
+	QUAD $0xd2e0898765a7deb2                           // .quad -3251447716342407502
+	QUAD $0xf8ebad2b84e0d58b                           // .quad -510123730351893109
+	QUAD $0x63cc55f49f88eb2f                           // .quad 7191217214140771119
+	QUAD $0x9b934c3b330c8577                           // .quad -7236356359111015049
+	QUAD $0x3cbf6b71c76b25fb                           // .quad 4377335499248575995
+	QUAD $0xc2781f49ffcfa6d5                           // .quad -4433759430461380907
+	QUAD $0x8bef464e3945ef7a                           // .quad -8363388681221443718
+	QUAD $0xf316271c7fc3908a                           // .quad -930513269649338230
+	QUAD $0x97758bf0e3cbb5ac                           // .quad -7532960934977096276
+	QUAD $0x97edd871cfda3a56                           // .quad -7499099821171918250
+	QUAD $0x3d52eeed1cbea317                           // .quad 4418856886560793367
+	QUAD $0xbde94e8e43d0c8ec                           // .quad -4762188758037509908
+	QUAD $0x4ca7aaa863ee4bdd                           // .quad 5523571108200991709
+	QUAD $0xed63a231d4c4fb27                           // .quad -1341049929119499481
+	QUAD $0x8fe8caa93e74ef6a                           // .quad -8076983103442849942
+	QUAD $0x945e455f24fb1cf8                           // .quad -7755685233340769032
+	QUAD $0xb3e2fd538e122b44                           // .quad -5484542860876174524
+	QUAD $0xb975d6b6ee39e436                           // .quad -5082920523248573386
+	QUAD $0x60dbbca87196b616                           // .quad 6979379479186945558
+	QUAD $0xe7d34c64a9c85d44                           // .quad -1741964635633328828
+	QUAD $0xbc8955e946fe31cd                           // .quad -4861259862362934835
+	QUAD $0x90e40fbeea1d3a4a                           // .quad -8006256924911912374
+	QUAD $0x6babab6398bdbe41                           // .quad 7758483227328495169
+	QUAD $0xb51d13aea4a488dd                           // .quad -5396135137712502563
+	QUAD $0xc696963c7eed2dd1                           // .quad -4136954021121544751
+	QUAD $0xe264589a4dcdab14                           // .quad -2133482903713240300
+	QUAD $0xfc1e1de5cf543ca2                           // .quad -279753253987271518
+	QUAD $0x8d7eb76070a08aec                           // .quad -8250955842461857044
+	QUAD $0x3b25a55f43294bcb                           // .quad 4261994450943298507
+	QUAD $0xb0de65388cc8ada8                           // .quad -5702008784649933400
+	QUAD $0x49ef0eb713f39ebe                           // .quad 5327493063679123134
+	QUAD $0xdd15fe86affad912                           // .quad -2515824962385028846
+	QUAD $0x6e3569326c784337                           // .quad 7941369183226839863
+	QUAD $0x8a2dbf142dfcc7ab                           // .quad -8489919629131724885
+	QUAD $0x49c2c37f07965404                           // .quad 5315025460606161924
+	QUAD $0xacb92ed9397bf996                           // .quad -6000713517987268202
+	QUAD $0xdc33745ec97be906                           // .quad -2579590211097073402
+	QUAD $0xd7e77a8f87daf7fb                           // .quad -2889205879056697349
+	QUAD $0x69a028bb3ded71a3                           // .quad 7611128154919104931
+	QUAD $0x86f0ac99b4e8dafd                           // .quad -8723282702051517699
+	QUAD $0xc40832ea0d68ce0c                           // .quad -4321147861633282548
+	QUAD $0xa8acd7c0222311bc                           // .quad -6292417359137009220
+	QUAD $0xf50a3fa490c30190                           // .quad -789748808614215280
+	QUAD $0xd2d80db02aabd62b                           // .quad -3253835680493873621
+	QUAD $0x792667c6da79e0fa                           // .quad 8729779031470891258
+	QUAD $0x83c7088e1aab65db                           // .quad -8951176327949752869
+	QUAD $0x577001b891185938                           // .quad 6300537770911226168
+	QUAD $0xa4b8cab1a1563f52                           // .quad -6577284391509803182
+	QUAD $0xed4c0226b55e6f86                           // .quad -1347699823215743098
+	QUAD $0xcde6fd5e09abcf26                           // .quad -3609919470959866074
+	QUAD $0x544f8158315b05b4                           // .quad 6075216638131242420
+	QUAD $0x80b05e5ac60b6178                           // .quad -9173728696990998152
+	QUAD $0x696361ae3db1c721                           // .quad 7594020797664053025
+	QUAD $0xa0dc75f1778e39d6                           // .quad -6855474852811359786
+	QUAD $0x03bc3a19cd1e38e9                           // .quad 269153960225290473
+	QUAD $0xc913936dd571c84c                           // .quad -3957657547586811828
+	QUAD $0x04ab48a04065c723                           // .quad 336442450281613091
+	QUAD $0xfb5878494ace3a5f                           // .quad -335385916056126881
+	QUAD $0x62eb0d64283f9c76                           // .quad 7127805559067090038
+	QUAD $0x9d174b2dcec0e47b                           // .quad -7127145225176161157
+	QUAD $0x3ba5d0bd324f8394                           // .quad 4298070930406474644
+	QUAD $0xc45d1df942711d9a                           // .quad -4297245513042813542
+	QUAD $0xca8f44ec7ee36479                           // .quad -3850783373846682503
+	QUAD $0xf5746577930d6500                           // .quad -759870872876129024
+	QUAD $0x7e998b13cf4e1ecb                           // .quad 9122475437414293195
+	QUAD $0x9968bf6abbe85f20                           // .quad -7392448323188662496
+	QUAD $0x9e3fedd8c321a67e                           // .quad -7043649776941685122
+	QUAD $0xbfc2ef456ae276e8                           // .quad -4628874385558440216
+	QUAD $0xc5cfe94ef3ea101e                           // .quad -4192876202749718498
+	QUAD $0xefb3ab16c59b14a2                           // .quad -1174406963520662366
+	QUAD $0xbba1f1d158724a12                           // .quad -4926390635932268014
+	QUAD $0x95d04aee3b80ece5                           // .quad -7651533379841495835
+	QUAD $0x2a8a6e45ae8edc97                           // .quad 3065383741939440791
+	QUAD $0xbb445da9ca61281f                           // .quad -4952730706374481889
+	QUAD $0xf52d09d71a3293bd                           // .quad -779956341003086915
+	QUAD $0xea1575143cf97226                           // .quad -1579227364540714458
+	QUAD $0x593c2626705f9c56                           // .quad 6430056314514152534
+	QUAD $0x924d692ca61be758                           // .quad -7904546130479028392
+	QUAD $0x6f8b2fb00c77836c                           // .quad 8037570393142690668
+	QUAD $0xb6e0c377cfa2e12e                           // .quad -5268996644671397586
+	QUAD $0x0b6dfb9c0f956447                           // .quad 823590954573587527
+	QUAD $0xe498f455c38b997a                           // .quad -1974559787411859078
+	QUAD $0x4724bd4189bd5eac                           // .quad 5126430365035880108
+	QUAD $0x8edf98b59a373fec                           // .quad -8151628894773493780
+	QUAD $0x58edec91ec2cb657                           // .quad 6408037956294850135
+	QUAD $0xb2977ee300c50fe7                           // .quad -5577850100039479321
+	QUAD $0x2f2967b66737e3ed                           // .quad 3398361426941174765
+	QUAD $0xdf3d5e9bc0f653e1                           // .quad -2360626606621961247
+	QUAD $0xbd79e0d20082ee74                           // .quad -4793553135802847628
+	QUAD $0x8b865b215899f46c                           // .quad -8392920656779807636
+	QUAD $0xecd8590680a3aa11                           // .quad -1380255401326171631
+	QUAD $0xae67f1e9aec07187                           // .quad -5879464802547371641
+	QUAD $0xe80e6f4820cc9495                           // .quad -1725319251657714539
+	QUAD $0xda01ee641a708de9                           // .quad -2737644984756826647
+	QUAD $0x3109058d147fdcdd                           // .quad 3533361486141316317
+	QUAD $0x884134fe908658b2                           // .quad -8628557143114098510
+	QUAD $0xbd4b46f0599fd415                           // .quad -4806670179178130411
+	QUAD $0xaa51823e34a7eede                           // .quad -6174010410465235234
+	QUAD $0x6c9e18ac7007c91a                           // .quad 7826720331309500698
+	QUAD $0xd4e5e2cdc1d1ea96                           // .quad -3105826994654156138
+	QUAD $0x03e2cf6bc604ddb0                           // .quad 280014188641050032
+	QUAD $0x850fadc09923329e                           // .quad -8858670899299929442
+	QUAD $0x84db8346b786151c                           // .quad -8873354301053463268
+	QUAD $0xa6539930bf6bff45                           // .quad -6461652605697523899
+	QUAD $0xe612641865679a63                           // .quad -1868320839462053277
+	QUAD $0xcfe87f7cef46ff16                           // .quad -3465379738694516970
+	QUAD $0x4fcb7e8f3f60c07e                           // .quad 5749828502977298558
+	QUAD $0x81f14fae158c5f6e                           // .quad -9083391364325154962
+	QUAD $0xe3be5e330f38f09d                           // .quad -2036086408133152611
+	QUAD $0xa26da3999aef7749                           // .quad -6742553186979055799
+	QUAD $0x5cadf5bfd3072cc5                           // .quad 6678264026688335045
+	QUAD $0xcb090c8001ab551c                           // .quad -3816505465296431844
+	QUAD $0x73d9732fc7c8f7f6                           // .quad 8347830033360418806
+	QUAD $0xfdcb4fa002162a63                           // .quad -158945813193151901
+	QUAD $0x2867e7fddcdd9afa                           // .quad 2911550761636567802
+	QUAD $0x9e9f11c4014dda7e                           // .quad -7016870160886801794
+	QUAD $0xb281e1fd541501b8                           // .quad -5583933584809066056
+	QUAD $0xc646d63501a1511d                           // .quad -4159401682681114339
+	QUAD $0x1f225a7ca91a4226                           // .quad 2243455055843443238
+	QUAD $0xf7d88bc24209a565                           // .quad -587566084924005019
+	QUAD $0x3375788de9b06958                           // .quad 3708002419115845976
+	QUAD $0x9ae757596946075f                           // .quad -7284757830718584993
+	QUAD $0x0052d6b1641c83ae                           // .quad 23317005467419566
+	QUAD $0xc1a12d2fc3978937                           // .quad -4494261269970843337
+	QUAD $0xc0678c5dbd23a49a                           // .quad -4582539761593113446
+	QUAD $0xf209787bb47d6b84                           // .quad -1006140569036166268
+	QUAD $0xf840b7ba963646e0                           // .quad -558244341782001952
+	QUAD $0x9745eb4d50ce6332                           // .quad -7546366883288685774
+	QUAD $0xb650e5a93bc3d898                           // .quad -5309491445654890344
+	QUAD $0xbd176620a501fbff                           // .quad -4821272585683469313
+	QUAD $0xa3e51f138ab4cebe                           // .quad -6636864307068612930
+	QUAD $0xec5d3fa8ce427aff                           // .quad -1414904713676948737
+	QUAD $0xc66f336c36b10137                           // .quad -4148040191917883081
+	QUAD $0x93ba47c980e98cdf                           // .quad -7801844473689174817
+	QUAD $0xb80b0047445d4184                           // .quad -5185050239897353852
+	QUAD $0xb8a8d9bbe123f017                           // .quad -5140619573684080617
+	QUAD $0xa60dc059157491e5                           // .quad -6481312799871692315
+	QUAD $0xe6d3102ad96cec1d                           // .quad -1814088448677712867
+	QUAD $0x87c89837ad68db2f                           // .quad -8662506518347195601
+	QUAD $0x9043ea1ac7e41392                           // .quad -8051334308064652398
+	QUAD $0x29babe4598c311fb                           // .quad 3006924907348169211
+	QUAD $0xb454e4a179dd1877                           // .quad -5452481866653427593
+	QUAD $0xf4296dd6fef3d67a                           // .quad -853029884242176390
+	QUAD $0xe16a1dc9d8545e94                           // .quad -2203916314889396588
+	QUAD $0x1899e4a65f58660c                           // .quad 1772699331562333708
+	QUAD $0x8ce2529e2734bb1d                           // .quad -8294976724446954723
+	QUAD $0x5ec05dcff72e7f8f                           // .quad 6827560182880305039
+	QUAD $0xb01ae745b101e9e4                           // .quad -5757034887131305500
+	QUAD $0x76707543f4fa1f73                           // .quad 8534450228600381299
+	QUAD $0xdc21a1171d42645d                           // .quad -2584607590486743971
+	QUAD $0x6a06494a791c53a8                           // .quad 7639874402088932264
+	QUAD $0x899504ae72497eba                           // .quad -8532908771695296838
+	QUAD $0x0487db9d17636892                           // .quad 326470965756389522
+	QUAD $0xabfa45da0edbde69                           // .quad -6054449946191733143
+	QUAD $0x45a9d2845d3c42b6                           // .quad 5019774725622874806
+	QUAD $0xd6f8d7509292d603                           // .quad -2956376414312278525
+	QUAD $0x0b8a2392ba45a9b2                           // .quad 831516194300602802
+	QUAD $0x865b86925b9bc5c2                           // .quad -8765264286586255934
+	QUAD $0x8e6cac7768d7141e                           // .quad -8183976793979022306
+	QUAD $0xa7f26836f282b732                           // .quad -6344894339805432014
+	QUAD $0x3207d795430cd926                           // .quad 3605087062808385830
+	QUAD $0xd1ef0244af2364ff                           // .quad -3319431906329402113
+	QUAD $0x7f44e6bd49e807b8                           // .quad 9170708441896323000
+	QUAD $0x8335616aed761f1f                           // .quad -8992173969096958177
+	QUAD $0x5f16206c9c6209a6                           // .quad 6851699533943015846
+	QUAD $0xa402b9c5a8d3a6e7                           // .quad -6628531442943809817
+	QUAD $0x36dba887c37a8c0f                           // .quad 3952938399001381903
+	QUAD $0xcd036837130890a1                           // .quad -3673978285252374367
+	QUAD $0xc2494954da2c9789                           // .quad -4446942528265218167
+	QUAD $0x802221226be55a64                           // .quad -9213765455923815836
+	QUAD $0xf2db9baa10b7bd6c                           // .quad -946992141904134804
+	QUAD $0xa02aa96b06deb0fd                           // .quad -6905520801477381891
+	QUAD $0x6f92829494e5acc7                           // .quad 8039631859474607303
+	QUAD $0xc83553c5c8965d3d                           // .quad -4020214983419339459
+	QUAD $0xcb772339ba1f17f9                           // .quad -3785518230938904583
+	QUAD $0xfa42a8b73abbf48c                           // .quad -413582710846786420
+	QUAD $0xff2a760414536efb                           // .quad -60105885123121413
+	QUAD $0x9c69a97284b578d7                           // .quad -7176018221920323369
+	QUAD $0xfef5138519684aba                           // .quad -75132356403901766
+	QUAD $0xc38413cf25e2d70d                           // .quad -4358336758973016307
+	QUAD $0x7eb258665fc25d69                           // .quad 9129456591349898601
+	QUAD $0xf46518c2ef5b8cd1                           // .quad -836234930288882479
+	QUAD $0xef2f773ffbd97a61                           // .quad -1211618658047395231
+	QUAD $0x98bf2f79d5993802                           // .quad -7440175859071633406
+	QUAD $0xaafb550ffacfd8fa                           // .quad -6126209340986631942
+	QUAD $0xbeeefb584aff8603                           // .quad -4688533805412153853
+	QUAD $0x95ba2a53f983cf38                           // .quad -7657761676233289928
+	QUAD $0xeeaaba2e5dbf6784                           // .quad -1248981238337804412
+	QUAD $0xdd945a747bf26183                           // .quad -2480258038432112253
+	QUAD $0x952ab45cfa97a0b2                           // .quad -7698142301602209614
+	QUAD $0x94f971119aeef9e4                           // .quad -7712008566467528220
+	QUAD $0xba756174393d88df                           // .quad -5010991858575374113
+	QUAD $0x7a37cd5601aab85d                           // .quad 8806733365625141341
+	QUAD $0xe912b9d1478ceb17                           // .quad -1652053804791829737
+	QUAD $0xac62e055c10ab33a                           // .quad -6025006692552756422
+	QUAD $0x91abb422ccb812ee                           // .quad -7950062655635975442
+	QUAD $0x577b986b314d6009                           // .quad 6303799689591218185
+	QUAD $0xb616a12b7fe617aa                           // .quad -5325892301117581398
+	QUAD $0xed5a7e85fda0b80b                           // .quad -1343622424865753077
+	QUAD $0xe39c49765fdf9d94                           // .quad -2045679357969588844
+	QUAD $0x14588f13be847307                           // .quad 1466078993672598279
+	QUAD $0x8e41ade9fbebc27d                           // .quad -8196078626372074883
+	QUAD $0x596eb2d8ae258fc8                           // .quad 6444284760518135752
+	QUAD $0xb1d219647ae6b31c                           // .quad -5633412264537705700
+	QUAD $0x6fca5f8ed9aef3bb                           // .quad 8055355950647669691
+	QUAD $0xde469fbd99a05fe3                           // .quad -2430079312244744221
+	QUAD $0x25de7bb9480d5854                           // .quad 2728754459941099604
+	QUAD $0x8aec23d680043bee                           // .quad -8436328597794046994
+	QUAD $0xaf561aa79a10ae6a                           // .quad -5812428961928401302
+	QUAD $0xada72ccc20054ae9                           // .quad -5933724728815170839
+	QUAD $0x1b2ba1518094da04                           // .quad 1957835834444274180
+	QUAD $0xd910f7ff28069da4                           // .quad -2805469892591575644
+	QUAD $0x90fb44d2f05d0842                           // .quad -7999724640327104446
+	QUAD $0x87aa9aff79042286                           // .quad -8670947710510816634
+	QUAD $0x353a1607ac744a53                           // .quad 3835402254873283155
+	QUAD $0xa99541bf57452b28                           // .quad -6226998619711132888
+	QUAD $0x42889b8997915ce8                           // .quad 4794252818591603944
+	QUAD $0xd3fa922f2d1675f2                           // .quad -3172062256211528206
+	QUAD $0x69956135febada11                           // .quad 7608094030047140369
+	QUAD $0x847c9b5d7c2e09b7                           // .quad -8900067937773286985
+	QUAD $0x43fab9837e699095                           // .quad 4898431519131537557
+	QUAD $0xa59bc234db398c25                           // .quad -6513398903789220827
+	QUAD $0x94f967e45e03f4bb                           // .quad -7712018656367741765
+	QUAD $0xcf02b2c21207ef2e                           // .quad -3530062611309138130
+	QUAD $0x1d1be0eebac278f5                           // .quad 2097517367411243253
+	QUAD $0x8161afb94b44f57d                           // .quad -9123818159709293187
+	QUAD $0x6462d92a69731732                           // .quad 7233582727691441970
+	QUAD $0xa1ba1ba79e1632dc                           // .quad -6793086681209228580
+	QUAD $0x7d7b8f7503cfdcfe                           // .quad 9041978409614302462
+	QUAD $0xca28a291859bbf93                           // .quad -3879672333084147821
+	QUAD $0x5cda735244c3d43e                           // .quad 6690786993590490174
+	QUAD $0xfcb2cb35e702af78                           // .quad -237904397927796872
+	QUAD $0x3a0888136afa64a7                           // .quad 4181741870994056359
+	QUAD $0x9defbf01b061adab                           // .quad -7066219276345954901
+	QUAD $0x088aaa1845b8fdd0                           // .quad 615491320315182544
+	QUAD $0xc56baec21c7a1916                           // .quad -4221088077005055722
+	QUAD $0x8aad549e57273d45                           // .quad -8454007886460797627
+	QUAD $0xf6c69a72a3989f5b                           // .quad -664674077828931749
+	QUAD $0x36ac54e2f678864b                           // .quad 3939617107816777291
+	QUAD $0x9a3c2087a63f6399                           // .quad -7332950326284164199
+	QUAD $0x84576a1bb416a7dd                           // .quad -8910536670511192099
+	QUAD $0xc0cb28a98fcf3c7f                           // .quad -4554501889427817345
+	QUAD $0x656d44a2a11c51d5                           // .quad 7308573235570561493
+	QUAD $0xf0fdf2d3f3c30b9f                           // .quad -1081441343357383777
+	QUAD $0x9f644ae5a4b1b325                           // .quad -6961356773836868827
+	QUAD $0x969eb7c47859e743                           // .quad -7593429867239446717
+	QUAD $0x873d5d9f0dde1fee                           // .quad -8701695967296086034
+	QUAD $0xbc4665b596706114                           // .quad -4880101315621920492
+	QUAD $0xa90cb506d155a7ea                           // .quad -6265433940692719638
+	QUAD $0xeb57ff22fc0c7959                           // .quad -1488440626100012711
+	QUAD $0x09a7f12442d588f2                           // .quad 695789805494438130
+	QUAD $0x9316ff75dd87cbd8                           // .quad -7847804418953589800
+	QUAD $0x0c11ed6d538aeb2f                           // .quad 869737256868047663
+	QUAD $0xb7dcbf5354e9bece                           // .quad -5198069505264599346
+	QUAD $0x8f1668c8a86da5fa                           // .quad -8136200465769716230
+	QUAD $0xe5d3ef282a242e81                           // .quad -1885900863153361279
+	QUAD $0xf96e017d694487bc                           // .quad -473439272678684740
+	QUAD $0x8fa475791a569d10                           // .quad -8096217067111932656
+	QUAD $0x37c981dcc395a9ac                           // .quad 4019886927579031980
+	QUAD $0xb38d92d760ec4455                           // .quad -5508585315462527915
+	QUAD $0x85bbe253f47b1417                           // .quad -8810199395808373737
+	QUAD $0xe070f78d3927556a                           // .quad -2274045625900771990
+	QUAD $0x93956d7478ccec8e                           // .quad -7812217631593927538
+	QUAD $0x8c469ab843b89562                           // .quad -8338807543829064350
+	QUAD $0x387ac8d1970027b2                           // .quad 4069786015789754290
+	QUAD $0xaf58416654a6babb                           // .quad -5811823411358942533
+	QUAD $0x06997b05fcc0319e                           // .quad 475546501309804958
+	QUAD $0xdb2e51bfe9d0696a                           // .quad -2653093245771290262
+	QUAD $0x441fece3bdf81f03                           // .quad 4908902581746016003
+	QUAD $0x88fcf317f22241e2                           // .quad -8575712306248138270
+	QUAD $0xd527e81cad7626c3                           // .quad -3087243809672255805
+	QUAD $0xab3c2fddeeaad25a                           // .quad -6107954364382784934
+	QUAD $0x8a71e223d8d3b074                           // .quad -8470740780517707660
+	QUAD $0xd60b3bd56a5586f1                           // .quad -3023256937051093263
+	QUAD $0xf6872d5667844e49                           // .quad -682526969396179383
+	QUAD $0x85c7056562757456                           // .quad -8807064613298015146
+	QUAD $0xb428f8ac016561db                           // .quad -5464844730172612133
+	QUAD $0xa738c6bebb12d16c                           // .quad -6397144748195131028
+	QUAD $0xe13336d701beba52                           // .quad -2219369894288377262
+	QUAD $0xd106f86e69d785c7                           // .quad -3384744916816525881
+	QUAD $0xecc0024661173473                           // .quad -1387106183930235789
+	QUAD $0x82a45b450226b39c                           // .quad -9032994600651410532
+	QUAD $0x27f002d7f95d0190                           // .quad 2877803288514593168
+	QUAD $0xa34d721642b06084                           // .quad -6679557232386875260
+	QUAD $0x31ec038df7b441f4                           // .quad 3597254110643241460
+	QUAD $0xcc20ce9bd35c78a5                           // .quad -3737760522056206171
+	QUAD $0x7e67047175a15271                           // .quad 9108253656731439729
+	QUAD $0xff290242c83396ce                           // .quad -60514634142869810
+	QUAD $0x0f0062c6e984d386                           // .quad 1080972517029761926
+	QUAD $0x9f79a169bd203e41                           // .quad -6955350673980375487
+	QUAD $0x52c07b78a3e60868                           // .quad 5962901664714590312
+	QUAD $0xc75809c42c684dd1                           // .quad -4082502324048081455
+	QUAD $0xa7709a56ccdf8a82                           // .quad -6381430974388925822
+	QUAD $0xf92e0c3537826145                           // .quad -491441886632713915
+	QUAD $0x88a66076400bb691                           // .quad -8600080377420466543
+	QUAD $0x9bbcc7a142b17ccb                           // .quad -7224680206786528053
+	QUAD $0x6acff893d00ea435                           // .quad 7696643601933968437
+	QUAD $0xc2abf989935ddbfe                           // .quad -4419164240055772162
+	QUAD $0x0583f6b8c4124d43                           // .quad 397432465562684739
+	QUAD $0xf356f7ebf83552fe                           // .quad -912269281642327298
+	QUAD $0xc3727a337a8b704a                           // .quad -4363290727450709942
+	QUAD $0x98165af37b2153de                           // .quad -7487697328667536418
+	QUAD $0x744f18c0592e4c5c                           // .quad 8380944645968776284
+	QUAD $0xbe1bf1b059e9a8d6                           // .quad -4747935642407032618
+	QUAD $0x1162def06f79df73                           // .quad 1252808770606194547
+	QUAD $0xeda2ee1c7064130c                           // .quad -1323233534581402868
+	QUAD $0x8addcb5645ac2ba8                           // .quad -8440366555225904216
+	QUAD $0x9485d4d1c63e8be7                           // .quad -7744549986754458649
+	QUAD $0x6d953e2bd7173692                           // .quad 7896285879677171346
+	QUAD $0xb9a74a0637ce2ee1                           // .quad -5069001465015685407
+	QUAD $0xc8fa8db6ccdd0437                           // .quad -3964700705685699529
+	QUAD $0xe8111c87c5c1ba99                           // .quad -1724565812842218855
+	QUAD $0x1d9c9892400a22a2                           // .quad 2133748077373825698
+	QUAD $0x910ab1d4db9914a0                           // .quad -7995382660667468640
+	QUAD $0x2503beb6d00cab4b                           // .quad 2667185096717282123
+	QUAD $0xb54d5e4a127f59c8                           // .quad -5382542307406947896
+	QUAD $0x2e44ae64840fd61d                           // .quad 3333981370896602653
+	QUAD $0xe2a0b5dc971f303a                           // .quad -2116491865831296966
+	QUAD $0x5ceaecfed289e5d2                           // .quad 6695424375237764562
+	QUAD $0x8da471a9de737e24                           // .quad -8240336443785642460
+	QUAD $0x7425a83e872c5f47                           // .quad 8369280469047205703
+	QUAD $0xb10d8e1456105dad                           // .quad -5688734536304665171
+	QUAD $0xd12f124e28f77719                           // .quad -3373457468973156583
+	QUAD $0xdd50f1996b947518                           // .quad -2499232151953443560
+	QUAD $0x82bd6b70d99aaa6f                           // .quad -9025939945749304721
+	QUAD $0x8a5296ffe33cc92f                           // .quad -8479549122611984081
+	QUAD $0x636cc64d1001550b                           // .quad 7164319141522920715
+	QUAD $0xace73cbfdc0bfb7b                           // .quad -5987750384837592197
+	QUAD $0x3c47f7e05401aa4e                           // .quad 4343712908476262990
+	QUAD $0xd8210befd30efa5a                           // .quad -2873001962619602342
+	QUAD $0x65acfaec34810a71                           // .quad 7326506586225052273
+	QUAD $0x8714a775e3e95c78                           // .quad -8713155254278333320
+	QUAD $0x7f1839a741a14d0d                           // .quad 9158133232781315341
+	QUAD $0xa8d9d1535ce3b396                           // .quad -6279758049420528746
+	QUAD $0x1ede48111209a050                           // .quad 2224294504121868368
+	QUAD $0xd31045a8341ca07c                           // .quad -3238011543348273028
+	QUAD $0x934aed0aab460432                           // .quad -7833187971778608078
+	QUAD $0x83ea2b892091e44d                           // .quad -8941286242233752499
+	QUAD $0xf81da84d5617853f                           // .quad -568112927868484289
+	QUAD $0xa4e4b66b68b65d60                           // .quad -6564921784364802720
+	QUAD $0x36251260ab9d668e                           // .quad 3901544858591782542
+	QUAD $0xce1de40642e3f4b9                           // .quad -3594466212028615495
+	QUAD $0xc1d72b7c6b426019                           // .quad -4479063491021217767
+	QUAD $0x80d2ae83e9ce78f3                           // .quad -9164070410158966541
+	QUAD $0xb24cf65b8612f81f                           // .quad -5598829363776522209
+	QUAD $0xa1075a24e4421730                           // .quad -6843401994271320272
+	QUAD $0xdee033f26797b627                           // .quad -2386850686293264857
+	QUAD $0xc94930ae1d529cfc                           // .quad -3942566474411762436
+	QUAD $0x169840ef017da3b1                           // .quad 1628122660560806833
+	QUAD $0xfb9b7cd9a4a7443c                           // .quad -316522074587315140
+	QUAD $0x8e1f289560ee864e                           // .quad -8205795374004271538
+	QUAD $0x9d412e0806e88aa5                           // .quad -7115355324258153819
+	QUAD $0xf1a6f2bab92a27e2                           // .quad -1033872180650563614
+	QUAD $0xc491798a08a2ad4e                           // .quad -4282508136895304370
+	QUAD $0xae10af696774b1db                           // .quad -5904026244240592421
+	QUAD $0xf5b5d7ec8acb58a2                           // .quad -741449152691742558
+	QUAD $0xacca6da1e0a8ef29                           // .quad -5995859411864064215
+	QUAD $0x9991a6f3d6bf1765                           // .quad -7380934748073420955
+	QUAD $0x17fd090a58d32af3                           // .quad 1728547772024695539
+	QUAD $0xbff610b0cc6edd3f                           // .quad -4614482416664388289
+	QUAD $0xddfc4b4cef07f5b0                           // .quad -2451001303396518480
+	QUAD $0xeff394dcff8a948e                           // .quad -1156417002403097458
+	QUAD $0x4abdaf101564f98e                           // .quad 5385653213018257806
+	QUAD $0x95f83d0a1fb69cd9                           // .quad -7640289654143017767
+	QUAD $0x9d6d1ad41abe37f1                           // .quad -7102991539009341455
+	QUAD $0xbb764c4ca7a4440f                           // .quad -4938676049251384305
+	QUAD $0x84c86189216dc5ed                           // .quad -8878739423761676819
+	QUAD $0xea53df5fd18d5513                           // .quad -1561659043136842477
+	QUAD $0x32fd3cf5b4e49bb4                           // .quad 3674159897003727796
+	QUAD $0x92746b9be2f8552c                           // .quad -7893565929601608404
+	QUAD $0x3fbc8c33221dc2a1                           // .quad 4592699871254659745
+	QUAD $0xb7118682dbb66a77                           // .quad -5255271393574622601
+	QUAD $0x0fabaf3feaa5334a                           // .quad 1129188820640936778
+	QUAD $0xe4d5e82392a40515                           // .quad -1957403223540890347
+	QUAD $0x29cb4d87f2a7400e                           // .quad 3011586022114279438
+	QUAD $0x8f05b1163ba6832d                           // .quad -8140906042354138323
+	QUAD $0x743e20e9ef511012                           // .quad 8376168546070237202
+	QUAD $0xb2c71d5bca9023f8                           // .quad -5564446534515285000
+	QUAD $0x914da9246b255416                           // .quad -7976533391121755114
+	QUAD $0xdf78e4b2bd342cf6                           // .quad -2343872149716718346
+	QUAD $0x1ad089b6c2f7548e                           // .quad 1932195658189984910
+	QUAD $0x8bab8eefb6409c1a                           // .quad -8382449121214030822
+	QUAD $0xa184ac2473b529b1                           // .quad -6808127464117294671
+	QUAD $0xae9672aba3d0c320                           // .quad -5866375383090150624
+	QUAD $0xc9e5d72d90a2741e                           // .quad -3898473311719230434
+	QUAD $0xda3c0f568cc4f3e8                           // .quad -2721283210435300376
+	QUAD $0x7e2fa67c7a658892                           // .quad 9092669226243950738
+	QUAD $0x8865899617fb1871                           // .quad -8618331034163144591
+	QUAD $0xddbb901b98feeab7                           // .quad -2469221522477225289
+	QUAD $0xaa7eebfb9df9de8d                           // .quad -6161227774276542835
+	QUAD $0x552a74227f3ea565                           // .quad 6136845133758244197
+	QUAD $0xd51ea6fa85785631                           // .quad -3089848699418290639
+	QUAD $0xd53a88958f87275f                           // .quad -3082000819042179233
+	QUAD $0x8533285c936b35de                           // .quad -8848684464777513506
+	QUAD $0x8a892abaf368f137                           // .quad -8464187042230111945
+	QUAD $0xa67ff273b8460356                           // .quad -6449169562544503978
+	QUAD $0x2d2b7569b0432d85                           // .quad 3254824252494523781
+	QUAD $0xd01fef10a657842c                           // .quad -3449775934753242068
+	QUAD $0x9c3b29620e29fc73                           // .quad -7189106879045698445
+	QUAD $0x8213f56a67f6b29b                           // .quad -9073638986861858149
+	QUAD $0x8349f3ba91b47b8f                           // .quad -8986383598807123057
+	QUAD $0xa298f2c501f45f42                           // .quad -6730362715149934782
+	QUAD $0x241c70a936219a73                           // .quad 2602078556773259891
+	QUAD $0xcb3f2f7642717713                           // .quad -3801267375510030573
+	QUAD $0xed238cd383aa0110                           // .quad -1359087822460813040
+	QUAD $0xfe0efb53d30dd4d7                           // .quad -139898200960150313
+	QUAD $0xf4363804324a40aa                           // .quad -849429889038008150
+	QUAD $0x9ec95d1463e8a506                           // .quad -7004965403241175802
+	QUAD $0xb143c6053edcd0d5                           // .quad -5673473379724898091
+	QUAD $0xc67bb4597ce2ce48                           // .quad -4144520735624081848
+	QUAD $0xdd94b7868e94050a                           // .quad -2480155706228734710
+	QUAD $0xf81aa16fdc1b81da                           // .quad -568964901102714406
+	QUAD $0xca7cf2b4191c8326                           // .quad -3855940325606653146
+	QUAD $0x9b10a4e5e9913128                           // .quad -7273132090830278360
+	QUAD $0xfd1c2f611f63a3f0                           // .quad -208239388580928528
+	QUAD $0xc1d4ce1f63f57d72                           // .quad -4479729095110460046
+	QUAD $0xbc633b39673c8cec                           // .quad -4871985254153548564
+	QUAD $0xf24a01a73cf2dccf                           // .quad -987975350460687153
+	QUAD $0xd5be0503e085d813                           // .quad -3044990783845967853
+	QUAD $0x976e41088617ca01                           // .quad -7535013621679011327
+	QUAD $0x4b2d8644d8a74e18                           // .quad 5417133557047315992
+	QUAD $0xbd49d14aa79dbc82                           // .quad -4807081008671376254
+	QUAD $0xddf8e7d60ed1219e                           // .quad -2451955090545630818
+	QUAD $0xec9c459d51852ba2                           // .quad -1397165242411832414
+	QUAD $0xcabb90e5c942b503                           // .quad -3838314940804713213
+	QUAD $0x93e1ab8252f33b45                           // .quad -7790757304148477115
+	QUAD $0x3d6a751f3b936243                           // .quad 4425478360848884291
+	QUAD $0xb8da1662e7b00a17                           // .quad -5126760611758208489
+	QUAD $0x0cc512670a783ad4                           // .quad 920161932633717460
+	QUAD $0xe7109bfba19c0c9d                           // .quad -1796764746270372707
+	QUAD $0x27fb2b80668b24c5                           // .quad 2880944217109767365
+	QUAD $0x906a617d450187e2                           // .quad -8040506994060064798
+	QUAD $0xb1f9f660802dedf6                           // .quad -5622191765467566602
+	QUAD $0xb484f9dc9641e9da                           // .quad -5438947724147693094
+	QUAD $0x5e7873f8a0396973                           // .quad 6807318348447705459
+	QUAD $0xe1a63853bbd26451                           // .quad -2186998636757228463
+	QUAD $0xdb0b487b6423e1e8                           // .quad -2662955059861265944
+	QUAD $0x8d07e33455637eb2                           // .quad -8284403175614349646
+	QUAD $0x91ce1a9a3d2cda62                           // .quad -7940379843253970334
+	QUAD $0xb049dc016abc5e5f                           // .quad -5743817951090549153
+	QUAD $0x7641a140cc7810fb                           // .quad 8521269269642088699
+	QUAD $0xdc5c5301c56b75f7                           // .quad -2568086420435798537
+	QUAD $0xa9e904c87fcb0a9d                           // .quad -6203421752542164323
+	QUAD $0x89b9b3e11b6329ba                           // .quad -8522583040413455942
+	QUAD $0x546345fa9fbdcd44                           // .quad 6080780864604458308
+	QUAD $0xac2820d9623bf429                           // .quad -6041542782089432023
+	QUAD $0xa97c177947ad4095                           // .quad -6234081974526590827
+	QUAD $0xd732290fbacaf133                           // .quad -2940242459184402125
+	QUAD $0x49ed8eabcccc485d                           // .quad 5327070802775656541
+	QUAD $0x867f59a9d4bed6c0                           // .quad -8755180564631333184
+	QUAD $0x5c68f256bfff5a74                           // .quad 6658838503469570676
+	QUAD $0xa81f301449ee8c70                           // .quad -6332289687361778576
+	QUAD $0x73832eec6fff3111                           // .quad 8323548129336963345
+	QUAD $0xd226fc195c6a2f8c                           // .quad -3303676090774835316
+	QUAD $0xc831fd53c5ff7eab                           // .quad -4021154456019173717
+	QUAD $0x83585d8fd9c25db7                           // .quad -8982326584375353929
+	QUAD $0xba3e7ca8b77f5e55                           // .quad -5026443070023967147
+	QUAD $0xa42e74f3d032f525                           // .quad -6616222212041804507
+	QUAD $0x28ce1bd2e55f35eb                           // .quad 2940318199324816875
+	QUAD $0xcd3a1230c43fb26f                           // .quad -3658591746624867729
+	QUAD $0x7980d163cf5b81b3                           // .quad 8755227902219092403
+	QUAD $0x80444b5e7aa7cf85                           // .quad -9204148869281624187
+	QUAD $0xd7e105bcc332621f                           // .quad -2891023177508298209
+	QUAD $0xa0555e361951c366                           // .quad -6893500068174642330
+	QUAD $0x8dd9472bf3fefaa7                           // .quad -8225464990312760665
+	QUAD $0xc86ab5c39fa63440                           // .quad -4005189066790915008
+	QUAD $0xb14f98f6f0feb951                           // .quad -5670145219463562927
+	QUAD $0xfa856334878fc150                           // .quad -394800315061255856
+	QUAD $0x6ed1bf9a569f33d3                           // .quad 7985374283903742931
+	QUAD $0x9c935e00d4b9d8d2                           // .quad -7164279224554366766
+	QUAD $0x0a862f80ec4700c8                           // .quad 758345818024902856
+	QUAD $0xc3b8358109e84f07                           // .quad -4343663012265570553
+	QUAD $0xcd27bb612758c0fa                           // .quad -3663753745896259334
+	QUAD $0xf4a642e14c6262c8                           // .quad -817892746904575288
+	QUAD $0x8038d51cb897789c                           // .quad -9207375118826243940
+	QUAD $0x98e7e9cccfbd7dbd                           // .quad -7428711994456441411
+	QUAD $0xe0470a63e6bd56c3                           // .quad -2285846861678029117
+	QUAD $0xbf21e44003acdd2c                           // .quad -4674203974643163860
+	QUAD $0x1858ccfce06cac74                           // .quad 1754377441329851508
+	QUAD $0xeeea5d5004981478                           // .quad -1231068949876566920
+	QUAD $0x0f37801e0c43ebc8                           // .quad 1096485900831157192
+	QUAD $0x95527a5202df0ccb                           // .quad -7686947121313936181
+	QUAD $0xd30560258f54e6ba                           // .quad -3241078642388441414
+	QUAD $0xbaa718e68396cffd                           // .quad -4996997883215032323
+	QUAD $0x47c6b82ef32a2069                           // .quad 5172023733869224041
+	QUAD $0xe950df20247c83fd                           // .quad -1634561335591402499
+	QUAD $0x4cdc331d57fa5441                           // .quad 5538357842881958977
+	QUAD $0x91d28b7416cdd27e                           // .quad -7939129862385708418
+	QUAD $0xe0133fe4adf8e952                           // .quad -2300424733252327086
+	QUAD $0xb6472e511c81471d                           // .quad -5312226309554747619
+	QUAD $0x58180fddd97723a6                           // .quad 6347841120289366950
+	QUAD $0xe3d8f9e563a198e5                           // .quad -2028596868516046619
+	QUAD $0x570f09eaa7ea7648                           // .quad 6273243709394548296
+	QUAD $0x8e679c2f5e44ff8f                           // .quad -8185402070463610993
+	QUAD $0x2cd2cc6551e513da                           // .quad 3229868618315797466
+	QUAD $0xb201833b35d63f73                           // .quad -5620066569652125837
+	QUAD $0xf8077f7ea65e58d1                           // .quad -574350245532641071
+	QUAD $0xde81e40a034bcf4f                           // .quad -2413397193637769393
+	QUAD $0xfb04afaf27faf782                           // .quad -358968903457900670
+	QUAD $0x8b112e86420f6191                           // .quad -8425902273664687727
+	QUAD $0x79c5db9af1f9b563                           // .quad 8774660907532399971
+	QUAD $0xadd57a27d29339f6                           // .quad -5920691823653471754
+	QUAD $0x18375281ae7822bc                           // .quad 1744954097560724156
+	QUAD $0xd94ad8b1c7380874                           // .quad -2789178761139451788
+	QUAD $0x8f2293910d0b15b5                           // .quad -8132775725879323211
+	QUAD $0x87cec76f1c830548                           // .quad -8660765753353239224
+	QUAD $0xb2eb3875504ddb22                           // .quad -5554283638921766110
+	QUAD $0xa9c2794ae3a3c69a                           // .quad -6214271173264161126
+	QUAD $0x5fa60692a46151eb                           // .quad 6892203506629956075
+	QUAD $0xd433179d9c8cb841                           // .quad -3156152948152813503
+	QUAD $0xdbc7c41ba6bcd333                           // .quad -2609901835997359309
+	QUAD $0x849feec281d7f328                           // .quad -8890124620236590296
+	QUAD $0x12b9b522906c0800                           // .quad 1349308723430688768
+	QUAD $0xa5c7ea73224deff3                           // .quad -6500969756868349965
+	QUAD $0xd768226b34870a00                           // .quad -2925050114139026944
+	QUAD $0xcf39e50feae16bef                           // .quad -3514526177658049553
+	QUAD $0xe6a1158300d46640                           // .quad -1828156321336891840
+	QUAD $0x81842f29f2cce375                           // .quad -9114107888677362827
+	QUAD $0x60495ae3c1097fd0                           // .quad 6938176635183661008
+	QUAD $0xa1e53af46f801c53                           // .quad -6780948842419315629
+	QUAD $0x385bb19cb14bdfc4                           // .quad 4061034775552188356
+	QUAD $0xca5e89b18b602368                           // .quad -3864500034596756632
+	QUAD $0x46729e03dd9ed7b5                           // .quad 5076293469440235445
+	QUAD $0xfcf62c1dee382c42                           // .quad -218939024818557886
+	QUAD $0x6c07a2c26a8346d1                           // .quad 7784369436827535057
+	QUAD $0x9e19db92b4e31ba9                           // .quad -7054365918152680535
+	QUAD $0xc7098b7305241885                           // .quad -4104596259247744891
+	QUAD $0xc5a05277621be293                           // .quad -4206271379263462765
+	QUAD $0xb8cbee4fc66d1ea7                           // .quad -5130745324059681113
+	QUAD $0xf70867153aa2db38                           // .quad -646153205651940552
+	QUAD $0x737f74f1dc043328                           // .quad 8322499218531169064
+	QUAD $0x9a65406d44a5c903                           // .quad -7321374781173544701
+	QUAD $0x505f522e53053ff2                           // .quad 5791438004736573426
+	QUAD $0xc0fe908895cf3b44                           // .quad -4540032458039542972
+	QUAD $0x647726b9e7c68fef                           // .quad 7239297505920716783
+	QUAD $0xf13e34aabb430a15                           // .quad -1063354554122040811
+	QUAD $0x5eca783430dc19f5                           // .quad 6830403950414141941
+	QUAD $0x96c6e0eab509e64d                           // .quad -7582125623967357363
+	QUAD $0xb67d16413d132072                           // .quad -5297053117264486286
+	QUAD $0xbc789925624c5fe0                           // .quad -4865971011531808800
+	QUAD $0xe41c5bd18c57e88f                           // .quad -2009630378153219953
+	QUAD $0xeb96bf6ebadf77d8                           // .quad -1470777745987373096
+	QUAD $0x8e91b962f7b6f159                           // .quad -8173548013986844327
+	QUAD $0x933e37a534cbaae7                           // .quad -7836765118883190041
+	QUAD $0x723627bbb5a4adb0                           // .quad 8229809056225996208
+	QUAD $0xb80dc58e81fe95a1                           // .quad -5184270380176599647
+	QUAD $0xcec3b1aaa30dd91c                           // .quad -3547796734999668452
+	QUAD $0xe61136f2227e3b09                           // .quad -1868651956793361655
+	QUAD $0x213a4f0aa5e8a7b1                           // .quad 2394313059052595121
+	QUAD $0x8fcac257558ee4e6                           // .quad -8085436500636932890
+	QUAD $0xa988e2cd4f62d19d                           // .quad -6230480713039031907
+	QUAD $0xb3bd72ed2af29e1f                           // .quad -5495109607368778209
+	QUAD $0x93eb1b80a33b8605                           // .quad -7788100891298789883
+	QUAD $0xe0accfa875af45a7                           // .quad -2257200990783584857
+	QUAD $0xbc72f130660533c3                           // .quad -4867563057061743677
+	QUAD $0x8c6c01c9498d8b88                           // .quad -8328279646880822392
+	QUAD $0xeb8fad7c7f8680b4                           // .quad -1472767802899791692
+	QUAD $0xaf87023b9bf0ee6a                           // .quad -5798663540173640086
+	QUAD $0xa67398db9f6820e1                           // .quad -6452645772052127519
+	QUAD $0xdb68c2ca82ed2a05                           // .quad -2636643406789662203
+	QUAD $0x88083f8943a1148c                           // .quad -8644589625959967604
+	QUAD $0x892179be91d43a43                           // .quad -8565431156884620733
+	QUAD $0x6a0a4f6b948959b0                           // .quad 7641007041259592112
+	QUAD $0xab69d82e364948d4                           // .quad -6095102927678388012
+	QUAD $0x848ce34679abb01c                           // .quad -8895485272135061476
+	QUAD $0xd6444e39c3db9b09                           // .quad -3007192641170597111
+	QUAD $0xf2d80e0c0c0b4e11                           // .quad -947992276657025519
+	QUAD $0x85eab0e41a6940e5                           // .quad -8797024428372705051
+	QUAD $0x6f8e118f0f0e2195                           // .quad 8038381691033493909
+	QUAD $0xa7655d1d2103911f                           // .quad -6384594517038493409
+	QUAD $0x4b7195f2d2d1a9fb                           // .quad 5436291095364479483
+	QUAD $0xd13eb46469447567                           // .quad -3369057127870728857
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+	// .p2align 4, 0x00
+_POW_TAB:
+	LONG $0x00000001 // .long 1
+	LONG $0x00000003 // .long 3
+	LONG $0x00000006 // .long 6
+	LONG $0x00000009 // .long 9
+	LONG $0x0000000d // .long 13
+	LONG $0x00000010 // .long 16
+	LONG $0x00000013 // .long 19
+	LONG $0x00000017 // .long 23
+	LONG $0x0000001a // .long 26
+
+	// .p2align 2, 0x00
+_MASK_USE_NUMBER:
+	LONG $0x00000002         // .long 2
+	QUAD $0x0000000000000000 // .p2align 4, 0x00
+
+_Digits:
+	QUAD $0x3330323031303030; QUAD $0x3730363035303430 // .ascii 16, '0001020304050607'
+	QUAD $0x3131303139303830; QUAD $0x3531343133313231 // .ascii 16, '0809101112131415'
+	QUAD $0x3931383137313631; QUAD $0x3332323231323032 // .ascii 16, '1617181920212223'
+	QUAD $0x3732363235323432; QUAD $0x3133303339323832 // .ascii 16, '2425262728293031'
+	QUAD $0x3533343333333233; QUAD $0x3933383337333633 // .ascii 16, '3233343536373839'
+	QUAD $0x3334323431343034; QUAD $0x3734363435343434 // .ascii 16, '4041424344454647'
+	QUAD $0x3135303539343834; QUAD $0x3535343533353235 // .ascii 16, '4849505152535455'
+	QUAD $0x3935383537353635; QUAD $0x3336323631363036 // .ascii 16, '5657585960616263'
+	QUAD $0x3736363635363436; QUAD $0x3137303739363836 // .ascii 16, '6465666768697071'
+	QUAD $0x3537343733373237; QUAD $0x3937383737373637 // .ascii 16, '7273747576777879'
+	QUAD $0x3338323831383038; QUAD $0x3738363835383438 // .ascii 16, '8081828384858687'
+	QUAD $0x3139303939383838; QUAD $0x3539343933393239 // .ascii 16, '8889909192939495'
+	QUAD $0x3939383937393639                           // .ascii 8, '96979899'
+	QUAD $0x0000000000000000                           // .p2align 4, 0x00
+
+_LB_a0a1aa40: // _pow10_ceil_sig.g
+	QUAD $0xff77b1fcbebcdc4f // .quad -38366372719436721
+	QUAD $0x25e8e89c13bb0f7b // .quad 2731688931043774331
+	QUAD $0x9faacf3df73609b1 // .quad -6941508010590729807
+	QUAD $0x77b191618c54e9ad // .quad 8624834609543440813
+	QUAD $0xc795830d75038c1d // .quad -4065198994811024355
+	QUAD $0xd59df5b9ef6a2418 // .quad -3054014793352862696
+	QUAD $0xf97ae3d0d2446f25 // .quad -469812725086392539
+	QUAD $0x4b0573286b44ad1e // .quad 5405853545163697438
+	QUAD $0x9becce62836ac577 // .quad -7211161980820077193
+	QUAD $0x4ee367f9430aec33 // .quad 5684501474941004851
+	QUAD $0xc2e801fb244576d5 // .quad -4402266457597708587
+	QUAD $0x229c41f793cda740 // .quad 2493940825248868160
+	QUAD $0xf3a20279ed56d48a // .quad -891147053569747830
+	QUAD $0x6b43527578c11110 // .quad 7729112049988473104
+	QUAD $0x9845418c345644d6 // .quad -7474495936122174250
+	QUAD $0x830a13896b78aaaa // .quad -9004363024039368022
+	QUAD $0xbe5691ef416bd60c // .quad -4731433901725329908
+	QUAD $0x23cc986bc656d554 // .quad 2579604275232953684
+	QUAD $0xedec366b11c6cb8f // .quad -1302606358729274481
+	QUAD $0x2cbfbe86b7ec8aa9 // .quad 3224505344041192105
+	QUAD $0x94b3a202eb1c3f39 // .quad -7731658001846878407
+	QUAD $0x7bf7d71432f3d6aa // .quad 8932844867666826922
+	QUAD $0xb9e08a83a5e34f07 // .quad -5052886483881210105
+	QUAD $0xdaf5ccd93fb0cc54 // .quad -2669001970698630060
+	QUAD $0xe858ad248f5c22c9 // .quad -1704422086424124727
+	QUAD $0xd1b3400f8f9cff69 // .quad -3336252463373287575
+	QUAD $0x91376c36d99995be // .quad -7982792831656159810
+	QUAD $0x23100809b9c21fa2 // .quad 2526528228819083170
+	QUAD $0xb58547448ffffb2d // .quad -5366805021142811859
+	QUAD $0xabd40a0c2832a78b // .quad -6065211750830921845
+	QUAD $0xe2e69915b3fff9f9 // .quad -2096820258001126919
+	QUAD $0x16c90c8f323f516d // .quad 1641857348316123501
+	QUAD $0x8dd01fad907ffc3b // .quad -8228041688891786181
+	QUAD $0xae3da7d97f6792e4 // .quad -5891368184943504668
+	QUAD $0xb1442798f49ffb4a // .quad -5673366092687344822
+	QUAD $0x99cd11cfdf41779d // .quad -7364210231179380835
+	QUAD $0xdd95317f31c7fa1d // .quad -2480021597431793123
+	QUAD $0x40405643d711d584 // .quad 4629795266307937668
+	QUAD $0x8a7d3eef7f1cfc52 // .quad -8467542526035952558
+	QUAD $0x482835ea666b2573 // .quad 5199465050656154995
+	QUAD $0xad1c8eab5ee43b66 // .quad -5972742139117552794
+	QUAD $0xda3243650005eed0 // .quad -2724040723534582064
+	QUAD $0xd863b256369d4a40 // .quad -2854241655469553088
+	QUAD $0x90bed43e40076a83 // .quad -8016736922845615485
+	QUAD $0x873e4f75e2224e68 // .quad -8701430062309552536
+	QUAD $0x5a7744a6e804a292 // .quad 6518754469289960082
+	QUAD $0xa90de3535aaae202 // .quad -6265101559459552766
+	QUAD $0x711515d0a205cb37 // .quad 8148443086612450103
+	QUAD $0xd3515c2831559a83 // .quad -3219690930897053053
+	QUAD $0x0d5a5b44ca873e04 // .quad 962181821410786820
+	QUAD $0x8412d9991ed58091 // .quad -8929835859451740015
+	QUAD $0xe858790afe9486c3 // .quad -1704479370831952189
+	QUAD $0xa5178fff668ae0b6 // .quad -6550608805887287114
+	QUAD $0x626e974dbe39a873 // .quad 7092772823314835571
+	QUAD $0xce5d73ff402d98e3 // .quad -3576574988931720989
+	QUAD $0xfb0a3d212dc81290 // .quad -357406007711231344
+	QUAD $0x80fa687f881c7f8e // .quad -9152888395723407474
+	QUAD $0x7ce66634bc9d0b9a // .quad 8999993282035256218
+	QUAD $0xa139029f6a239f72 // .quad -6829424476226871438
+	QUAD $0x1c1fffc1ebc44e81 // .quad 2026619565689294465
+	QUAD $0xc987434744ac874e // .quad -3925094576856201394
+	QUAD $0xa327ffb266b56221 // .quad -6690097579743157727
+	QUAD $0xfbe9141915d7a922 // .quad -294682202642863838
+	QUAD $0x4bf1ff9f0062baa9 // .quad 5472436080603216553
+	QUAD $0x9d71ac8fada6c9b5 // .quad -7101705404292871755
+	QUAD $0x6f773fc3603db4aa // .quad 8031958568804398250
+	QUAD $0xc4ce17b399107c22 // .quad -4265445736938701790
+	QUAD $0xcb550fb4384d21d4 // .quad -3795109844276665900
+	QUAD $0xf6019da07f549b2b // .quad -720121152745989333
+	QUAD $0x7e2a53a146606a49 // .quad 9091170749936331337
+	QUAD $0x99c102844f94e0fb // .quad -7367604748107325189
+	QUAD $0x2eda7444cbfc426e // .quad 3376138709496513134
+	QUAD $0xc0314325637a1939 // .quad -4597819916706768583
+	QUAD $0xfa911155fefb5309 // .quad -391512631556746487
+	QUAD $0xf03d93eebc589f88 // .quad -1135588877456072824
+	QUAD $0x793555ab7eba27cb // .quad 8733981247408842699
+	QUAD $0x96267c7535b763b5 // .quad -7627272076051127371
+	QUAD $0x4bc1558b2f3458df // .quad 5458738279630526687
+	QUAD $0xbbb01b9283253ca2 // .quad -4922404076636521310
+	QUAD $0x9eb1aaedfb016f17 // .quad -7011635205744005353
+	QUAD $0xea9c227723ee8bcb // .quad -1541319077368263733
+	QUAD $0x465e15a979c1cadd // .quad 5070514048102157021
+	QUAD $0x92a1958a7675175f // .quad -7880853450996246689
+	QUAD $0x0bfacd89ec191eca // .quad 863228270850154186
+	QUAD $0xb749faed14125d36 // .quad -5239380795317920458
+	QUAD $0xcef980ec671f667c // .quad -3532650679864695172
+	QUAD $0xe51c79a85916f484 // .quad -1937539975720012668
+	QUAD $0x82b7e12780e7401b // .quad -9027499368258256869
+	QUAD $0x8f31cc0937ae58d2 // .quad -8128491512466089774
+	QUAD $0xd1b2ecb8b0908811 // .quad -3336344095947716591
+	QUAD $0xb2fe3f0b8599ef07 // .quad -5548928372155224313
+	QUAD $0x861fa7e6dcb4aa16 // .quad -8782116138362033642
+	QUAD $0xdfbdcece67006ac9 // .quad -2324474446766642487
+	QUAD $0x67a791e093e1d49b // .quad 7469098900757009563
+	QUAD $0x8bd6a141006042bd // .quad -8370325556870233411
+	QUAD $0xe0c8bb2c5c6d24e1 // .quad -2249342214667950879
+	QUAD $0xaecc49914078536d // .quad -5851220927660403859
+	QUAD $0x58fae9f773886e19 // .quad 6411694268519837209
+	QUAD $0xda7f5bf590966848 // .quad -2702340141148116920
+	QUAD $0xaf39a475506a899f // .quad -5820440219632367201
+	QUAD $0x888f99797a5e012d // .quad -8606491615858654931
+	QUAD $0x6d8406c952429604 // .quad 7891439908798240260
+	QUAD $0xaab37fd7d8f58178 // .quad -6146428501395930760
+	QUAD $0xc8e5087ba6d33b84 // .quad -3970758169284363388
+	QUAD $0xd5605fcdcf32e1d6 // .quad -3071349608317525546
+	QUAD $0xfb1e4a9a90880a65 // .quad -351761693178066331
+	QUAD $0x855c3be0a17fcd26 // .quad -8837122532839535322
+	QUAD $0x5cf2eea09a550680 // .quad 6697677969404790400
+	QUAD $0xa6b34ad8c9dfc06f // .quad -6434717147622031249
+	QUAD $0xf42faa48c0ea481f // .quad -851274575098787809
+	QUAD $0xd0601d8efc57b08b // .quad -3431710416100151157
+	QUAD $0xf13b94daf124da27 // .quad -1064093218873484761
+	QUAD $0x823c12795db6ce57 // .quad -9062348037703676329
+	QUAD $0x76c53d08d6b70859 // .quad 8558313775058847833
+	QUAD $0xa2cb1717b52481ed // .quad -6716249028702207507
+	QUAD $0x54768c4b0c64ca6f // .quad 6086206200396171887
+	QUAD $0xcb7ddcdda26da268 // .quad -3783625267450371480
+	QUAD $0xa9942f5dcf7dfd0a // .quad -6227300304786948854
+	QUAD $0xfe5d54150b090b02 // .quad -117845565885576446
+	QUAD $0xd3f93b35435d7c4d // .quad -3172439362556298163
+	QUAD $0x9efa548d26e5a6e1 // .quad -6991182506319567135
+	QUAD $0xc47bc5014a1a6db0 // .quad -4288617610811380304
+	QUAD $0xc6b8e9b0709f109a // .quad -4127292114472071014
+	QUAD $0x359ab6419ca1091c // .quad 3862600023340550428
+	QUAD $0xf867241c8cc6d4c0 // .quad -547429124662700864
+	QUAD $0xc30163d203c94b63 // .quad -4395122007679087773
+	QUAD $0x9b407691d7fc44f8 // .quad -7259672230555269896
+	QUAD $0x79e0de63425dcf1e // .quad 8782263791269039902
+	QUAD $0xc21094364dfb5636 // .quad -4462904269766699466
+	QUAD $0x985915fc12f542e5 // .quad -7468914334623251739
+	QUAD $0xf294b943e17a2bc4 // .quad -966944318780986428
+	QUAD $0x3e6f5b7b17b2939e // .quad 4498915137003099038
+	QUAD $0x979cf3ca6cec5b5a // .quad -7521869226879198374
+	QUAD $0xa705992ceecf9c43 // .quad -6411550076227838909
+	QUAD $0xbd8430bd08277231 // .quad -4790650515171610063
+	QUAD $0x50c6ff782a838354 // .quad 5820620459997365076
+	QUAD $0xece53cec4a314ebd // .quad -1376627125537124675
+	QUAD $0xa4f8bf5635246429 // .quad -6559282480285457367
+	QUAD $0x940f4613ae5ed136 // .quad -7777920981101784778
+	QUAD $0x871b7795e136be9a // .quad -8711237568605798758
+	QUAD $0xb913179899f68584 // .quad -5110715207949843068
+	QUAD $0x28e2557b59846e40 // .quad 2946011094524915264
+	QUAD $0xe757dd7ec07426e5 // .quad -1776707991509915931
+	QUAD $0x331aeada2fe589d0 // .quad 3682513868156144080
+	QUAD $0x9096ea6f3848984f // .quad -8027971522334779313
+	QUAD $0x3ff0d2c85def7622 // .quad 4607414176811284002
+	QUAD $0xb4bca50b065abe63 // .quad -5423278384491086237
+	QUAD $0x0fed077a756b53aa // .quad 1147581702586717098
+	QUAD $0xe1ebce4dc7f16dfb // .quad -2167411962186469893
+	QUAD $0xd3e8495912c62895 // .quad -3177208890193991531
+	QUAD $0x8d3360f09cf6e4bd // .quad -8272161504007625539
+	QUAD $0x64712dd7abbbd95d // .quad 7237616480483531101
+	QUAD $0xb080392cc4349dec // .quad -5728515861582144020
+	QUAD $0xbd8d794d96aacfb4 // .quad -4788037454677749836
+	QUAD $0xdca04777f541c567 // .quad -2548958808550292121
+	QUAD $0xecf0d7a0fc5583a1 // .quad -1373360799919799391
+	QUAD $0x89e42caaf9491b60 // .quad -8510628282985014432
+	QUAD $0xf41686c49db57245 // .quad -858350499949874619
+	QUAD $0xac5d37d5b79b6239 // .quad -6026599335303880135
+	QUAD $0x311c2875c522ced6 // .quad 3538747893490044630
+	QUAD $0xd77485cb25823ac7 // .quad -2921563150702462265
+	QUAD $0x7d633293366b828c // .quad 9035120885289943692
+	QUAD $0x86a8d39ef77164bc // .quad -8743505996830120772
+	QUAD $0xae5dff9c02033198 // .quad -5882264492762254952
+	QUAD $0xa8530886b54dbdeb // .quad -6317696477610263061
+	QUAD $0xd9f57f830283fdfd // .quad -2741144597525430787
+	QUAD $0xd267caa862a12d66 // .quad -3285434578585440922
+	QUAD $0xd072df63c324fd7c // .quad -3426430746906788484
+	QUAD $0x8380dea93da4bc60 // .quad -8970925639256982432
+	QUAD $0x4247cb9e59f71e6e // .quad 4776009810824339054
+	QUAD $0xa46116538d0deb78 // .quad -6601971030643840136
+	QUAD $0x52d9be85f074e609 // .quad 5970012263530423817
+	QUAD $0xcd795be870516656 // .quad -3640777769877412266
+	QUAD $0x67902e276c921f8c // .quad 7462515329413029772
+	QUAD $0x806bd9714632dff6 // .quad -9193015133814464522
+	QUAD $0x00ba1cd8a3db53b7 // .quad 52386062455755703
+	QUAD $0xa086cfcd97bf97f3 // .quad -6879582898840692749
+	QUAD $0x80e8a40eccd228a5 // .quad -9157889458785081179
+	QUAD $0xc8a883c0fdaf7df0 // .quad -3987792605123478032
+	QUAD $0x6122cd128006b2ce // .quad 6999382250228200142
+	QUAD $0xfad2a4b13d1b5d6c // .quad -373054737976959636
+	QUAD $0x796b805720085f82 // .quad 8749227812785250178
+	QUAD $0x9cc3a6eec6311a63 // .quad -7150688238876681629
+	QUAD $0xcbe3303674053bb1 // .quad -3755104653863994447
+	QUAD $0xc3f490aa77bd60fc // .quad -4326674280168464132
+	QUAD $0xbedbfc4411068a9d // .quad -4693880817329993059
+	QUAD $0xf4f1b4d515acb93b // .quad -796656831783192261
+	QUAD $0xee92fb5515482d45 // .quad -1255665003235103419
+	QUAD $0x991711052d8bf3c5 // .quad -7415439547505577019
+	QUAD $0x751bdd152d4d1c4b // .quad 8438581409832836171
+	QUAD $0xbf5cd54678eef0b6 // .quad -4657613415954583370
+	QUAD $0xd262d45a78a0635e // .quad -3286831292991118498
+	QUAD $0xef340a98172aace4 // .quad -1210330751515841308
+	QUAD $0x86fb897116c87c35 // .quad -8720225134666286027
+	QUAD $0x9580869f0e7aac0e // .quad -7673985747338482674
+	QUAD $0xd45d35e6ae3d4da1 // .quad -3144297699952734815
+	QUAD $0xbae0a846d2195712 // .quad -4980796165745715438
+	QUAD $0x8974836059cca10a // .quad -8542058143368306422
+	QUAD $0xe998d258869facd7 // .quad -1614309188754756393
+	QUAD $0x2bd1a438703fc94c // .quad 3157485376071780684
+	QUAD $0x91ff83775423cc06 // .quad -7926472270612804602
+	QUAD $0x7b6306a34627ddd0 // .quad 8890957387685944784
+	QUAD $0xb67f6455292cbf08 // .quad -5296404319838617848
+	QUAD $0x1a3bc84c17b1d543 // .quad 1890324697752655171
+	QUAD $0xe41f3d6a7377eeca // .quad -2008819381370884406
+	QUAD $0x20caba5f1d9e4a94 // .quad 2362905872190818964
+	QUAD $0x8e938662882af53e // .quad -8173041140997884610
+	QUAD $0x547eb47b7282ee9d // .quad 6088502188546649757
+	QUAD $0xb23867fb2a35b28d // .quad -5604615407819967859
+	QUAD $0xe99e619a4f23aa44 // .quad -1612744301171463612
+	QUAD $0xdec681f9f4c31f31 // .quad -2394083241347571919
+	QUAD $0x6405fa00e2ec94d5 // .quad 7207441660390446293
+	QUAD $0x8b3c113c38f9f37e // .quad -8413831053483314306
+	QUAD $0xde83bc408dd3dd05 // .quad -2412877989897052923
+	QUAD $0xae0b158b4738705e // .quad -5905602798426754978
+	QUAD $0x9624ab50b148d446 // .quad -7627783505798704058
+	QUAD $0xd98ddaee19068c76 // .quad -2770317479606055818
+	QUAD $0x3badd624dd9b0958 // .quad 4300328673033783640
+	QUAD $0x87f8a8d4cfa417c9 // .quad -8648977452394866743
+	QUAD $0xe54ca5d70a80e5d7 // .quad -1923980597781273129
+	QUAD $0xa9f6d30a038d1dbc // .quad -6199535797066195524
+	QUAD $0x5e9fcf4ccd211f4d // .quad 6818396289628184397
+	QUAD $0xd47487cc8470652b // .quad -3137733727905356501
+	QUAD $0x7647c32000696720 // .quad 8522995362035230496
+	QUAD $0x84c8d4dfd2c63f3b // .quad -8878612607581929669
+	QUAD $0x29ecd9f40041e074 // .quad 3021029092058325108
+	QUAD $0xa5fb0a17c777cf09 // .quad -6486579741050024183
+	QUAD $0xf468107100525891 // .quad -835399653354481519
+	QUAD $0xcf79cc9db955c2cc // .quad -3496538657885142324
+	QUAD $0x7182148d4066eeb5 // .quad 8179122470161673909
+	QUAD $0x81ac1fe293d599bf // .quad -9102865688819295809
+	QUAD $0xc6f14cd848405531 // .quad -4111420493003729615
+	QUAD $0xa21727db38cb002f // .quad -6766896092596731857
+	QUAD $0xb8ada00e5a506a7d // .quad -5139275616254662019
+	QUAD $0xca9cf1d206fdc03b // .quad -3846934097318526917
+	QUAD $0xa6d90811f0e4851d // .quad -6424094520318327523
+	QUAD $0xfd442e4688bd304a // .quad -196981603220770742
+	QUAD $0x908f4a166d1da664 // .quad -8030118150397909404
+	QUAD $0x9e4a9cec15763e2e // .quad -7040642529654063570
+	QUAD $0x9a598e4e043287ff // .quad -7324666853212387329
+	QUAD $0xc5dd44271ad3cdba // .quad -4189117143640191558
+	QUAD $0x40eff1e1853f29fe // .quad 4679224488766679550
+	QUAD $0xf7549530e188c128 // .quad -624710411122851544
+	QUAD $0xd12bee59e68ef47d // .quad -3374341425896426371
+	QUAD $0x9a94dd3e8cf578b9 // .quad -7307973034592864071
+	QUAD $0x82bb74f8301958cf // .quad -9026492418826348337
+	QUAD $0xc13a148e3032d6e7 // .quad -4523280274813692185
+	QUAD $0xe36a52363c1faf02 // .quad -2059743486678159614
+	QUAD $0xf18899b1bc3f8ca1 // .quad -1042414325089727327
+	QUAD $0xdc44e6c3cb279ac2 // .quad -2574679358347699518
+	QUAD $0x96f5600f15a7b7e5 // .quad -7569037980822161435
+	QUAD $0x29ab103a5ef8c0ba // .quad 3002511419460075706
+	QUAD $0xbcb2b812db11a5de // .quad -4849611457600313890
+	QUAD $0x7415d448f6b6f0e8 // .quad 8364825292752482536
+	QUAD $0xebdf661791d60f56 // .quad -1450328303573004458
+	QUAD $0x111b495b3464ad22 // .quad 1232659579085827362
+	QUAD $0x936b9fcebb25c995 // .quad -7823984217374209643
+	QUAD $0xcab10dd900beec35 // .quad -3841273781498745803
+	QUAD $0xb84687c269ef3bfb // .quad -5168294253290374149
+	QUAD $0x3d5d514f40eea743 // .quad 4421779809981343555
+	QUAD $0xe65829b3046b0afa // .quad -1848681798185579782
+	QUAD $0x0cb4a5a3112a5113 // .quad 915538744049291539
+	QUAD $0x8ff71a0fe2c2e6dc // .quad -8072955151507069220
+	QUAD $0x47f0e785eaba72ac // .quad 5183897733458195116
+	QUAD $0xb3f4e093db73a093 // .quad -5479507920956448621
+	QUAD $0x59ed216765690f57 // .quad 6479872166822743895
+	QUAD $0xe0f218b8d25088b8 // .quad -2237698882768172872
+	QUAD $0x306869c13ec3532d // .quad 3488154190101041965
+	QUAD $0x8c974f7383725573 // .quad -8316090829371189901
+	QUAD $0x1e414218c73a13fc // .quad 2180096368813151228
+	QUAD $0xafbd2350644eeacf // .quad -5783427518286599473
+	QUAD $0xe5d1929ef90898fb // .quad -1886565557410948869
+	QUAD $0xdbac6c247d62a583 // .quad -2617598379430861437
+	QUAD $0xdf45f746b74abf3a // .quad -2358206946763686086
+	QUAD $0x894bc396ce5da772 // .quad -8553528014785370254
+	QUAD $0x6b8bba8c328eb784 // .quad 7749492695127472004
+	QUAD $0xab9eb47c81f5114f // .quad -6080224000054324913
+	QUAD $0x066ea92f3f326565 // .quad 463493832054564197
+	QUAD $0xd686619ba27255a2 // .quad -2988593981640518238
+	QUAD $0xc80a537b0efefebe // .quad -4032318728359182658
+	QUAD $0x8613fd0145877585 // .quad -8785400266166405755
+	QUAD $0xbd06742ce95f5f37 // .quad -4826042214438183113
+	QUAD $0xa798fc4196e952e7 // .quad -6370064314280619289
+	QUAD $0x2c48113823b73705 // .quad 3190819268807046917
+	QUAD $0xd17f3b51fca3a7a0 // .quad -3350894374423386208
+	QUAD $0xf75a15862ca504c6 // .quad -623161932418579258
+	QUAD $0x82ef85133de648c4 // .quad -9011838011655698236
+	QUAD $0x9a984d73dbe722fc // .quad -7307005235402693892
+	QUAD $0xa3ab66580d5fdaf5 // .quad -6653111496142234891
+	QUAD $0xc13e60d0d2e0ebbb // .quad -4522070525825979461
+	QUAD $0xcc963fee10b7d1b3 // .quad -3704703351750405709
+	QUAD $0x318df905079926a9 // .quad 3570783879572301481
+	QUAD $0xffbbcfe994e5c61f // .quad -19193171260619233
+	QUAD $0xfdf17746497f7053 // .quad -148206168962011053
+	QUAD $0x9fd561f1fd0f9bd3 // .quad -6929524759678968877
+	QUAD $0xfeb6ea8bedefa634 // .quad -92628855601256908
+	QUAD $0xc7caba6e7c5382c8 // .quad -4050219931171323192
+	QUAD $0xfe64a52ee96b8fc1 // .quad -115786069501571135
+	QUAD $0xf9bd690a1b68637b // .quad -451088895536766085
+	QUAD $0x3dfdce7aa3c673b1 // .quad 4466953431550423985
+	QUAD $0x9c1661a651213e2d // .quad -7199459587351560659
+	QUAD $0x06bea10ca65c084f // .quad 486002885505321039
+	QUAD $0xc31bfa0fe5698db8 // .quad -4387638465762062920
+	QUAD $0x486e494fcff30a63 // .quad 5219189625309039203
+	QUAD $0xf3e2f893dec3f126 // .quad -872862063775190746
+	QUAD $0x5a89dba3c3efccfb // .quad 6523987031636299003
+	QUAD $0x986ddb5c6b3a76b7 // .quad -7463067817500576073
+	QUAD $0xf89629465a75e01d // .quad -534194123654701027
+	QUAD $0xbe89523386091465 // .quad -4717148753448332187
+	QUAD $0xf6bbb397f1135824 // .quad -667742654568376284
+	QUAD $0xee2ba6c0678b597f // .quad -1284749923383027329
+	QUAD $0x746aa07ded582e2d // .quad 8388693718644305453
+	QUAD $0x94db483840b717ef // .quad -7720497729755473937
+	QUAD $0xa8c2a44eb4571cdd // .quad -6286281471915778851
+	QUAD $0xba121a4650e4ddeb // .quad -5038936143766954517
+	QUAD $0x92f34d62616ce414 // .quad -7857851839894723564
+	QUAD $0xe896a0d7e51e1566 // .quad -1686984161281305242
+	QUAD $0x77b020baf9c81d18 // .quad 8624429273841147160
+	QUAD $0x915e2486ef32cd60 // .quad -7971894128441897632
+	QUAD $0x0ace1474dc1d122f // .quad 778582277723329071
+	QUAD $0xb5b5ada8aaff80b8 // .quad -5353181642124984136
+	QUAD $0x0d819992132456bb // .quad 973227847154161339
+	QUAD $0xe3231912d5bf60e6 // .quad -2079791034228842266
+	QUAD $0x10e1fff697ed6c6a // .quad 1216534808942701674
+	QUAD $0x8df5efabc5979c8f // .quad -8217398424034108273
+	QUAD $0xca8d3ffa1ef463c2 // .quad -3851351762838199358
+	QUAD $0xb1736b96b6fd83b3 // .quad -5660062011615247437
+	QUAD $0xbd308ff8a6b17cb3 // .quad -4814189703547749197
+	QUAD $0xddd0467c64bce4a0 // .quad -2463391496091671392
+	QUAD $0xac7cb3f6d05ddbdf // .quad -6017737129434686497
+	QUAD $0x8aa22c0dbef60ee4 // .quad -8457148712698376476
+	QUAD $0x6bcdf07a423aa96c // .quad 7768129340171790700
+	QUAD $0xad4ab7112eb3929d // .quad -5959749872445582691
+	QUAD $0x86c16c98d2c953c7 // .quad -8736582398494813241
+	QUAD $0xd89d64d57a607744 // .quad -2838001322129590460
+	QUAD $0xe871c7bf077ba8b8 // .quad -1697355961263740744
+	QUAD $0x87625f056c7c4a8b // .quad -8691279853972075893
+	QUAD $0x11471cd764ad4973 // .quad 1244995533423855987
+	QUAD $0xa93af6c6c79b5d2d // .quad -6252413799037706963
+	QUAD $0xd598e40d3dd89bd0 // .quad -3055441601647567920
+	QUAD $0xd389b47879823479 // .quad -3203831230369745799
+	QUAD $0x4aff1d108d4ec2c4 // .quad 5404070034795315908
+	QUAD $0x843610cb4bf160cb // .quad -8919923546622172981
+	QUAD $0xcedf722a585139bb // .quad -3539985255894009413
+	QUAD $0xa54394fe1eedb8fe // .quad -6538218414850328322
+	QUAD $0xc2974eb4ee658829 // .quad -4424981569867511767
+	QUAD $0xce947a3da6a9273e // .quad -3561087000135522498
+	QUAD $0x733d226229feea33 // .quad 8303831092947774003
+	QUAD $0x811ccc668829b887 // .quad -9143208402725783417
+	QUAD $0x0806357d5a3f5260 // .quad 578208414664970848
+	QUAD $0xa163ff802a3426a8 // .quad -6817324484979841368
+	QUAD $0xca07c2dcb0cf26f8 // .quad -3888925500096174344
+	QUAD $0xc9bcff6034c13052 // .quad -3909969587797413806
+	QUAD $0xfc89b393dd02f0b6 // .quad -249470856692830026
+	QUAD $0xfc2c3f3841f17c67 // .quad -275775966319379353
+	QUAD $0xbbac2078d443ace3 // .quad -4923524589293425437
+	QUAD $0x9d9ba7832936edc0 // .quad -7089889006590693952
+	QUAD $0xd54b944b84aa4c0e // .quad -3077202868308390898
+	QUAD $0xc5029163f384a931 // .quad -4250675239810979535
+	QUAD $0x0a9e795e65d4df12 // .quad 765182433041899282
+	QUAD $0xf64335bcf065d37d // .quad -701658031336336515
+	QUAD $0x4d4617b5ff4a16d6 // .quad 5568164059729762006
+	QUAD $0x99ea0196163fa42e // .quad -7356065297226292178
+	QUAD $0x504bced1bf8e4e46 // .quad 5785945546544795206
+	QUAD $0xc06481fb9bcf8d39 // .quad -4583395603105477319
+	QUAD $0xe45ec2862f71e1d7 // .quad -1990940103673781801
+	QUAD $0xf07da27a82c37088 // .quad -1117558485454458744
+	QUAD $0x5d767327bb4e5a4d // .quad 6734696907262548557
+	QUAD $0x964e858c91ba2655 // .quad -7616003081050118571
+	QUAD $0x3a6a07f8d510f870 // .quad 4209185567039092848
+	QUAD $0xbbe226efb628afea // .quad -4908317832885260310
+	QUAD $0x890489f70a55368c // .quad -8573576096483297652
+	QUAD $0xeadab0aba3b2dbe5 // .quad -1523711272679187483
+	QUAD $0x2b45ac74ccea842f // .quad 3118087934678041647
+	QUAD $0x92c8ae6b464fc96f // .quad -7869848573065574033
+	QUAD $0x3b0b8bc90012929e // .quad 4254647968387469982
+	QUAD $0xb77ada0617e3bbcb // .quad -5225624697904579637
+	QUAD $0x09ce6ebb40173745 // .quad 706623942056949573
+	QUAD $0xe55990879ddcaabd // .quad -1920344853953336643
+	QUAD $0xcc420a6a101d0516 // .quad -3728406090856200938
+	QUAD $0x8f57fa54c2a9eab6 // .quad -8117744561361917258
+	QUAD $0x9fa946824a12232e // .quad -6941939825212513490
+	QUAD $0xb32df8e9f3546564 // .quad -5535494683275008668
+	QUAD $0x47939822dc96abfa // .quad 5157633273766521850
+	QUAD $0xdff9772470297ebd // .quad -2307682335666372931
+	QUAD $0x59787e2b93bc56f8 // .quad 6447041592208152312
+	QUAD $0x8bfbea76c619ef36 // .quad -8359830487432564938
+	QUAD $0x57eb4edb3c55b65b // .quad 6335244004343789147
+	QUAD $0xaefae51477a06b03 // .quad -5838102090863318269
+	QUAD $0xede622920b6b23f2 // .quad -1304317031425039374
+	QUAD $0xdab99e59958885c4 // .quad -2685941595151759932
+	QUAD $0xe95fab368e45ecee // .quad -1630396289281299218
+	QUAD $0x88b402f7fd75539b // .quad -8596242524610931813
+	QUAD $0x11dbcb0218ebb415 // .quad 1286845328412881941
+	QUAD $0xaae103b5fcd2a881 // .quad -6133617137336276863
+	QUAD $0xd652bdc29f26a11a // .quad -3003129357911285478
+	QUAD $0xd59944a37c0752a2 // .quad -3055335403242958174
+	QUAD $0x4be76d3346f04960 // .quad 5469460339465668960
+	QUAD $0x857fcae62d8493a5 // .quad -8827113654667930715
+	QUAD $0x6f70a4400c562ddc // .quad 8030098730593431004
+	QUAD $0xa6dfbd9fb8e5b88e // .quad -6422206049907525490
+	QUAD $0xcb4ccd500f6bb953 // .quad -3797434642040374957
+	QUAD $0xd097ad07a71f26b2 // .quad -3416071543957018958
+	QUAD $0x7e2000a41346a7a8 // .quad 9088264752731695016
+	QUAD $0x825ecc24c873782f // .quad -9052573742614218705
+	QUAD $0x8ed400668c0c28c9 // .quad -8154892584824854327
+	QUAD $0xa2f67f2dfa90563b // .quad -6704031159840385477
+	QUAD $0x728900802f0f32fb // .quad 8253128342678483707
+	QUAD $0xcbb41ef979346bca // .quad -3768352931373093942
+	QUAD $0x4f2b40a03ad2ffba // .quad 5704724409920716730
+	QUAD $0xfea126b7d78186bc // .quad -98755145788979524
+	QUAD $0xe2f610c84987bfa9 // .quad -2092466524453879895
+	QUAD $0x9f24b832e6b0f436 // .quad -6979250993759194058
+	QUAD $0x0dd9ca7d2df4d7ca // .quad 998051431430019018
+	QUAD $0xc6ede63fa05d3143 // .quad -4112377723771604669
+	QUAD $0x91503d1c79720dbc // .quad -7975807747567252036
+	QUAD $0xf8a95fcf88747d94 // .quad -528786136287117932
+	QUAD $0x75a44c6397ce912b // .quad 8476984389250486571
+	QUAD $0x9b69dbe1b548ce7c // .quad -7248020362820530564
+	QUAD $0xc986afbe3ee11abb // .quad -3925256793573221701
+	QUAD $0xc24452da229b021b // .quad -4448339435098275301
+	QUAD $0xfbe85badce996169 // .quad -294884973539139223
+	QUAD $0xf2d56790ab41c2a2 // .quad -948738275445456222
+	QUAD $0xfae27299423fb9c4 // .quad -368606216923924028
+	QUAD $0x97c560ba6b0919a5 // .quad -7510490449794491995
+	QUAD $0xdccd879fc967d41b // .quad -2536221894791146469
+	QUAD $0xbdb6b8e905cb600f // .quad -4776427043815727089
+	QUAD $0x5400e987bbc1c921 // .quad 6053094668365842721
+	QUAD $0xed246723473e3813 // .quad -1358847786342270957
+	QUAD $0x290123e9aab23b69 // .quad 2954682317029915497
+	QUAD $0x9436c0760c86e30b // .quad -7766808894105001205
+	QUAD $0xf9a0b6720aaf6522 // .quad -459166561069996766
+	QUAD $0xb94470938fa89bce // .quad -5096825099203863602
+	QUAD $0xf808e40e8d5b3e6a // .quad -573958201337495958
+	QUAD $0xe7958cb87392c2c2 // .quad -1759345355577441598
+	QUAD $0xb60b1d1230b20e05 // .quad -5329133770099257851
+	QUAD $0x90bd77f3483bb9b9 // .quad -8017119874876982855
+	QUAD $0xb1c6f22b5e6f48c3 // .quad -5636551615525730109
+	QUAD $0xb4ecd5f01a4aa828 // .quad -5409713825168840664
+	QUAD $0x1e38aeb6360b1af4 // .quad 2177682517447613172
+	QUAD $0xe2280b6c20dd5232 // .quad -2150456263033662926
+	QUAD $0x25c6da63c38de1b1 // .quad 2722103146809516465
+	QUAD $0x8d590723948a535f // .quad -8261564192037121185
+	QUAD $0x579c487e5a38ad0f // .quad 6313000485183335695
+	QUAD $0xb0af48ec79ace837 // .quad -5715269221619013577
+	QUAD $0x2d835a9df0c6d852 // .quad 3279564588051781714
+	QUAD $0xdcdb1b2798182244 // .quad -2532400508596379068
+	QUAD $0xf8e431456cf88e66 // .quad -512230283362660762
+	QUAD $0x8a08f0f8bf0f156b // .quad -8500279345513818773
+	QUAD $0x1b8e9ecb641b5900 // .quad 1985699082112030976
+	QUAD $0xac8b2d36eed2dac5 // .quad -6013663163464885563
+	QUAD $0xe272467e3d222f40 // .quad -2129562165787349184
+	QUAD $0xd7adf884aa879177 // .quad -2905392935903719049
+	QUAD $0x5b0ed81dcc6abb10 // .quad 6561419329620589328
+	QUAD $0x86ccbb52ea94baea // .quad -8733399612580906262
+	QUAD $0x98e947129fc2b4ea // .quad -7428327965055601430
+	QUAD $0xa87fea27a539e9a5 // .quad -6305063497298744923
+	QUAD $0x3f2398d747b36225 // .quad 4549648098962661925
+	QUAD $0xd29fe4b18e88640e // .quad -3269643353196043250
+	QUAD $0x8eec7f0d19a03aae // .quad -8147997931578836306
+	QUAD $0x83a3eeeef9153e89 // .quad -8961056123388608887
+	QUAD $0x1953cf68300424ad // .quad 1825030320404309165
+	QUAD $0xa48ceaaab75a8e2b // .quad -6589634135808373205
+	QUAD $0x5fa8c3423c052dd8 // .quad 6892973918932774360
+	QUAD $0xcdb02555653131b6 // .quad -3625356651333078602
+	QUAD $0x3792f412cb06794e // .quad 4004531380238580046
+	QUAD $0x808e17555f3ebf11 // .quad -9183376934724255983
+	QUAD $0xe2bbd88bbee40bd1 // .quad -2108853905778275375
+	QUAD $0xa0b19d2ab70e6ed6 // .quad -6867535149977932074
+	QUAD $0x5b6aceaeae9d0ec5 // .quad 6587304654631931589
+	QUAD $0xc8de047564d20a8b // .quad -3972732919045027189
+	QUAD $0xf245825a5a445276 // .quad -989241218564861322
+	QUAD $0xfb158592be068d2e // .quad -354230130378896082
+	QUAD $0xeed6e2f0f0d56713 // .quad -1236551523206076653
+	QUAD $0x9ced737bb6c4183d // .quad -7138922859127891907
+	QUAD $0x55464dd69685606c // .quad 6144684325637283948
+	QUAD $0xc428d05aa4751e4c // .quad -4311967555482476980
+	QUAD $0xaa97e14c3c26b887 // .quad -6154202648235558777
+	QUAD $0xf53304714d9265df // .quad -778273425925708321
+	QUAD $0xd53dd99f4b3066a9 // .quad -3081067291867060567
+	QUAD $0x993fe2c6d07b7fab // .quad -7403949918844649557
+	QUAD $0xe546a8038efe402a // .quad -1925667057416912854
+	QUAD $0xbf8fdb78849a5f96 // .quad -4643251380128424042
+	QUAD $0xde98520472bdd034 // .quad -2407083821771141068
+	QUAD $0xef73d256a5c0f77c // .quad -1192378206733142148
+	QUAD $0x963e66858f6d4441 // .quad -7620540795641314239
+	QUAD $0x95a8637627989aad // .quad -7662765406849295699
+	QUAD $0xdde7001379a44aa9 // .quad -2456994988062127447
+	QUAD $0xbb127c53b17ec159 // .quad -4966770740134231719
+	QUAD $0x5560c018580d5d53 // .quad 6152128301777116499
+	QUAD $0xe9d71b689dde71af // .quad -1596777406740401745
+	QUAD $0xaab8f01e6e10b4a7 // .quad -6144897678060768089
+	QUAD $0x9226712162ab070d // .quad -7915514906853832947
+	QUAD $0xcab3961304ca70e9 // .quad -3840561048787980055
+	QUAD $0xb6b00d69bb55c8d1 // .quad -5282707615139903279
+	QUAD $0x3d607b97c5fd0d23 // .quad 4422670725869800739
+	QUAD $0xe45c10c42a2b3b05 // .quad -1991698500497491195
+	QUAD $0x8cb89a7db77c506b // .quad -8306719647944912789
+	QUAD $0x8eb98a7a9a5b04e3 // .quad -8162340590452013853
+	QUAD $0x77f3608e92adb243 // .quad 8643358275316593219
+	QUAD $0xb267ed1940f1c61c // .quad -5591239719637629412
+	QUAD $0x55f038b237591ed4 // .quad 6192511825718353620
+	QUAD $0xdf01e85f912e37a3 // .quad -2377363631119648861
+	QUAD $0x6b6c46dec52f6689 // .quad 7740639782147942025
+	QUAD $0x8b61313bbabce2c6 // .quad -8403381297090862394
+	QUAD $0x2323ac4b3b3da016 // .quad 2532056854628769814
+	QUAD $0xae397d8aa96c1b77 // .quad -5892540602936190089
+	QUAD $0xabec975e0a0d081b // .quad -6058300968568813541
+	QUAD $0xd9c7dced53c72255 // .quad -2753989735242849707
+	QUAD $0x96e7bd358c904a22 // .quad -7572876210711016926
+	QUAD $0x881cea14545c7575 // .quad -8638772612167862923
+	QUAD $0x7e50d64177da2e55 // .quad 9102010423587778133
+	QUAD $0xaa242499697392d2 // .quad -6186779746782440750
+	QUAD $0xdde50bd1d5d0b9ea // .quad -2457545025797441046
+	QUAD $0xd4ad2dbfc3d07787 // .quad -3121788665050663033
+	QUAD $0x955e4ec64b44e865 // .quad -7683617300674189211
+	QUAD $0x84ec3c97da624ab4 // .quad -8868646943297746252
+	QUAD $0xbd5af13bef0b113f // .quad -4802260812921368257
+	QUAD $0xa6274bbdd0fadd61 // .quad -6474122660694794911
+	QUAD $0xecb1ad8aeacdd58f // .quad -1391139997724322417
+	QUAD $0xcfb11ead453994ba // .quad -3480967307441105734
+	QUAD $0x67de18eda5814af3 // .quad 7484447039699372787
+	QUAD $0x81ceb32c4b43fcf4 // .quad -9093133594791772940
+	QUAD $0x80eacf948770ced8 // .quad -9157278655470055720
+	QUAD $0xa2425ff75e14fc31 // .quad -6754730975062328271
+	QUAD $0xa1258379a94d028e // .quad -6834912300910181746
+	QUAD $0xcad2f7f5359a3b3e // .quad -3831727700400522434
+	QUAD $0x096ee45813a04331 // .quad 679731660717048625
+	QUAD $0xfd87b5f28300ca0d // .quad -177973607073265139
+	QUAD $0x8bca9d6e188853fd // .quad -8373707460958465027
+	QUAD $0x9e74d1b791e07e48 // .quad -7028762532061872568
+	QUAD $0x775ea264cf55347e // .quad 8601490892183123070
+	QUAD $0xc612062576589dda // .quad -4174267146649952806
+	QUAD $0x95364afe032a819e // .quad -7694880458480647778
+	QUAD $0xf79687aed3eec551 // .quad -606147914885053103
+	QUAD $0x3a83ddbd83f52205 // .quad 4216457482181353989
+	QUAD $0x9abe14cd44753b52 // .quad -7296371474444240046
+	QUAD $0xc4926a9672793543 // .quad -4282243101277735613
+	QUAD $0xc16d9a0095928a27 // .quad -4508778324627912153
+	QUAD $0x75b7053c0f178294 // .quad 8482254178684994196
+	QUAD $0xf1c90080baf72cb1 // .quad -1024286887357502287
+	QUAD $0x5324c68b12dd6339 // .quad 5991131704928854841
+	QUAD $0x971da05074da7bee // .quad -7557708332239520786
+	QUAD $0xd3f6fc16ebca5e04 // .quad -3173071712060547580
+	QUAD $0xbce5086492111aea // .quad -4835449396872013078
+	QUAD $0x88f4bb1ca6bcf585 // .quad -8578025658503072379
+	QUAD $0xec1e4a7db69561a5 // .quad -1432625727662628443
+	QUAD $0x2b31e9e3d06c32e6 // .quad 3112525982153323238
+	QUAD $0x9392ee8e921d5d07 // .quad -7812920107430224633
+	QUAD $0x3aff322e62439fd0 // .quad 4251171748059520976
+	QUAD $0xb877aa3236a4b449 // .quad -5154464115860392887
+	QUAD $0x09befeb9fad487c3 // .quad 702278666647013315
+	QUAD $0xe69594bec44de15b // .quad -1831394126398103205
+	QUAD $0x4c2ebe687989a9b4 // .quad 5489534351736154548
+	QUAD $0x901d7cf73ab0acd9 // .quad -8062150356639896359
+	QUAD $0x0f9d37014bf60a11 // .quad 1125115960621402641
+	QUAD $0xb424dc35095cd80f // .quad -5466001927372482545
+	QUAD $0x538484c19ef38c95 // .quad 6018080969204141205
+	QUAD $0xe12e13424bb40e13 // .quad -2220816390788215277
+	QUAD $0x2865a5f206b06fba // .quad 2910915193077788602
+	QUAD $0x8cbccc096f5088cb // .quad -8305539271883716405
+	QUAD $0xf93f87b7442e45d4 // .quad -486521013540076076
+	QUAD $0xafebff0bcb24aafe // .quad -5770238071427257602
+	QUAD $0xf78f69a51539d749 // .quad -608151266925095095
+	QUAD $0xdbe6fecebdedd5be // .quad -2601111570856684098
+	QUAD $0xb573440e5a884d1c // .quad -5371875102083756772
+	QUAD $0x89705f4136b4a597 // .quad -8543223759426509417
+	QUAD $0x31680a88f8953031 // .quad 3560107088838733873
+	QUAD $0xabcc77118461cefc // .quad -6067343680855748868
+	QUAD $0xfdc20d2b36ba7c3e // .quad -161552157378970562
+	QUAD $0xd6bf94d5e57a42bc // .quad -2972493582642298180
+	QUAD $0x3d32907604691b4d // .quad 4409745821703674701
+	QUAD $0x8637bd05af6c69b5 // .quad -8775337516792518219
+	QUAD $0xa63f9a49c2c1b110 // .quad -6467280898289979120
+	QUAD $0xa7c5ac471b478423 // .quad -6357485877563259869
+	QUAD $0x0fcf80dc33721d54 // .quad 1139270913992301908
+	QUAD $0xd1b71758e219652b // .quad -3335171328526686933
+	QUAD $0xd3c36113404ea4a9 // .quad -3187597375937010519
+	QUAD $0x83126e978d4fdf3b // .quad -9002011107970261189
+	QUAD $0x645a1cac083126ea // .quad 7231123676894144234
+	QUAD $0xa3d70a3d70a3d70a // .quad -6640827866535438582
+	QUAD $0x3d70a3d70a3d70a4 // .quad 4427218577690292388
+	QUAD $0xcccccccccccccccc // .quad -3689348814741910324
+	QUAD $0xcccccccccccccccd // .quad -3689348814741910323
+	QUAD $0x8000000000000000 // .quad -9223372036854775808
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xa000000000000000 // .quad -6917529027641081856
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xc800000000000000 // .quad -4035225266123964416
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xfa00000000000000 // .quad -432345564227567616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x9c40000000000000 // .quad -7187745005283311616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xc350000000000000 // .quad -4372995238176751616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xf424000000000000 // .quad -854558029293551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x9896800000000000 // .quad -7451627795949551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xbebc200000000000 // .quad -4702848726509551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xee6b280000000000 // .quad -1266874889709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x9502f90000000000 // .quad -7709325833709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xba43b74000000000 // .quad -5024971273709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xe8d4a51000000000 // .quad -1669528073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x9184e72a00000000 // .quad -7960984073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xb5e620f480000000 // .quad -5339544073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xe35fa931a0000000 // .quad -2062744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x8e1bc9bf04000000 // .quad -8206744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xb1a2bc2ec5000000 // .quad -5646744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xde0b6b3a76400000 // .quad -2446744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x8ac7230489e80000 // .quad -8446744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xad78ebc5ac620000 // .quad -5946744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xd8d726b7177a8000 // .quad -2821744073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x878678326eac9000 // .quad -8681119073709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xa968163f0a57b400 // .quad -6239712823709551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xd3c21bcecceda100 // .quad -3187955011209551616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x84595161401484a0 // .quad -8910000909647051616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xa56fa5b99019a5c8 // .quad -6525815118631426616
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0xcecb8f27f4200f3a // .quad -3545582879861895366
+	QUAD $0x0000000000000000 // .quad 0
+	QUAD $0x813f3978f8940984 // .quad -9133518327554766460
+	QUAD $0x4000000000000000 // .quad 4611686018427387904
+	QUAD $0xa18f07d736b90be5 // .quad -6805211891016070171
+	QUAD $0x5000000000000000 // .quad 5764607523034234880
+	QUAD $0xc9f2c9cd04674ede // .quad -3894828845342699810
+	QUAD $0xa400000000000000 // .quad -6629298651489370112
+	QUAD $0xfc6f7c4045812296 // .quad -256850038250986858
+	QUAD $0x4d00000000000000 // .quad 5548434740920451072
+	QUAD $0x9dc5ada82b70b59d // .quad -7078060301547948643
+	QUAD $0xf020000000000000 // .quad -1143914305352105984
+	QUAD $0xc5371912364ce305 // .quad -4235889358507547899
+	QUAD $0x6c28000000000000 // .quad 7793479155164643328
+	QUAD $0xf684df56c3e01bc6 // .quad -683175679707046970
+	QUAD $0xc732000000000000 // .quad -4093209111326359552
+	QUAD $0x9a130b963a6c115c // .quad -7344513827457986212
+	QUAD $0x3c7f400000000000 // .quad 4359273333062107136
+	QUAD $0xc097ce7bc90715b3 // .quad -4568956265895094861
+	QUAD $0x4b9f100000000000 // .quad 5449091666327633920
+	QUAD $0xf0bdc21abb48db20 // .quad -1099509313941480672
+	QUAD $0x1e86d40000000000 // .quad 2199678564482154496
+	QUAD $0x96769950b50d88f4 // .quad -7604722348854507276
+	QUAD $0x1314448000000000 // .quad 1374799102801346560
+	QUAD $0xbc143fa4e250eb31 // .quad -4894216917640746191
+	QUAD $0x17d955a000000000 // .quad 1718498878501683200
+	QUAD $0xeb194f8e1ae525fd // .quad -1506085128623544835
+	QUAD $0x5dcfab0800000000 // .quad 6759809616554491904
+	QUAD $0x92efd1b8d0cf37be // .quad -7858832233030797378
+	QUAD $0x5aa1cae500000000 // .quad 6530724019560251392
+	QUAD $0xb7abc627050305ad // .quad -5211854272861108819
+	QUAD $0xf14a3d9e40000000 // .quad -1059967012404461568
+	QUAD $0xe596b7b0c643c719 // .quad -1903131822648998119
+	QUAD $0x6d9ccd05d0000000 // .quad 7898413271349198848
+	QUAD $0x8f7e32ce7bea5c6f // .quad -8106986416796705681
+	QUAD $0xe4820023a2000000 // .quad -1981020733047832576
+	QUAD $0xb35dbf821ae4f38b // .quad -5522047002568494197
+	QUAD $0xdda2802c8a800000 // .quad -2476275916309790720
+	QUAD $0xe0352f62a19e306e // .quad -2290872734783229842
+	QUAD $0xd50b2037ad200000 // .quad -3095344895387238400
+	QUAD $0x8c213d9da502de45 // .quad -8349324486880600507
+	QUAD $0x4526f422cc340000 // .quad 4982938468024057856
+	QUAD $0xaf298d050e4395d6 // .quad -5824969590173362730
+	QUAD $0x9670b12b7f410000 // .quad -7606384970252091392
+	QUAD $0xdaf3f04651d47b4c // .quad -2669525969289315508
+	QUAD $0x3c0cdd765f114000 // .quad 4327076842467049472
+	QUAD $0x88d8762bf324cd0f // .quad -8585982758446904049
+	QUAD $0xa5880a69fb6ac800 // .quad -6518949010312869888
+	QUAD $0xab0e93b6efee0053 // .quad -6120792429631242157
+	QUAD $0x8eea0d047a457a00 // .quad -8148686262891087360
+	QUAD $0xd5d238a4abe98068 // .quad -3039304518611664792
+	QUAD $0x72a4904598d6d880 // .quad 8260886245095692416
+	QUAD $0x85a36366eb71f041 // .quad -8817094351773372351
+	QUAD $0x47a6da2b7f864750 // .quad 5163053903184807760
+	QUAD $0xa70c3c40a64e6c51 // .quad -6409681921289327535
+	QUAD $0x999090b65f67d924 // .quad -7381240676301154012
+	QUAD $0xd0cf4b50cfe20765 // .quad -3400416383184271515
+	QUAD $0xfff4b4e3f741cf6d // .quad -3178808521666707
+	QUAD $0x82818f1281ed449f // .quad -9042789267131251553
+	QUAD $0xbff8f10e7a8921a5 // .quad -4613672773753429595
+	QUAD $0xa321f2d7226895c7 // .quad -6691800565486676537
+	QUAD $0xaff72d52192b6a0e // .quad -5767090967191786994
+	QUAD $0xcbea6f8ceb02bb39 // .quad -3753064688430957767
+	QUAD $0x9bf4f8a69f764491 // .quad -7208863708989733743
+	QUAD $0xfee50b7025c36a08 // .quad -79644842111309304
+	QUAD $0x02f236d04753d5b5 // .quad 212292400617608629
+	QUAD $0x9f4f2726179a2245 // .quad -6967307053960650171
+	QUAD $0x01d762422c946591 // .quad 132682750386005393
+	QUAD $0xc722f0ef9d80aad6 // .quad -4097447799023424810
+	QUAD $0x424d3ad2b7b97ef6 // .quad 4777539456409894646
+	QUAD $0xf8ebad2b84e0d58b // .quad -510123730351893109
+	QUAD $0xd2e0898765a7deb3 // .quad -3251447716342407501
+	QUAD $0x9b934c3b330c8577 // .quad -7236356359111015049
+	QUAD $0x63cc55f49f88eb30 // .quad 7191217214140771120
+	QUAD $0xc2781f49ffcfa6d5 // .quad -4433759430461380907
+	QUAD $0x3cbf6b71c76b25fc // .quad 4377335499248575996
+	QUAD $0xf316271c7fc3908a // .quad -930513269649338230
+	QUAD $0x8bef464e3945ef7b // .quad -8363388681221443717
+	QUAD $0x97edd871cfda3a56 // .quad -7499099821171918250
+	QUAD $0x97758bf0e3cbb5ad // .quad -7532960934977096275
+	QUAD $0xbde94e8e43d0c8ec // .quad -4762188758037509908
+	QUAD $0x3d52eeed1cbea318 // .quad 4418856886560793368
+	QUAD $0xed63a231d4c4fb27 // .quad -1341049929119499481
+	QUAD $0x4ca7aaa863ee4bde // .quad 5523571108200991710
+	QUAD $0x945e455f24fb1cf8 // .quad -7755685233340769032
+	QUAD $0x8fe8caa93e74ef6b // .quad -8076983103442849941
+	QUAD $0xb975d6b6ee39e436 // .quad -5082920523248573386
+	QUAD $0xb3e2fd538e122b45 // .quad -5484542860876174523
+	QUAD $0xe7d34c64a9c85d44 // .quad -1741964635633328828
+	QUAD $0x60dbbca87196b617 // .quad 6979379479186945559
+	QUAD $0x90e40fbeea1d3a4a // .quad -8006256924911912374
+	QUAD $0xbc8955e946fe31ce // .quad -4861259862362934834
+	QUAD $0xb51d13aea4a488dd // .quad -5396135137712502563
+	QUAD $0x6babab6398bdbe42 // .quad 7758483227328495170
+	QUAD $0xe264589a4dcdab14 // .quad -2133482903713240300
+	QUAD $0xc696963c7eed2dd2 // .quad -4136954021121544750
+	QUAD $0x8d7eb76070a08aec // .quad -8250955842461857044
+	QUAD $0xfc1e1de5cf543ca3 // .quad -279753253987271517
+	QUAD $0xb0de65388cc8ada8 // .quad -5702008784649933400
+	QUAD $0x3b25a55f43294bcc // .quad 4261994450943298508
+	QUAD $0xdd15fe86affad912 // .quad -2515824962385028846
+	QUAD $0x49ef0eb713f39ebf // .quad 5327493063679123135
+	QUAD $0x8a2dbf142dfcc7ab // .quad -8489919629131724885
+	QUAD $0x6e3569326c784338 // .quad 7941369183226839864
+	QUAD $0xacb92ed9397bf996 // .quad -6000713517987268202
+	QUAD $0x49c2c37f07965405 // .quad 5315025460606161925
+	QUAD $0xd7e77a8f87daf7fb // .quad -2889205879056697349
+	QUAD $0xdc33745ec97be907 // .quad -2579590211097073401
+	QUAD $0x86f0ac99b4e8dafd // .quad -8723282702051517699
+	QUAD $0x69a028bb3ded71a4 // .quad 7611128154919104932
+	QUAD $0xa8acd7c0222311bc // .quad -6292417359137009220
+	QUAD $0xc40832ea0d68ce0d // .quad -4321147861633282547
+	QUAD $0xd2d80db02aabd62b // .quad -3253835680493873621
+	QUAD $0xf50a3fa490c30191 // .quad -789748808614215279
+	QUAD $0x83c7088e1aab65db // .quad -8951176327949752869
+	QUAD $0x792667c6da79e0fb // .quad 8729779031470891259
+	QUAD $0xa4b8cab1a1563f52 // .quad -6577284391509803182
+	QUAD $0x577001b891185939 // .quad 6300537770911226169
+	QUAD $0xcde6fd5e09abcf26 // .quad -3609919470959866074
+	QUAD $0xed4c0226b55e6f87 // .quad -1347699823215743097
+	QUAD $0x80b05e5ac60b6178 // .quad -9173728696990998152
+	QUAD $0x544f8158315b05b5 // .quad 6075216638131242421
+	QUAD $0xa0dc75f1778e39d6 // .quad -6855474852811359786
+	QUAD $0x696361ae3db1c722 // .quad 7594020797664053026
+	QUAD $0xc913936dd571c84c // .quad -3957657547586811828
+	QUAD $0x03bc3a19cd1e38ea // .quad 269153960225290474
+	QUAD $0xfb5878494ace3a5f // .quad -335385916056126881
+	QUAD $0x04ab48a04065c724 // .quad 336442450281613092
+	QUAD $0x9d174b2dcec0e47b // .quad -7127145225176161157
+	QUAD $0x62eb0d64283f9c77 // .quad 7127805559067090039
+	QUAD $0xc45d1df942711d9a // .quad -4297245513042813542
+	QUAD $0x3ba5d0bd324f8395 // .quad 4298070930406474645
+	QUAD $0xf5746577930d6500 // .quad -759870872876129024
+	QUAD $0xca8f44ec7ee3647a // .quad -3850783373846682502
+	QUAD $0x9968bf6abbe85f20 // .quad -7392448323188662496
+	QUAD $0x7e998b13cf4e1ecc // .quad 9122475437414293196
+	QUAD $0xbfc2ef456ae276e8 // .quad -4628874385558440216
+	QUAD $0x9e3fedd8c321a67f // .quad -7043649776941685121
+	QUAD $0xefb3ab16c59b14a2 // .quad -1174406963520662366
+	QUAD $0xc5cfe94ef3ea101f // .quad -4192876202749718497
+	QUAD $0x95d04aee3b80ece5 // .quad -7651533379841495835
+	QUAD $0xbba1f1d158724a13 // .quad -4926390635932268013
+	QUAD $0xbb445da9ca61281f // .quad -4952730706374481889
+	QUAD $0x2a8a6e45ae8edc98 // .quad 3065383741939440792
+	QUAD $0xea1575143cf97226 // .quad -1579227364540714458
+	QUAD $0xf52d09d71a3293be // .quad -779956341003086914
+	QUAD $0x924d692ca61be758 // .quad -7904546130479028392
+	QUAD $0x593c2626705f9c57 // .quad 6430056314514152535
+	QUAD $0xb6e0c377cfa2e12e // .quad -5268996644671397586
+	QUAD $0x6f8b2fb00c77836d // .quad 8037570393142690669
+	QUAD $0xe498f455c38b997a // .quad -1974559787411859078
+	QUAD $0x0b6dfb9c0f956448 // .quad 823590954573587528
+	QUAD $0x8edf98b59a373fec // .quad -8151628894773493780
+	QUAD $0x4724bd4189bd5ead // .quad 5126430365035880109
+	QUAD $0xb2977ee300c50fe7 // .quad -5577850100039479321
+	QUAD $0x58edec91ec2cb658 // .quad 6408037956294850136
+	QUAD $0xdf3d5e9bc0f653e1 // .quad -2360626606621961247
+	QUAD $0x2f2967b66737e3ee // .quad 3398361426941174766
+	QUAD $0x8b865b215899f46c // .quad -8392920656779807636
+	QUAD $0xbd79e0d20082ee75 // .quad -4793553135802847627
+	QUAD $0xae67f1e9aec07187 // .quad -5879464802547371641
+	QUAD $0xecd8590680a3aa12 // .quad -1380255401326171630
+	QUAD $0xda01ee641a708de9 // .quad -2737644984756826647
+	QUAD $0xe80e6f4820cc9496 // .quad -1725319251657714538
+	QUAD $0x884134fe908658b2 // .quad -8628557143114098510
+	QUAD $0x3109058d147fdcde // .quad 3533361486141316318
+	QUAD $0xaa51823e34a7eede // .quad -6174010410465235234
+	QUAD $0xbd4b46f0599fd416 // .quad -4806670179178130410
+	QUAD $0xd4e5e2cdc1d1ea96 // .quad -3105826994654156138
+	QUAD $0x6c9e18ac7007c91b // .quad 7826720331309500699
+	QUAD $0x850fadc09923329e // .quad -8858670899299929442
+	QUAD $0x03e2cf6bc604ddb1 // .quad 280014188641050033
+	QUAD $0xa6539930bf6bff45 // .quad -6461652605697523899
+	QUAD $0x84db8346b786151d // .quad -8873354301053463267
+	QUAD $0xcfe87f7cef46ff16 // .quad -3465379738694516970
+	QUAD $0xe612641865679a64 // .quad -1868320839462053276
+	QUAD $0x81f14fae158c5f6e // .quad -9083391364325154962
+	QUAD $0x4fcb7e8f3f60c07f // .quad 5749828502977298559
+	QUAD $0xa26da3999aef7749 // .quad -6742553186979055799
+	QUAD $0xe3be5e330f38f09e // .quad -2036086408133152610
+	QUAD $0xcb090c8001ab551c // .quad -3816505465296431844
+	QUAD $0x5cadf5bfd3072cc6 // .quad 6678264026688335046
+	QUAD $0xfdcb4fa002162a63 // .quad -158945813193151901
+	QUAD $0x73d9732fc7c8f7f7 // .quad 8347830033360418807
+	QUAD $0x9e9f11c4014dda7e // .quad -7016870160886801794
+	QUAD $0x2867e7fddcdd9afb // .quad 2911550761636567803
+	QUAD $0xc646d63501a1511d // .quad -4159401682681114339
+	QUAD $0xb281e1fd541501b9 // .quad -5583933584809066055
+	QUAD $0xf7d88bc24209a565 // .quad -587566084924005019
+	QUAD $0x1f225a7ca91a4227 // .quad 2243455055843443239
+	QUAD $0x9ae757596946075f // .quad -7284757830718584993
+	QUAD $0x3375788de9b06959 // .quad 3708002419115845977
+	QUAD $0xc1a12d2fc3978937 // .quad -4494261269970843337
+	QUAD $0x0052d6b1641c83af // .quad 23317005467419567
+	QUAD $0xf209787bb47d6b84 // .quad -1006140569036166268
+	QUAD $0xc0678c5dbd23a49b // .quad -4582539761593113445
+	QUAD $0x9745eb4d50ce6332 // .quad -7546366883288685774
+	QUAD $0xf840b7ba963646e1 // .quad -558244341782001951
+	QUAD $0xbd176620a501fbff // .quad -4821272585683469313
+	QUAD $0xb650e5a93bc3d899 // .quad -5309491445654890343
+	QUAD $0xec5d3fa8ce427aff // .quad -1414904713676948737
+	QUAD $0xa3e51f138ab4cebf // .quad -6636864307068612929
+	QUAD $0x93ba47c980e98cdf // .quad -7801844473689174817
+	QUAD $0xc66f336c36b10138 // .quad -4148040191917883080
+	QUAD $0xb8a8d9bbe123f017 // .quad -5140619573684080617
+	QUAD $0xb80b0047445d4185 // .quad -5185050239897353851
+	QUAD $0xe6d3102ad96cec1d // .quad -1814088448677712867
+	QUAD $0xa60dc059157491e6 // .quad -6481312799871692314
+	QUAD $0x9043ea1ac7e41392 // .quad -8051334308064652398
+	QUAD $0x87c89837ad68db30 // .quad -8662506518347195600
+	QUAD $0xb454e4a179dd1877 // .quad -5452481866653427593
+	QUAD $0x29babe4598c311fc // .quad 3006924907348169212
+	QUAD $0xe16a1dc9d8545e94 // .quad -2203916314889396588
+	QUAD $0xf4296dd6fef3d67b // .quad -853029884242176389
+	QUAD $0x8ce2529e2734bb1d // .quad -8294976724446954723
+	QUAD $0x1899e4a65f58660d // .quad 1772699331562333709
+	QUAD $0xb01ae745b101e9e4 // .quad -5757034887131305500
+	QUAD $0x5ec05dcff72e7f90 // .quad 6827560182880305040
+	QUAD $0xdc21a1171d42645d // .quad -2584607590486743971
+	QUAD $0x76707543f4fa1f74 // .quad 8534450228600381300
+	QUAD $0x899504ae72497eba // .quad -8532908771695296838
+	QUAD $0x6a06494a791c53a9 // .quad 7639874402088932265
+	QUAD $0xabfa45da0edbde69 // .quad -6054449946191733143
+	QUAD $0x0487db9d17636893 // .quad 326470965756389523
+	QUAD $0xd6f8d7509292d603 // .quad -2956376414312278525
+	QUAD $0x45a9d2845d3c42b7 // .quad 5019774725622874807
+	QUAD $0x865b86925b9bc5c2 // .quad -8765264286586255934
+	QUAD $0x0b8a2392ba45a9b3 // .quad 831516194300602803
+	QUAD $0xa7f26836f282b732 // .quad -6344894339805432014
+	QUAD $0x8e6cac7768d7141f // .quad -8183976793979022305
+	QUAD $0xd1ef0244af2364ff // .quad -3319431906329402113
+	QUAD $0x3207d795430cd927 // .quad 3605087062808385831
+	QUAD $0x8335616aed761f1f // .quad -8992173969096958177
+	QUAD $0x7f44e6bd49e807b9 // .quad 9170708441896323001
+	QUAD $0xa402b9c5a8d3a6e7 // .quad -6628531442943809817
+	QUAD $0x5f16206c9c6209a7 // .quad 6851699533943015847
+	QUAD $0xcd036837130890a1 // .quad -3673978285252374367
+	QUAD $0x36dba887c37a8c10 // .quad 3952938399001381904
+	QUAD $0x802221226be55a64 // .quad -9213765455923815836
+	QUAD $0xc2494954da2c978a // .quad -4446942528265218166
+	QUAD $0xa02aa96b06deb0fd // .quad -6905520801477381891
+	QUAD $0xf2db9baa10b7bd6d // .quad -946992141904134803
+	QUAD $0xc83553c5c8965d3d // .quad -4020214983419339459
+	QUAD $0x6f92829494e5acc8 // .quad 8039631859474607304
+	QUAD $0xfa42a8b73abbf48c // .quad -413582710846786420
+	QUAD $0xcb772339ba1f17fa // .quad -3785518230938904582
+	QUAD $0x9c69a97284b578d7 // .quad -7176018221920323369
+	QUAD $0xff2a760414536efc // .quad -60105885123121412
+	QUAD $0xc38413cf25e2d70d // .quad -4358336758973016307
+	QUAD $0xfef5138519684abb // .quad -75132356403901765
+	QUAD $0xf46518c2ef5b8cd1 // .quad -836234930288882479
+	QUAD $0x7eb258665fc25d6a // .quad 9129456591349898602
+	QUAD $0x98bf2f79d5993802 // .quad -7440175859071633406
+	QUAD $0xef2f773ffbd97a62 // .quad -1211618658047395230
+	QUAD $0xbeeefb584aff8603 // .quad -4688533805412153853
+	QUAD $0xaafb550ffacfd8fb // .quad -6126209340986631941
+	QUAD $0xeeaaba2e5dbf6784 // .quad -1248981238337804412
+	QUAD $0x95ba2a53f983cf39 // .quad -7657761676233289927
+	QUAD $0x952ab45cfa97a0b2 // .quad -7698142301602209614
+	QUAD $0xdd945a747bf26184 // .quad -2480258038432112252
+	QUAD $0xba756174393d88df // .quad -5010991858575374113
+	QUAD $0x94f971119aeef9e5 // .quad -7712008566467528219
+	QUAD $0xe912b9d1478ceb17 // .quad -1652053804791829737
+	QUAD $0x7a37cd5601aab85e // .quad 8806733365625141342
+	QUAD $0x91abb422ccb812ee // .quad -7950062655635975442
+	QUAD $0xac62e055c10ab33b // .quad -6025006692552756421
+	QUAD $0xb616a12b7fe617aa // .quad -5325892301117581398
+	QUAD $0x577b986b314d600a // .quad 6303799689591218186
+	QUAD $0xe39c49765fdf9d94 // .quad -2045679357969588844
+	QUAD $0xed5a7e85fda0b80c // .quad -1343622424865753076
+	QUAD $0x8e41ade9fbebc27d // .quad -8196078626372074883
+	QUAD $0x14588f13be847308 // .quad 1466078993672598280
+	QUAD $0xb1d219647ae6b31c // .quad -5633412264537705700
+	QUAD $0x596eb2d8ae258fc9 // .quad 6444284760518135753
+	QUAD $0xde469fbd99a05fe3 // .quad -2430079312244744221
+	QUAD $0x6fca5f8ed9aef3bc // .quad 8055355950647669692
+	QUAD $0x8aec23d680043bee // .quad -8436328597794046994
+	QUAD $0x25de7bb9480d5855 // .quad 2728754459941099605
+	QUAD $0xada72ccc20054ae9 // .quad -5933724728815170839
+	QUAD $0xaf561aa79a10ae6b // .quad -5812428961928401301
+	QUAD $0xd910f7ff28069da4 // .quad -2805469892591575644
+	QUAD $0x1b2ba1518094da05 // .quad 1957835834444274181
+	QUAD $0x87aa9aff79042286 // .quad -8670947710510816634
+	QUAD $0x90fb44d2f05d0843 // .quad -7999724640327104445
+	QUAD $0xa99541bf57452b28 // .quad -6226998619711132888
+	QUAD $0x353a1607ac744a54 // .quad 3835402254873283156
+	QUAD $0xd3fa922f2d1675f2 // .quad -3172062256211528206
+	QUAD $0x42889b8997915ce9 // .quad 4794252818591603945
+	QUAD $0x847c9b5d7c2e09b7 // .quad -8900067937773286985
+	QUAD $0x69956135febada12 // .quad 7608094030047140370
+	QUAD $0xa59bc234db398c25 // .quad -6513398903789220827
+	QUAD $0x43fab9837e699096 // .quad 4898431519131537558
+	QUAD $0xcf02b2c21207ef2e // .quad -3530062611309138130
+	QUAD $0x94f967e45e03f4bc // .quad -7712018656367741764
+	QUAD $0x8161afb94b44f57d // .quad -9123818159709293187
+	QUAD $0x1d1be0eebac278f6 // .quad 2097517367411243254
+	QUAD $0xa1ba1ba79e1632dc // .quad -6793086681209228580
+	QUAD $0x6462d92a69731733 // .quad 7233582727691441971
+	QUAD $0xca28a291859bbf93 // .quad -3879672333084147821
+	QUAD $0x7d7b8f7503cfdcff // .quad 9041978409614302463
+	QUAD $0xfcb2cb35e702af78 // .quad -237904397927796872
+	QUAD $0x5cda735244c3d43f // .quad 6690786993590490175
+	QUAD $0x9defbf01b061adab // .quad -7066219276345954901
+	QUAD $0x3a0888136afa64a8 // .quad 4181741870994056360
+	QUAD $0xc56baec21c7a1916 // .quad -4221088077005055722
+	QUAD $0x088aaa1845b8fdd1 // .quad 615491320315182545
+	QUAD $0xf6c69a72a3989f5b // .quad -664674077828931749
+	QUAD $0x8aad549e57273d46 // .quad -8454007886460797626
+	QUAD $0x9a3c2087a63f6399 // .quad -7332950326284164199
+	QUAD $0x36ac54e2f678864c // .quad 3939617107816777292
+	QUAD $0xc0cb28a98fcf3c7f // .quad -4554501889427817345
+	QUAD $0x84576a1bb416a7de // .quad -8910536670511192098
+	QUAD $0xf0fdf2d3f3c30b9f // .quad -1081441343357383777
+	QUAD $0x656d44a2a11c51d6 // .quad 7308573235570561494
+	QUAD $0x969eb7c47859e743 // .quad -7593429867239446717
+	QUAD $0x9f644ae5a4b1b326 // .quad -6961356773836868826
+	QUAD $0xbc4665b596706114 // .quad -4880101315621920492
+	QUAD $0x873d5d9f0dde1fef // .quad -8701695967296086033
+	QUAD $0xeb57ff22fc0c7959 // .quad -1488440626100012711
+	QUAD $0xa90cb506d155a7eb // .quad -6265433940692719637
+	QUAD $0x9316ff75dd87cbd8 // .quad -7847804418953589800
+	QUAD $0x09a7f12442d588f3 // .quad 695789805494438131
+	QUAD $0xb7dcbf5354e9bece // .quad -5198069505264599346
+	QUAD $0x0c11ed6d538aeb30 // .quad 869737256868047664
+	QUAD $0xe5d3ef282a242e81 // .quad -1885900863153361279
+	QUAD $0x8f1668c8a86da5fb // .quad -8136200465769716229
+	QUAD $0x8fa475791a569d10 // .quad -8096217067111932656
+	QUAD $0xf96e017d694487bd // .quad -473439272678684739
+	QUAD $0xb38d92d760ec4455 // .quad -5508585315462527915
+	QUAD $0x37c981dcc395a9ad // .quad 4019886927579031981
+	QUAD $0xe070f78d3927556a // .quad -2274045625900771990
+	QUAD $0x85bbe253f47b1418 // .quad -8810199395808373736
+	QUAD $0x8c469ab843b89562 // .quad -8338807543829064350
+	QUAD $0x93956d7478ccec8f // .quad -7812217631593927537
+	QUAD $0xaf58416654a6babb // .quad -5811823411358942533
+	QUAD $0x387ac8d1970027b3 // .quad 4069786015789754291
+	QUAD $0xdb2e51bfe9d0696a // .quad -2653093245771290262
+	QUAD $0x06997b05fcc0319f // .quad 475546501309804959
+	QUAD $0x88fcf317f22241e2 // .quad -8575712306248138270
+	QUAD $0x441fece3bdf81f04 // .quad 4908902581746016004
+	QUAD $0xab3c2fddeeaad25a // .quad -6107954364382784934
+	QUAD $0xd527e81cad7626c4 // .quad -3087243809672255804
+	QUAD $0xd60b3bd56a5586f1 // .quad -3023256937051093263
+	QUAD $0x8a71e223d8d3b075 // .quad -8470740780517707659
+	QUAD $0x85c7056562757456 // .quad -8807064613298015146
+	QUAD $0xf6872d5667844e4a // .quad -682526969396179382
+	QUAD $0xa738c6bebb12d16c // .quad -6397144748195131028
+	QUAD $0xb428f8ac016561dc // .quad -5464844730172612132
+	QUAD $0xd106f86e69d785c7 // .quad -3384744916816525881
+	QUAD $0xe13336d701beba53 // .quad -2219369894288377261
+	QUAD $0x82a45b450226b39c // .quad -9032994600651410532
+	QUAD $0xecc0024661173474 // .quad -1387106183930235788
+	QUAD $0xa34d721642b06084 // .quad -6679557232386875260
+	QUAD $0x27f002d7f95d0191 // .quad 2877803288514593169
+	QUAD $0xcc20ce9bd35c78a5 // .quad -3737760522056206171
+	QUAD $0x31ec038df7b441f5 // .quad 3597254110643241461
+	QUAD $0xff290242c83396ce // .quad -60514634142869810
+	QUAD $0x7e67047175a15272 // .quad 9108253656731439730
+	QUAD $0x9f79a169bd203e41 // .quad -6955350673980375487
+	QUAD $0x0f0062c6e984d387 // .quad 1080972517029761927
+	QUAD $0xc75809c42c684dd1 // .quad -4082502324048081455
+	QUAD $0x52c07b78a3e60869 // .quad 5962901664714590313
+	QUAD $0xf92e0c3537826145 // .quad -491441886632713915
+	QUAD $0xa7709a56ccdf8a83 // .quad -6381430974388925821
+	QUAD $0x9bbcc7a142b17ccb // .quad -7224680206786528053
+	QUAD $0x88a66076400bb692 // .quad -8600080377420466542
+	QUAD $0xc2abf989935ddbfe // .quad -4419164240055772162
+	QUAD $0x6acff893d00ea436 // .quad 7696643601933968438
+	QUAD $0xf356f7ebf83552fe // .quad -912269281642327298
+	QUAD $0x0583f6b8c4124d44 // .quad 397432465562684740
+	QUAD $0x98165af37b2153de // .quad -7487697328667536418
+	QUAD $0xc3727a337a8b704b // .quad -4363290727450709941
+	QUAD $0xbe1bf1b059e9a8d6 // .quad -4747935642407032618
+	QUAD $0x744f18c0592e4c5d // .quad 8380944645968776285
+	QUAD $0xeda2ee1c7064130c // .quad -1323233534581402868
+	QUAD $0x1162def06f79df74 // .quad 1252808770606194548
+	QUAD $0x9485d4d1c63e8be7 // .quad -7744549986754458649
+	QUAD $0x8addcb5645ac2ba9 // .quad -8440366555225904215
+	QUAD $0xb9a74a0637ce2ee1 // .quad -5069001465015685407
+	QUAD $0x6d953e2bd7173693 // .quad 7896285879677171347
+	QUAD $0xe8111c87c5c1ba99 // .quad -1724565812842218855
+	QUAD $0xc8fa8db6ccdd0438 // .quad -3964700705685699528
+	QUAD $0x910ab1d4db9914a0 // .quad -7995382660667468640
+	QUAD $0x1d9c9892400a22a3 // .quad 2133748077373825699
+	QUAD $0xb54d5e4a127f59c8 // .quad -5382542307406947896
+	QUAD $0x2503beb6d00cab4c // .quad 2667185096717282124
+	QUAD $0xe2a0b5dc971f303a // .quad -2116491865831296966
+	QUAD $0x2e44ae64840fd61e // .quad 3333981370896602654
+	QUAD $0x8da471a9de737e24 // .quad -8240336443785642460
+	QUAD $0x5ceaecfed289e5d3 // .quad 6695424375237764563
+	QUAD $0xb10d8e1456105dad // .quad -5688734536304665171
+	QUAD $0x7425a83e872c5f48 // .quad 8369280469047205704
+	QUAD $0xdd50f1996b947518 // .quad -2499232151953443560
+	QUAD $0xd12f124e28f7771a // .quad -3373457468973156582
+	QUAD $0x8a5296ffe33cc92f // .quad -8479549122611984081
+	QUAD $0x82bd6b70d99aaa70 // .quad -9025939945749304720
+	QUAD $0xace73cbfdc0bfb7b // .quad -5987750384837592197
+	QUAD $0x636cc64d1001550c // .quad 7164319141522920716
+	QUAD $0xd8210befd30efa5a // .quad -2873001962619602342
+	QUAD $0x3c47f7e05401aa4f // .quad 4343712908476262991
+	QUAD $0x8714a775e3e95c78 // .quad -8713155254278333320
+	QUAD $0x65acfaec34810a72 // .quad 7326506586225052274
+	QUAD $0xa8d9d1535ce3b396 // .quad -6279758049420528746
+	QUAD $0x7f1839a741a14d0e // .quad 9158133232781315342
+	QUAD $0xd31045a8341ca07c // .quad -3238011543348273028
+	QUAD $0x1ede48111209a051 // .quad 2224294504121868369
+	QUAD $0x83ea2b892091e44d // .quad -8941286242233752499
+	QUAD $0x934aed0aab460433 // .quad -7833187971778608077
+	QUAD $0xa4e4b66b68b65d60 // .quad -6564921784364802720
+	QUAD $0xf81da84d56178540 // .quad -568112927868484288
+	QUAD $0xce1de40642e3f4b9 // .quad -3594466212028615495
+	QUAD $0x36251260ab9d668f // .quad 3901544858591782543
+	QUAD $0x80d2ae83e9ce78f3 // .quad -9164070410158966541
+	QUAD $0xc1d72b7c6b42601a // .quad -4479063491021217766
+	QUAD $0xa1075a24e4421730 // .quad -6843401994271320272
+	QUAD $0xb24cf65b8612f820 // .quad -5598829363776522208
+	QUAD $0xc94930ae1d529cfc // .quad -3942566474411762436
+	QUAD $0xdee033f26797b628 // .quad -2386850686293264856
+	QUAD $0xfb9b7cd9a4a7443c // .quad -316522074587315140
+	QUAD $0x169840ef017da3b2 // .quad 1628122660560806834
+	QUAD $0x9d412e0806e88aa5 // .quad -7115355324258153819
+	QUAD $0x8e1f289560ee864f // .quad -8205795374004271537
+	QUAD $0xc491798a08a2ad4e // .quad -4282508136895304370
+	QUAD $0xf1a6f2bab92a27e3 // .quad -1033872180650563613
+	QUAD $0xf5b5d7ec8acb58a2 // .quad -741449152691742558
+	QUAD $0xae10af696774b1dc // .quad -5904026244240592420
+	QUAD $0x9991a6f3d6bf1765 // .quad -7380934748073420955
+	QUAD $0xacca6da1e0a8ef2a // .quad -5995859411864064214
+	QUAD $0xbff610b0cc6edd3f // .quad -4614482416664388289
+	QUAD $0x17fd090a58d32af4 // .quad 1728547772024695540
+	QUAD $0xeff394dcff8a948e // .quad -1156417002403097458
+	QUAD $0xddfc4b4cef07f5b1 // .quad -2451001303396518479
+	QUAD $0x95f83d0a1fb69cd9 // .quad -7640289654143017767
+	QUAD $0x4abdaf101564f98f // .quad 5385653213018257807
+	QUAD $0xbb764c4ca7a4440f // .quad -4938676049251384305
+	QUAD $0x9d6d1ad41abe37f2 // .quad -7102991539009341454
+	QUAD $0xea53df5fd18d5513 // .quad -1561659043136842477
+	QUAD $0x84c86189216dc5ee // .quad -8878739423761676818
+	QUAD $0x92746b9be2f8552c // .quad -7893565929601608404
+	QUAD $0x32fd3cf5b4e49bb5 // .quad 3674159897003727797
+	QUAD $0xb7118682dbb66a77 // .quad -5255271393574622601
+	QUAD $0x3fbc8c33221dc2a2 // .quad 4592699871254659746
+	QUAD $0xe4d5e82392a40515 // .quad -1957403223540890347
+	QUAD $0x0fabaf3feaa5334b // .quad 1129188820640936779
+	QUAD $0x8f05b1163ba6832d // .quad -8140906042354138323
+	QUAD $0x29cb4d87f2a7400f // .quad 3011586022114279439
+	QUAD $0xb2c71d5bca9023f8 // .quad -5564446534515285000
+	QUAD $0x743e20e9ef511013 // .quad 8376168546070237203
+	QUAD $0xdf78e4b2bd342cf6 // .quad -2343872149716718346
+	QUAD $0x914da9246b255417 // .quad -7976533391121755113
+	QUAD $0x8bab8eefb6409c1a // .quad -8382449121214030822
+	QUAD $0x1ad089b6c2f7548f // .quad 1932195658189984911
+	QUAD $0xae9672aba3d0c320 // .quad -5866375383090150624
+	QUAD $0xa184ac2473b529b2 // .quad -6808127464117294670
+	QUAD $0xda3c0f568cc4f3e8 // .quad -2721283210435300376
+	QUAD $0xc9e5d72d90a2741f // .quad -3898473311719230433
+	QUAD $0x8865899617fb1871 // .quad -8618331034163144591
+	QUAD $0x7e2fa67c7a658893 // .quad 9092669226243950739
+	QUAD $0xaa7eebfb9df9de8d // .quad -6161227774276542835
+	QUAD $0xddbb901b98feeab8 // .quad -2469221522477225288
+	QUAD $0xd51ea6fa85785631 // .quad -3089848699418290639
+	QUAD $0x552a74227f3ea566 // .quad 6136845133758244198
+	QUAD $0x8533285c936b35de // .quad -8848684464777513506
+	QUAD $0xd53a88958f872760 // .quad -3082000819042179232
+	QUAD $0xa67ff273b8460356 // .quad -6449169562544503978
+	QUAD $0x8a892abaf368f138 // .quad -8464187042230111944
+	QUAD $0xd01fef10a657842c // .quad -3449775934753242068
+	QUAD $0x2d2b7569b0432d86 // .quad 3254824252494523782
+	QUAD $0x8213f56a67f6b29b // .quad -9073638986861858149
+	QUAD $0x9c3b29620e29fc74 // .quad -7189106879045698444
+	QUAD $0xa298f2c501f45f42 // .quad -6730362715149934782
+	QUAD $0x8349f3ba91b47b90 // .quad -8986383598807123056
+	QUAD $0xcb3f2f7642717713 // .quad -3801267375510030573
+	QUAD $0x241c70a936219a74 // .quad 2602078556773259892
+	QUAD $0xfe0efb53d30dd4d7 // .quad -139898200960150313
+	QUAD $0xed238cd383aa0111 // .quad -1359087822460813039
+	QUAD $0x9ec95d1463e8a506 // .quad -7004965403241175802
+	QUAD $0xf4363804324a40ab // .quad -849429889038008149
+	QUAD $0xc67bb4597ce2ce48 // .quad -4144520735624081848
+	QUAD $0xb143c6053edcd0d6 // .quad -5673473379724898090
+	QUAD $0xf81aa16fdc1b81da // .quad -568964901102714406
+	QUAD $0xdd94b7868e94050b // .quad -2480155706228734709
+	QUAD $0x9b10a4e5e9913128 // .quad -7273132090830278360
+	QUAD $0xca7cf2b4191c8327 // .quad -3855940325606653145
+	QUAD $0xc1d4ce1f63f57d72 // .quad -4479729095110460046
+	QUAD $0xfd1c2f611f63a3f1 // .quad -208239388580928527
+	QUAD $0xf24a01a73cf2dccf // .quad -987975350460687153
+	QUAD $0xbc633b39673c8ced // .quad -4871985254153548563
+	QUAD $0x976e41088617ca01 // .quad -7535013621679011327
+	QUAD $0xd5be0503e085d814 // .quad -3044990783845967852
+	QUAD $0xbd49d14aa79dbc82 // .quad -4807081008671376254
+	QUAD $0x4b2d8644d8a74e19 // .quad 5417133557047315993
+	QUAD $0xec9c459d51852ba2 // .quad -1397165242411832414
+	QUAD $0xddf8e7d60ed1219f // .quad -2451955090545630817
+	QUAD $0x93e1ab8252f33b45 // .quad -7790757304148477115
+	QUAD $0xcabb90e5c942b504 // .quad -3838314940804713212
+	QUAD $0xb8da1662e7b00a17 // .quad -5126760611758208489
+	QUAD $0x3d6a751f3b936244 // .quad 4425478360848884292
+	QUAD $0xe7109bfba19c0c9d // .quad -1796764746270372707
+	QUAD $0x0cc512670a783ad5 // .quad 920161932633717461
+	QUAD $0x906a617d450187e2 // .quad -8040506994060064798
+	QUAD $0x27fb2b80668b24c6 // .quad 2880944217109767366
+	QUAD $0xb484f9dc9641e9da // .quad -5438947724147693094
+	QUAD $0xb1f9f660802dedf7 // .quad -5622191765467566601
+	QUAD $0xe1a63853bbd26451 // .quad -2186998636757228463
+	QUAD $0x5e7873f8a0396974 // .quad 6807318348447705460
+	QUAD $0x8d07e33455637eb2 // .quad -8284403175614349646
+	QUAD $0xdb0b487b6423e1e9 // .quad -2662955059861265943
+	QUAD $0xb049dc016abc5e5f // .quad -5743817951090549153
+	QUAD $0x91ce1a9a3d2cda63 // .quad -7940379843253970333
+	QUAD $0xdc5c5301c56b75f7 // .quad -2568086420435798537
+	QUAD $0x7641a140cc7810fc // .quad 8521269269642088700
+	QUAD $0x89b9b3e11b6329ba // .quad -8522583040413455942
+	QUAD $0xa9e904c87fcb0a9e // .quad -6203421752542164322
+	QUAD $0xac2820d9623bf429 // .quad -6041542782089432023
+	QUAD $0x546345fa9fbdcd45 // .quad 6080780864604458309
+	QUAD $0xd732290fbacaf133 // .quad -2940242459184402125
+	QUAD $0xa97c177947ad4096 // .quad -6234081974526590826
+	QUAD $0x867f59a9d4bed6c0 // .quad -8755180564631333184
+	QUAD $0x49ed8eabcccc485e // .quad 5327070802775656542
+	QUAD $0xa81f301449ee8c70 // .quad -6332289687361778576
+	QUAD $0x5c68f256bfff5a75 // .quad 6658838503469570677
+	QUAD $0xd226fc195c6a2f8c // .quad -3303676090774835316
+	QUAD $0x73832eec6fff3112 // .quad 8323548129336963346
+	QUAD $0x83585d8fd9c25db7 // .quad -8982326584375353929
+	QUAD $0xc831fd53c5ff7eac // .quad -4021154456019173716
+	QUAD $0xa42e74f3d032f525 // .quad -6616222212041804507
+	QUAD $0xba3e7ca8b77f5e56 // .quad -5026443070023967146
+	QUAD $0xcd3a1230c43fb26f // .quad -3658591746624867729
+	QUAD $0x28ce1bd2e55f35ec // .quad 2940318199324816876
+	QUAD $0x80444b5e7aa7cf85 // .quad -9204148869281624187
+	QUAD $0x7980d163cf5b81b4 // .quad 8755227902219092404
+	QUAD $0xa0555e361951c366 // .quad -6893500068174642330
+	QUAD $0xd7e105bcc3326220 // .quad -2891023177508298208
+	QUAD $0xc86ab5c39fa63440 // .quad -4005189066790915008
+	QUAD $0x8dd9472bf3fefaa8 // .quad -8225464990312760664
+	QUAD $0xfa856334878fc150 // .quad -394800315061255856
+	QUAD $0xb14f98f6f0feb952 // .quad -5670145219463562926
+	QUAD $0x9c935e00d4b9d8d2 // .quad -7164279224554366766
+	QUAD $0x6ed1bf9a569f33d4 // .quad 7985374283903742932
+	QUAD $0xc3b8358109e84f07 // .quad -4343663012265570553
+	QUAD $0x0a862f80ec4700c9 // .quad 758345818024902857
+	QUAD $0xf4a642e14c6262c8 // .quad -817892746904575288
+	QUAD $0xcd27bb612758c0fb // .quad -3663753745896259333
+	QUAD $0x98e7e9cccfbd7dbd // .quad -7428711994456441411
+	QUAD $0x8038d51cb897789d // .quad -9207375118826243939
+	QUAD $0xbf21e44003acdd2c // .quad -4674203974643163860
+	QUAD $0xe0470a63e6bd56c4 // .quad -2285846861678029116
+	QUAD $0xeeea5d5004981478 // .quad -1231068949876566920
+	QUAD $0x1858ccfce06cac75 // .quad 1754377441329851509
+	QUAD $0x95527a5202df0ccb // .quad -7686947121313936181
+	QUAD $0x0f37801e0c43ebc9 // .quad 1096485900831157193
+	QUAD $0xbaa718e68396cffd // .quad -4996997883215032323
+	QUAD $0xd30560258f54e6bb // .quad -3241078642388441413
+	QUAD $0xe950df20247c83fd // .quad -1634561335591402499
+	QUAD $0x47c6b82ef32a206a // .quad 5172023733869224042
+	QUAD $0x91d28b7416cdd27e // .quad -7939129862385708418
+	QUAD $0x4cdc331d57fa5442 // .quad 5538357842881958978
+	QUAD $0xb6472e511c81471d // .quad -5312226309554747619
+	QUAD $0xe0133fe4adf8e953 // .quad -2300424733252327085
+	QUAD $0xe3d8f9e563a198e5 // .quad -2028596868516046619
+	QUAD $0x58180fddd97723a7 // .quad 6347841120289366951
+	QUAD $0x8e679c2f5e44ff8f // .quad -8185402070463610993
+	QUAD $0x570f09eaa7ea7649 // .quad 6273243709394548297
+	QUAD $0xb201833b35d63f73 // .quad -5620066569652125837
+	QUAD $0x2cd2cc6551e513db // .quad 3229868618315797467
+	QUAD $0xde81e40a034bcf4f // .quad -2413397193637769393
+	QUAD $0xf8077f7ea65e58d2 // .quad -574350245532641070
+	QUAD $0x8b112e86420f6191 // .quad -8425902273664687727
+	QUAD $0xfb04afaf27faf783 // .quad -358968903457900669
+	QUAD $0xadd57a27d29339f6 // .quad -5920691823653471754
+	QUAD $0x79c5db9af1f9b564 // .quad 8774660907532399972
+	QUAD $0xd94ad8b1c7380874 // .quad -2789178761139451788
+	QUAD $0x18375281ae7822bd // .quad 1744954097560724157
+	QUAD $0x87cec76f1c830548 // .quad -8660765753353239224
+	QUAD $0x8f2293910d0b15b6 // .quad -8132775725879323210
+	QUAD $0xa9c2794ae3a3c69a // .quad -6214271173264161126
+	QUAD $0xb2eb3875504ddb23 // .quad -5554283638921766109
+	QUAD $0xd433179d9c8cb841 // .quad -3156152948152813503
+	QUAD $0x5fa60692a46151ec // .quad 6892203506629956076
+	QUAD $0x849feec281d7f328 // .quad -8890124620236590296
+	QUAD $0xdbc7c41ba6bcd334 // .quad -2609901835997359308
+	QUAD $0xa5c7ea73224deff3 // .quad -6500969756868349965
+	QUAD $0x12b9b522906c0801 // .quad 1349308723430688769
+	QUAD $0xcf39e50feae16bef // .quad -3514526177658049553
+	QUAD $0xd768226b34870a01 // .quad -2925050114139026943
+	QUAD $0x81842f29f2cce375 // .quad -9114107888677362827
+	QUAD $0xe6a1158300d46641 // .quad -1828156321336891839
+	QUAD $0xa1e53af46f801c53 // .quad -6780948842419315629
+	QUAD $0x60495ae3c1097fd1 // .quad 6938176635183661009
+	QUAD $0xca5e89b18b602368 // .quad -3864500034596756632
+	QUAD $0x385bb19cb14bdfc5 // .quad 4061034775552188357
+	QUAD $0xfcf62c1dee382c42 // .quad -218939024818557886
+	QUAD $0x46729e03dd9ed7b6 // .quad 5076293469440235446
+	QUAD $0x9e19db92b4e31ba9 // .quad -7054365918152680535
+	QUAD $0x6c07a2c26a8346d2 // .quad 7784369436827535058
+
+	// .p2align 4, 0x00
+_VecShiftShuffles:
+	QUAD $0x0706050403020100; QUAD $0x0f0e0d0c0b0a0908 // .ascii 16, '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f'
+	QUAD $0x0807060504030201; QUAD $0xff0f0e0d0c0b0a09 // .ascii 16, '\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff'
+	QUAD $0x0908070605040302; QUAD $0xffff0f0e0d0c0b0a // .ascii 16, '\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff'
+	QUAD $0x0a09080706050403; QUAD $0xffffff0f0e0d0c0b // .ascii 16, '\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff'
+	QUAD $0x0b0a090807060504; QUAD $0xffffffff0f0e0d0c // .ascii 16, '\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff'
+	QUAD $0x0c0b0a0908070605; QUAD $0xffffffffff0f0e0d // .ascii 16, '\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff'
+	QUAD $0x0d0c0b0a09080706; QUAD $0xffffffffffff0f0e // .ascii 16, '\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff'
+	QUAD $0x0e0d0c0b0a090807; QUAD $0xffffffffffffff0f // .ascii 16, '\x07\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0x0f0e0d0c0b0a0908; QUAD $0xffffffffffffffff // .ascii 16, '\x08\t\n\x0b\x0c\r\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff'
+
+	// .p2align 4, 0x00
+__SingleQuoteTab:
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000030303030755c                           // .asciz 8, '\\u0000\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000031303030755c                           // .asciz 8, '\\u0001\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000032303030755c                           // .asciz 8, '\\u0002\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000033303030755c                           // .asciz 8, '\\u0003\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000034303030755c                           // .asciz 8, '\\u0004\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000035303030755c                           // .asciz 8, '\\u0005\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000036303030755c                           // .asciz 8, '\\u0006\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000037303030755c                           // .asciz 8, '\\u0007\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000038303030755c                           // .asciz 8, '\\u0008\x00\x00'
+	QUAD $0x0000000000000002                           // .quad 2
+	QUAD $0x000000000000745c                           // .asciz 8, '\\t\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000002                           // .quad 2
+	QUAD $0x0000000000006e5c                           // .asciz 8, '\\n\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000062303030755c                           // .asciz 8, '\\u000b\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000063303030755c                           // .asciz 8, '\\u000c\x00\x00'
+	QUAD $0x0000000000000002                           // .quad 2
+	QUAD $0x000000000000725c                           // .asciz 8, '\\r\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000065303030755c                           // .asciz 8, '\\u000e\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000066303030755c                           // .asciz 8, '\\u000f\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000030313030755c                           // .asciz 8, '\\u0010\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000031313030755c                           // .asciz 8, '\\u0011\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000032313030755c                           // .asciz 8, '\\u0012\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000033313030755c                           // .asciz 8, '\\u0013\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000034313030755c                           // .asciz 8, '\\u0014\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000035313030755c                           // .asciz 8, '\\u0015\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000036313030755c                           // .asciz 8, '\\u0016\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000037313030755c                           // .asciz 8, '\\u0017\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000038313030755c                           // .asciz 8, '\\u0018\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000039313030755c                           // .asciz 8, '\\u0019\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000061313030755c                           // .asciz 8, '\\u001a\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000062313030755c                           // .asciz 8, '\\u001b\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000063313030755c                           // .asciz 8, '\\u001c\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000064313030755c                           // .asciz 8, '\\u001d\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000065313030755c                           // .asciz 8, '\\u001e\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000066313030755c                           // .asciz 8, '\\u001f\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000002                           // .quad 2
+	QUAD $0x000000000000225c                           // .asciz 8, '\\"\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000002                           // .quad 2
+	QUAD $0x0000000000005c5c                           // .asciz 8, '\\\\\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+	// .p2align 4, 0x00
+__DoubleQuoteTab:
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0030303030755c5c                           // .asciz 8, '\\\\u0000\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0031303030755c5c                           // .asciz 8, '\\\\u0001\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0032303030755c5c                           // .asciz 8, '\\\\u0002\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0033303030755c5c                           // .asciz 8, '\\\\u0003\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0034303030755c5c                           // .asciz 8, '\\\\u0004\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0035303030755c5c                           // .asciz 8, '\\\\u0005\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0036303030755c5c                           // .asciz 8, '\\\\u0006\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0037303030755c5c                           // .asciz 8, '\\\\u0007\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0038303030755c5c                           // .asciz 8, '\\\\u0008\x00'
+	QUAD $0x0000000000000003                           // .quad 3
+	QUAD $0x0000000000745c5c                           // .asciz 8, '\\\\t\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000003                           // .quad 3
+	QUAD $0x00000000006e5c5c                           // .asciz 8, '\\\\n\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0062303030755c5c                           // .asciz 8, '\\\\u000b\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0063303030755c5c                           // .asciz 8, '\\\\u000c\x00'
+	QUAD $0x0000000000000003                           // .quad 3
+	QUAD $0x0000000000725c5c                           // .asciz 8, '\\\\r\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0065303030755c5c                           // .asciz 8, '\\\\u000e\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0066303030755c5c                           // .asciz 8, '\\\\u000f\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0030313030755c5c                           // .asciz 8, '\\\\u0010\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0031313030755c5c                           // .asciz 8, '\\\\u0011\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0032313030755c5c                           // .asciz 8, '\\\\u0012\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0033313030755c5c                           // .asciz 8, '\\\\u0013\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0034313030755c5c                           // .asciz 8, '\\\\u0014\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0035313030755c5c                           // .asciz 8, '\\\\u0015\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0036313030755c5c                           // .asciz 8, '\\\\u0016\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0037313030755c5c                           // .asciz 8, '\\\\u0017\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0038313030755c5c                           // .asciz 8, '\\\\u0018\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0039313030755c5c                           // .asciz 8, '\\\\u0019\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0061313030755c5c                           // .asciz 8, '\\\\u001a\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0062313030755c5c                           // .asciz 8, '\\\\u001b\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0063313030755c5c                           // .asciz 8, '\\\\u001c\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0064313030755c5c                           // .asciz 8, '\\\\u001d\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0065313030755c5c                           // .asciz 8, '\\\\u001e\x00'
+	QUAD $0x0000000000000007                           // .quad 7
+	QUAD $0x0066313030755c5c                           // .asciz 8, '\\\\u001f\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000004                           // .quad 4
+	QUAD $0x00000000225c5c5c                           // .asciz 8, '\\\\\\"\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000004                           // .quad 4
+	QUAD $0x000000005c5c5c5c                           // .asciz 8, '\\\\\\\\\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+	// .p2align 4, 0x00
+__EscTab:
+	QUAD $0x0101010101010101; QUAD $0x0101010101010101     // .ascii 16, '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01'
+	QUAD $0x0101010101010101; QUAD $0x0101010101010101     // .ascii 16, '\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01'
+	QUAD $0x0000000000010000; QUAD $0x0000000000000000     // .ascii 16, '\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; LONG $0x00000000; BYTE $0x01 // .ascii 13, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000     // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	WORD $0x0000; BYTE $0x00                               // .space 3, '\x00\x00\x00'
+
+	// .p2align 4, 0x00
+__UnquoteTab:
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000220000; QUAD $0x2f00000000000000 // .ascii 16, '\x00\x00"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00/'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000005c00000000 // .ascii 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\\\x00\x00\x00'
+	QUAD $0x000c000000080000; QUAD $0x000a000000000000 // .ascii 16, '\x00\x00\x08\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\n\x00'
+	LONG $0x000d0000; WORD $0xff09                     // .ascii 6, '\x00\x00\r\x00\t\xff'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; WORD $0x0000             // .space 10, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+	// .p2align 4, 0x00
+__HtmlQuoteTab:
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000036323030755c                           // .asciz 8, '\\u0026\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000063333030755c                           // .asciz 8, '\\u003c\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000065333030755c                           // .asciz 8, '\\u003e\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000038323032755c                           // .asciz 8, '\\u2028\x00\x00'
+	QUAD $0x0000000000000006                           // .quad 6
+	QUAD $0x000039323032755c                           // .asciz 8, '\\u2029\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+
+	// .p2align 4, 0x00
+_LSHIFT_TAB:
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .space 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000                           // .space 8, '\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000001                                   // .long 1
+	QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000001                                   // .long 1
+	QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000001                                   // .long 1
+	QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000002                                   // .long 2
+	QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000002                                   // .long 2
+	QUAD $0x0000000035323133; QUAD $0x0000000000000000 // .asciz 16, '3125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000002                                   // .long 2
+	QUAD $0x0000003532363531; QUAD $0x0000000000000000 // .asciz 16, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000003                                   // .long 3
+	QUAD $0x0000003532313837; QUAD $0x0000000000000000 // .asciz 16, '78125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000003                                   // .long 3
+	QUAD $0x0000353236303933; QUAD $0x0000000000000000 // .asciz 16, '390625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000003                                   // .long 3
+	QUAD $0x0035323133353931; QUAD $0x0000000000000000 // .asciz 16, '1953125\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000004                                   // .long 4
+	QUAD $0x0035323635363739; QUAD $0x0000000000000000 // .asciz 16, '9765625\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000004                                   // .long 4
+	QUAD $0x3532313832383834; QUAD $0x0000000000000000 // .asciz 16, '48828125\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000004                                   // .long 4
+	QUAD $0x3236303431343432; QUAD $0x0000000000000035 // .asciz 16, '244140625\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000004                                   // .long 4
+	QUAD $0x3133303730323231; QUAD $0x0000000000003532 // .asciz 16, '1220703125\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000005                                   // .long 5
+	QUAD $0x3635313533303136; QUAD $0x0000000000003532 // .asciz 16, '6103515625\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000005                                   // .long 5
+	QUAD $0x3837353731353033; QUAD $0x0000000000353231 // .asciz 16, '30517578125\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000005                                   // .long 5
+	QUAD $0x3938373835323531; QUAD $0x0000000035323630 // .asciz 16, '152587890625\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000006                                   // .long 6
+	QUAD $0x3534393339323637; QUAD $0x0000000035323133 // .asciz 16, '762939453125\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000006                                   // .long 6
+	QUAD $0x3237393634313833; QUAD $0x0000003532363536 // .asciz 16, '3814697265625\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000006                                   // .long 6
+	QUAD $0x3638343337303931; QUAD $0x0000353231383233 // .asciz 16, '19073486328125\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000007                                   // .long 7
+	QUAD $0x3133343736333539; QUAD $0x0000353236303436 // .asciz 16, '95367431640625\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000007                                   // .long 7
+	QUAD $0x3531373338363734; QUAD $0x0035323133303238 // .asciz 16, '476837158203125\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000007                                   // .long 7
+	QUAD $0x3735383134383332; QUAD $0x3532363531303139 // .asciz 16, '2384185791015625'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000007                                   // .long 7
+	QUAD $0x3832393032393131; QUAD $0x3231383730353539 // .asciz 16, '1192092895507812'
+	QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000008                                   // .long 8
+	QUAD $0x3434363430363935; QUAD $0x3236303933353737 // .asciz 16, '5960464477539062'
+	QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000008                                   // .long 8
+	QUAD $0x3232333230383932; QUAD $0x3133353936373833 // .asciz 16, '2980232238769531'
+	QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000008                                   // .long 8
+	QUAD $0x3136313130393431; QUAD $0x3536373438333931 // .asciz 16, '1490116119384765'
+	QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000009                                   // .long 9
+	QUAD $0x3530383530353437; QUAD $0x3832383332393639 // .asciz 16, '7450580596923828'
+	QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000009                                   // .long 9
+	QUAD $0x3230393235323733; QUAD $0x3431393136343839 // .asciz 16, '3725290298461914'
+	QUAD $0x0000000035323630; QUAD $0x0000000000000000 // .asciz 16, '0625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000009                                   // .long 9
+	QUAD $0x3135343632363831; QUAD $0x3735393033323934 // .asciz 16, '1862645149230957'
+	QUAD $0x0000003532313330; QUAD $0x0000000000000000 // .asciz 16, '03125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000a                                   // .long 10
+	QUAD $0x3735323233313339; QUAD $0x3538373435313634 // .asciz 16, '9313225746154785'
+	QUAD $0x0000003532363531; QUAD $0x0000000000000000 // .asciz 16, '15625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000a                                   // .long 10
+	QUAD $0x3832313636353634; QUAD $0x3239333737303337 // .asciz 16, '4656612873077392'
+	QUAD $0x0000353231383735; QUAD $0x0000000000000000 // .asciz 16, '578125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000a                                   // .long 10
+	QUAD $0x3436303338323332; QUAD $0x3639363833353633 // .asciz 16, '2328306436538696'
+	QUAD $0x0035323630393832; QUAD $0x0000000000000000 // .asciz 16, '2890625\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000a                                   // .long 10
+	QUAD $0x3233353134363131; QUAD $0x3834333936323831 // .asciz 16, '1164153218269348'
+	QUAD $0x3532313335343431; QUAD $0x0000000000000000 // .asciz 16, '14453125\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000b                                   // .long 11
+	QUAD $0x3036363730323835; QUAD $0x3034373634333139 // .asciz 16, '5820766091346740'
+	QUAD $0x3532363536323237; QUAD $0x0000000000000000 // .asciz 16, '72265625\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000b                                   // .long 11
+	QUAD $0x3033383330313932; QUAD $0x3037333337363534 // .asciz 16, '2910383045673370'
+	QUAD $0x3231383233313633; QUAD $0x0000000000000035 // .asciz 16, '361328125\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000b                                   // .long 11
+	QUAD $0x3531393135353431; QUAD $0x3538363633383232 // .asciz 16, '1455191522836685'
+	QUAD $0x3630343636303831; QUAD $0x0000000000003532 // .asciz 16, '1806640625\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000c                                   // .long 12
+	QUAD $0x3637353935373237; QUAD $0x3532343338313431 // .asciz 16, '7275957614183425'
+	QUAD $0x3133303233333039; QUAD $0x0000000000003532 // .asciz 16, '9033203125\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000c                                   // .long 12
+	QUAD $0x3838373937333633; QUAD $0x3231373139303730 // .asciz 16, '3637978807091712'
+	QUAD $0x3531303636313539; QUAD $0x0000000000353236 // .asciz 16, '95166015625\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000c                                   // .long 12
+	QUAD $0x3439383938313831; QUAD $0x3635383534353330 // .asciz 16, '1818989403545856'
+	QUAD $0x3730303338353734; QUAD $0x0000000035323138 // .asciz 16, '475830078125\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000d                                   // .long 13
+	QUAD $0x3037343934393039; QUAD $0x3238323932373731 // .asciz 16, '9094947017729282'
+	QUAD $0x3933303531393733; QUAD $0x0000000035323630 // .asciz 16, '379150390625\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000d                                   // .long 13
+	QUAD $0x3533373437343534; QUAD $0x3134363436383830 // .asciz 16, '4547473508864641'
+	QUAD $0x3931353735393831; QUAD $0x0000003532313335 // .asciz 16, '1895751953125\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000d                                   // .long 13
+	QUAD $0x3736333733373232; QUAD $0x3032333233343435 // .asciz 16, '2273736754432320'
+	QUAD $0x3935373837343935; QUAD $0x0000353236353637 // .asciz 16, '59478759765625\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000d                                   // .long 13
+	QUAD $0x3338363836333131; QUAD $0x3036313631323737 // .asciz 16, '1136868377216160'
+	QUAD $0x3937333933373932; QUAD $0x0035323138323838 // .asciz 16, '297393798828125\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000e                                   // .long 14
+	QUAD $0x3831343334383635; QUAD $0x3130383038303638 // .asciz 16, '5684341886080801'
+	QUAD $0x3939383639363834; QUAD $0x0035323630343134 // .asciz 16, '486968994140625\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000e                                   // .long 14
+	QUAD $0x3930373132343832; QUAD $0x3030343034303334 // .asciz 16, '2842170943040400'
+	QUAD $0x3934343834333437; QUAD $0x3532313330373037 // .asciz 16, '7434844970703125'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000e                                   // .long 14
+	QUAD $0x3435383031323431; QUAD $0x3030323032353137 // .asciz 16, '1421085471520200'
+	QUAD $0x3432323437313733; QUAD $0x3236353135333538 // .asciz 16, '3717422485351562'
+	QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000f                                   // .long 15
+	QUAD $0x3337323435303137; QUAD $0x3130303130363735 // .asciz 16, '7105427357601001'
+	QUAD $0x3432313137383538; QUAD $0x3231383735373632 // .asciz 16, '8587112426757812'
+	QUAD $0x0000000000000035; QUAD $0x0000000000000000 // .asciz 16, '5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000f                                   // .long 15
+	QUAD $0x3633313732353533; QUAD $0x3030353030383837 // .asciz 16, '3552713678800500'
+	QUAD $0x3236353533393239; QUAD $0x3630393837333331 // .asciz 16, '9293556213378906'
+	QUAD $0x0000000000003532; QUAD $0x0000000000000000 // .asciz 16, '25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x0000000f                                   // .long 15
+	QUAD $0x3836353336373731; QUAD $0x3035323030343933 // .asciz 16, '1776356839400250'
+	QUAD $0x3138373736343634; QUAD $0x3335343938363630 // .asciz 16, '4646778106689453'
+	QUAD $0x0000000000353231; QUAD $0x0000000000000000 // .asciz 16, '125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000010                                   // .long 16
+	QUAD $0x3134383731383838; QUAD $0x3235323130303739 // .asciz 16, '8881784197001252'
+	QUAD $0x3530393833333233; QUAD $0x3536323734343333 // .asciz 16, '3233890533447265'
+	QUAD $0x0000000000353236; QUAD $0x0000000000000000 // .asciz 16, '625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000010                                   // .long 16
+	QUAD $0x3032393830343434; QUAD $0x3632363030353839 // .asciz 16, '4440892098500626'
+	QUAD $0x3235343936313631; QUAD $0x3233363332373636 // .asciz 16, '1616945266723632'
+	QUAD $0x0000000035323138; QUAD $0x0000000000000000 // .asciz 16, '8125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000010                                   // .long 16
+	QUAD $0x3036343430323232; QUAD $0x3331333035323934 // .asciz 16, '2220446049250313'
+	QUAD $0x3632373438303830; QUAD $0x3631383136333333 // .asciz 16, '0808472633361816'
+	QUAD $0x0000003532363034; QUAD $0x0000000000000000 // .asciz 16, '40625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000010                                   // .long 16
+	QUAD $0x3033323230313131; QUAD $0x3635313532363432 // .asciz 16, '1110223024625156'
+	QUAD $0x3336333234303435; QUAD $0x3830393038363631 // .asciz 16, '5404236316680908'
+	QUAD $0x0000353231333032; QUAD $0x0000000000000000 // .asciz 16, '203125\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000011                                   // .long 17
+	QUAD $0x3135313131353535; QUAD $0x3238373532313332 // .asciz 16, '5551115123125782'
+	QUAD $0x3531383131323037; QUAD $0x3134353430343338 // .asciz 16, '7021181583404541'
+	QUAD $0x0000353236353130; QUAD $0x0000000000000000 // .asciz 16, '015625\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000011                                   // .long 17
+	QUAD $0x3537353535373732; QUAD $0x3139383236353136 // .asciz 16, '2775557561562891'
+	QUAD $0x3730393530313533; QUAD $0x3037323230373139 // .asciz 16, '3510590791702270'
+	QUAD $0x0035323138373035; QUAD $0x0000000000000000 // .asciz 16, '5078125\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000011                                   // .long 17
+	QUAD $0x3738373737383331; QUAD $0x3534343138373038 // .asciz 16, '1387778780781445'
+	QUAD $0x3335393235353736; QUAD $0x3533313135383539 // .asciz 16, '6755295395851135'
+	QUAD $0x3532363039333532; QUAD $0x0000000000000000 // .asciz 16, '25390625\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000012                                   // .long 18
+	QUAD $0x3933393838333936; QUAD $0x3832323730393330 // .asciz 16, '6938893903907228'
+	QUAD $0x3936373436373733; QUAD $0x3637363535323937 // .asciz 16, '3776476979255676'
+	QUAD $0x3532313335393632; QUAD $0x0000000000000000 // .asciz 16, '26953125\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000012                                   // .long 18
+	QUAD $0x3936343439363433; QUAD $0x3431363335393135 // .asciz 16, '3469446951953614'
+	QUAD $0x3438333238383831; QUAD $0x3833383732363938 // .asciz 16, '1888238489627838'
+	QUAD $0x3236353637343331; QUAD $0x0000000000000035 // .asciz 16, '134765625\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000012                                   // .long 18
+	QUAD $0x3433323734333731; QUAD $0x3730383637393537 // .asciz 16, '1734723475976807'
+	QUAD $0x3239313134343930; QUAD $0x3931393331383434 // .asciz 16, '0944119244813919'
+	QUAD $0x3138323833373630; QUAD $0x0000000000003532 // .asciz 16, '0673828125\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	LONG $0x00000013                                   // .long 19
+	QUAD $0x3337313633373638; QUAD $0x3533303438383937 // .asciz 16, '8673617379884035'
+	QUAD $0x3236393530323734; QUAD $0x3539353936303432 // .asciz 16, '4720596224069595'
+	QUAD $0x3630343139363333; QUAD $0x0000000000003532 // .asciz 16, '3369140625\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	QUAD $0x0000000000000000; QUAD $0x0000000000000000 // .asciz 16, '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+	LONG $0x00000000                                   // .asciz 4, '\x00\x00\x00\x00'
+	QUAD $0x0000000000000000                           // .p2align 4, 0x00
+
+_P10_TAB:
+	QUAD $0x3ff0000000000000 // .quad 0x3ff0000000000000
+	QUAD $0x4024000000000000 // .quad 0x4024000000000000
+	QUAD $0x4059000000000000 // .quad 0x4059000000000000
+	QUAD $0x408f400000000000 // .quad 0x408f400000000000
+	QUAD $0x40c3880000000000 // .quad 0x40c3880000000000
+	QUAD $0x40f86a0000000000 // .quad 0x40f86a0000000000
+	QUAD $0x412e848000000000 // .quad 0x412e848000000000
+	QUAD $0x416312d000000000 // .quad 0x416312d000000000
+	QUAD $0x4197d78400000000 // .quad 0x4197d78400000000
+	QUAD $0x41cdcd6500000000 // .quad 0x41cdcd6500000000
+	QUAD $0x4202a05f20000000 // .quad 0x4202a05f20000000
+	QUAD $0x42374876e8000000 // .quad 0x42374876e8000000
+	QUAD $0x426d1a94a2000000 // .quad 0x426d1a94a2000000
+	QUAD $0x42a2309ce5400000 // .quad 0x42a2309ce5400000
+	QUAD $0x42d6bcc41e900000 // .quad 0x42d6bcc41e900000
+	QUAD $0x430c6bf526340000 // .quad 0x430c6bf526340000
+	QUAD $0x4341c37937e08000 // .quad 0x4341c37937e08000
+	QUAD $0x4376345785d8a000 // .quad 0x4376345785d8a000
+	QUAD $0x43abc16d674ec800 // .quad 0x43abc16d674ec800
+	QUAD $0x43e158e460913d00 // .quad 0x43e158e460913d00
+	QUAD $0x4415af1d78b58c40 // .quad 0x4415af1d78b58c40
+	QUAD $0x444b1ae4d6e2ef50 // .quad 0x444b1ae4d6e2ef50
+	QUAD $0x4480f0cf064dd592 // .quad 0x4480f0cf064dd592
+	QUAD $0x0000000000000000 // .p2align 4, 0x00
+
+_LB_96b09a0f: // _pow10_ceil_sig_f32.g
+	QUAD $0x81ceb32c4b43fcf5 // .quad -9093133594791772939
+	QUAD $0xa2425ff75e14fc32 // .quad -6754730975062328270
+	QUAD $0xcad2f7f5359a3b3f // .quad -3831727700400522433
+	QUAD $0xfd87b5f28300ca0e // .quad -177973607073265138
+	QUAD $0x9e74d1b791e07e49 // .quad -7028762532061872567
+	QUAD $0xc612062576589ddb // .quad -4174267146649952805
+	QUAD $0xf79687aed3eec552 // .quad -606147914885053102
+	QUAD $0x9abe14cd44753b53 // .quad -7296371474444240045
+	QUAD $0xc16d9a0095928a28 // .quad -4508778324627912152
+	QUAD $0xf1c90080baf72cb2 // .quad -1024286887357502286
+	QUAD $0x971da05074da7bef // .quad -7557708332239520785
+	QUAD $0xbce5086492111aeb // .quad -4835449396872013077
+	QUAD $0xec1e4a7db69561a6 // .quad -1432625727662628442
+	QUAD $0x9392ee8e921d5d08 // .quad -7812920107430224632
+	QUAD $0xb877aa3236a4b44a // .quad -5154464115860392886
+	QUAD $0xe69594bec44de15c // .quad -1831394126398103204
+	QUAD $0x901d7cf73ab0acda // .quad -8062150356639896358
+	QUAD $0xb424dc35095cd810 // .quad -5466001927372482544
+	QUAD $0xe12e13424bb40e14 // .quad -2220816390788215276
+	QUAD $0x8cbccc096f5088cc // .quad -8305539271883716404
+	QUAD $0xafebff0bcb24aaff // .quad -5770238071427257601
+	QUAD $0xdbe6fecebdedd5bf // .quad -2601111570856684097
+	QUAD $0x89705f4136b4a598 // .quad -8543223759426509416
+	QUAD $0xabcc77118461cefd // .quad -6067343680855748867
+	QUAD $0xd6bf94d5e57a42bd // .quad -2972493582642298179
+	QUAD $0x8637bd05af6c69b6 // .quad -8775337516792518218
+	QUAD $0xa7c5ac471b478424 // .quad -6357485877563259868
+	QUAD $0xd1b71758e219652c // .quad -3335171328526686932
+	QUAD $0x83126e978d4fdf3c // .quad -9002011107970261188
+	QUAD $0xa3d70a3d70a3d70b // .quad -6640827866535438581
+	QUAD $0xcccccccccccccccd // .quad -3689348814741910323
+	QUAD $0x8000000000000000 // .quad -9223372036854775808
+	QUAD $0xa000000000000000 // .quad -6917529027641081856
+	QUAD $0xc800000000000000 // .quad -4035225266123964416
+	QUAD $0xfa00000000000000 // .quad -432345564227567616
+	QUAD $0x9c40000000000000 // .quad -7187745005283311616
+	QUAD $0xc350000000000000 // .quad -4372995238176751616
+	QUAD $0xf424000000000000 // .quad -854558029293551616
+	QUAD $0x9896800000000000 // .quad -7451627795949551616
+	QUAD $0xbebc200000000000 // .quad -4702848726509551616
+	QUAD $0xee6b280000000000 // .quad -1266874889709551616
+	QUAD $0x9502f90000000000 // .quad -7709325833709551616
+	QUAD $0xba43b74000000000 // .quad -5024971273709551616
+	QUAD $0xe8d4a51000000000 // .quad -1669528073709551616
+	QUAD $0x9184e72a00000000 // .quad -7960984073709551616
+	QUAD $0xb5e620f480000000 // .quad -5339544073709551616
+	QUAD $0xe35fa931a0000000 // .quad -2062744073709551616
+	QUAD $0x8e1bc9bf04000000 // .quad -8206744073709551616
+	QUAD $0xb1a2bc2ec5000000 // .quad -5646744073709551616
+	QUAD $0xde0b6b3a76400000 // .quad -2446744073709551616
+	QUAD $0x8ac7230489e80000 // .quad -8446744073709551616
+	QUAD $0xad78ebc5ac620000 // .quad -5946744073709551616
+	QUAD $0xd8d726b7177a8000 // .quad -2821744073709551616
+	QUAD $0x878678326eac9000 // .quad -8681119073709551616
+	QUAD $0xa968163f0a57b400 // .quad -6239712823709551616
+	QUAD $0xd3c21bcecceda100 // .quad -3187955011209551616
+	QUAD $0x84595161401484a0 // .quad -8910000909647051616
+	QUAD $0xa56fa5b99019a5c8 // .quad -6525815118631426616
+	QUAD $0xcecb8f27f4200f3a // .quad -3545582879861895366
+	QUAD $0x813f3978f8940985 // .quad -9133518327554766459
+	QUAD $0xa18f07d736b90be6 // .quad -6805211891016070170
+	QUAD $0xc9f2c9cd04674edf // .quad -3894828845342699809
+	QUAD $0xfc6f7c4045812297 // .quad -256850038250986857
+	QUAD $0x9dc5ada82b70b59e // .quad -7078060301547948642
+	QUAD $0xc5371912364ce306 // .quad -4235889358507547898
+	QUAD $0xf684df56c3e01bc7 // .quad -683175679707046969
+	QUAD $0x9a130b963a6c115d // .quad -7344513827457986211
+	QUAD $0xc097ce7bc90715b4 // .quad -4568956265895094860
+	QUAD $0xf0bdc21abb48db21 // .quad -1099509313941480671
+	QUAD $0x96769950b50d88f5 // .quad -7604722348854507275
+	QUAD $0xbc143fa4e250eb32 // .quad -4894216917640746190
+	QUAD $0xeb194f8e1ae525fe // .quad -1506085128623544834
+	QUAD $0x92efd1b8d0cf37bf // .quad -7858832233030797377
+	QUAD $0xb7abc627050305ae // .quad -5211854272861108818
+	QUAD $0xe596b7b0c643c71a // .quad -1903131822648998118
+	QUAD $0x8f7e32ce7bea5c70 // .quad -8106986416796705680
+	QUAD $0xb35dbf821ae4f38c // .quad -5522047002568494196
+
+TEXT ·__f32toa(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -56(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_f32toa:
+	MOVQ  out+0(FP), DI
+	MOVSD val+8(FP), X0
+	CALL  ·__native_entry__+28688(SB) // _f32toa
+	MOVQ  AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__f64toa(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -80(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_f64toa:
+	MOVQ  out+0(FP), DI
+	MOVSD val+8(FP), X0
+	CALL  ·__native_entry__+464(SB) // _f64toa
+	MOVQ  AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__get_by_path(SB), NOSPLIT | NOFRAME, $0 - 32
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -264(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_get_by_path:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ path+16(FP), DX
+	CALL ·__native_entry__+26432(SB) // _get_by_path
+	MOVQ AX, ret+24(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__html_escape(SB), NOSPLIT | NOFRAME, $0 - 40
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -64(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_html_escape:
+	MOVQ sp+0(FP), DI
+	MOVQ nb+8(FP), SI
+	MOVQ dp+16(FP), DX
+	MOVQ dn+24(FP), CX
+	CALL ·__native_entry__+9584(SB) // _html_escape
+	MOVQ AX, ret+32(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__i64toa(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -16(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_i64toa:
+	MOVQ out+0(FP), DI
+	MOVQ val+8(FP), SI
+	CALL ·__native_entry__+3744(SB) // _i64toa
+	MOVQ AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__lspace(SB), NOSPLIT | NOFRAME, $0 - 32
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -8(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_lspace:
+	MOVQ sp+0(FP), DI
+	MOVQ nb+8(FP), SI
+	MOVQ off+16(FP), DX
+	CALL ·__native_entry__+80(SB) // _lspace
+	MOVQ AX, ret+24(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__quote(SB), NOSPLIT | NOFRAME, $0 - 48
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -80(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_quote:
+	MOVQ sp+0(FP), DI
+	MOVQ nb+8(FP), SI
+	MOVQ dp+16(FP), DX
+	MOVQ dn+24(FP), CX
+	MOVQ flags+32(FP), R8
+	CALL ·__native_entry__+5472(SB) // _quote
+	MOVQ AX, ret+40(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__skip_array(SB), NOSPLIT | NOFRAME, $0 - 40
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -128(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_skip_array:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ m+16(FP), DX
+	MOVQ flags+24(FP), CX
+	CALL ·__native_entry__+19184(SB) // _skip_array
+	MOVQ AX, ret+32(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__skip_number(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -72(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_skip_number:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	CALL ·__native_entry__+22528(SB) // _skip_number
+	MOVQ AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__skip_object(SB), NOSPLIT | NOFRAME, $0 - 40
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -128(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_skip_object:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ m+16(FP), DX
+	MOVQ flags+24(FP), CX
+	CALL ·__native_entry__+21088(SB) // _skip_object
+	MOVQ AX, ret+32(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__skip_one(SB), NOSPLIT | NOFRAME, $0 - 40
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -128(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_skip_one:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ m+16(FP), DX
+	MOVQ flags+24(FP), CX
+	CALL ·__native_entry__+22688(SB) // _skip_one
+	MOVQ AX, ret+32(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__skip_one_fast(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -160(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_skip_one_fast:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	CALL ·__native_entry__+22912(SB) // _skip_one_fast
+	MOVQ AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__u64toa(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -8(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_u64toa:
+	MOVQ out+0(FP), DI
+	MOVQ val+8(FP), SI
+	CALL ·__native_entry__+4016(SB) // _u64toa
+	MOVQ AX, ret+16(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__unquote(SB), NOSPLIT | NOFRAME, $0 - 48
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -128(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_unquote:
+	MOVQ sp+0(FP), DI
+	MOVQ nb+8(FP), SI
+	MOVQ dp+16(FP), DX
+	MOVQ ep+24(FP), CX
+	MOVQ flags+32(FP), R8
+	CALL ·__native_entry__+7184(SB) // _unquote
+	MOVQ AX, ret+40(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__validate_one(SB), NOSPLIT | NOFRAME, $0 - 32
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -128(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_validate_one:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ m+16(FP), DX
+	CALL ·__native_entry__+22736(SB) // _validate_one
+	MOVQ AX, ret+24(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__validate_utf8(SB), NOSPLIT | NOFRAME, $0 - 32
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -48(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_validate_utf8:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ m+16(FP), DX
+	CALL ·__native_entry__+27456(SB) // _validate_utf8
+	MOVQ AX, ret+24(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__validate_utf8_fast(SB), NOSPLIT | NOFRAME, $0 - 16
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -24(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_validate_utf8_fast:
+	MOVQ s+0(FP), DI
+	CALL ·__native_entry__+28128(SB) // _validate_utf8_fast
+	MOVQ AX, ret+8(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__value(SB), NOSPLIT | NOFRAME, $0 - 48
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -368(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_value:
+	MOVQ s+0(FP), DI
+	MOVQ n+8(FP), SI
+	MOVQ p+16(FP), DX
+	MOVQ v+24(FP), CX
+	MOVQ flags+32(FP), R8
+	CALL ·__native_entry__+13216(SB) // _value
+	MOVQ AX, ret+40(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__vnumber(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -280(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_vnumber:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ v+16(FP), DX
+	LEAQ ·__native_entry__+16928(SB), AX // _vnumber
+	JMP  AX
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__vsigned(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -16(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_vsigned:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ v+16(FP), DX
+	LEAQ ·__native_entry__+18464(SB), AX // _vsigned
+	JMP  AX
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__vstring(SB), NOSPLIT | NOFRAME, $0 - 32
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -128(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_vstring:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ v+16(FP), DX
+	MOVQ flags+24(FP), CX
+	LEAQ ·__native_entry__+15408(SB), AX // _vstring
+	JMP  AX
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__vunsigned(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -24(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_vunsigned:
+	MOVQ s+0(FP), DI
+	MOVQ p+8(FP), SI
+	MOVQ v+16(FP), DX
+	LEAQ ·__native_entry__+18816(SB), AX // _vunsigned
+	JMP  AX
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
diff --git a/vendor/github.com/bytedance/sonic/internal/native/sse/native_export_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/sse/native_export_amd64.go
new file mode 100644
index 000000000..898bad431
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/sse/native_export_amd64.go
@@ -0,0 +1,49 @@
+// Code generated by Makefile, DO NOT EDIT.
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package sse
+
+var (
+    S_f64toa = _subr__f64toa
+    S_f32toa = _subr__f32toa
+    S_i64toa = _subr__i64toa
+    S_u64toa = _subr__u64toa
+    S_lspace = _subr__lspace
+)
+
+var (
+    S_quote   = _subr__quote
+    S_unquote = _subr__unquote
+)
+
+var (
+    S_value     = _subr__value
+    S_vstring   = _subr__vstring
+    S_vnumber   = _subr__vnumber
+    S_vsigned   = _subr__vsigned
+    S_vunsigned = _subr__vunsigned
+)
+
+var (
+    S_skip_one    = _subr__skip_one
+    S_skip_one_fast = _subr__skip_one_fast
+    S_skip_array  = _subr__skip_array
+    S_skip_object = _subr__skip_object
+    S_skip_number = _subr__skip_number
+    S_get_by_path = _subr__get_by_path
+)
diff --git a/vendor/github.com/bytedance/sonic/internal/native/sse/native_subr_amd64.go b/vendor/github.com/bytedance/sonic/internal/native/sse/native_subr_amd64.go
new file mode 100644
index 000000000..26dee6de2
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/sse/native_subr_amd64.go
@@ -0,0 +1,109 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package sse
+
+//go:nosplit
+//go:noescape
+//goland:noinspection ALL
+func __native_entry__() uintptr
+
+var (
+    _subr__f32toa             = __native_entry__() + 28688
+    _subr__f64toa             = __native_entry__() + 464
+    _subr__get_by_path        = __native_entry__() + 26432
+    _subr__html_escape        = __native_entry__() + 9584
+    _subr__i64toa             = __native_entry__() + 3744
+    _subr__lspace             = __native_entry__() + 80
+    _subr__quote              = __native_entry__() + 5472
+    _subr__skip_array         = __native_entry__() + 19184
+    _subr__skip_number        = __native_entry__() + 22528
+    _subr__skip_object        = __native_entry__() + 21088
+    _subr__skip_one           = __native_entry__() + 22688
+    _subr__skip_one_fast      = __native_entry__() + 22912
+    _subr__u64toa             = __native_entry__() + 4016
+    _subr__unquote            = __native_entry__() + 7184
+    _subr__validate_one       = __native_entry__() + 22736
+    _subr__validate_utf8      = __native_entry__() + 27456
+    _subr__validate_utf8_fast = __native_entry__() + 28128
+    _subr__value              = __native_entry__() + 13216
+    _subr__vnumber            = __native_entry__() + 16928
+    _subr__vsigned            = __native_entry__() + 18464
+    _subr__vstring            = __native_entry__() + 15408
+    _subr__vunsigned          = __native_entry__() + 18816
+)
+
+const (
+    _stack__f32toa = 56
+    _stack__f64toa = 80
+    _stack__get_by_path = 264
+    _stack__html_escape = 64
+    _stack__i64toa = 16
+    _stack__lspace = 8
+    _stack__quote = 80
+    _stack__skip_array = 128
+    _stack__skip_number = 72
+    _stack__skip_object = 128
+    _stack__skip_one = 128
+    _stack__skip_one_fast = 160
+    _stack__u64toa = 8
+    _stack__unquote = 128
+    _stack__validate_one = 128
+    _stack__validate_utf8 = 48
+    _stack__validate_utf8_fast = 24
+    _stack__value = 368
+    _stack__vnumber = 280
+    _stack__vsigned = 16
+    _stack__vstring = 128
+    _stack__vunsigned = 24
+)
+
+var (
+    _ = _subr__f32toa
+    _ = _subr__f64toa
+    _ = _subr__get_by_path
+    _ = _subr__html_escape
+    _ = _subr__i64toa
+    _ = _subr__lspace
+    _ = _subr__quote
+    _ = _subr__skip_array
+    _ = _subr__skip_number
+    _ = _subr__skip_object
+    _ = _subr__skip_one
+    _ = _subr__skip_one_fast
+    _ = _subr__u64toa
+    _ = _subr__unquote
+    _ = _subr__validate_one
+    _ = _subr__validate_utf8
+    _ = _subr__validate_utf8_fast
+    _ = _subr__value
+    _ = _subr__vnumber
+    _ = _subr__vsigned
+    _ = _subr__vstring
+    _ = _subr__vunsigned
+)
+
+const (
+    _ = _stack__f32toa
+    _ = _stack__f64toa
+    _ = _stack__get_by_path
+    _ = _stack__html_escape
+    _ = _stack__i64toa
+    _ = _stack__lspace
+    _ = _stack__quote
+    _ = _stack__skip_array
+    _ = _stack__skip_number
+    _ = _stack__skip_object
+    _ = _stack__skip_one
+    _ = _stack__skip_one_fast
+    _ = _stack__u64toa
+    _ = _stack__unquote
+    _ = _stack__validate_one
+    _ = _stack__validate_utf8
+    _ = _stack__validate_utf8_fast
+    _ = _stack__value
+    _ = _stack__vnumber
+    _ = _stack__vsigned
+    _ = _stack__vstring
+    _ = _stack__vunsigned
+)
diff --git a/vendor/github.com/bytedance/sonic/internal/native/types/types.go b/vendor/github.com/bytedance/sonic/internal/native/types/types.go
new file mode 100644
index 000000000..00437303c
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/native/types/types.go
@@ -0,0 +1,134 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package types
+
+import (
+    `fmt`
+    `sync`
+)
+
+type ValueType int
+type ParsingError uint
+type SearchingError uint
+
+// NOTE: !NOT MODIFIED ONLY.
+// This definitions are followed in native/types.h.
+
+const (
+    V_EOF     ValueType = 1
+    V_NULL    ValueType = 2
+    V_TRUE    ValueType = 3
+    V_FALSE   ValueType = 4
+    V_ARRAY   ValueType = 5
+    V_OBJECT  ValueType = 6
+    V_STRING  ValueType = 7
+    V_DOUBLE  ValueType = 8
+    V_INTEGER ValueType = 9
+    _         ValueType = 10    // V_KEY_SEP
+    _         ValueType = 11    // V_ELEM_SEP
+    _         ValueType = 12    // V_ARRAY_END
+    _         ValueType = 13    // V_OBJECT_END
+    V_MAX
+)
+
+const (
+    B_DOUBLE_UNQUOTE  = 0
+    B_UNICODE_REPLACE = 1
+    B_VALIDATE_STRING = 5
+)
+
+const (
+    F_DOUBLE_UNQUOTE  = 1 << B_DOUBLE_UNQUOTE
+    F_UNICODE_REPLACE = 1 << B_UNICODE_REPLACE
+    F_VALIDATE_STRING = 1 << B_VALIDATE_STRING
+)
+
+const (
+    MAX_RECURSE = 4096
+)
+
+const (
+    SPACE_MASK = (1 << ' ') | (1 << '\t') | (1 << '\r') | (1 << '\n')
+)
+
+const (
+    ERR_EOF                ParsingError = 1
+    ERR_INVALID_CHAR       ParsingError = 2
+    ERR_INVALID_ESCAPE     ParsingError = 3
+    ERR_INVALID_UNICODE    ParsingError = 4
+    ERR_INTEGER_OVERFLOW   ParsingError = 5
+    ERR_INVALID_NUMBER_FMT ParsingError = 6
+    ERR_RECURSE_EXCEED_MAX ParsingError = 7
+    ERR_FLOAT_INFINITY     ParsingError = 8
+    ERR_MISMATCH           ParsingError = 9
+    ERR_INVALID_UTF8       ParsingError = 10
+)
+
+var _ParsingErrors = []string{
+    0                      : "ok",
+    ERR_EOF                : "eof",
+    ERR_INVALID_CHAR       : "invalid char",
+    ERR_INVALID_ESCAPE     : "invalid escape char",
+    ERR_INVALID_UNICODE    : "invalid unicode escape",
+    ERR_INTEGER_OVERFLOW   : "integer overflow",
+    ERR_INVALID_NUMBER_FMT : "invalid number format",
+    ERR_RECURSE_EXCEED_MAX : "recursion exceeded max depth",
+    ERR_FLOAT_INFINITY     : "float number is infinity",
+    ERR_MISMATCH           : "mismatched type with value",
+    ERR_INVALID_UTF8       : "invalid UTF8",
+}
+
+func (self ParsingError) Error() string {
+    return "json: error when parsing input: " + self.Message()
+}
+
+func (self ParsingError) Message() string {
+    if int(self) < len(_ParsingErrors) {
+        return _ParsingErrors[self]
+    } else {
+        return fmt.Sprintf("unknown error %d", self)
+    }
+}
+
+type JsonState struct {
+    Vt ValueType
+    Dv   float64
+    Iv   int64
+    Ep   int
+    Dbuf *byte
+    Dcap int
+}
+
+type StateMachine struct {
+    Sp int
+    Vt [MAX_RECURSE]int
+}
+
+var stackPool = sync.Pool{
+    New: func()interface{}{
+        return &StateMachine{}
+    },
+}
+
+func NewStateMachine() *StateMachine {
+    return stackPool.Get().(*StateMachine)
+}
+
+func FreeStateMachine(fsm *StateMachine) {
+    stackPool.Put(fsm)
+}
+
diff --git a/vendor/github.com/bytedance/sonic/internal/resolver/asm.s b/vendor/github.com/bytedance/sonic/internal/resolver/asm.s
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/resolver/asm.s
diff --git a/vendor/github.com/bytedance/sonic/internal/resolver/resolver.go b/vendor/github.com/bytedance/sonic/internal/resolver/resolver.go
new file mode 100644
index 000000000..796d5d823
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/resolver/resolver.go
@@ -0,0 +1,214 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package resolver
+
+import (
+    `fmt`
+    `reflect`
+    `strings`
+    `sync`
+)
+
+type FieldOpts int
+type OffsetType int
+
+const (
+    F_omitempty FieldOpts = 1 << iota
+    F_stringize
+)
+
+const (
+    F_offset OffsetType = iota
+    F_deref
+)
+
+type Offset struct {
+    Size uintptr
+    Kind OffsetType
+    Type reflect.Type
+}
+
+type FieldMeta struct {
+    Name string
+    Path []Offset
+    Opts FieldOpts
+    Type reflect.Type
+}
+
+func (self *FieldMeta) String() string {
+    var path []string
+    var opts []string
+
+    /* dump the field path */
+    for _, off := range self.Path {
+        if off.Kind == F_offset {
+            path = append(path, fmt.Sprintf("%d", off.Size))
+        } else {
+            path = append(path, fmt.Sprintf("%d.(*%s)", off.Size, off.Type))
+        }
+    }
+
+    /* check for "string" */
+    if (self.Opts & F_stringize) != 0 {
+        opts = append(opts, "string")
+    }
+
+    /* check for "omitempty" */
+    if (self.Opts & F_omitempty) != 0 {
+        opts = append(opts, "omitempty")
+    }
+
+    /* format the field */
+    return fmt.Sprintf(
+        "{Field \"%s\" @ %s, opts=%s, type=%s}",
+        self.Name,
+        strings.Join(path, "."),
+        strings.Join(opts, ","),
+        self.Type,
+    )
+}
+
+func (self *FieldMeta) optimize() {
+    var n int
+    var v uintptr
+
+    /* merge adjacent offsets */
+    for _, o := range self.Path {
+        if v += o.Size; o.Kind == F_deref {
+            self.Path[n].Size    = v
+            self.Path[n].Type, v = o.Type, 0
+            self.Path[n].Kind, n = F_deref, n + 1
+        }
+    }
+
+    /* last offset value */
+    if v != 0 {
+        self.Path[n].Size = v
+        self.Path[n].Type = nil
+        self.Path[n].Kind = F_offset
+        n++
+    }
+
+    /* must be at least 1 offset */
+    if n != 0 {
+        self.Path = self.Path[:n]
+    } else {
+        self.Path = []Offset{{Kind: F_offset}}
+    }
+}
+
+func resolveFields(vt reflect.Type) []FieldMeta {
+    tfv := typeFields(vt)
+    ret := []FieldMeta(nil)
+
+    /* convert each field */
+    for _, fv := range tfv.list {
+        item := vt
+        path := []Offset(nil)
+        opts := FieldOpts(0)
+
+        /* check for "string" */
+        if fv.quoted {
+            opts |= F_stringize
+        }
+
+        /* check for "omitempty" */
+        if fv.omitEmpty {
+            opts |= F_omitempty
+        }
+
+        /* dump the field path */
+        for _, i := range fv.index {
+            kind := F_offset
+            fval := item.Field(i)
+            item  = fval.Type
+
+            /* deref the pointer if needed */
+            if item.Kind() == reflect.Ptr {
+                kind = F_deref
+                item = item.Elem()
+            }
+
+            /* add to path */
+            path = append(path, Offset {
+                Kind: kind,
+                Type: item,
+                Size: fval.Offset,
+            })
+        }
+
+        /* get the index to the last offset */
+        fvt := fv.typ
+        idx := len(path) - 1
+
+        /* do not dereference into fields */
+        if path[idx].Kind == F_deref {
+            fvt = reflect.PtrTo(fvt)
+            path[idx].Kind = F_offset
+        }
+
+        /* add to result */
+        ret = append(ret, FieldMeta {
+            Type: fvt,
+            Opts: opts,
+            Path: path,
+            Name: fv.name,
+        })
+    }
+
+    /* optimize the offsets */
+    for i := range ret {
+        ret[i].optimize()
+    }
+
+    /* all done */
+    return ret
+}
+
+var (
+    fieldLock  = sync.RWMutex{}
+    fieldCache = map[reflect.Type][]FieldMeta{}
+)
+
+func ResolveStruct(vt reflect.Type) []FieldMeta {
+    var ok bool
+    var fm []FieldMeta
+
+    /* attempt to read from cache */
+    fieldLock.RLock()
+    fm, ok = fieldCache[vt]
+    fieldLock.RUnlock()
+
+    /* check if it was cached */
+    if ok {
+        return fm
+    }
+
+    /* otherwise use write-lock */
+    fieldLock.Lock()
+    defer fieldLock.Unlock()
+
+    /* double check */
+    if fm, ok = fieldCache[vt]; ok {
+        return fm
+    }
+
+    /* resolve the field */
+    fm = resolveFields(vt)
+    fieldCache[vt] = fm
+    return fm
+}
diff --git a/vendor/github.com/bytedance/sonic/internal/resolver/stubs.go b/vendor/github.com/bytedance/sonic/internal/resolver/stubs.go
new file mode 100644
index 000000000..ac27aa3d6
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/resolver/stubs.go
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package resolver
+
+import (
+    _ `encoding/json`
+    `reflect`
+    _ `unsafe`
+)
+
+type StdField struct {
+    name        string
+    nameBytes   []byte
+    equalFold   func()
+    nameNonEsc  string
+    nameEscHTML string
+    tag         bool
+    index       []int
+    typ         reflect.Type
+    omitEmpty   bool
+    quoted      bool
+    encoder     func()
+}
+
+type StdStructFields struct {
+    list      []StdField
+    nameIndex map[string]int
+}
+
+//go:noescape
+//go:linkname typeFields encoding/json.typeFields
+func typeFields(_ reflect.Type) StdStructFields
diff --git a/vendor/github.com/bytedance/sonic/internal/rt/asm_amd64.s b/vendor/github.com/bytedance/sonic/internal/rt/asm_amd64.s
new file mode 100644
index 000000000..8250e38d3
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/rt/asm_amd64.s
@@ -0,0 +1,60 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT·
+
+#include "go_asm.h"
+#include "funcdata.h"
+#include "textflag.h"
+
+TEXT ·MoreStack(SB), NOSPLIT, $0 - 8
+    NO_LOCAL_POINTERS
+_entry:
+    MOVQ (TLS), R14
+    MOVQ size+0(FP), R12
+    NOTQ R12
+    LEAQ (SP)(R12*1), R12
+    CMPQ R12, 16(R14)
+    JBE  _stack_grow
+    RET
+_stack_grow:
+    CALL runtime·morestack_noctxt<>(SB)
+    JMP  _entry
+
+
+TEXT ·StopProf(SB), NOSPLIT, $0-0
+    NO_LOCAL_POINTERS
+    CMPB github·com∕bytedance∕sonic∕internal∕rt·StopProfiling(SB), $0
+    JEQ  _ret_1
+    MOVL $1, AX
+    LEAQ github·com∕bytedance∕sonic∕internal∕rt·yieldCount(SB), CX
+    LOCK
+    XADDL AX, (CX)
+    MOVL runtime·prof+4(SB), AX
+    TESTL AX, AX
+    JEQ _ret_1
+    MOVL AX, github·com∕bytedance∕sonic∕internal∕rt·oldHz(SB)
+    MOVL $0, runtime·prof+4(SB)
+_ret_1:
+    RET
+
+
+TEXT ·StartProf(SB), NOSPLIT, $0-0
+    NO_LOCAL_POINTERS
+    CMPB github·com∕bytedance∕sonic∕internal∕rt·StopProfiling(SB), $0
+    JEQ  _ret_2
+    MOVL $-1, AX
+    LEAQ github·com∕bytedance∕sonic∕internal∕rt·yieldCount(SB), CX
+    LOCK
+    XADDL AX, (CX)
+    CMPL github·com∕bytedance∕sonic∕internal∕rt·yieldCount(SB), $0
+    JNE _ret_2
+    CMPL runtime·prof+4(SB), $0
+    JNE _ret_2
+    CMPL github·com∕bytedance∕sonic∕internal∕rt·oldHz(SB), $0
+    JNE _branch_1
+    MOVL $100, github·com∕bytedance∕sonic∕internal∕rt·oldHz(SB)
+_branch_1:
+    MOVL github·com∕bytedance∕sonic∕internal∕rt·oldHz(SB), AX
+    MOVL AX, runtime·prof+4(SB)
+_ret_2:
+    RET
+    
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/internal/rt/asm_arm64.s b/vendor/github.com/bytedance/sonic/internal/rt/asm_arm64.s
new file mode 100644
index 000000000..a168a8266
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/rt/asm_arm64.s
@@ -0,0 +1,10 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+#include "go_asm.h"
+#include "funcdata.h"
+#include "textflag.h"
+
+TEXT ·MoreStack(SB), NOSPLIT, $0 - 8
+    NO_LOCAL_POINTERS
+    RET
diff --git a/vendor/github.com/bytedance/sonic/internal/rt/fastmem.go b/vendor/github.com/bytedance/sonic/internal/rt/fastmem.go
new file mode 100644
index 000000000..358ce80ce
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/rt/fastmem.go
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package rt
+
+import (
+    `unsafe`
+    `reflect`
+)
+
+//go:nosplit
+func Get16(v []byte) int16 {
+    return *(*int16)((*GoSlice)(unsafe.Pointer(&v)).Ptr)
+}
+
+//go:nosplit
+func Get32(v []byte) int32 {
+    return *(*int32)((*GoSlice)(unsafe.Pointer(&v)).Ptr)
+}
+
+//go:nosplit
+func Get64(v []byte) int64 {
+    return *(*int64)((*GoSlice)(unsafe.Pointer(&v)).Ptr)
+}
+
+//go:nosplit
+func Mem2Str(v []byte) (s string) {
+    (*GoString)(unsafe.Pointer(&s)).Len = (*GoSlice)(unsafe.Pointer(&v)).Len
+    (*GoString)(unsafe.Pointer(&s)).Ptr = (*GoSlice)(unsafe.Pointer(&v)).Ptr
+    return
+}
+
+//go:nosplit
+func Str2Mem(s string) (v []byte) {
+    (*GoSlice)(unsafe.Pointer(&v)).Cap = (*GoString)(unsafe.Pointer(&s)).Len
+    (*GoSlice)(unsafe.Pointer(&v)).Len = (*GoString)(unsafe.Pointer(&s)).Len
+    (*GoSlice)(unsafe.Pointer(&v)).Ptr = (*GoString)(unsafe.Pointer(&s)).Ptr
+    return
+}
+
+func BytesFrom(p unsafe.Pointer, n int, c int) (r []byte) {
+    (*GoSlice)(unsafe.Pointer(&r)).Ptr = p
+    (*GoSlice)(unsafe.Pointer(&r)).Len = n
+    (*GoSlice)(unsafe.Pointer(&r)).Cap = c
+    return
+}
+
+func FuncAddr(f interface{}) unsafe.Pointer {
+    if vv := UnpackEface(f); vv.Type.Kind() != reflect.Func {
+        panic("f is not a function")
+    } else {
+        return *(*unsafe.Pointer)(vv.Value)
+    }
+}
+
+func IndexChar(src string, index int) unsafe.Pointer {
+	return unsafe.Pointer(uintptr((*GoString)(unsafe.Pointer(&src)).Ptr) + uintptr(index))
+}
+
+func IndexByte(ptr []byte, index int) unsafe.Pointer {
+	return unsafe.Pointer(uintptr((*GoSlice)(unsafe.Pointer(&ptr)).Ptr) + uintptr(index))
+}
+
+//go:nosplit
+func GuardSlice(buf *[]byte, n int) {
+	c := cap(*buf)
+	l := len(*buf)
+	if c-l < n {
+		c = c>>1 + n + l
+		if c < 32 {
+			c = 32
+		}
+		tmp := make([]byte, l, c)
+		copy(tmp, *buf)
+		*buf = tmp
+	}
+	return
+}
+
+//go:nosplit
+func Ptr2SlicePtr(s unsafe.Pointer, l int, c int) unsafe.Pointer {
+    slice := &GoSlice{
+        Ptr: s,
+        Len: l,
+        Cap: c,
+    }
+    return unsafe.Pointer(slice)
+}
+
+//go:nosplit
+func StrPtr(s string) unsafe.Pointer {
+    return (*GoString)(unsafe.Pointer(&s)).Ptr
+}
+
+//go:nosplit
+func StrFrom(p unsafe.Pointer, n int64) (s string) {
+    (*GoString)(unsafe.Pointer(&s)).Ptr = p
+    (*GoString)(unsafe.Pointer(&s)).Len = int(n)
+    return
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/internal/rt/fastvalue.go b/vendor/github.com/bytedance/sonic/internal/rt/fastvalue.go
new file mode 100644
index 000000000..87df6b94a
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/rt/fastvalue.go
@@ -0,0 +1,200 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package rt
+
+import (
+    `reflect`
+    `unsafe`
+)
+
+var (
+	reflectRtypeItab = findReflectRtypeItab()
+)
+
+const (
+    F_direct    = 1 << 5
+    F_kind_mask = (1 << 5) - 1
+)
+
+type GoType struct {
+    Size       uintptr
+    PtrData    uintptr
+    Hash       uint32
+    Flags      uint8
+    Align      uint8
+    FieldAlign uint8
+    KindFlags  uint8
+    Traits     unsafe.Pointer
+    GCData     *byte
+    Str        int32
+    PtrToSelf  int32
+}
+
+func (self *GoType) Kind() reflect.Kind {
+    return reflect.Kind(self.KindFlags & F_kind_mask)
+}
+
+func (self *GoType) Pack() (t reflect.Type) {
+    (*GoIface)(unsafe.Pointer(&t)).Itab = reflectRtypeItab
+    (*GoIface)(unsafe.Pointer(&t)).Value = unsafe.Pointer(self)
+    return
+}
+
+func (self *GoType) String() string {
+    return self.Pack().String()
+}
+
+func (self *GoType) Indirect() bool {
+    return self.KindFlags & F_direct == 0
+}
+
+type GoMap struct {
+    Count      int
+    Flags      uint8
+    B          uint8
+    Overflow   uint16
+    Hash0      uint32
+    Buckets    unsafe.Pointer
+    OldBuckets unsafe.Pointer
+    Evacuate   uintptr
+    Extra      unsafe.Pointer
+}
+
+type GoMapIterator struct {
+    K           unsafe.Pointer
+    V           unsafe.Pointer
+    T           *GoMapType
+    H           *GoMap
+    Buckets     unsafe.Pointer
+    Bptr        *unsafe.Pointer
+    Overflow    *[]unsafe.Pointer
+    OldOverflow *[]unsafe.Pointer
+    StartBucket uintptr
+    Offset      uint8
+    Wrapped     bool
+    B           uint8
+    I           uint8
+    Bucket      uintptr
+    CheckBucket uintptr
+}
+
+type GoItab struct {
+    it unsafe.Pointer
+    Vt *GoType
+    hv uint32
+    _  [4]byte
+    fn [1]uintptr
+}
+
+type GoIface struct {
+    Itab  *GoItab
+    Value unsafe.Pointer
+}
+
+type GoEface struct {
+    Type  *GoType
+    Value unsafe.Pointer
+}
+
+func (self GoEface) Pack() (v interface{}) {
+    *(*GoEface)(unsafe.Pointer(&v)) = self
+    return
+}
+
+type GoPtrType struct {
+    GoType
+    Elem *GoType
+}
+
+type GoMapType struct {
+    GoType
+    Key        *GoType
+    Elem       *GoType
+    Bucket     *GoType
+    Hasher     func(unsafe.Pointer, uintptr) uintptr
+    KeySize    uint8
+    ElemSize   uint8
+    BucketSize uint16
+    Flags      uint32
+}
+
+func (self *GoMapType) IndirectElem() bool {
+    return self.Flags & 2 != 0
+}
+
+type GoStructType struct {
+    GoType
+    Pkg    *byte
+    Fields []GoStructField
+}
+
+type GoStructField struct {
+    Name     *byte
+    Type     *GoType
+    OffEmbed uintptr
+}
+
+type GoInterfaceType struct {
+    GoType
+    PkgPath *byte
+    Methods []GoInterfaceMethod
+}
+
+type GoInterfaceMethod struct {
+    Name int32
+    Type int32
+}
+
+type GoSlice struct {
+    Ptr unsafe.Pointer
+    Len int
+    Cap int
+}
+
+type GoString struct {
+    Ptr unsafe.Pointer
+    Len int
+}
+
+func PtrElem(t *GoType) *GoType {
+    return (*GoPtrType)(unsafe.Pointer(t)).Elem
+}
+
+func MapType(t *GoType) *GoMapType {
+    return (*GoMapType)(unsafe.Pointer(t))
+}
+
+func IfaceType(t *GoType) *GoInterfaceType {
+    return (*GoInterfaceType)(unsafe.Pointer(t))
+}
+
+func UnpackType(t reflect.Type) *GoType {
+    return (*GoType)((*GoIface)(unsafe.Pointer(&t)).Value)
+}
+
+func UnpackEface(v interface{}) GoEface {
+    return *(*GoEface)(unsafe.Pointer(&v))
+}
+
+func UnpackIface(v interface{}) GoIface {
+    return *(*GoIface)(unsafe.Pointer(&v))
+}
+
+func findReflectRtypeItab() *GoItab {
+    v := reflect.TypeOf(struct{}{})
+    return (*GoIface)(unsafe.Pointer(&v)).Itab
+}
diff --git a/vendor/github.com/bytedance/sonic/internal/rt/gcwb.go b/vendor/github.com/bytedance/sonic/internal/rt/gcwb.go
new file mode 100644
index 000000000..c3217c899
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/rt/gcwb.go
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package rt
+
+import (
+    `os`
+    `sync/atomic`
+    `unsafe`
+
+    `golang.org/x/arch/x86/x86asm`
+)
+
+const (
+    _MaxInstr = 15
+)
+
+func isvar(arg x86asm.Arg) bool {
+    v, ok := arg.(x86asm.Mem)
+    return ok && v.Base == x86asm.RIP
+}
+
+func iszero(arg x86asm.Arg) bool {
+    v, ok := arg.(x86asm.Imm)
+    return ok && v == 0
+}
+
+func GcwbAddr() uintptr {
+    var err error
+    var off uintptr
+    var ins x86asm.Inst
+
+    /* get the function address */
+    pc := uintptr(0)
+    fp := FuncAddr(atomic.StorePointer)
+
+    /* search within the first 16 instructions */
+    for i := 0; i < 16; i++ {
+        mem := unsafe.Pointer(uintptr(fp) + pc)
+        buf := BytesFrom(mem, _MaxInstr, _MaxInstr)
+
+        /* disassemble the instruction */
+        if ins, err = x86asm.Decode(buf, 64); err != nil {
+            panic("gcwbaddr: " + err.Error())
+        }
+
+        /* check for a byte comparison with zero */
+        if ins.Op == x86asm.CMP && ins.MemBytes == 1 && isvar(ins.Args[0]) && iszero(ins.Args[1]) {
+            off = pc + uintptr(ins.Len) + uintptr(ins.Args[0].(x86asm.Mem).Disp)
+            break
+        }
+
+        /* move to next instruction */
+        nb := ins.Len
+        pc += uintptr(nb)
+    }
+
+    /* check for address */
+    if off == 0 {
+        panic("gcwbaddr: could not locate the variable `writeBarrier`")
+    } else {
+        return uintptr(fp) + off
+    }
+}
+
+// StopProfiling is used to stop traceback introduced by SIGPROF while native code is running.
+// WARN: this option is only a workaround for traceback issue (https://github.com/bytedance/sonic/issues/310),
+// and will be dropped when the issue is fixed.
+var StopProfiling = os.Getenv("SONIC_STOP_PROFILING") != ""
+
+// WARN: must be aligned with runtime.Prof
+// type Prof struct {
+//     signalLock uint32
+// 	hz int32
+// }
+
+var (
+    // // go:linkname runtimeProf runtime.prof
+    // runtimeProf Prof
+
+    // count of native-C calls
+    yieldCount uint32
+
+    // previous value of runtimeProf.hz
+    oldHz int32
+)
+
+//go:nosplit
+func MoreStack(size uintptr)
+
+func StopProf()
+
+// func StopProf() {
+//     atomic.AddUint32(&yieldCount, 1)
+//     if runtimeProf.hz != 0 {
+//         oldHz = runtimeProf.hz
+//         runtimeProf.hz = 0
+//     }
+// }
+
+func StartProf()
+
+// func StartProf() {
+//     atomic.AddUint32(&yieldCount, ^uint32(0))
+//     if yieldCount == 0 && runtimeProf.hz == 0 {
+//         if oldHz == 0 {
+//             oldHz = 100
+//         }
+//         runtimeProf.hz = oldHz
+//     }
+// }
diff --git a/vendor/github.com/bytedance/sonic/internal/rt/int48.go b/vendor/github.com/bytedance/sonic/internal/rt/int48.go
new file mode 100644
index 000000000..e9f82d731
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/rt/int48.go
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package rt
+
+const (
+    MinInt48 = -(1 << 47)
+    MaxInt48 = +(1 << 47) - 1
+)
+
+func PackInt(v int) uint64 {
+    if u := uint64(v); v < MinInt48 || v > MaxInt48 {
+        panic("int48 out of range")
+    } else {
+        return ((u >> 63) << 47) | (u & 0x00007fffffffffff)
+    }
+}
+
+func UnpackInt(v uint64) int {
+    v &= 0x0000ffffffffffff
+    v |= (v >> 47) * (0xffff << 48)
+    return int(v)
+}
diff --git a/vendor/github.com/bytedance/sonic/internal/rt/stackmap.go b/vendor/github.com/bytedance/sonic/internal/rt/stackmap.go
new file mode 100644
index 000000000..e2c28c598
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/internal/rt/stackmap.go
@@ -0,0 +1,180 @@
+/**
+ * Copyright 2023 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package rt
+
+import (
+    `fmt`
+    `strings`
+    `unsafe`
+
+)
+
+type Bitmap struct {
+    N int
+    B []byte
+}
+
+func (self *Bitmap) grow() {
+    if self.N >= len(self.B) * 8 {
+        self.B = append(self.B, 0)
+    }
+}
+
+func (self *Bitmap) mark(i int, bv int) {
+    if bv != 0 {
+        self.B[i / 8] |= 1 << (i % 8)
+    } else {
+        self.B[i / 8] &^= 1 << (i % 8)
+    }
+}
+
+func (self *Bitmap) Set(i int, bv int) {
+    if i >= self.N {
+        panic("bitmap: invalid bit position")
+    } else {
+        self.mark(i, bv)
+    }
+}
+
+func (self *Bitmap) Append(bv int) {
+    self.grow()
+    self.mark(self.N, bv)
+    self.N++
+}
+
+func (self *Bitmap) AppendMany(n int, bv int) {
+    for i := 0; i < n; i++ {
+        self.Append(bv)
+    }
+}
+
+// var (
+//     _stackMapLock  = sync.Mutex{}
+//     _stackMapCache = make(map[*StackMap]struct{})
+// )
+
+type BitVec struct {
+    N uintptr
+    B unsafe.Pointer
+}
+
+func (self BitVec) Bit(i uintptr) byte {
+    return (*(*byte)(unsafe.Pointer(uintptr(self.B) + i / 8)) >> (i % 8)) & 1
+}
+
+func (self BitVec) String() string {
+    var i uintptr
+    var v []string
+
+    /* add each bit */
+    for i = 0; i < self.N; i++ {
+        v = append(v, fmt.Sprintf("%d", self.Bit(i)))
+    }
+
+    /* join them together */
+    return fmt.Sprintf(
+        "BitVec { %s }",
+        strings.Join(v, ", "),
+    )
+}
+
+type StackMap struct {
+    N int32
+    L int32
+    B [1]byte
+}
+
+// func (self *StackMap) add() {
+//     _stackMapLock.Lock()
+//     _stackMapCache[self] = struct{}{}
+//     _stackMapLock.Unlock()
+// }
+
+func (self *StackMap) Pin() uintptr {
+    // self.add()
+    return uintptr(unsafe.Pointer(self))
+}
+
+func (self *StackMap) Get(i int32) BitVec {
+    return BitVec {
+        N: uintptr(self.L),
+        B: unsafe.Pointer(uintptr(unsafe.Pointer(&self.B)) + uintptr(i * ((self.L + 7) >> 3))),
+    }
+}
+
+func (self *StackMap) String() string {
+    sb := strings.Builder{}
+    sb.WriteString("StackMap {")
+
+    /* dump every stack map */
+    for i := int32(0); i < self.N; i++ {
+        sb.WriteRune('\n')
+        sb.WriteString("    " + self.Get(i).String())
+    }
+
+    /* close the stackmap */
+    sb.WriteString("\n}")
+    return sb.String()
+}
+
+func (self *StackMap) MarshalBinary() ([]byte, error) {
+    size := int(self.N) * int(self.L) + int(unsafe.Sizeof(self.L)) + int(unsafe.Sizeof(self.N))
+    return BytesFrom(unsafe.Pointer(self), size, size), nil
+}
+
+var (
+    byteType = UnpackEface(byte(0)).Type
+)
+
+const (
+    _StackMapSize = unsafe.Sizeof(StackMap{})
+)
+
+//go:linkname mallocgc runtime.mallocgc
+//goland:noinspection GoUnusedParameter
+func mallocgc(nb uintptr, vt *GoType, zero bool) unsafe.Pointer
+
+type StackMapBuilder struct {
+    b Bitmap
+}
+
+func (self *StackMapBuilder) Build() (p *StackMap) {
+    nb := len(self.b.B)
+    bm := mallocgc(_StackMapSize + uintptr(nb) - 1, byteType, false)
+
+    /* initialize as 1 bitmap of N bits */
+    p = (*StackMap)(bm)
+    p.N, p.L = 1, int32(self.b.N)
+    copy(BytesFrom(unsafe.Pointer(&p.B), nb, nb), self.b.B)
+    return
+}
+
+func (self *StackMapBuilder) AddField(ptr bool) {
+    if ptr {
+        self.b.Append(1)
+    } else {
+        self.b.Append(0)
+    }
+}
+
+func (self *StackMapBuilder) AddFields(n int, ptr bool) {
+    if ptr {
+        self.b.AppendMany(n, 1)
+    } else {
+        self.b.AppendMany(n, 0)
+    }
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/introduction-1.png b/vendor/github.com/bytedance/sonic/introduction-1.png
new file mode 100644
index 000000000..3a2845ec6
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/introduction-1.png
diff --git a/vendor/github.com/bytedance/sonic/introduction-2.png b/vendor/github.com/bytedance/sonic/introduction-2.png
new file mode 100644
index 000000000..25b16638c
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/introduction-2.png
diff --git a/vendor/github.com/bytedance/sonic/loader/funcdata.go b/vendor/github.com/bytedance/sonic/loader/funcdata.go
new file mode 100644
index 000000000..9b760f615
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/loader/funcdata.go
@@ -0,0 +1,144 @@
+/**
+ * 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 loader
+
+import (
+    `encoding`
+    `encoding/binary`
+    `fmt`
+    `reflect`
+    `strings`
+    `sync`
+    `unsafe`
+)
+
+const (
+    _MinLC uint8 = 1
+    _PtrSize uint8 = 8
+)
+
+const (
+    _N_FUNCDATA = 8
+    _INVALID_FUNCDATA_OFFSET = ^uint32(0)
+    _FUNC_SIZE = unsafe.Sizeof(_func{})
+    
+    _MINFUNC = 16 // minimum size for a function
+    _BUCKETSIZE    = 256 * _MINFUNC
+    _SUBBUCKETS    = 16
+    _SUB_BUCKETSIZE = _BUCKETSIZE / _SUBBUCKETS
+)
+
+// PCDATA and FUNCDATA table indexes.
+//
+// See funcdata.h and $GROOT/src/cmd/internal/objabi/funcdata.go.
+const (
+    _FUNCDATA_ArgsPointerMaps    = 0
+    _FUNCDATA_LocalsPointerMaps  = 1
+    _FUNCDATA_StackObjects       = 2
+    _FUNCDATA_InlTree            = 3
+    _FUNCDATA_OpenCodedDeferInfo = 4
+    _FUNCDATA_ArgInfo            = 5
+    _FUNCDATA_ArgLiveInfo        = 6
+    _FUNCDATA_WrapInfo           = 7
+
+    // ArgsSizeUnknown is set in Func.argsize to mark all functions
+    // whose argument size is unknown (C vararg functions, and
+    // assembly code without an explicit specification).
+    // This value is generated by the compiler, assembler, or linker.
+    ArgsSizeUnknown = -0x80000000
+)
+
+// moduledata used to cache the funcdata and findfuncbucket of one module
+var moduleCache = struct {
+    m map[*moduledata][]byte
+    sync.Mutex
+}{
+    m: make(map[*moduledata][]byte),
+}
+
+// Func contains information about a function.
+type Func struct {
+    ID          uint8  // see runtime/symtab.go
+    Flag        uint8  // see runtime/symtab.go
+    ArgsSize    int32  // args byte size
+    EntryOff    uint32 // start pc, offset to moduledata.text
+    TextSize    uint32 // size of func text
+    DeferReturn uint32 // offset of start of a deferreturn call instruction from entry, if any.
+    FileIndex   uint32 // index into filetab 
+    Name        string // name of function
+
+    // PC data
+    Pcsp            *Pcdata // PC -> SP delta
+    Pcfile          *Pcdata // PC -> file index
+    Pcline          *Pcdata // PC -> line number
+    PcUnsafePoint   *Pcdata // PC -> unsafe point, must be PCDATA_UnsafePointSafe or PCDATA_UnsafePointUnsafe
+    PcStackMapIndex *Pcdata // PC -> stack map index, relative to ArgsPointerMaps and LocalsPointerMaps
+    PcInlTreeIndex  *Pcdata // PC -> inlining tree index, relative to InlTree
+    PcArgLiveIndex  *Pcdata // PC -> arg live index, relative to ArgLiveInfo
+    
+    // Func data, must implement encoding.BinaryMarshaler
+    ArgsPointerMaps    encoding.BinaryMarshaler // concrete type: *StackMap
+    LocalsPointerMaps  encoding.BinaryMarshaler // concrete type: *StackMap
+    StackObjects       encoding.BinaryMarshaler
+    InlTree            encoding.BinaryMarshaler
+    OpenCodedDeferInfo encoding.BinaryMarshaler
+    ArgInfo            encoding.BinaryMarshaler
+    ArgLiveInfo        encoding.BinaryMarshaler
+    WrapInfo           encoding.BinaryMarshaler
+}
+
+func getOffsetOf(data interface{}, field string) uintptr {
+    t := reflect.TypeOf(data)
+    fv, ok := t.FieldByName(field)
+    if !ok {
+        panic(fmt.Sprintf("field %s not found in struct %s", field, t.Name()))
+    }
+    return fv.Offset
+}
+
+func rnd(v int64, r int64) int64 {
+    if r <= 0 {
+        return v
+    }
+    v += r - 1
+    c := v % r
+    if c < 0 {
+        c += r
+    }
+    v -= c
+    return v
+}
+
+var (
+    byteOrder binary.ByteOrder = binary.LittleEndian
+)
+
+func funcNameParts(name string) (string, string, string) {
+    i := strings.IndexByte(name, '[')
+    if i < 0 {
+        return name, "", ""
+    }
+    // TODO: use LastIndexByte once the bootstrap compiler is >= Go 1.5.
+    j := len(name) - 1
+    for j > i && name[j] != ']' {
+        j--
+    }
+    if j <= i {
+        return name, "", ""
+    }
+    return name[:i], "[...]", name[j+1:]
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/loader/funcdata_go115.go b/vendor/github.com/bytedance/sonic/loader/funcdata_go115.go
new file mode 100644
index 000000000..f35f03d56
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/loader/funcdata_go115.go
@@ -0,0 +1,541 @@
+// go:build go1.15 && !go1.18
+// +build go1.15,!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 = 0xfffffff0
+)
+
+type pcHeader struct {
+    magic          uint32  // 0xFFFFFFF0
+    pad1, pad2     uint8   // 0,0
+    minLC          uint8   // min instruction size
+    ptrSize        uint8   // size of a ptr in bytes
+    nfunc          int     // number of functions in the module
+    nfiles         uint    // number of entries in the file tab
+    textStart      uintptr // base for function entry PC offsets in this module, equal to moduledata.text
+    funcnameOffset uintptr // offset to the funcnametab variable from pcHeader
+    cuOffset       uintptr // offset to the cutab variable from pcHeader
+    filetabOffset  uintptr // offset to the filetab variable from pcHeader
+    pctabOffset    uintptr // offset to the pctab variable from pcHeader
+    pclnOffset     uintptr // offset to the pclntab variable from pcHeader
+}
+
+type 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
+    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
+
+    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 {
+    entryOff uint32 // 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
+    flag      uint8
+    _         [1]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   uint32
+    funcoff uint32
+}
+
+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
+}
+
+// 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
+}
+
+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]
+//  ...
+//
+// 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) {
+    // 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, f := range funcs {
+        size = rnd(size, int64(_PtrSize))
+        //writePCToFunc
+        startLocations[i] = uint32(size)
+        size += int64(uint8(_FUNC_SIZE)+f.nfuncdata*4+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])})
+    }
+
+    // Final entry of table is just end pc offset.
+    lastFunc := funcs[len(funcs)-1]
+    ftab = append(ftab, funcTab{uint32(lastFunc.entryOff + 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)
+    }
+
+    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
+    }
+    // Final entry of table is just end pc offset.
+    lastFunc := funcs[len(funcs)-1]
+    byteOrder.PutUint32(pclntab[offs:offs+4], uint32(lastFunc.entryOff+lastFuncSize))
+
+    // 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)
+
+        // 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
+        }
+
+        // funcdata refs as offsets from gofunc
+        for _, funcdata := range funcdataOffs[i] {
+            byteOrder.PutUint32(pclntab[off:off+4], uint32(funcdata))
+            off += 4
+        }
+
+    }
+
+    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 + uint32((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)
+            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
+
+    // make pcdata table
+    // NOTICE: _func only use offset to index pcdata, thus no need mmap() pcdata 
+    pctab, pcdataOffs, _funcs := makePctab(funcs, 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 := makeFtab(_funcs, lastFuncsize)
+    mod.ftab = ftab
+
+    // write pc->func (modmap) findfunc table
+    ffstart := writeFindfunctab(&cache, ftab)
+
+    // make pclnt table
+    pclntab := makePclntable(_funcs, lastFuncsize, pcdataOffs, 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,
+        minLC   : _MinLC,
+        ptrSize : _PtrSize,
+        nfunc   : len(funcs),
+        nfiles: uint(len(cu)),
+        textStart: mod.text,
+        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, 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.entryOff = 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.flag = f.Flag
+        _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/funcdata_go118.go b/vendor/github.com/bytedance/sonic/loader/funcdata_go118.go
new file mode 100644
index 000000000..a2bac857a
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/loader/funcdata_go118.go
@@ -0,0 +1,541 @@
+// go:build go1.18 && !go1.20
+// +build go1.18,!go1.20
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package loader
+
+import (
+    `encoding`
+    `os`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+const (
+    _Magic uint32 = 0xfffffff0
+)
+
+type pcHeader struct {
+    magic          uint32  // 0xFFFFFFF0
+    pad1, pad2     uint8   // 0,0
+    minLC          uint8   // min instruction size
+    ptrSize        uint8   // size of a ptr in bytes
+    nfunc          int     // number of functions in the module
+    nfiles         uint    // number of entries in the file tab
+    textStart      uintptr // base for function entry PC offsets in this module, equal to moduledata.text
+    funcnameOffset uintptr // offset to the funcnametab variable from pcHeader
+    cuOffset       uintptr // offset to the cutab variable from pcHeader
+    filetabOffset  uintptr // offset to the filetab variable from pcHeader
+    pctabOffset    uintptr // offset to the pctab variable from pcHeader
+    pclnOffset     uintptr // offset to the pclntab variable from pcHeader
+}
+
+type 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
+    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
+
+    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 {
+    entryOff uint32 // 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
+    flag      uint8
+    _         [1]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   uint32
+    funcoff uint32
+}
+
+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
+}
+
+// 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
+}
+
+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]
+//  ...
+//
+// 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) {
+    // 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, f := range funcs {
+        size = rnd(size, int64(_PtrSize))
+        //writePCToFunc
+        startLocations[i] = uint32(size)
+        size += int64(uint8(_FUNC_SIZE)+f.nfuncdata*4+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])})
+    }
+
+    // Final entry of table is just end pc offset.
+    lastFunc := funcs[len(funcs)-1]
+    ftab = append(ftab, funcTab{uint32(lastFunc.entryOff + 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)
+    }
+
+    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
+    }
+    // Final entry of table is just end pc offset.
+    lastFunc := funcs[len(funcs)-1]
+    byteOrder.PutUint32(pclntab[offs:offs+4], uint32(lastFunc.entryOff+lastFuncSize))
+
+    // 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)
+
+        // 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
+        }
+
+        // funcdata refs as offsets from gofunc
+        for _, funcdata := range funcdataOffs[i] {
+            byteOrder.PutUint32(pclntab[off:off+4], uint32(funcdata))
+            off += 4
+        }
+
+    }
+
+    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 + uint32((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)
+            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
+
+    // make pcdata table
+    // NOTICE: _func only use offset to index pcdata, thus no need mmap() pcdata 
+    pctab, pcdataOffs, _funcs := makePctab(funcs, 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 := makeFtab(_funcs, lastFuncsize)
+    mod.ftab = ftab
+
+    // write pc->func (modmap) findfunc table
+    ffstart := writeFindfunctab(&cache, ftab)
+
+    // make pclnt table
+    pclntab := makePclntable(_funcs, lastFuncsize, pcdataOffs, 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,
+        minLC   : _MinLC,
+        ptrSize : _PtrSize,
+        nfunc   : len(funcs),
+        nfiles: uint(len(cu)),
+        textStart: mod.text,
+        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, 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.entryOff = 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.flag = f.Flag
+        _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/funcdata_go120.go b/vendor/github.com/bytedance/sonic/loader/funcdata_go120.go
new file mode 100644
index 000000000..906fe375d
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/loader/funcdata_go120.go
@@ -0,0 +1,545 @@
+//go:build go1.20 && !go1.21
+// +build go1.20,!go1.21
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package loader
+
+import (
+    `encoding`
+    `os`
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+const (
+    _Magic uint32 = 0xFFFFFFF1
+)
+
+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
+    covctrs, ecovctrs     uintptr
+    end, gcdata, gcbss    uintptr
+    types, etypes         uintptr
+    rodata                uintptr
+
+    // TODO: generate funcinfo object to memory
+    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
+
+    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 {
+    entryOff uint32 // 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
+    startLine int32  // line number of start of function (func keyword/TEXT directive)
+    funcID    uint8 // set for certain special runtime functions
+    flag      uint8
+    _         [1]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   uint32
+    funcoff uint32
+}
+
+type pcHeader struct {
+    magic          uint32  // 0xFFFFFFF0
+    pad1, pad2     uint8   // 0,0
+    minLC          uint8   // min instruction size
+    ptrSize        uint8   // size of a ptr in bytes
+    nfunc          int     // number of functions in the module
+    nfiles         uint    // number of entries in the file tab
+    textStart      uintptr // base for function entry PC offsets in this module, equal to moduledata.text
+    funcnameOffset uintptr // offset to the funcnametab variable from pcHeader
+    cuOffset       uintptr // offset to the cutab variable from pcHeader
+    filetabOffset  uintptr // offset to the filetab variable from pcHeader
+    pctabOffset    uintptr // offset to the pctab variable from pcHeader
+    pclnOffset     uintptr // offset to the pclntab variable from pcHeader
+}
+
+type bitVector struct {
+    n        int32 // # of bits
+    bytedata *uint8
+}
+
+type ptabEntry struct {
+    name int32
+    typ  int32
+}
+
+type textSection struct {
+    vaddr    uintptr // prelinked section vaddr
+    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
+}
+
+// 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
+}
+
+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]
+//  ...
+//
+// 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) {
+    // 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, f := range funcs {
+        size = rnd(size, int64(_PtrSize))
+        //writePCToFunc
+        startLocations[i] = uint32(size)
+        size += int64(uint8(_FUNC_SIZE)+f.nfuncdata*4+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])})
+    }
+
+    // Final entry of table is just end pc offset.
+    lastFunc := funcs[len(funcs)-1]
+    ftab = append(ftab, funcTab{uint32(lastFunc.entryOff + 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)
+    }
+
+    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
+    }
+    // Final entry of table is just end pc offset.
+    lastFunc := funcs[len(funcs)-1]
+    byteOrder.PutUint32(pclntab[offs:offs+4], uint32(lastFunc.entryOff+lastFuncSize))
+
+    // 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)
+
+        // 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
+        }
+
+        // funcdata refs as offsets from gofunc
+        for _, funcdata := range funcdataOffs[i] {
+            byteOrder.PutUint32(pclntab[off:off+4], uint32(funcdata))
+            off += 4
+        }
+
+    }
+
+    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 + uint32((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)
+            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
+
+    // make pcdata table
+    // NOTICE: _func only use offset to index pcdata, thus no need mmap() pcdata 
+    pctab, pcdataOffs, _funcs := makePctab(funcs, 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 := makeFtab(_funcs, lastFuncsize)
+    mod.ftab = ftab
+
+    // write pc->func (modmap) findfunc table
+    ffstart := writeFindfunctab(&cache, ftab)
+
+    // make pclnt table
+    pclntab := makePclntable(_funcs, lastFuncsize, pcdataOffs, 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,
+        minLC   : _MinLC,
+        ptrSize : _PtrSize,
+        nfunc   : len(funcs),
+        nfiles: uint(len(cu)),
+        textStart: mod.text,
+        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, 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.entryOff = 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.flag = f.Flag
+        _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.go b/vendor/github.com/bytedance/sonic/loader/loader.go
new file mode 100644
index 000000000..929d8c23d
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/loader/loader.go
@@ -0,0 +1,37 @@
+/**
+ * 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 loader
+
+import (
+    `unsafe`
+)
+
+// Function is a function pointer
+type Function unsafe.Pointer
+
+// Options used to load a module
+type Options struct {
+    // NoPreempt is used to disable async preemption for this module
+    NoPreempt bool
+}
+
+// Loader is a helper used to load a module simply
+type Loader struct {
+    Name string // module name
+    File string // file name
+    Options 
+}
\ 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
new file mode 100644
index 000000000..1e44b36a6
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/loader/loader_go115.go
@@ -0,0 +1,33 @@
+//go:build go1.15 && !go1.18
+// +build go1.15,!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 (
+
+    `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_go118.go
new file mode 100644
index 000000000..9a0fe4843
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/loader/loader_go118.go
@@ -0,0 +1,104 @@
+//go:build go1.18 && !go1.21
+// +build go1.18,!go1.21
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package loader
+
+import (
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+// LoadFuncs loads only one function as module, and returns the function pointer
+//   - text: machine code
+//   - funcName: function name
+//   - frameSize: stack frame size. 
+//   - argSize: argument total size (in bytes)
+//   - argPtrs: indicates if a slot (8 Bytes) of arguments memory stores pointer, from low to high
+//   - localPtrs: indicates if a slot (8 Bytes) of local variants memory stores pointer, from low to high
+// 
+// WARN: 
+//   - the function MUST has fixed SP offset equaling to this, otherwise it go.gentraceback will fail
+//   - the function MUST has only one stack map for all arguments and local variants
+func (self Loader) LoadOne(text []byte, funcName string, frameSize int, argSize int, argPtrs []bool, localPtrs []bool) Function {
+    size := uint32(len(text))
+
+    fn := Func{
+        Name: funcName,
+        TextSize: size,
+        ArgsSize: int32(argSize),
+    }
+
+    // NOTICE: suppose the function has fixed SP offset equaling to frameSize, thus make only one pcsp pair
+    fn.Pcsp = &Pcdata{
+        {PC: size, Val: int32(frameSize)},
+    }
+
+    if self.NoPreempt {
+        fn.PcUnsafePoint = &Pcdata{
+            {PC: size, Val: PCDATA_UnsafePointUnsafe},
+        }
+    } else {
+        fn.PcUnsafePoint = &Pcdata{
+            {PC: size, Val: PCDATA_UnsafePointSafe},
+        }
+    }
+
+    // NOTICE: suppose the function has only one stack map at index 0
+    fn.PcStackMapIndex = &Pcdata{
+        {PC: size, Val: 0},
+    }
+
+    if argPtrs != nil {
+        args := rt.StackMapBuilder{}
+        for _, b := range argPtrs {
+            args.AddField(b)
+        }
+        fn.ArgsPointerMaps = args.Build()
+    }
+    
+    if localPtrs != nil {
+        locals := rt .StackMapBuilder{}
+        for _, b := range localPtrs {
+            locals.AddField(b)
+        }
+        fn.LocalsPointerMaps = locals.Build()
+    }
+
+    out := Load(text, []Func{fn}, self.Name + funcName, []string{self.File})
+    return out[0]
+}
+
+// Load loads given machine codes and corresponding function information into go moduledata
+// and returns runnable function pointer
+// WARN: this API is experimental, use it carefully
+func Load(text []byte, funcs []Func, modulename string, filenames []string) (out []Function) {
+    // generate module data and allocate memory address
+    mod := makeModuledata(modulename, filenames, funcs, text)
+
+    // verify and register the new module
+    moduledataverify1(mod)
+    registerModule(mod)
+
+    // encapsulate function address
+    out = make([]Function, len(funcs))
+    for i, f := range funcs {
+        m := uintptr(mod.text + uintptr(f.EntryOff))
+        out[i] = Function(&m)
+    }
+    return 
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/loader/mmap_unix.go b/vendor/github.com/bytedance/sonic/loader/mmap_unix.go
new file mode 100644
index 000000000..50b80bf20
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/loader/mmap_unix.go
@@ -0,0 +1,45 @@
+//go:build darwin || linux
+// +build darwin linux
+
+/**
+ * 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 loader
+
+import (
+    `syscall`
+)
+
+const (
+    _AP = syscall.MAP_ANON  | syscall.MAP_PRIVATE
+    _RX = syscall.PROT_READ | syscall.PROT_EXEC
+    _RW = syscall.PROT_READ | syscall.PROT_WRITE
+)
+
+
+func mmap(nb int) uintptr {
+    if m, _, e := syscall.RawSyscall6(syscall.SYS_MMAP, 0, uintptr(nb), _RW, _AP, 0, 0); e != 0 {
+        panic(e)
+    } else {
+        return m
+    }
+}
+
+func mprotect(p uintptr, nb int) {
+    if _, _, err := syscall.RawSyscall(syscall.SYS_MPROTECT, p, uintptr(nb), _RX); err != 0 {
+        panic(err)
+    }
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/loader/mmap_windows.go b/vendor/github.com/bytedance/sonic/loader/mmap_windows.go
new file mode 100644
index 000000000..1760a7117
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/loader/mmap_windows.go
@@ -0,0 +1,84 @@
+//go:build windows
+// +build windows
+
+// build
+
+/*
+ * 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 (
+    `syscall`
+    `unsafe`
+)
+
+const (
+    MEM_COMMIT  = 0x00001000
+    MEM_RESERVE = 0x00002000
+)
+
+var (
+    libKernel32                = syscall.NewLazyDLL("KERNEL32.DLL")
+    libKernel32_VirtualAlloc   = libKernel32.NewProc("VirtualAlloc")
+    libKernel32_VirtualProtect = libKernel32.NewProc("VirtualProtect")
+)
+
+func mmap(nb int) uintptr {
+    addr, err := winapi_VirtualAlloc(0, nb, MEM_COMMIT|MEM_RESERVE, syscall.PAGE_READWRITE)
+    if err != nil {
+        panic(err)
+    }
+    return addr
+}
+
+func mprotect(p uintptr, nb int) (oldProtect int) {
+    err := winapi_VirtualProtect(p, nb, syscall.PAGE_EXECUTE_READ, &oldProtect)
+    if err != nil {
+        panic(err)
+    }
+    return
+}
+
+// winapi_VirtualAlloc allocate memory
+// Doc: https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc
+func winapi_VirtualAlloc(lpAddr uintptr, dwSize int, flAllocationType int, flProtect int) (uintptr, error) {
+    r1, _, err := libKernel32_VirtualAlloc.Call(
+        lpAddr,
+        uintptr(dwSize),
+        uintptr(flAllocationType),
+        uintptr(flProtect),
+    )
+    if r1 == 0 {
+        return 0, err
+    }
+    return r1, nil
+}
+
+// winapi_VirtualProtect change memory protection
+// Doc: https://docs.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualprotect
+func winapi_VirtualProtect(lpAddr uintptr, dwSize int, flNewProtect int, lpflOldProtect *int) error {
+    r1, _, err := libKernel32_VirtualProtect.Call(
+        lpAddr,
+        uintptr(dwSize),
+        uintptr(flNewProtect),
+        uintptr(unsafe.Pointer(lpflOldProtect)),
+    )
+    if r1 == 0 {
+        return err
+    }
+    return nil
+}
diff --git a/vendor/github.com/bytedance/sonic/loader/pcdata.go b/vendor/github.com/bytedance/sonic/loader/pcdata.go
new file mode 100644
index 000000000..b5c62d17b
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/loader/pcdata.go
@@ -0,0 +1,100 @@
+/**
+ * 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 loader
+
+const (
+    _N_PCDATA   = 4
+
+    _PCDATA_UnsafePoint   = 0
+    _PCDATA_StackMapIndex = 1
+    _PCDATA_InlTreeIndex  = 2
+    _PCDATA_ArgLiveIndex  = 3
+
+    _PCDATA_INVALID_OFFSET = 0
+)
+
+const (
+    // PCDATA_UnsafePoint values.
+    PCDATA_UnsafePointSafe   = -1 // Safe for async preemption
+    PCDATA_UnsafePointUnsafe = -2 // Unsafe for async preemption
+
+    // PCDATA_Restart1(2) apply on a sequence of instructions, within
+    // which if an async preemption happens, we should back off the PC
+    // to the start of the sequence when resume.
+    // We need two so we can distinguish the start/end of the sequence
+    // in case that two sequences are next to each other.
+    PCDATA_Restart1 = -3
+    PCDATA_Restart2 = -4
+
+    // Like PCDATA_RestartAtEntry, but back to function entry if async
+    // preempted.
+    PCDATA_RestartAtEntry = -5
+
+    _PCDATA_START_VAL = -1
+)
+
+var emptyByte byte
+
+func encodeValue(v int) []byte {
+    return encodeVariant(toZigzag(v))
+}
+
+func toZigzag(v int) int {
+    return (v << 1) ^ (v >> 31)
+}
+
+func encodeVariant(v int) []byte {
+    var u int
+    var r []byte
+
+    /* split every 7 bits */
+    for v > 127 {
+        u = v & 0x7f
+        v = v >> 7
+        r = append(r, byte(u) | 0x80)
+    }
+
+    /* check for last one */
+    if v == 0 {
+        return r
+    }
+
+    /* add the last one */
+    r = append(r, byte(v))
+    return r
+}
+
+type Pcvalue struct {
+    PC  uint32 // PC offset from func entry
+    Val int32
+}
+
+type Pcdata []Pcvalue
+
+// see https://docs.google.com/document/d/1lyPIbmsYbXnpNj57a261hgOYVpNRcgydurVQIyZOz_o/pub
+func (self Pcdata) MarshalBinary() (data []byte, err error) {
+    // delta value always starts from -1
+    sv := int32(_PCDATA_START_VAL)
+    sp := uint32(0)
+    for _, v := range self {
+        data = append(data, encodeVariant(toZigzag(int(v.Val - sv)))...)
+        data = append(data, encodeVariant(int(v.PC - sp))...)
+        sp = v.PC
+        sv = v.Val
+    }
+    return
+}
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/loader/stubs.go b/vendor/github.com/bytedance/sonic/loader/stubs.go
new file mode 100644
index 000000000..71439c4b7
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/loader/stubs.go
@@ -0,0 +1,35 @@
+/**
+ * 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 loader
+
+import (
+	_ `unsafe`
+)
+
+//go:linkname lastmoduledatap runtime.lastmoduledatap
+//goland:noinspection GoUnusedGlobalVariable
+var lastmoduledatap *moduledata
+
+func registerModule(mod *moduledata) {
+    lastmoduledatap.next = mod
+    lastmoduledatap = mod
+}
+
+//go:linkname moduledataverify1 runtime.moduledataverify1
+func moduledataverify1(_ *moduledata)
+
+
diff --git a/vendor/github.com/bytedance/sonic/option/option.go b/vendor/github.com/bytedance/sonic/option/option.go
new file mode 100644
index 000000000..359f99206
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/option/option.go
@@ -0,0 +1,78 @@
+/*
+ * 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 option
+
+// CompileOptions includes all options for encoder or decoder compiler.
+type CompileOptions struct {
+    // the maximum depth for compilation inline
+    MaxInlineDepth int
+
+    // the loop times for recursively pretouch
+    RecursiveDepth int
+}
+
+var (
+    // Default value(3) means the compiler only inline 3 layers of nested struct. 
+    // when the depth exceeds, the compiler will recurse 
+    // and compile subsequent structs when they are decoded 
+    DefaultMaxInlineDepth = 3
+
+    // Default value(1) means `Pretouch()` will be recursively executed once,
+    // if any nested struct is left (depth exceeds MaxInlineDepth)
+    DefaultRecursiveDepth = 1
+)
+
+// DefaultCompileOptions set default compile options.
+func DefaultCompileOptions() CompileOptions {
+    return CompileOptions{
+        RecursiveDepth: DefaultRecursiveDepth,
+        MaxInlineDepth: DefaultMaxInlineDepth,
+    }
+}
+
+// CompileOption is a function used to change DefaultCompileOptions.
+type CompileOption func(o *CompileOptions)
+
+// WithCompileRecursiveDepth sets the loop times of recursive pretouch 
+// in both decoder and encoder,
+// for both concrete type and its pointer type.
+//
+// For deep nested struct (depth exceeds MaxInlineDepth), 
+// try to set more loops to completely compile, 
+// thus reduce JIT unstability in the first hit.
+func WithCompileRecursiveDepth(loop int) CompileOption {
+    return func(o *CompileOptions) {
+            if loop < 0 {
+                panic("loop must be >= 0")
+            }
+            o.RecursiveDepth = loop
+        }
+}
+
+// WithCompileMaxInlineDepth sets the max depth of inline compile 
+// in decoder and encoder.
+//
+// For large nested struct, try to set smaller depth to reduce compiling time.
+func WithCompileMaxInlineDepth(depth int) CompileOption {
+    return func(o *CompileOptions) {
+            if depth <= 0 {
+                panic("depth must be > 0")
+            }
+            o.MaxInlineDepth = depth
+        }
+}
+ 
\ No newline at end of file
diff --git a/vendor/github.com/bytedance/sonic/other-langs.png b/vendor/github.com/bytedance/sonic/other-langs.png
new file mode 100644
index 000000000..8aae25453
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/other-langs.png
diff --git a/vendor/github.com/bytedance/sonic/sonic.go b/vendor/github.com/bytedance/sonic/sonic.go
new file mode 100644
index 000000000..6cbb1ad41
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/sonic.go
@@ -0,0 +1,161 @@
+// +build amd64,go1.15,!go1.21
+
+/*
+ * Copyright 2021 ByteDance Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//go:generate make
+package sonic
+
+import (
+    `io`
+    `reflect`
+
+    `github.com/bytedance/sonic/decoder`
+    `github.com/bytedance/sonic/encoder`
+    `github.com/bytedance/sonic/option`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+type frozenConfig struct {
+    Config
+    encoderOpts encoder.Options
+    decoderOpts decoder.Options
+}
+
+// Froze convert the Config to API
+func (cfg Config) Froze() API {
+    api := &frozenConfig{Config: cfg}
+
+    // configure encoder options:
+    if cfg.EscapeHTML {
+        api.encoderOpts |= encoder.EscapeHTML
+    }
+    if cfg.SortMapKeys {
+        api.encoderOpts |= encoder.SortMapKeys
+    }
+    if cfg.CompactMarshaler {
+        api.encoderOpts |= encoder.CompactMarshaler
+    }
+    if cfg.NoQuoteTextMarshaler {
+        api.encoderOpts |= encoder.NoQuoteTextMarshaler
+    }
+    if cfg.NoNullSliceOrMap {
+        api.encoderOpts |= encoder.NoNullSliceOrMap
+    }
+    if cfg.ValidateString {
+        api.encoderOpts |= encoder.ValidateString
+    }
+
+    // configure decoder options:
+    if cfg.UseInt64 {
+        api.decoderOpts |= decoder.OptionUseInt64
+    }
+    if cfg.UseNumber {
+        api.decoderOpts |= decoder.OptionUseNumber
+    }
+    if cfg.DisallowUnknownFields {
+        api.decoderOpts |= decoder.OptionDisableUnknown
+    }
+    if cfg.CopyString {
+        api.decoderOpts |= decoder.OptionCopyString
+    }
+    if cfg.ValidateString {
+        api.decoderOpts |= decoder.OptionValidateString
+    }
+    return api
+}
+
+// Marshal is implemented by sonic
+func (cfg frozenConfig) Marshal(val interface{}) ([]byte, error) {
+    return encoder.Encode(val, cfg.encoderOpts)
+}
+
+// MarshalToString is implemented by sonic
+func (cfg frozenConfig) MarshalToString(val interface{}) (string, error) {
+    buf, err := encoder.Encode(val, cfg.encoderOpts)
+    return rt.Mem2Str(buf), err
+}
+
+// MarshalIndent is implemented by sonic
+func (cfg frozenConfig) MarshalIndent(val interface{}, prefix, indent string) ([]byte, error) {
+    return encoder.EncodeIndented(val, prefix, indent, cfg.encoderOpts)
+}
+
+// UnmarshalFromString is implemented by sonic
+func (cfg frozenConfig) UnmarshalFromString(buf string, val interface{}) error {
+    dec := decoder.NewDecoder(buf)
+    dec.SetOptions(cfg.decoderOpts)
+    err := dec.Decode(val)
+
+    /* check for errors */
+    if err != nil {
+        return err
+    }
+
+    return dec.CheckTrailings()
+}
+
+// Unmarshal is implemented by sonic
+func (cfg frozenConfig) Unmarshal(buf []byte, val interface{}) error {
+    return cfg.UnmarshalFromString(string(buf), val)
+}
+
+// NewEncoder is implemented by sonic
+func (cfg frozenConfig) NewEncoder(writer io.Writer) Encoder {
+    enc := encoder.NewStreamEncoder(writer)
+    enc.Opts = cfg.encoderOpts
+    return enc
+}
+
+// NewDecoder is implemented by sonic
+func (cfg frozenConfig) NewDecoder(reader io.Reader) Decoder {
+    dec := decoder.NewStreamDecoder(reader)
+    dec.SetOptions(cfg.decoderOpts)
+    return dec
+}
+
+// Valid is implemented by sonic
+func (cfg frozenConfig) Valid(data []byte) bool {
+    ok, _ := encoder.Valid(data)
+    return ok
+}
+
+// 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 {
+	if err := encoder.Pretouch(vt, opts...); err != nil {
+	    return err
+	} 
+	if err := decoder.Pretouch(vt, opts...); err != nil {
+		return err
+	}
+	// to pretouch the corresponding pointer type as well
+	if vt.Kind() == reflect.Ptr {
+		vt = vt.Elem()
+	} else {
+		vt = reflect.PtrTo(vt)
+	}
+	if err := encoder.Pretouch(vt, opts...); err != nil {
+	    return err
+	} 
+	if err := decoder.Pretouch(vt, opts...); err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/vendor/github.com/bytedance/sonic/unquote/unquote.go b/vendor/github.com/bytedance/sonic/unquote/unquote.go
new file mode 100644
index 000000000..0ffdaac7d
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/unquote/unquote.go
@@ -0,0 +1,56 @@
+/*
+ * 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 unquote
+
+import (
+    `unsafe`
+
+    `github.com/bytedance/sonic/internal/native`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/rt`
+)
+
+func String(s string) (ret string, err types.ParsingError) {
+    mm := make([]byte, 0, len(s))
+    err = intoBytesUnsafe(s, &mm)
+    ret = rt.Mem2Str(mm)
+    return
+}
+
+func IntoBytes(s string, m *[]byte) types.ParsingError {
+    if cap(*m) < len(s) {
+        return types.ERR_EOF
+    } else {
+        return intoBytesUnsafe(s, m)
+    }
+}
+
+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)
+
+    /* check for errors */
+    if ret < 0 {
+        return types.ParsingError(-ret)
+    }
+
+    /* update the length */
+    slv.Len = ret
+    return 0
+}
diff --git a/vendor/github.com/bytedance/sonic/utf8/utf8.go b/vendor/github.com/bytedance/sonic/utf8/utf8.go
new file mode 100644
index 000000000..59d2caefe
--- /dev/null
+++ b/vendor/github.com/bytedance/sonic/utf8/utf8.go
@@ -0,0 +1,71 @@
+/*
+ * 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 utf8
+
+import (
+    `github.com/bytedance/sonic/internal/rt`
+    `github.com/bytedance/sonic/internal/native/types`
+    `github.com/bytedance/sonic/internal/native`
+)
+
+// CorrectWith corrects the invalid utf8 byte with repl string.
+func CorrectWith(dst []byte, src []byte, repl string) []byte {
+    sstr := rt.Mem2Str(src)
+    sidx := 0
+
+    /* state machine records the invalid postions */
+    m := types.NewStateMachine()
+    m.Sp = 0 // invalid utf8 numbers
+
+    for sidx < len(sstr) {
+        scur  := sidx
+        ecode := native.ValidateUTF8(&sstr, &sidx, m)
+
+        if m.Sp != 0 {
+            if m.Sp > len(sstr) {
+                panic("numbers of invalid utf8 exceed the string len!")
+            }
+        }
+        
+        for i := 0; i < m.Sp; i++ {
+            ipos := m.Vt[i] // invalid utf8 position
+            dst  = append(dst, sstr[scur:ipos]...)
+            dst  = append(dst, repl...)
+            scur = m.Vt[i] + 1
+        }
+        /* append the remained valid utf8 bytes */
+        dst = append(dst, sstr[scur:sidx]...)
+
+        /* not enough space, reset and continue */
+        if ecode != 0 {
+            m.Sp = 0
+        }
+    }
+
+    types.FreeStateMachine(m)
+    return dst
+}
+
+// Validate is a simd-accelereated drop-in replacement for the standard library's utf8.Valid.
+func Validate(src []byte) bool {
+    return ValidateString(rt.Mem2Str(src))
+}
+
+// ValidateString as Validate, but for string.
+func ValidateString(src string) bool {
+    return native.ValidateUTF8Fast(&src) == 0
+}
\ No newline at end of file
diff --git a/vendor/github.com/chenzhuoyu/base64x/.gitignore b/vendor/github.com/chenzhuoyu/base64x/.gitignore
new file mode 100644
index 000000000..a2fd30e98
--- /dev/null
+++ b/vendor/github.com/chenzhuoyu/base64x/.gitignore
@@ -0,0 +1,43 @@
+*.o
+*.swp
+*.swm
+*.swn
+*.a
+*.so
+_obj
+_test
+*.[568vq]
+[568vq].out
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+_testmain.go
+*.exe
+*.exe~
+*.test
+*.prof
+*.rar
+*.zip
+*.gz
+*.psd
+*.bmd
+*.cfg
+*.pptx
+*.log
+*nohup.out
+*settings.pyc
+*.sublime-project
+*.sublime-workspace
+.DS_Store
+/.idea/
+/.vscode/
+/output/
+/vendor/
+/Gopkg.lock
+/Gopkg.toml
+coverage.html
+coverage.out
+coverage.xml
+junit.xml
diff --git a/vendor/github.com/chenzhuoyu/base64x/.gitmodules b/vendor/github.com/chenzhuoyu/base64x/.gitmodules
new file mode 100644
index 000000000..b8d11c921
--- /dev/null
+++ b/vendor/github.com/chenzhuoyu/base64x/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "tools/asm2asm"]
+	path = tools/asm2asm
+	url = https://github.com/chenzhuoyu/asm2asm
diff --git a/vendor/github.com/chenzhuoyu/base64x/LICENSE b/vendor/github.com/chenzhuoyu/base64x/LICENSE
new file mode 100644
index 000000000..261eeb9e9
--- /dev/null
+++ b/vendor/github.com/chenzhuoyu/base64x/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
diff --git a/vendor/github.com/chenzhuoyu/base64x/Makefile b/vendor/github.com/chenzhuoyu/base64x/Makefile
new file mode 100644
index 000000000..436d8bafd
--- /dev/null
+++ b/vendor/github.com/chenzhuoyu/base64x/Makefile
@@ -0,0 +1,28 @@
+.PHONY: all clean
+
+CFLAGS := -mavx
+CFLAGS += -mavx2
+CFLAGS += -mno-bmi
+CFLAGS += -mno-red-zone
+CFLAGS += -fno-asynchronous-unwind-tables
+CFLAGS += -fno-stack-protector
+CFLAGS += -fno-exceptions
+CFLAGS += -fno-builtin
+CFLAGS += -fno-rtti
+CFLAGS += -nostdlib
+CFLAGS += -O3
+
+NATIVE_ASM := $(wildcard native/*.S)
+NATIVE_SRC := $(wildcard native/*.h)
+NATIVE_SRC += $(wildcard native/*.c)
+
+all: native_amd64.s
+
+clean:
+	rm -vf native_amd64.s output/*.s
+
+native_amd64.s: ${NATIVE_SRC} ${NATIVE_ASM} native_amd64.go
+	mkdir -p output
+	clang ${CFLAGS} -S -o output/native.s native/native.c
+	python3 tools/asm2asm/asm2asm.py native_amd64.s output/native.s ${NATIVE_ASM}
+	asmfmt -w native_amd64.s
diff --git a/vendor/github.com/chenzhuoyu/base64x/README.md b/vendor/github.com/chenzhuoyu/base64x/README.md
new file mode 100644
index 000000000..4a3a7c98a
--- /dev/null
+++ b/vendor/github.com/chenzhuoyu/base64x/README.md
@@ -0,0 +1,4 @@
+# base64x
+
+High performance drop-in replacement of the `encoding/base64` library.
+
diff --git a/vendor/github.com/chenzhuoyu/base64x/base64x.go b/vendor/github.com/chenzhuoyu/base64x/base64x.go
new file mode 100644
index 000000000..3d457176b
--- /dev/null
+++ b/vendor/github.com/chenzhuoyu/base64x/base64x.go
@@ -0,0 +1,157 @@
+package base64x
+
+import (
+    `encoding/base64`
+)
+
+// An Encoding is a radix 64 encoding/decoding scheme, defined by a
+// 64-character alphabet. The most common encoding is the "base64"
+// encoding defined in RFC 4648 and used in MIME (RFC 2045) and PEM
+// (RFC 1421).  RFC 4648 also defines an alternate encoding, which is
+// the standard encoding with - and _ substituted for + and /.
+type Encoding int
+
+const (
+    _MODE_URL  = 1 << 0
+    _MODE_RAW  = 1 << 1
+    _MODE_AVX2 = 1 << 2
+    _MODE_JSON = 1 << 3
+)
+
+// StdEncoding is the standard base64 encoding, as defined in
+// RFC 4648.
+const StdEncoding Encoding = 0
+
+// URLEncoding is the alternate base64 encoding defined in RFC 4648.
+// It is typically used in URLs and file names.
+const URLEncoding Encoding = _MODE_URL
+
+// RawStdEncoding is the standard raw, unpadded base64 encoding,
+// as defined in RFC 4648 section 3.2.
+//
+// This is the same as StdEncoding but omits padding characters.
+const RawStdEncoding Encoding = _MODE_RAW
+
+// RawURLEncoding is the unpadded alternate base64 encoding defined in RFC 4648.
+// It is typically used in URLs and file names.
+//
+// This is the same as URLEncoding but omits padding characters.
+const RawURLEncoding Encoding = _MODE_RAW | _MODE_URL
+
+// JSONStdEncoding is the StdEncoding and encoded as JSON string as RFC 8259.
+const JSONStdEncoding Encoding = _MODE_JSON;
+
+var (
+    archFlags = 0
+)
+
+/** Encoder Functions **/
+
+// Encode encodes src using the specified encoding, writing
+// EncodedLen(len(src)) bytes to out.
+//
+// The encoding pads the output to a multiple of 4 bytes,
+// so Encode is not appropriate for use on individual blocks
+// of a large data stream.
+//
+// If out is not large enough to contain the encoded result,
+// it will panic.
+func (self Encoding) Encode(out []byte, src []byte) {
+    if len(src) != 0 {
+        if buf := out[:0:len(out)]; self.EncodedLen(len(src)) <= len(out) {
+            self.EncodeUnsafe(&buf, src)
+        } else {
+            panic("encoder output buffer is too small")
+        }
+    }
+}
+
+// EncodeUnsafe behaves like Encode, except it does NOT check if
+// out is large enough to contain the encoded result.
+//
+// It will also update the length of out.
+func (self Encoding) EncodeUnsafe(out *[]byte, src []byte) {
+    __b64encode(out, &src, int(self) | archFlags)
+}
+
+// EncodeToString returns the base64 encoding of src.
+func (self Encoding) EncodeToString(src []byte) string {
+    nbs := len(src)
+    ret := make([]byte, 0, self.EncodedLen(nbs))
+
+    /* encode in native code */
+    self.EncodeUnsafe(&ret, src)
+    return mem2str(ret)
+}
+
+// EncodedLen returns the length in bytes of the base64 encoding
+// of an input buffer of length n.
+func (self Encoding) EncodedLen(n int) int {
+    if (self & _MODE_RAW) == 0 {
+        return (n + 2) / 3 * 4
+    } else {
+        return (n * 8 + 5) / 6
+    }
+}
+
+/** Decoder Functions **/
+
+// Decode decodes src using the encoding enc. It writes at most
+// DecodedLen(len(src)) bytes to out and returns the number of bytes
+// written. If src contains invalid base64 data, it will return the
+// number of bytes successfully written and base64.CorruptInputError.
+//
+// New line characters (\r and \n) are ignored.
+//
+// If out is not large enough to contain the encoded result,
+// it will panic.
+func (self Encoding) Decode(out []byte, src []byte) (int, error) {
+    if len(src) == 0 {
+        return 0, nil
+    } else if buf := out[:0:len(out)]; self.DecodedLen(len(src)) <= len(out) {
+        return self.DecodeUnsafe(&buf, src)
+    } else {
+        panic("decoder output buffer is too small")
+    }
+}
+
+// DecodeUnsafe behaves like Decode, except it does NOT check if
+// out is large enough to contain the decoded result.
+//
+// It will also update the length of out.
+func (self Encoding) DecodeUnsafe(out *[]byte, src []byte) (int, error) {
+    if n := __b64decode(out, mem2addr(src), len(src), int(self) | archFlags); n >= 0 {
+        return n, nil
+    } else {
+        return 0, base64.CorruptInputError(-n - 1)
+    }
+}
+
+// DecodeString returns the bytes represented by the base64 string s.
+func (self Encoding) DecodeString(s string) ([]byte, error) {
+    src := str2mem(s)
+    ret := make([]byte, 0, self.DecodedLen(len(s)))
+
+    /* decode into the allocated buffer */
+    if _, err := self.DecodeUnsafe(&ret, src); err != nil {
+        return nil, err
+    } else {
+        return ret, nil
+    }
+}
+
+// DecodedLen returns the maximum length in bytes of the decoded data
+// corresponding to n bytes of base64-encoded data.
+func (self Encoding) DecodedLen(n int) int {
+    if (self & _MODE_RAW) == 0 {
+        return n / 4 * 3
+    } else {
+        return n * 6 / 8
+    }
+}
+
+func init() {
+    if hasAVX2() {
+        archFlags = _MODE_AVX2
+    }
+}
diff --git a/vendor/github.com/chenzhuoyu/base64x/cpuid.go b/vendor/github.com/chenzhuoyu/base64x/cpuid.go
new file mode 100644
index 000000000..a768c768d
--- /dev/null
+++ b/vendor/github.com/chenzhuoyu/base64x/cpuid.go
@@ -0,0 +1,17 @@
+package base64x
+
+import (
+    `fmt`
+    `os`
+
+    `github.com/klauspost/cpuid/v2`
+)
+
+func hasAVX2() bool {
+    switch v := os.Getenv("B64X_MODE"); v {
+        case ""       : fallthrough
+        case "auto"   : return cpuid.CPU.Has(cpuid.AVX2)
+        case "noavx2" : return false
+        default       : panic(fmt.Sprintf("invalid mode: '%s', should be one of 'auto', 'noavx2'", v))
+    }
+}
\ No newline at end of file
diff --git a/vendor/github.com/chenzhuoyu/base64x/faststr.go b/vendor/github.com/chenzhuoyu/base64x/faststr.go
new file mode 100644
index 000000000..83b58ea1f
--- /dev/null
+++ b/vendor/github.com/chenzhuoyu/base64x/faststr.go
@@ -0,0 +1,23 @@
+package base64x
+
+import (
+    `reflect`
+    `unsafe`
+)
+
+func mem2str(v []byte) (s string) {
+    (*reflect.StringHeader)(unsafe.Pointer(&s)).Len  = (*reflect.SliceHeader)(unsafe.Pointer(&v)).Len
+    (*reflect.StringHeader)(unsafe.Pointer(&s)).Data = (*reflect.SliceHeader)(unsafe.Pointer(&v)).Data
+    return
+}
+
+func str2mem(s string) (v []byte) {
+    (*reflect.SliceHeader)(unsafe.Pointer(&v)).Cap  = (*reflect.StringHeader)(unsafe.Pointer(&s)).Len
+    (*reflect.SliceHeader)(unsafe.Pointer(&v)).Len  = (*reflect.StringHeader)(unsafe.Pointer(&s)).Len
+    (*reflect.SliceHeader)(unsafe.Pointer(&v)).Data = (*reflect.StringHeader)(unsafe.Pointer(&s)).Data
+    return
+}
+
+func mem2addr(v []byte) unsafe.Pointer {
+    return *(*unsafe.Pointer)(unsafe.Pointer(&v))
+}
diff --git a/vendor/github.com/chenzhuoyu/base64x/native_amd64.go b/vendor/github.com/chenzhuoyu/base64x/native_amd64.go
new file mode 100644
index 000000000..a6f95575a
--- /dev/null
+++ b/vendor/github.com/chenzhuoyu/base64x/native_amd64.go
@@ -0,0 +1,16 @@
+//go:generate make
+package base64x
+
+import (
+    `unsafe`
+)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __b64encode(out *[]byte, src *[]byte, mode int)
+
+//go:nosplit
+//go:noescape
+//goland:noinspection GoUnusedParameter
+func __b64decode(out *[]byte, src unsafe.Pointer, len int, mode int) (ret int)
diff --git a/vendor/github.com/chenzhuoyu/base64x/native_amd64.s b/vendor/github.com/chenzhuoyu/base64x/native_amd64.s
new file mode 100644
index 000000000..7f7a58720
--- /dev/null
+++ b/vendor/github.com/chenzhuoyu/base64x/native_amd64.s
@@ -0,0 +1,4416 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+#include "go_asm.h"
+#include "funcdata.h"
+#include "textflag.h"
+
+TEXT ·__native_entry__(SB), NOSPLIT, $0
+	NO_LOCAL_POINTERS
+	LONG $0xf9058d48; WORD $0xffff; BYTE $0xff // leaq         $-7(%rip), %rax
+	MOVQ AX, 8(SP)
+	RET
+
+LCPI0_0:
+	BYTE $0x47 // .byte 71
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xed // .byte 237
+	BYTE $0xf0 // .byte 240
+	BYTE $0x41 // .byte 65
+	BYTE $0x00 // .byte 0
+	BYTE $0x00 // .byte 0
+	BYTE $0x47 // .byte 71
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xed // .byte 237
+	BYTE $0xf0 // .byte 240
+	BYTE $0x41 // .byte 65
+	BYTE $0x00 // .byte 0
+	BYTE $0x00 // .byte 0
+
+LCPI0_1:
+	BYTE $0x47 // .byte 71
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xef // .byte 239
+	BYTE $0x20 // .byte 32
+	BYTE $0x41 // .byte 65
+	BYTE $0x00 // .byte 0
+	BYTE $0x00 // .byte 0
+	BYTE $0x47 // .byte 71
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xfc // .byte 252
+	BYTE $0xef // .byte 239
+	BYTE $0x20 // .byte 32
+	BYTE $0x41 // .byte 65
+	BYTE $0x00 // .byte 0
+	BYTE $0x00 // .byte 0
+
+LCPI0_2:
+	BYTE $0x01 // .byte 1
+	BYTE $0x00 // .byte 0
+	BYTE $0x02 // .byte 2
+	BYTE $0x01 // .byte 1
+	BYTE $0x04 // .byte 4
+	BYTE $0x03 // .byte 3
+	BYTE $0x05 // .byte 5
+	BYTE $0x04 // .byte 4
+	BYTE $0x07 // .byte 7
+	BYTE $0x06 // .byte 6
+	BYTE $0x08 // .byte 8
+	BYTE $0x07 // .byte 7
+	BYTE $0x0a // .byte 10
+	BYTE $0x09 // .byte 9
+	BYTE $0x0b // .byte 11
+	BYTE $0x0a // .byte 10
+	BYTE $0x01 // .byte 1
+	BYTE $0x00 // .byte 0
+	BYTE $0x02 // .byte 2
+	BYTE $0x01 // .byte 1
+	BYTE $0x04 // .byte 4
+	BYTE $0x03 // .byte 3
+	BYTE $0x05 // .byte 5
+	BYTE $0x04 // .byte 4
+	BYTE $0x07 // .byte 7
+	BYTE $0x06 // .byte 6
+	BYTE $0x08 // .byte 8
+	BYTE $0x07 // .byte 7
+	BYTE $0x0a // .byte 10
+	BYTE $0x09 // .byte 9
+	BYTE $0x0b // .byte 11
+	BYTE $0x0a // .byte 10
+
+LCPI0_3:
+	WORD $0xfc00 // .word 64512
+	WORD $0x0fc0 // .word 4032
+	WORD $0xfc00 // .word 64512
+	WORD $0x0fc0 // .word 4032
+	WORD $0xfc00 // .word 64512
+	WORD $0x0fc0 // .word 4032
+	WORD $0xfc00 // .word 64512
+	WORD $0x0fc0 // .word 4032
+	WORD $0xfc00 // .word 64512
+	WORD $0x0fc0 // .word 4032
+	WORD $0xfc00 // .word 64512
+	WORD $0x0fc0 // .word 4032
+	WORD $0xfc00 // .word 64512
+	WORD $0x0fc0 // .word 4032
+	WORD $0xfc00 // .word 64512
+	WORD $0x0fc0 // .word 4032
+
+LCPI0_4:
+	WORD $0x0040 // .word 64
+	WORD $0x0400 // .word 1024
+	WORD $0x0040 // .word 64
+	WORD $0x0400 // .word 1024
+	WORD $0x0040 // .word 64
+	WORD $0x0400 // .word 1024
+	WORD $0x0040 // .word 64
+	WORD $0x0400 // .word 1024
+	WORD $0x0040 // .word 64
+	WORD $0x0400 // .word 1024
+	WORD $0x0040 // .word 64
+	WORD $0x0400 // .word 1024
+	WORD $0x0040 // .word 64
+	WORD $0x0400 // .word 1024
+	WORD $0x0040 // .word 64
+	WORD $0x0400 // .word 1024
+
+LCPI0_5:
+	WORD $0x03f0 // .word 1008
+	WORD $0x003f // .word 63
+	WORD $0x03f0 // .word 1008
+	WORD $0x003f // .word 63
+	WORD $0x03f0 // .word 1008
+	WORD $0x003f // .word 63
+	WORD $0x03f0 // .word 1008
+	WORD $0x003f // .word 63
+	WORD $0x03f0 // .word 1008
+	WORD $0x003f // .word 63
+	WORD $0x03f0 // .word 1008
+	WORD $0x003f // .word 63
+	WORD $0x03f0 // .word 1008
+	WORD $0x003f // .word 63
+	WORD $0x03f0 // .word 1008
+	WORD $0x003f // .word 63
+
+LCPI0_6:
+	QUAD $0x1a1a1a1a1a1a1a1a; QUAD $0x1a1a1a1a1a1a1a1a // .space 16, '\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a'
+	QUAD $0x1a1a1a1a1a1a1a1a; QUAD $0x1a1a1a1a1a1a1a1a // .space 16, '\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a\x1a'
+
+LCPI0_7:
+	QUAD $0x3333333333333333; QUAD $0x3333333333333333 // .space 16, '3333333333333333'
+	QUAD $0x3333333333333333; QUAD $0x3333333333333333 // .space 16, '3333333333333333'
+
+LCPI0_8:
+	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'
+
+_b64encode:
+	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
+	MOVQ  8(SI), R9
+	TESTQ R9, R9
+	JE    LBB0_29
+	MOVQ  0(DI), R8
+	MOVQ  0(SI), R12
+	ADDQ  R12, R9
+	LEAQ  -28(R9), SI
+	LONG  $0x610d8d48; WORD $0x002f; BYTE $0x00 // leaq         $12129(%rip), %rcx  /* _TabEncodeCharsetStd(%rip) */
+	LONG  $0x9a1d8d4c; WORD $0x002f; BYTE $0x00 // leaq         $12186(%rip), %r11  /* _TabEncodeCharsetURL(%rip) */
+	TESTB $1, DX
+	LONG  $0xd9440f4c                           // cmoveq       %rcx, %r11
+	JE    LBB0_2
+	QUAD  $0xfffffebc056ffec5                   // vmovdqu      $-324(%rip), %ymm0  /* LCPI0_1(%rip) */
+	JMP   LBB0_4
+
+LBB0_2:
+	QUAD $0xfffffe92056ffec5 // vmovdqu      $-366(%rip), %ymm0  /* LCPI0_0(%rip) */
+
+LBB0_4:
+	ADDQ  8(DI), R8
+	MOVL  DX, R10
+	ANDL  $4, R10
+	CMPQ  R12, SI
+	JA    LBB0_5
+	TESTL R10, R10
+	JE    LBB0_7
+	QUAD  $0xfffffead0d6ffec5 // vmovdqu      $-339(%rip), %ymm1  /* LCPI0_2(%rip) */
+	QUAD  $0xfffffec5156ffec5 // vmovdqu      $-315(%rip), %ymm2  /* LCPI0_3(%rip) */
+	QUAD  $0xfffffedd1d6ffec5 // vmovdqu      $-291(%rip), %ymm3  /* LCPI0_4(%rip) */
+	QUAD  $0xfffffef5256ffec5 // vmovdqu      $-267(%rip), %ymm4  /* LCPI0_5(%rip) */
+	QUAD  $0xffffff0d2d6ffec5 // vmovdqu      $-243(%rip), %ymm5  /* LCPI0_6(%rip) */
+	QUAD  $0xffffff25356ffec5 // vmovdqu      $-219(%rip), %ymm6  /* LCPI0_7(%rip) */
+	QUAD  $0xffffff3d3d6ffec5 // vmovdqu      $-195(%rip), %ymm7  /* LCPI0_8(%rip) */
+	MOVQ  R8, R14
+
+LBB0_9:
+	LONG $0x6f7a41c4; WORD $0x2404 // vmovdqu      (%r12), %xmm8
+	QUAD $0x010c2444383d43c4       // vinserti128  $1, $12(%r12), %ymm8, %ymm8
+	LONG $0x003d62c4; BYTE $0xc1   // vpshufb      %ymm1, %ymm8, %ymm8
+	LONG $0xcadb3dc5               // vpand        %ymm2, %ymm8, %ymm9
+	LONG $0xcbe435c5               // vpmulhuw     %ymm3, %ymm9, %ymm9
+	LONG $0xc4db3dc5               // vpand        %ymm4, %ymm8, %ymm8
+	LONG $0x712dc1c4; WORD $0x08f0 // vpsllw       $8, %ymm8, %ymm10
+	LONG $0x713dc1c4; WORD $0x04f0 // vpsllw       $4, %ymm8, %ymm8
+	LONG $0x0e3d43c4; WORD $0xaac2 // vpblendw     $170, %ymm10, %ymm8, %ymm8
+	LONG $0xeb3d41c4; BYTE $0xc1   // vpor         %ymm9, %ymm8, %ymm8
+	LONG $0x645541c4; BYTE $0xc8   // vpcmpgtb     %ymm8, %ymm5, %ymm9
+	LONG $0xcfdb35c5               // vpand        %ymm7, %ymm9, %ymm9
+	LONG $0xd6d83dc5               // vpsubusb     %ymm6, %ymm8, %ymm10
+	LONG $0xeb3541c4; BYTE $0xca   // vpor         %ymm10, %ymm9, %ymm9
+	LONG $0x007d42c4; BYTE $0xc9   // vpshufb      %ymm9, %ymm0, %ymm9
+	LONG $0xfc3541c4; BYTE $0xc0   // vpaddb       %ymm8, %ymm9, %ymm8
+	LONG $0x7f7e41c4; BYTE $0x06   // vmovdqu      %ymm8, (%r14)
+	ADDQ $32, R14
+	ADDQ $24, R12
+	CMPQ R12, SI
+	JBE  LBB0_9
+	JMP  LBB0_10
+
+LBB0_5:
+	MOVQ R8, R14
+
+LBB0_10:
+	LEAQ -24(R9), SI
+	CMPQ R12, SI
+	JA   LBB0_13
+
+LBB0_11:
+	TESTL R10, R10
+	JE    LBB0_13
+	LONG  $0x6f7ac1c4; WORD $0x240c             // vmovdqu      (%r12), %xmm1
+	LONG  $0x6f7ac1c4; WORD $0x2454; BYTE $0x08 // vmovdqu      $8(%r12), %xmm2
+	LONG  $0xda73e9c5; BYTE $0x04               // vpsrldq      $4, %xmm2, %xmm2
+	LONG  $0x3875e3c4; WORD $0x01ca             // vinserti128  $1, %xmm2, %ymm1, %ymm1
+	QUAD  $0xfffdda0d0075e2c4; BYTE $0xff       // vpshufb      $-550(%rip), %ymm1, %ymm1  /* LCPI0_2(%rip) */
+	QUAD  $0xfffffdf215dbf5c5                   // vpand        $-526(%rip), %ymm1, %ymm2  /* LCPI0_3(%rip) */
+	QUAD  $0xfffffe0a15e4edc5                   // vpmulhuw     $-502(%rip), %ymm2, %ymm2  /* LCPI0_4(%rip) */
+	QUAD  $0xfffffe220ddbf5c5                   // vpand        $-478(%rip), %ymm1, %ymm1  /* LCPI0_5(%rip) */
+	LONG  $0xf171e5c5; BYTE $0x08               // vpsllw       $8, %ymm1, %ymm3
+	LONG  $0xf171f5c5; BYTE $0x04               // vpsllw       $4, %ymm1, %ymm1
+	LONG  $0x0e75e3c4; WORD $0xaacb             // vpblendw     $170, %ymm3, %ymm1, %ymm1
+	LONG  $0xcaebf5c5                           // vpor         %ymm2, %ymm1, %ymm1
+	QUAD  $0xfffffe26156ffec5                   // vmovdqu      $-474(%rip), %ymm2  /* LCPI0_6(%rip) */
+	LONG  $0xd164edc5                           // vpcmpgtb     %ymm1, %ymm2, %ymm2
+	QUAD  $0xfffffe3a1dd8f5c5                   // vpsubusb     $-454(%rip), %ymm1, %ymm3  /* LCPI0_7(%rip) */
+	QUAD  $0xfffffe5215dbedc5                   // vpand        $-430(%rip), %ymm2, %ymm2  /* LCPI0_8(%rip) */
+	LONG  $0xd3ebedc5                           // vpor         %ymm3, %ymm2, %ymm2
+	LONG  $0x007de2c4; BYTE $0xc2               // vpshufb      %ymm2, %ymm0, %ymm0
+	LONG  $0xc1fcfdc5                           // vpaddb       %ymm1, %ymm0, %ymm0
+	LONG  $0x7f7ec1c4; BYTE $0x06               // vmovdqu      %ymm0, (%r14)
+	ADDQ  $32, R14
+	ADDQ  $24, R12
+
+LBB0_13:
+	CMPQ R12, R9
+	JE   LBB0_28
+	LEAQ -4(R9), R10
+	CMPQ R12, R10
+	JA   LBB0_17
+
+LBB0_15:
+	MOVL    0(R12), SI
+	BSWAPL  SI
+	MOVQ    SI, R15
+	SHRQ    $26, R15
+	MOVL    SI, CX
+	SHRL    $20, CX
+	ANDL    $63, CX
+	MOVL    SI, BX
+	SHRL    $14, BX
+	ANDL    $63, BX
+	SHRL    $8, SI
+	ANDL    $63, SI
+	ADDQ    $3, R12
+	MOVBLZX 0(R11)(R15*1), AX
+	MOVB    AX, 0(R14)
+	MOVBLZX 0(R11)(CX*1), AX
+	MOVB    AX, 1(R14)
+	MOVBLZX 0(R11)(BX*1), AX
+	MOVB    AX, 2(R14)
+	MOVBLZX 0(R11)(SI*1), AX
+	MOVB    AX, 3(R14)
+	ADDQ    $4, R14
+	CMPQ    R12, R10
+	JBE     LBB0_15
+
+LBB0_17:
+	SUBQ    R12, R9
+	MOVBLZX 0(R12), R10
+	CMPQ    R9, $1
+	JE      LBB0_24
+	MOVQ    R10, SI
+	SHLQ    $16, SI
+	CMPQ    R9, $2
+	JE      LBB0_21
+	CMPQ    R9, $3
+	JNE     LBB0_28
+	MOVBLZX 2(R12), DX
+	ORL     DX, SI
+	MOVBLZX 1(R12), AX
+	SHLL    $8, AX
+	ORL     SI, AX
+	SHRQ    $2, R10
+	MOVB    0(R11)(R10*1), CX
+	MOVB    CX, 0(R14)
+	MOVL    AX, CX
+	SHRL    $12, CX
+	ANDL    $63, CX
+	MOVB    0(R11)(CX*1), CX
+	MOVB    CX, 1(R14)
+	SHRL    $6, AX
+	ANDL    $63, AX
+	MOVB    0(R11)(AX*1), AX
+	MOVB    AX, 2(R14)
+	ANDL    $63, DX
+	MOVB    0(R11)(DX*1), AX
+	MOVB    AX, 3(R14)
+	JMP     LBB0_27
+
+LBB0_7:
+	MOVQ R8, R14
+	LEAQ -24(R9), SI
+	CMPQ R12, SI
+	JBE  LBB0_11
+	JMP  LBB0_13
+
+LBB0_21:
+	MOVBLZX 1(R12), AX
+	MOVL    AX, CX
+	SHLL    $8, CX
+	ORL     SI, CX
+	SHRQ    $2, R10
+	MOVB    0(R11)(R10*1), BX
+	MOVB    BX, 0(R14)
+	SHRL    $12, CX
+	ANDL    $63, CX
+	MOVB    0(R11)(CX*1), CX
+	MOVB    CX, 1(R14)
+	ANDL    $15, AX
+	MOVB    0(R11)(AX*4), AX
+	MOVB    AX, 2(R14)
+	TESTB   $2, DX
+	JNE     LBB0_22
+	MOVB    $61, 3(R14)
+	JMP     LBB0_27
+
+LBB0_24:
+	MOVQ  R10, AX
+	SHRQ  $2, AX
+	MOVB  0(R11)(AX*1), AX
+	MOVB  AX, 0(R14)
+	SHLL  $4, R10
+	ANDL  $48, R10
+	MOVB  0(R11)(R10*1), AX
+	MOVB  AX, 1(R14)
+	TESTB $2, DX
+	JNE   LBB0_25
+	MOVW  $15677, 2(R14)
+
+LBB0_27:
+	ADDQ $4, R14
+	JMP  LBB0_28
+
+LBB0_22:
+	ADDQ $3, R14
+	JMP  LBB0_28
+
+LBB0_25:
+	ADDQ $2, R14
+
+LBB0_28:
+	SUBQ R8, R14
+	ADDQ R14, 8(DI)
+
+LBB0_29:
+	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
+	RET
+
+LCPI1_0:
+	BYTE $0xa8 // .byte 168
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf0 // .byte 240
+	BYTE $0x54 // .byte 84
+	BYTE $0x50 // .byte 80
+	BYTE $0x50 // .byte 80
+	BYTE $0x50 // .byte 80
+	BYTE $0x54 // .byte 84
+	BYTE $0xa8 // .byte 168
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf0 // .byte 240
+	BYTE $0x54 // .byte 84
+	BYTE $0x50 // .byte 80
+	BYTE $0x50 // .byte 80
+	BYTE $0x50 // .byte 80
+	BYTE $0x54 // .byte 84
+
+LCPI1_1:
+	BYTE $0xa8 // .byte 168
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf0 // .byte 240
+	BYTE $0x50 // .byte 80
+	BYTE $0x50 // .byte 80
+	BYTE $0x54 // .byte 84
+	BYTE $0x50 // .byte 80
+	BYTE $0x70 // .byte 112
+	BYTE $0xa8 // .byte 168
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf8 // .byte 248
+	BYTE $0xf0 // .byte 240
+	BYTE $0x50 // .byte 80
+	BYTE $0x50 // .byte 80
+	BYTE $0x54 // .byte 84
+	BYTE $0x50 // .byte 80
+	BYTE $0x70 // .byte 112
+
+LCPI1_2:
+	QUAD $0x2f2f2f2f2f2f2f2f; QUAD $0x2f2f2f2f2f2f2f2f // .space 16, '////////////////'
+	QUAD $0x2f2f2f2f2f2f2f2f; QUAD $0x2f2f2f2f2f2f2f2f // .space 16, '////////////////'
+
+LCPI1_3:
+	QUAD $0x5f5f5f5f5f5f5f5f; QUAD $0x5f5f5f5f5f5f5f5f // .space 16, '________________'
+	QUAD $0x5f5f5f5f5f5f5f5f; QUAD $0x5f5f5f5f5f5f5f5f // .space 16, '________________'
+
+LCPI1_4:
+	QUAD $0x1010101010101010; QUAD $0x1010101010101010 // .space 16, '\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10'
+	QUAD $0x1010101010101010; QUAD $0x1010101010101010 // .space 16, '\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10'
+
+LCPI1_5:
+	QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, '                '
+	QUAD $0x2020202020202020; QUAD $0x2020202020202020 // .space 16, '                '
+
+LCPI1_6:
+	BYTE $0x00 // .byte 0
+	BYTE $0x00 // .byte 0
+	BYTE $0x13 // .byte 19
+	BYTE $0x04 // .byte 4
+	BYTE $0xbf // .byte 191
+	BYTE $0xbf // .byte 191
+	BYTE $0xb9 // .byte 185
+	BYTE $0xb9 // .byte 185
+	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 $0x00 // .byte 0
+	BYTE $0x00 // .byte 0
+	BYTE $0x13 // .byte 19
+	BYTE $0x04 // .byte 4
+	BYTE $0xbf // .byte 191
+	BYTE $0xbf // .byte 191
+	BYTE $0xb9 // .byte 185
+	BYTE $0xb9 // .byte 185
+	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
+
+LCPI1_7:
+	BYTE $0x00 // .byte 0
+	BYTE $0x00 // .byte 0
+	BYTE $0x11 // .byte 17
+	BYTE $0x04 // .byte 4
+	BYTE $0xbf // .byte 191
+	BYTE $0xbf // .byte 191
+	BYTE $0xb9 // .byte 185
+	BYTE $0xb9 // .byte 185
+	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 $0x00 // .byte 0
+	BYTE $0x00 // .byte 0
+	BYTE $0x11 // .byte 17
+	BYTE $0x04 // .byte 4
+	BYTE $0xbf // .byte 191
+	BYTE $0xbf // .byte 191
+	BYTE $0xb9 // .byte 185
+	BYTE $0xb9 // .byte 185
+	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
+
+LCPI1_8:
+	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'
+
+LCPI1_9:
+	BYTE $0x01 // .byte 1
+	BYTE $0x02 // .byte 2
+	BYTE $0x04 // .byte 4
+	BYTE $0x08 // .byte 8
+	BYTE $0x10 // .byte 16
+	BYTE $0x20 // .byte 32
+	BYTE $0x40 // .byte 64
+	BYTE $0x80 // .byte 128
+	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 $0x01 // .byte 1
+	BYTE $0x02 // .byte 2
+	BYTE $0x04 // .byte 4
+	BYTE $0x08 // .byte 8
+	BYTE $0x10 // .byte 16
+	BYTE $0x20 // .byte 32
+	BYTE $0x40 // .byte 64
+	BYTE $0x80 // .byte 128
+	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
+
+LCPI1_10:
+	QUAD $0x3f3f3f3f3f3f3f3f; QUAD $0x3f3f3f3f3f3f3f3f // .space 16, '????????????????'
+	QUAD $0x3f3f3f3f3f3f3f3f; QUAD $0x3f3f3f3f3f3f3f3f // .space 16, '????????????????'
+
+LCPI1_11:
+	BYTE $0x40 // .byte 64
+	BYTE $0x01 // .byte 1
+	BYTE $0x40 // .byte 64
+	BYTE $0x01 // .byte 1
+	BYTE $0x40 // .byte 64
+	BYTE $0x01 // .byte 1
+	BYTE $0x40 // .byte 64
+	BYTE $0x01 // .byte 1
+	BYTE $0x40 // .byte 64
+	BYTE $0x01 // .byte 1
+	BYTE $0x40 // .byte 64
+	BYTE $0x01 // .byte 1
+	BYTE $0x40 // .byte 64
+	BYTE $0x01 // .byte 1
+	BYTE $0x40 // .byte 64
+	BYTE $0x01 // .byte 1
+	BYTE $0x40 // .byte 64
+	BYTE $0x01 // .byte 1
+	BYTE $0x40 // .byte 64
+	BYTE $0x01 // .byte 1
+	BYTE $0x40 // .byte 64
+	BYTE $0x01 // .byte 1
+	BYTE $0x40 // .byte 64
+	BYTE $0x01 // .byte 1
+	BYTE $0x40 // .byte 64
+	BYTE $0x01 // .byte 1
+	BYTE $0x40 // .byte 64
+	BYTE $0x01 // .byte 1
+	BYTE $0x40 // .byte 64
+	BYTE $0x01 // .byte 1
+	BYTE $0x40 // .byte 64
+	BYTE $0x01 // .byte 1
+
+LCPI1_12:
+	WORD $0x1000 // .word 4096
+	WORD $0x0001 // .word 1
+	WORD $0x1000 // .word 4096
+	WORD $0x0001 // .word 1
+	WORD $0x1000 // .word 4096
+	WORD $0x0001 // .word 1
+	WORD $0x1000 // .word 4096
+	WORD $0x0001 // .word 1
+	WORD $0x1000 // .word 4096
+	WORD $0x0001 // .word 1
+	WORD $0x1000 // .word 4096
+	WORD $0x0001 // .word 1
+	WORD $0x1000 // .word 4096
+	WORD $0x0001 // .word 1
+	WORD $0x1000 // .word 4096
+	WORD $0x0001 // .word 1
+
+LCPI1_14:
+	BYTE $0x02 // .byte 2
+	BYTE $0x01 // .byte 1
+	BYTE $0x00 // .byte 0
+	BYTE $0x06 // .byte 6
+	BYTE $0x05 // .byte 5
+	BYTE $0x04 // .byte 4
+	BYTE $0x0a // .byte 10
+	BYTE $0x09 // .byte 9
+	BYTE $0x08 // .byte 8
+	BYTE $0x0e // .byte 14
+	BYTE $0x0d // .byte 13
+	BYTE $0x0c // .byte 12
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x00 // .space 1, '\x00'
+	BYTE $0x05 // .byte 5
+	BYTE $0x04 // .byte 4
+	BYTE $0x0a // .byte 10
+	BYTE $0x09 // .byte 9
+	BYTE $0x08 // .byte 8
+	BYTE $0x0e // .byte 14
+	BYTE $0x0d // .byte 13
+	BYTE $0x0c // .byte 12
+	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'
+
+LCPI1_13:
+	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'
+	BYTE $0x02 // .byte 2
+	BYTE $0x01 // .byte 1
+	BYTE $0x00 // .byte 0
+	BYTE $0x06 // .byte 6
+
+_b64decode:
+	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
+	SUBQ  $80, SP
+	TESTQ DX, DX
+	JE    LBB1_3
+	MOVQ  0(DI), BX
+	MOVQ  8(DI), R15
+	ADDQ  BX, R15
+	ADDQ  16(DI), BX
+	ADDQ  SI, DX
+	TESTB $1, CX
+	LONG  $0xee058d4c; WORD $0x002a; BYTE $0x00 // leaq         $10990(%rip), %r8  /* _VecDecodeCharsetStd(%rip) */
+	LONG  $0xe7058d48; WORD $0x002b; BYTE $0x00 // leaq         $11239(%rip), %rax  /* _VecDecodeCharsetURL(%rip) */
+	LONG  $0xc0440f49                           // cmoveq       %r8, %rax
+	MOVQ  AX, -56(BP)
+	TESTB $4, CX
+	MOVQ  SI, -96(BP)
+	MOVQ  DI, -120(BP)
+	MOVQ  R15, -112(BP)
+	MOVQ  BX, -88(BP)
+	JNE   LBB1_4
+	MOVL  CX, R8
+	ANDL  $8, R8
+	ANDL  $2, CX
+	MOVL  CX, -44(BP)
+	JMP   LBB1_764
+
+LBB1_3:
+	XORL AX, AX
+	JMP  LBB1_763
+
+LBB1_4:
+	LEAQ  -32(DX), R14
+	LEAQ  -32(BX), R13
+	TESTB $1, CX
+	JE    LBB1_9
+	QUAD  $0xfffffdcd056ffec5 // vmovdqu      $-563(%rip), %ymm0  /* LCPI1_1(%rip) */
+	JNE   LBB1_10
+
+LBB1_6:
+	QUAD $0xfffffde30d6ffec5 // vmovdqu      $-541(%rip), %ymm1  /* LCPI1_2(%rip) */
+	JNE  LBB1_11
+
+LBB1_7:
+	QUAD $0xfffffe19156ffec5 // vmovdqu      $-487(%rip), %ymm2  /* LCPI1_4(%rip) */
+	JNE  LBB1_12
+
+LBB1_8:
+	QUAD $0xfffffe4f1d6ffec5 // vmovdqu      $-433(%rip), %ymm3  /* LCPI1_6(%rip) */
+	JMP  LBB1_13
+
+LBB1_9:
+	QUAD $0xfffffd85056ffec5 // vmovdqu      $-635(%rip), %ymm0  /* LCPI1_0(%rip) */
+	JE   LBB1_6
+
+LBB1_10:
+	QUAD $0xfffffddb0d6ffec5 // vmovdqu      $-549(%rip), %ymm1  /* LCPI1_3(%rip) */
+	JE   LBB1_7
+
+LBB1_11:
+	QUAD $0xfffffe11156ffec5 // vmovdqu      $-495(%rip), %ymm2  /* LCPI1_5(%rip) */
+	JE   LBB1_8
+
+LBB1_12:
+	QUAD $0xfffffe471d6ffec5 // vmovdqu      $-441(%rip), %ymm3  /* LCPI1_7(%rip) */
+
+LBB1_13:
+	MOVL CX, R8
+	ANDL $8, R8
+	ANDL $2, CX
+	CMPQ R14, SI
+	MOVL CX, -44(BP)
+	JB   LBB1_205
+	CMPQ R15, R13
+	JA   LBB1_764
+	QUAD $0xfffffe40256ffec5 // vmovdqu      $-448(%rip), %ymm4  /* LCPI1_8(%rip) */
+	QUAD $0xfffffe582d6ffec5 // vmovdqu      $-424(%rip), %ymm5  /* LCPI1_9(%rip) */
+	LONG $0xf6efc9c5         // vpxor        %xmm6, %xmm6, %xmm6
+	MOVQ $-4294967296, DI
+	QUAD $0xfffffe82056f7ec5 // vmovdqu      $-382(%rip), %ymm8  /* LCPI1_11(%rip) */
+	QUAD $0xfffffe9a0d6f7ec5 // vmovdqu      $-358(%rip), %ymm9  /* LCPI1_12(%rip) */
+	QUAD $0xfffffed2156f7ac5 // vmovdqu      $-302(%rip), %xmm10  /* LCPI1_13(%rip) */
+	QUAD $0xfffffeaa1d6f7ec5 // vmovdqu      $-342(%rip), %ymm11  /* LCPI1_14(%rip) */
+	MOVQ SI, R10
+	MOVQ R14, -72(BP)
+	MOVQ R13, -80(BP)
+
+LBB1_16:
+	LONG $0x6f7e41c4; BYTE $0x22   // vmovdqu      (%r10), %ymm12
+	LONG $0x7215c1c4; WORD $0x04d4 // vpsrld       $4, %ymm12, %ymm13
+	LONG $0xecdb15c5               // vpand        %ymm4, %ymm13, %ymm13
+	LONG $0xf4db1dc5               // vpand        %ymm4, %ymm12, %ymm14
+	LONG $0x007d42c4; BYTE $0xf6   // vpshufb      %ymm14, %ymm0, %ymm14
+	LONG $0x005542c4; BYTE $0xfd   // vpshufb      %ymm13, %ymm5, %ymm15
+	LONG $0xdb0541c4; BYTE $0xf6   // vpand        %ymm14, %ymm15, %ymm14
+	LONG $0xf6740dc5               // vpcmpeqb     %ymm6, %ymm14, %ymm14
+	LONG $0xd77dc1c4; BYTE $0xc6   // vpmovmskb    %ymm14, %eax
+	ORQ  DI, AX
+	BSFQ AX, AX
+	CMPL AX, $31
+	JA   LBB1_19
+	CMPQ R10, DX
+	JAE  LBB1_110
+	MOVQ R10, R12
+	JMP  LBB1_22
+
+LBB1_19:
+	LONG $0xf1741dc5               // vpcmpeqb     %ymm1, %ymm12, %ymm14
+	LONG $0x006542c4; BYTE $0xed   // vpshufb      %ymm13, %ymm3, %ymm13
+	LONG $0x4c1563c4; WORD $0xe0ea // vpblendvb    %ymm14, %ymm2, %ymm13, %ymm13
+	LONG $0xfc1541c4; BYTE $0xe4   // vpaddb       %ymm12, %ymm13, %ymm12
+	QUAD $0xfffffdde25db1dc5       // vpand        $-546(%rip), %ymm12, %ymm12  /* LCPI1_10(%rip) */
+	LONG $0x041d42c4; BYTE $0xe0   // vpmaddubsw   %ymm8, %ymm12, %ymm12
+	LONG $0xf51d41c4; BYTE $0xe1   // vpmaddwd     %ymm9, %ymm12, %ymm12
+	LONG $0x397d63c4; WORD $0x01e7 // vextracti128 $1, %ymm12, %xmm7
+	LONG $0x0041c2c4; BYTE $0xfa   // vpshufb      %xmm10, %xmm7, %xmm7
+	LONG $0x001d42c4; BYTE $0xe3   // vpshufb      %ymm11, %ymm12, %ymm12
+	LONG $0x021de3c4; WORD $0x08ff // vpblendd     $8, %ymm7, %ymm12, %ymm7
+	LONG $0x0245e3c4; WORD $0xc0fe // vpblendd     $192, %ymm6, %ymm7, %ymm7
+	LONG $0x7f7ec1c4; BYTE $0x3f   // vmovdqu      %ymm7, (%r15)
+	ADDQ $32, R10
+	ADDQ $24, R15
+	JMP  LBB1_110
+
+LBB1_38:
+	CMPB CX, $110
+	JNE  LBB1_43
+
+LBB1_20:
+	MOVQ SI, R12
+
+LBB1_21:
+	CMPQ R12, DX
+	JAE  LBB1_40
+
+LBB1_22:
+	LEAQ    1(R12), CX
+	MOVBLZX 0(R12), SI
+	CMPB    SI, $92
+	JNE     LBB1_34
+	TESTL   R8, R8
+	JE      LBB1_36
+	LEAQ    2(R12), SI
+	MOVB    $-1, R9
+	CMPQ    SI, DX
+	JA      LBB1_42
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $113
+	JLE     LBB1_38
+	CMPB    CX, $114
+	JE      LBB1_20
+	CMPB    CX, $117
+	JNE     LBB1_45
+	MOVQ    DX, CX
+	SUBQ    SI, CX
+	CMPQ    CX, $4
+	JL      LBB1_45
+	MOVL    0(SI), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), CX
+	ANDL    $-2139062144, DI
+	TESTL   CX, DI
+	JNE     LBB1_45
+	LEAL    421075225(BX), CX
+	ORL     BX, CX
+	TESTL   $-2139062144, CX
+	JNE     LBB1_45
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R11
+	ANDL    DI, AX
+	TESTL   R11, AX
+	JNE     LBB1_45
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_45
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, SI
+	SHRL    $4, SI
+	ORL     BX, SI
+	MOVL    SI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    SI, CX
+	ANDL    $128, CX
+	ADDQ    $6, R12
+	ORL     AX, CX
+	JNE     LBB1_46
+	CMPB    SI, $13
+	JNE     LBB1_37
+	JMP     LBB1_21
+
+LBB1_34:
+	MOVQ CX, R12
+	CMPB SI, $13
+	JNE  LBB1_37
+	JMP  LBB1_21
+
+LBB1_36:
+	MOVQ CX, R12
+	CMPB SI, $13
+	JE   LBB1_21
+
+LBB1_37:
+	MOVL SI, R9
+	CMPB SI, $10
+	JE   LBB1_21
+	JMP  LBB1_46
+
+LBB1_40:
+	MOVB $1, CX
+	XORL DI, DI
+	XORL R11, R11
+
+LBB1_41:
+	TESTB CX, CX
+	JE    LBB1_49
+	JMP   LBB1_109
+
+LBB1_42:
+	MOVQ CX, R12
+	JMP  LBB1_46
+
+LBB1_43:
+	CMPB CX, $47
+	JNE  LBB1_45
+	MOVL CX, R9
+
+LBB1_45:
+	MOVQ SI, R12
+
+LBB1_46:
+	MOVBLZX R9, AX
+	MOVQ    -56(BP), CX
+	MOVBLZX 0(CX)(AX*1), DI
+	MOVB    $1, R13
+	CMPL    DI, $255
+	JE      LBB1_72
+	MOVL    $1, R11
+	CMPQ    R12, DX
+	JB      LBB1_54
+
+LBB1_48:
+	MOVQ -80(BP), R13
+
+LBB1_49:
+	MOVL  DI, -64(BP)
+	CMPL  -44(BP), $0
+	SETEQ CX
+	CMPL  R11, $1
+	SETEQ BX
+	CMPQ  R12, DX
+	JB    LBB1_102
+	CMPL  R11, $4
+	JE    LBB1_102
+	ORB   BX, CX
+	JNE   LBB1_97
+	JMP   LBB1_102
+
+LBB1_70:
+	CMPB CX, $110
+	JNE  LBB1_112
+
+LBB1_52:
+	MOVQ SI, R12
+
+LBB1_53:
+	CMPQ R12, DX
+	JAE  LBB1_98
+
+LBB1_54:
+	LEAQ    1(R12), CX
+	MOVBLZX 0(R12), SI
+	CMPB    SI, $92
+	JNE     LBB1_66
+	TESTL   R8, R8
+	JE      LBB1_68
+	LEAQ    2(R12), SI
+	MOVB    $-1, R9
+	CMPQ    SI, DX
+	JA      LBB1_100
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $113
+	JLE     LBB1_70
+	CMPB    CX, $114
+	JE      LBB1_52
+	CMPB    CX, $117
+	JNE     LBB1_114
+	MOVQ    DX, AX
+	SUBQ    SI, AX
+	CMPQ    AX, $4
+	JL      LBB1_114
+	MOVL    DI, R14
+	MOVL    0(SI), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), AX
+	ANDL    $-2139062144, DI
+	TESTL   AX, DI
+	JNE     LBB1_99
+	LEAL    421075225(BX), AX
+	ORL     BX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_99
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R11
+	ANDL    DI, AX
+	TESTL   R11, AX
+	JNE     LBB1_99
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_99
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, SI
+	SHRL    $4, SI
+	ORL     BX, SI
+	MOVL    SI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    SI, CX
+	ANDL    $128, CX
+	ADDQ    $6, R12
+	ORL     AX, CX
+	MOVL    R14, DI
+	MOVQ    -72(BP), R14
+	JE      LBB1_67
+	JMP     LBB1_115
+
+LBB1_66:
+	MOVQ CX, R12
+
+LBB1_67:
+	CMPB SI, $13
+	JNE  LBB1_69
+	JMP  LBB1_53
+
+LBB1_68:
+	MOVQ CX, R12
+	CMPB SI, $13
+	JE   LBB1_53
+
+LBB1_69:
+	MOVL SI, R9
+	CMPB SI, $10
+	JE   LBB1_53
+	JMP  LBB1_115
+
+LBB1_72:
+	XORL DI, DI
+	XORL AX, AX
+	XORL R11, R11
+
+LBB1_73:
+	CMPL  -44(BP), $0
+	JNE   LBB1_96
+	CMPB  R9, $61
+	JNE   LBB1_96
+	TESTB R13, R13
+	JNE   LBB1_96
+	MOVL  DI, -64(BP)
+	CMPQ  R12, DX
+	MOVQ  -80(BP), R13
+	JAE   LBB1_102
+	MOVL  AX, -100(BP)
+	MOVQ  R12, SI
+	JMP   LBB1_80
+
+LBB1_95:
+	MOVQ BX, SI
+	CMPQ SI, DX
+	JB   LBB1_80
+	JMP  LBB1_101
+
+LBB1_78:
+	MOVQ R12, SI
+	CMPQ SI, DX
+	JAE  LBB1_101
+
+LBB1_80:
+	LEAQ    1(SI), BX
+	MOVBLZX 0(SI), DI
+	CMPB    DI, $92
+	JNE     LBB1_92
+	TESTL   R8, R8
+	JE      LBB1_92
+	LEAQ    2(SI), R12
+	CMPQ    R12, DX
+	JA      LBB1_143
+	MOVBLZX 0(BX), CX
+	CMPB    CX, $110
+	JE      LBB1_78
+	CMPB    CX, $114
+	JE      LBB1_78
+	CMPB    CX, $117
+	JNE     LBB1_97
+	MOVQ    DX, AX
+	SUBQ    R12, AX
+	CMPQ    AX, $4
+	JL      LBB1_97
+	MOVL    0(R12), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), AX
+	ANDL    $-2139062144, DI
+	TESTL   AX, DI
+	JNE     LBB1_97
+	LEAL    421075225(BX), AX
+	ORL     BX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_97
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R9
+	ANDL    DI, AX
+	TESTL   R9, AX
+	JNE     LBB1_97
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_97
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, DI
+	SHRL    $4, DI
+	ORL     BX, DI
+	MOVL    DI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    DI, CX
+	ANDL    $128, CX
+	ADDQ    $6, SI
+	ORL     AX, CX
+	MOVQ    SI, BX
+	MOVQ    SI, R12
+	JNE     LBB1_97
+
+LBB1_92:
+	CMPB DI, $10
+	JE   LBB1_95
+	CMPB DI, $13
+	JE   LBB1_95
+	CMPB DI, $61
+	JNE  LBB1_143
+	CMPB -100(BP), $0
+	JE   LBB1_147
+
+LBB1_143:
+	MOVQ BX, R12
+	JMP  LBB1_97
+
+LBB1_96:
+	MOVQ -80(BP), R13
+
+LBB1_97:
+	XORL  CX, CX
+	CMPQ  R12, DX
+	SETEQ CX
+	ADDQ  R12, CX
+	CMPQ  CX, R10
+	MOVQ  $-4294967296, DI
+	JE    LBB1_110
+	JMP   LBB1_762
+
+LBB1_98:
+	MOVL $1, R11
+	XORL CX, CX
+	MOVQ -80(BP), R13
+	JMP  LBB1_41
+
+LBB1_99:
+	MOVQ SI, R12
+	MOVL R14, DI
+	MOVQ -72(BP), R14
+	JMP  LBB1_115
+
+LBB1_100:
+	MOVQ CX, R12
+	JMP  LBB1_115
+
+LBB1_101:
+	MOVQ SI, R12
+
+LBB1_102:
+	MOVB    $4, AX
+	SUBB    R11, AX
+	MOVBLZX AX, AX
+	ADDL    AX, AX
+	LEAL    0(AX)(AX*2), CX
+	MOVL    -64(BP), AX
+	SHLL    CX, AX
+	CMPL    R11, $2
+	MOVQ    R15, CX
+	JE      LBB1_107
+	CMPL    R11, $3
+	JE      LBB1_106
+	CMPL    R11, $4
+	JNE     LBB1_108
+	MOVB    AX, 2(CX)
+
+LBB1_106:
+	MOVB AH, 1(CX)
+
+LBB1_107:
+	SHRL $16, AX
+	MOVB AX, 0(CX)
+
+LBB1_108:
+	MOVL R11, AX
+	LEAQ 0(AX)(CX*1), R15
+	ADDQ $-1, R15
+
+LBB1_109:
+	MOVQ R12, R10
+	MOVQ $-4294967296, DI
+
+LBB1_110:
+	CMPQ R10, R14
+	JA   LBB1_206
+	CMPQ R15, R13
+	JBE  LBB1_16
+	JMP  LBB1_206
+
+LBB1_112:
+	CMPB CX, $47
+	JNE  LBB1_114
+	MOVL CX, R9
+
+LBB1_114:
+	MOVQ SI, R12
+
+LBB1_115:
+	MOVBLZX R9, AX
+	MOVQ    -56(BP), CX
+	MOVBLZX 0(CX)(AX*1), CX
+	CMPL    CX, $255
+	JE      LBB1_138
+	SHLL    $6, DI
+	ORL     CX, DI
+	MOVL    $2, R11
+	CMPQ    R12, DX
+	JAE     LBB1_48
+	MOVQ    -80(BP), R13
+	JMP     LBB1_120
+
+LBB1_136:
+	CMPB CX, $110
+	JNE  LBB1_169
+
+LBB1_118:
+	MOVQ SI, R12
+
+LBB1_119:
+	CMPQ R12, DX
+	JAE  LBB1_142
+
+LBB1_120:
+	LEAQ    1(R12), CX
+	MOVBLZX 0(R12), SI
+	CMPB    SI, $92
+	JNE     LBB1_132
+	TESTL   R8, R8
+	JE      LBB1_134
+	LEAQ    2(R12), SI
+	MOVB    $-1, R9
+	CMPQ    SI, DX
+	JA      LBB1_146
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $113
+	JLE     LBB1_136
+	CMPB    CX, $114
+	JE      LBB1_118
+	CMPB    CX, $117
+	JNE     LBB1_171
+	MOVQ    DX, AX
+	SUBQ    SI, AX
+	CMPQ    AX, $4
+	JL      LBB1_171
+	MOVL    DI, R14
+	MOVL    0(SI), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), AX
+	ANDL    $-2139062144, DI
+	TESTL   AX, DI
+	JNE     LBB1_144
+	LEAL    421075225(BX), AX
+	ORL     BX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_144
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R11
+	ANDL    DI, AX
+	TESTL   R11, AX
+	JNE     LBB1_144
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_144
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, SI
+	SHRL    $4, SI
+	ORL     BX, SI
+	MOVL    SI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    SI, CX
+	ANDL    $128, CX
+	ADDQ    $6, R12
+	ORL     AX, CX
+	MOVL    R14, DI
+	MOVQ    -72(BP), R14
+	JE      LBB1_133
+	JMP     LBB1_172
+
+LBB1_132:
+	MOVQ CX, R12
+
+LBB1_133:
+	CMPB SI, $13
+	JNE  LBB1_135
+	JMP  LBB1_119
+
+LBB1_134:
+	MOVQ CX, R12
+	CMPB SI, $13
+	JE   LBB1_119
+
+LBB1_135:
+	MOVL SI, R9
+	CMPB SI, $10
+	JE   LBB1_119
+	JMP  LBB1_172
+
+LBB1_138:
+	XORL AX, AX
+	MOVL $1, R11
+	JMP  LBB1_73
+
+LBB1_142:
+	MOVL $2, R11
+	XORL CX, CX
+	JMP  LBB1_41
+
+LBB1_144:
+	MOVQ SI, R12
+	MOVL R14, DI
+	MOVQ -72(BP), R14
+	JMP  LBB1_172
+
+LBB1_146:
+	MOVQ CX, R12
+	JMP  LBB1_172
+
+LBB1_147:
+	CMPQ BX, DX
+	JB   LBB1_151
+
+LBB1_148:
+	MOVQ BX, R12
+	JMP  LBB1_102
+
+LBB1_149:
+	MOVQ R12, BX
+
+LBB1_150:
+	CMPQ BX, DX
+	JAE  LBB1_148
+
+LBB1_151:
+	LEAQ    1(BX), CX
+	MOVBLZX 0(BX), SI
+	CMPB    SI, $92
+	JNE     LBB1_164
+	TESTL   R8, R8
+	JE      LBB1_164
+	LEAQ    2(BX), R12
+	CMPQ    R12, DX
+	JA      LBB1_204
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $110
+	JE      LBB1_149
+	CMPB    CX, $114
+	JE      LBB1_149
+	CMPB    CX, $117
+	JNE     LBB1_97
+	MOVQ    DX, AX
+	SUBQ    R12, AX
+	CMPQ    AX, $4
+	JL      LBB1_97
+	MOVL    0(R12), CX
+	MOVL    CX, SI
+	NOTL    SI
+	LEAL    -808464432(CX), AX
+	ANDL    $-2139062144, SI
+	TESTL   AX, SI
+	JNE     LBB1_97
+	LEAL    421075225(CX), AX
+	ORL     CX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_97
+	MOVL    CX, DI
+	ANDL    $2139062143, DI
+	MOVL    $-1061109568, AX
+	SUBL    DI, AX
+	LEAL    1179010630(DI), R9
+	ANDL    SI, AX
+	TESTL   R9, AX
+	JNE     LBB1_97
+	MOVL    $-522133280, AX
+	SUBL    DI, AX
+	ADDL    $960051513, DI
+	ANDL    AX, SI
+	TESTL   DI, SI
+	JNE     LBB1_97
+	BSWAPL  CX
+	MOVL    CX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, CX
+	ADDL    AX, CX
+	MOVL    CX, SI
+	SHRL    $4, SI
+	ORL     CX, SI
+	MOVL    SI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    SI, CX
+	ANDL    $128, CX
+	ADDQ    $6, BX
+	ORL     AX, CX
+	MOVQ    BX, R12
+	JE      LBB1_165
+	JMP     LBB1_97
+
+LBB1_164:
+	MOVQ CX, R12
+
+LBB1_165:
+	CMPB SI, $13
+	JE   LBB1_149
+	MOVQ R12, BX
+	CMPB SI, $10
+	JE   LBB1_150
+	JMP  LBB1_97
+
+LBB1_169:
+	CMPB CX, $47
+	JNE  LBB1_171
+	MOVL CX, R9
+
+LBB1_171:
+	MOVQ SI, R12
+
+LBB1_172:
+	MOVBLZX R9, AX
+	MOVQ    -56(BP), CX
+	MOVBLZX 0(CX)(AX*1), CX
+	CMPL    CX, $255
+	JE      LBB1_194
+	SHLL    $6, DI
+	ORL     CX, DI
+	MOVL    $3, R11
+	CMPQ    R12, DX
+	JB      LBB1_176
+	JMP     LBB1_49
+
+LBB1_192:
+	CMPB CX, $110
+	JNE  LBB1_197
+
+LBB1_174:
+	MOVQ SI, R12
+
+LBB1_175:
+	MOVL $3, R11
+	XORL CX, CX
+	CMPQ R12, DX
+	JAE  LBB1_41
+
+LBB1_176:
+	LEAQ    1(R12), CX
+	MOVBLZX 0(R12), SI
+	CMPB    SI, $92
+	JNE     LBB1_189
+	TESTL   R8, R8
+	JE      LBB1_189
+	LEAQ    2(R12), SI
+	MOVB    $-1, R9
+	CMPQ    SI, DX
+	JA      LBB1_196
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $113
+	JLE     LBB1_192
+	CMPB    CX, $114
+	JE      LBB1_174
+	CMPB    CX, $117
+	JNE     LBB1_199
+	MOVQ    DX, AX
+	SUBQ    SI, AX
+	CMPQ    AX, $4
+	JL      LBB1_199
+	MOVL    DI, R14
+	MOVL    0(SI), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), AX
+	ANDL    $-2139062144, DI
+	TESTL   AX, DI
+	JNE     LBB1_195
+	LEAL    421075225(BX), AX
+	ORL     BX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_195
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R11
+	ANDL    DI, AX
+	TESTL   R11, AX
+	JNE     LBB1_195
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_195
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, SI
+	SHRL    $4, SI
+	ORL     BX, SI
+	MOVL    SI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    SI, CX
+	ANDL    $128, CX
+	ADDQ    $6, R12
+	ORL     AX, CX
+	MOVL    R14, DI
+	MOVQ    -72(BP), R14
+	JE      LBB1_190
+	JMP     LBB1_200
+
+LBB1_189:
+	MOVQ CX, R12
+
+LBB1_190:
+	CMPB SI, $13
+	JE   LBB1_175
+	MOVL SI, R9
+	CMPB SI, $10
+	JE   LBB1_175
+	JMP  LBB1_200
+
+LBB1_194:
+	XORL R13, R13
+	MOVL $2, R11
+	XORL AX, AX
+	JMP  LBB1_73
+
+LBB1_195:
+	MOVQ SI, R12
+	MOVL R14, DI
+	MOVQ -72(BP), R14
+	JMP  LBB1_200
+
+LBB1_196:
+	MOVQ CX, R12
+	JMP  LBB1_200
+
+LBB1_197:
+	CMPB CX, $47
+	JNE  LBB1_199
+	MOVL CX, R9
+
+LBB1_199:
+	MOVQ SI, R12
+
+LBB1_200:
+	MOVBLZX R9, AX
+	MOVQ    -56(BP), CX
+	MOVBLZX 0(CX)(AX*1), CX
+	CMPL    CX, $255
+	JE      LBB1_202
+	SHLL    $6, DI
+	ORL     CX, DI
+	MOVL    $4, R11
+	JMP     LBB1_49
+
+LBB1_202:
+	XORL R13, R13
+	MOVL $3, R11
+	MOVB $1, AX
+	JMP  LBB1_73
+
+LBB1_204:
+	MOVQ CX, R12
+	JMP  LBB1_97
+
+LBB1_764:
+	MOVQ SI, R10
+	LEAQ -8(DX), AX
+	MOVQ AX, -80(BP)
+	CMPQ R10, AX
+	JBE  LBB1_207
+	JMP  LBB1_393
+
+LBB1_205:
+	MOVQ SI, R10
+
+LBB1_206:
+	LEAQ -8(DX), AX
+	MOVQ AX, -80(BP)
+	CMPQ R10, AX
+	JA   LBB1_393
+
+LBB1_207:
+	MOVQ -88(BP), AX
+	ADDQ $-8, AX
+	MOVQ AX, -72(BP)
+	CMPQ R15, AX
+	JA   LBB1_393
+
+LBB1_208:
+	MOVQ    R15, -64(BP)
+	MOVBLZX 0(R10), AX
+	MOVQ    -56(BP), DI
+	MOVBLZX 0(DI)(AX*1), R9
+	MOVBLZX 1(R10), AX
+	MOVBLZX 0(DI)(AX*1), SI
+	MOVBLZX 2(R10), AX
+	MOVBLZX 0(DI)(AX*1), R12
+	MOVBLZX 3(R10), AX
+	MOVBLZX 0(DI)(AX*1), AX
+	MOVBLZX 4(R10), CX
+	MOVBLZX 0(DI)(CX*1), R13
+	MOVBLZX 5(R10), CX
+	MOVBLZX 0(DI)(CX*1), R11
+	MOVBLZX 6(R10), CX
+	MOVBLZX 0(DI)(CX*1), BX
+	MOVBLZX 7(R10), CX
+	MOVBLZX 0(DI)(CX*1), CX
+	MOVL    SI, DI
+	ORL     R9, DI
+	MOVL    AX, R15
+	ORL     R12, R15
+	ORL     DI, R15
+	MOVL    R11, DI
+	ORL     R13, DI
+	MOVL    BX, R14
+	ORL     DI, R14
+	ORL     R15, R14
+	MOVL    CX, DI
+	ORL     R14, DI
+	CMPB    DI, $-1
+	JE      LBB1_210
+	SHLQ    $58, R9
+	SHLQ    $52, SI
+	ORQ     R9, SI
+	SHLQ    $46, R12
+	SHLQ    $40, AX
+	ORQ     R12, AX
+	ORQ     SI, AX
+	SHLQ    $34, R13
+	SHLQ    $28, R11
+	ORQ     R13, R11
+	SHLQ    $22, BX
+	ORQ     R11, BX
+	ORQ     AX, BX
+	SHLQ    $16, CX
+	ORQ     BX, CX
+	BSWAPQ  CX
+	MOVQ    -64(BP), AX
+	MOVQ    CX, 0(AX)
+	ADDQ    $8, R10
+	ADDQ    $6, AX
+	MOVQ    AX, -64(BP)
+	CMPQ    R10, -80(BP)
+	JBE     LBB1_330
+	JMP     LBB1_392
+
+LBB1_210:
+	CMPQ R10, DX
+	JAE  LBB1_329
+	MOVQ R10, R14
+	JMP  LBB1_214
+
+LBB1_230:
+	CMPB CX, $110
+	JNE  LBB1_236
+
+LBB1_212:
+	MOVQ SI, R14
+
+LBB1_213:
+	CMPQ R14, DX
+	JAE  LBB1_232
+
+LBB1_214:
+	LEAQ    1(R14), CX
+	MOVBLZX 0(R14), SI
+	CMPB    SI, $92
+	JNE     LBB1_226
+	TESTL   R8, R8
+	JE      LBB1_228
+	LEAQ    2(R14), SI
+	MOVB    $-1, R13
+	CMPQ    SI, DX
+	JA      LBB1_235
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $113
+	JLE     LBB1_230
+	CMPB    CX, $114
+	JE      LBB1_212
+	CMPB    CX, $117
+	JNE     LBB1_238
+	MOVQ    DX, CX
+	SUBQ    SI, CX
+	CMPQ    CX, $4
+	JL      LBB1_238
+	MOVL    0(SI), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), CX
+	ANDL    $-2139062144, DI
+	TESTL   CX, DI
+	JNE     LBB1_238
+	LEAL    421075225(BX), CX
+	ORL     BX, CX
+	TESTL   $-2139062144, CX
+	JNE     LBB1_238
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R9
+	ANDL    DI, AX
+	TESTL   R9, AX
+	JNE     LBB1_238
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_238
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, SI
+	SHRL    $4, SI
+	ORL     BX, SI
+	MOVL    SI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    SI, CX
+	ANDL    $128, CX
+	ADDQ    $6, R14
+	ORL     AX, CX
+	JNE     LBB1_239
+	CMPB    SI, $13
+	JNE     LBB1_229
+	JMP     LBB1_213
+
+LBB1_226:
+	MOVQ CX, R14
+	CMPB SI, $13
+	JNE  LBB1_229
+	JMP  LBB1_213
+
+LBB1_228:
+	MOVQ CX, R14
+	CMPB SI, $13
+	JE   LBB1_213
+
+LBB1_229:
+	MOVL SI, R13
+	CMPB SI, $10
+	JE   LBB1_213
+	JMP  LBB1_239
+
+LBB1_232:
+	MOVB $1, CX
+	XORL DI, DI
+	XORL R11, R11
+
+LBB1_233:
+	TESTB CX, CX
+	JE    LBB1_241
+	MOVQ  R14, R10
+	CMPQ  R10, -80(BP)
+	JBE   LBB1_330
+	JMP   LBB1_392
+
+LBB1_235:
+	MOVQ CX, R14
+	JMP  LBB1_239
+
+LBB1_236:
+	CMPB CX, $47
+	JNE  LBB1_238
+	MOVL CX, R13
+
+LBB1_238:
+	MOVQ SI, R14
+
+LBB1_239:
+	MOVBLZX R13, AX
+	MOVQ    -56(BP), CX
+	MOVBLZX 0(CX)(AX*1), DI
+	MOVB    $1, R9
+	CMPL    DI, $255
+	JE      LBB1_264
+	MOVL    $1, R11
+	CMPQ    R14, DX
+	JB      LBB1_246
+
+LBB1_241:
+	MOVL  DI, R15
+	CMPL  -44(BP), $0
+	SETEQ CX
+	CMPL  R11, $1
+	SETEQ BX
+	CMPQ  R14, DX
+	JB    LBB1_292
+	CMPL  R11, $4
+	JE    LBB1_292
+	ORB   BX, CX
+	JNE   LBB1_328
+	JMP   LBB1_292
+
+LBB1_262:
+	CMPB CX, $110
+	JNE  LBB1_299
+
+LBB1_244:
+	MOVQ SI, R14
+
+LBB1_245:
+	CMPQ R14, DX
+	JAE  LBB1_288
+
+LBB1_246:
+	LEAQ    1(R14), CX
+	MOVBLZX 0(R14), SI
+	CMPB    SI, $92
+	JNE     LBB1_258
+	TESTL   R8, R8
+	JE      LBB1_260
+	LEAQ    2(R14), SI
+	MOVB    $-1, R13
+	CMPQ    SI, DX
+	JA      LBB1_290
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $113
+	JLE     LBB1_262
+	CMPB    CX, $114
+	JE      LBB1_244
+	CMPB    CX, $117
+	JNE     LBB1_301
+	MOVQ    DX, AX
+	SUBQ    SI, AX
+	CMPQ    AX, $4
+	JL      LBB1_301
+	MOVL    DI, R15
+	MOVL    0(SI), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), AX
+	ANDL    $-2139062144, DI
+	TESTL   AX, DI
+	JNE     LBB1_289
+	LEAL    421075225(BX), AX
+	ORL     BX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_289
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R11
+	ANDL    DI, AX
+	TESTL   R11, AX
+	JNE     LBB1_289
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_289
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, SI
+	SHRL    $4, SI
+	ORL     BX, SI
+	MOVL    SI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    SI, CX
+	ANDL    $128, CX
+	ADDQ    $6, R14
+	ORL     AX, CX
+	MOVL    R15, DI
+	JE      LBB1_259
+	JMP     LBB1_302
+
+LBB1_258:
+	MOVQ CX, R14
+
+LBB1_259:
+	CMPB SI, $13
+	JNE  LBB1_261
+	JMP  LBB1_245
+
+LBB1_260:
+	MOVQ CX, R14
+	CMPB SI, $13
+	JE   LBB1_245
+
+LBB1_261:
+	MOVL SI, R13
+	CMPB SI, $10
+	JE   LBB1_245
+	JMP  LBB1_302
+
+LBB1_264:
+	XORL DI, DI
+	XORL R12, R12
+	XORL R11, R11
+
+LBB1_265:
+	CMPL  -44(BP), $0
+	JNE   LBB1_328
+	CMPB  R13, $61
+	JNE   LBB1_328
+	TESTB R9, R9
+	JNE   LBB1_328
+	MOVL  DI, R15
+	CMPQ  R14, DX
+	JAE   LBB1_292
+	MOVQ  R14, BX
+	JMP   LBB1_272
+
+LBB1_287:
+	MOVQ SI, BX
+	CMPQ BX, DX
+	JB   LBB1_272
+	JMP  LBB1_291
+
+LBB1_270:
+	MOVQ R14, BX
+	CMPQ BX, DX
+	JAE  LBB1_291
+
+LBB1_272:
+	LEAQ    1(BX), SI
+	MOVBLZX 0(BX), DI
+	CMPB    DI, $92
+	JNE     LBB1_284
+	TESTL   R8, R8
+	JE      LBB1_284
+	LEAQ    2(BX), R14
+	CMPQ    R14, DX
+	JA      LBB1_327
+	MOVBLZX 0(SI), CX
+	CMPB    CX, $110
+	JE      LBB1_270
+	CMPB    CX, $114
+	JE      LBB1_270
+	CMPB    CX, $117
+	JNE     LBB1_328
+	MOVQ    DX, AX
+	SUBQ    R14, AX
+	CMPQ    AX, $4
+	JL      LBB1_328
+	MOVL    0(R14), CX
+	MOVL    CX, SI
+	NOTL    SI
+	LEAL    -808464432(CX), AX
+	ANDL    $-2139062144, SI
+	TESTL   AX, SI
+	JNE     LBB1_328
+	LEAL    421075225(CX), AX
+	ORL     CX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_328
+	MOVL    CX, DI
+	ANDL    $2139062143, DI
+	MOVL    $-1061109568, AX
+	SUBL    DI, AX
+	LEAL    1179010630(DI), R9
+	ANDL    SI, AX
+	TESTL   R9, AX
+	JNE     LBB1_328
+	MOVL    $-522133280, AX
+	SUBL    DI, AX
+	ADDL    $960051513, DI
+	ANDL    AX, SI
+	TESTL   DI, SI
+	JNE     LBB1_328
+	BSWAPL  CX
+	MOVL    CX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, CX
+	ADDL    AX, CX
+	MOVL    CX, DI
+	SHRL    $4, DI
+	ORL     CX, DI
+	MOVL    DI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    DI, CX
+	ANDL    $128, CX
+	ADDQ    $6, BX
+	ORL     AX, CX
+	MOVQ    BX, SI
+	MOVQ    BX, R14
+	JNE     LBB1_328
+
+LBB1_284:
+	CMPB  DI, $10
+	JE    LBB1_287
+	CMPB  DI, $13
+	JE    LBB1_287
+	CMPB  DI, $61
+	JNE   LBB1_327
+	TESTB R12, R12
+	JE    LBB1_334
+
+LBB1_327:
+	MOVQ SI, R14
+
+LBB1_328:
+	XORL  CX, CX
+	CMPQ  R14, DX
+	SETEQ CX
+	ADDQ  R14, CX
+	CMPQ  CX, R10
+	JNE   LBB1_762
+
+LBB1_329:
+	CMPQ R10, -80(BP)
+	JA   LBB1_392
+
+LBB1_330:
+	MOVQ -64(BP), R15
+	CMPQ R15, -72(BP)
+	JBE  LBB1_208
+	JMP  LBB1_393
+
+LBB1_288:
+	MOVL $1, R11
+	XORL CX, CX
+	JMP  LBB1_233
+
+LBB1_289:
+	MOVQ SI, R14
+	MOVL R15, DI
+	JMP  LBB1_302
+
+LBB1_290:
+	MOVQ CX, R14
+	JMP  LBB1_302
+
+LBB1_291:
+	MOVQ BX, R14
+
+LBB1_292:
+	MOVB    $4, AX
+	SUBB    R11, AX
+	MOVBLZX AX, AX
+	ADDL    AX, AX
+	LEAL    0(AX)(AX*2), CX
+	MOVL    R15, AX
+	SHLL    CX, AX
+	CMPL    R11, $2
+	MOVQ    -64(BP), CX
+	JE      LBB1_297
+	CMPL    R11, $3
+	JE      LBB1_296
+	CMPL    R11, $4
+	JNE     LBB1_298
+	MOVB    AX, 2(CX)
+
+LBB1_296:
+	MOVB AH, 1(CX)
+
+LBB1_297:
+	SHRL $16, AX
+	MOVB AX, 0(CX)
+
+LBB1_298:
+	MOVL R11, AX
+	ADDQ AX, CX
+	ADDQ $-1, CX
+	MOVQ CX, -64(BP)
+	MOVQ R14, R10
+	CMPQ R10, -80(BP)
+	JBE  LBB1_330
+	JMP  LBB1_392
+
+LBB1_299:
+	CMPB CX, $47
+	JNE  LBB1_301
+	MOVL CX, R13
+
+LBB1_301:
+	MOVQ SI, R14
+
+LBB1_302:
+	MOVBLZX R13, AX
+	MOVQ    -56(BP), CX
+	MOVBLZX 0(CX)(AX*1), CX
+	CMPL    CX, $255
+	JE      LBB1_324
+	SHLL    $6, DI
+	ORL     CX, DI
+	MOVL    $2, R11
+	CMPQ    R14, DX
+	JB      LBB1_306
+	JMP     LBB1_241
+
+LBB1_322:
+	CMPB CX, $110
+	JNE  LBB1_356
+
+LBB1_304:
+	MOVQ SI, R14
+
+LBB1_305:
+	CMPQ R14, DX
+	JAE  LBB1_331
+
+LBB1_306:
+	LEAQ    1(R14), CX
+	MOVBLZX 0(R14), SI
+	CMPB    SI, $92
+	JNE     LBB1_318
+	TESTL   R8, R8
+	JE      LBB1_320
+	LEAQ    2(R14), SI
+	MOVB    $-1, R13
+	CMPQ    SI, DX
+	JA      LBB1_333
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $113
+	JLE     LBB1_322
+	CMPB    CX, $114
+	JE      LBB1_304
+	CMPB    CX, $117
+	JNE     LBB1_358
+	MOVQ    DX, AX
+	SUBQ    SI, AX
+	CMPQ    AX, $4
+	JL      LBB1_358
+	MOVL    DI, R11
+	MOVL    0(SI), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), AX
+	ANDL    $-2139062144, DI
+	TESTL   AX, DI
+	JNE     LBB1_332
+	LEAL    421075225(BX), AX
+	ORL     BX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_332
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R9
+	ANDL    DI, AX
+	TESTL   R9, AX
+	JNE     LBB1_332
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_332
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, SI
+	SHRL    $4, SI
+	ORL     BX, SI
+	MOVL    SI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    SI, CX
+	ANDL    $128, CX
+	ADDQ    $6, R14
+	ORL     AX, CX
+	MOVL    R11, DI
+	JE      LBB1_319
+	JMP     LBB1_359
+
+LBB1_318:
+	MOVQ CX, R14
+
+LBB1_319:
+	CMPB SI, $13
+	JNE  LBB1_321
+	JMP  LBB1_305
+
+LBB1_320:
+	MOVQ CX, R14
+	CMPB SI, $13
+	JE   LBB1_305
+
+LBB1_321:
+	MOVL SI, R13
+	CMPB SI, $10
+	JE   LBB1_305
+	JMP  LBB1_359
+
+LBB1_324:
+	XORL R12, R12
+	MOVL $1, R11
+	JMP  LBB1_265
+
+LBB1_331:
+	MOVL $2, R11
+	XORL CX, CX
+	JMP  LBB1_233
+
+LBB1_332:
+	MOVQ SI, R14
+	MOVL R11, DI
+	JMP  LBB1_359
+
+LBB1_333:
+	MOVQ CX, R14
+	JMP  LBB1_359
+
+LBB1_334:
+	CMPQ SI, DX
+	JB   LBB1_338
+
+LBB1_335:
+	MOVQ SI, R14
+	JMP  LBB1_292
+
+LBB1_336:
+	MOVQ R14, SI
+
+LBB1_337:
+	CMPQ SI, DX
+	JAE  LBB1_335
+
+LBB1_338:
+	LEAQ    1(SI), CX
+	MOVBLZX 0(SI), DI
+	CMPB    DI, $92
+	JNE     LBB1_351
+	TESTL   R8, R8
+	JE      LBB1_351
+	LEAQ    2(SI), R14
+	CMPQ    R14, DX
+	JA      LBB1_391
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $110
+	JE      LBB1_336
+	CMPB    CX, $114
+	JE      LBB1_336
+	CMPB    CX, $117
+	JNE     LBB1_328
+	MOVQ    DX, AX
+	SUBQ    R14, AX
+	CMPQ    AX, $4
+	JL      LBB1_328
+	MOVL    0(R14), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), AX
+	ANDL    $-2139062144, DI
+	TESTL   AX, DI
+	JNE     LBB1_328
+	LEAL    421075225(BX), AX
+	ORL     BX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_328
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R9
+	ANDL    DI, AX
+	TESTL   R9, AX
+	JNE     LBB1_328
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_328
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, DI
+	SHRL    $4, DI
+	ORL     BX, DI
+	MOVL    DI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    DI, CX
+	ANDL    $128, CX
+	ADDQ    $6, SI
+	ORL     AX, CX
+	MOVQ    SI, R14
+	JE      LBB1_352
+	JMP     LBB1_328
+
+LBB1_351:
+	MOVQ CX, R14
+
+LBB1_352:
+	CMPB DI, $13
+	JE   LBB1_336
+	MOVQ R14, SI
+	CMPB DI, $10
+	JE   LBB1_337
+	JMP  LBB1_328
+
+LBB1_356:
+	CMPB CX, $47
+	JNE  LBB1_358
+	MOVL CX, R13
+
+LBB1_358:
+	MOVQ SI, R14
+
+LBB1_359:
+	MOVBLZX R13, AX
+	MOVQ    -56(BP), CX
+	MOVBLZX 0(CX)(AX*1), CX
+	CMPL    CX, $255
+	JE      LBB1_381
+	SHLL    $6, DI
+	ORL     CX, DI
+	MOVL    $3, R11
+	CMPQ    R14, DX
+	JB      LBB1_363
+	JMP     LBB1_241
+
+LBB1_379:
+	CMPB CX, $110
+	JNE  LBB1_384
+
+LBB1_361:
+	MOVQ SI, R14
+
+LBB1_362:
+	MOVL $3, R11
+	XORL CX, CX
+	CMPQ R14, DX
+	JAE  LBB1_233
+
+LBB1_363:
+	LEAQ    1(R14), CX
+	MOVBLZX 0(R14), SI
+	CMPB    SI, $92
+	JNE     LBB1_375
+	TESTL   R8, R8
+	JE      LBB1_377
+	LEAQ    2(R14), SI
+	MOVB    $-1, R13
+	CMPQ    SI, DX
+	JA      LBB1_383
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $113
+	JLE     LBB1_379
+	CMPB    CX, $114
+	JE      LBB1_361
+	CMPB    CX, $117
+	JNE     LBB1_386
+	MOVQ    DX, AX
+	SUBQ    SI, AX
+	CMPQ    AX, $4
+	JL      LBB1_386
+	MOVL    DI, R11
+	MOVL    0(SI), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), AX
+	ANDL    $-2139062144, DI
+	TESTL   AX, DI
+	JNE     LBB1_382
+	LEAL    421075225(BX), AX
+	ORL     BX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_382
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R9
+	ANDL    DI, AX
+	TESTL   R9, AX
+	JNE     LBB1_382
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_382
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, SI
+	SHRL    $4, SI
+	ORL     BX, SI
+	MOVL    SI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    SI, CX
+	ANDL    $128, CX
+	ADDQ    $6, R14
+	ORL     AX, CX
+	MOVL    R11, DI
+	JE      LBB1_376
+	JMP     LBB1_387
+
+LBB1_375:
+	MOVQ CX, R14
+
+LBB1_376:
+	CMPB SI, $13
+	JNE  LBB1_378
+	JMP  LBB1_362
+
+LBB1_377:
+	MOVQ CX, R14
+	CMPB SI, $13
+	JE   LBB1_362
+
+LBB1_378:
+	MOVL SI, R13
+	CMPB SI, $10
+	JE   LBB1_362
+	JMP  LBB1_387
+
+LBB1_381:
+	XORL R9, R9
+	MOVL $2, R11
+	XORL R12, R12
+	JMP  LBB1_265
+
+LBB1_382:
+	MOVQ SI, R14
+	MOVL R11, DI
+	JMP  LBB1_387
+
+LBB1_383:
+	MOVQ CX, R14
+	JMP  LBB1_387
+
+LBB1_384:
+	CMPB CX, $47
+	JNE  LBB1_386
+	MOVL CX, R13
+
+LBB1_386:
+	MOVQ SI, R14
+
+LBB1_387:
+	MOVBLZX R13, AX
+	MOVQ    -56(BP), CX
+	MOVBLZX 0(CX)(AX*1), CX
+	CMPL    CX, $255
+	JE      LBB1_389
+	SHLL    $6, DI
+	ORL     CX, DI
+	MOVL    $4, R11
+	JMP     LBB1_241
+
+LBB1_389:
+	XORL R9, R9
+	MOVL $3, R11
+	MOVB $1, R12
+	JMP  LBB1_265
+
+LBB1_391:
+	MOVQ CX, R14
+	JMP  LBB1_328
+
+LBB1_392:
+	MOVQ -64(BP), R15
+
+LBB1_393:
+	LEAQ -4(DX), R14
+	CMPQ R10, R14
+	MOVQ R15, -64(BP)
+	JA   LBB1_581
+	MOVQ -88(BP), AX
+	ADDQ $-4, AX
+	CMPQ R15, AX
+	JA   LBB1_581
+	MOVQ AX, R15
+	MOVQ AX, -88(BP)
+
+LBB1_396:
+	MOVBLZX 0(R10), AX
+	MOVQ    -56(BP), DI
+	MOVBLZX 0(DI)(AX*1), R9
+	MOVBLZX 1(R10), AX
+	MOVBLZX 0(DI)(AX*1), BX
+	MOVBLZX 2(R10), CX
+	MOVBLZX 0(DI)(CX*1), SI
+	MOVBLZX 3(R10), CX
+	MOVBLZX 0(DI)(CX*1), CX
+	MOVL    BX, AX
+	ORL     R9, AX
+	MOVL    SI, DI
+	ORL     CX, DI
+	ORL     AX, DI
+	CMPB    DI, $-1
+	JE      LBB1_398
+	SHLL    $26, R9
+	SHLL    $20, BX
+	ORL     R9, BX
+	SHLL    $14, SI
+	SHLL    $8, CX
+	ORL     SI, CX
+	ORL     BX, CX
+	BSWAPL  CX
+	MOVQ    -64(BP), AX
+	MOVL    CX, 0(AX)
+	ADDQ    $4, R10
+	ADDQ    $3, AX
+	MOVQ    AX, -64(BP)
+	CMPQ    R10, R14
+	JBE     LBB1_517
+	JMP     LBB1_581
+
+LBB1_398:
+	CMPQ R10, DX
+	JAE  LBB1_516
+	MOVQ R10, R12
+	JMP  LBB1_402
+
+LBB1_418:
+	CMPB CX, $110
+	JNE  LBB1_424
+
+LBB1_400:
+	MOVQ SI, R12
+
+LBB1_401:
+	CMPQ R12, DX
+	JAE  LBB1_420
+
+LBB1_402:
+	LEAQ    1(R12), CX
+	MOVBLZX 0(R12), SI
+	CMPB    SI, $92
+	JNE     LBB1_414
+	TESTL   R8, R8
+	JE      LBB1_416
+	LEAQ    2(R12), SI
+	MOVB    $-1, R13
+	CMPQ    SI, DX
+	JA      LBB1_423
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $113
+	JLE     LBB1_418
+	CMPB    CX, $114
+	JE      LBB1_400
+	CMPB    CX, $117
+	JNE     LBB1_426
+	MOVQ    DX, CX
+	SUBQ    SI, CX
+	CMPQ    CX, $4
+	JL      LBB1_426
+	MOVL    0(SI), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), CX
+	ANDL    $-2139062144, DI
+	TESTL   CX, DI
+	JNE     LBB1_426
+	LEAL    421075225(BX), CX
+	ORL     BX, CX
+	TESTL   $-2139062144, CX
+	JNE     LBB1_426
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R9
+	ANDL    DI, AX
+	TESTL   R9, AX
+	JNE     LBB1_426
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_426
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, SI
+	SHRL    $4, SI
+	ORL     BX, SI
+	MOVL    SI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    SI, CX
+	ANDL    $128, CX
+	ADDQ    $6, R12
+	ORL     AX, CX
+	JNE     LBB1_427
+	CMPB    SI, $13
+	JNE     LBB1_417
+	JMP     LBB1_401
+
+LBB1_414:
+	MOVQ CX, R12
+	CMPB SI, $13
+	JNE  LBB1_417
+	JMP  LBB1_401
+
+LBB1_416:
+	MOVQ CX, R12
+	CMPB SI, $13
+	JE   LBB1_401
+
+LBB1_417:
+	MOVL SI, R13
+	CMPB SI, $10
+	JE   LBB1_401
+	JMP  LBB1_427
+
+LBB1_420:
+	MOVB $1, CX
+	XORL R9, R9
+	XORL R11, R11
+
+LBB1_421:
+	TESTB CX, CX
+	JE    LBB1_429
+	MOVQ  R12, R10
+	CMPQ  R10, R14
+	JBE   LBB1_517
+	JMP   LBB1_581
+
+LBB1_423:
+	MOVQ CX, R12
+	JMP  LBB1_427
+
+LBB1_424:
+	CMPB CX, $47
+	JNE  LBB1_426
+	MOVL CX, R13
+
+LBB1_426:
+	MOVQ SI, R12
+
+LBB1_427:
+	MOVBLZX R13, AX
+	MOVQ    -56(BP), CX
+	MOVBLZX 0(CX)(AX*1), R9
+	MOVB    $1, AX
+	CMPL    R9, $255
+	JE      LBB1_452
+	MOVL    $1, R11
+	CMPQ    R12, DX
+	JB      LBB1_434
+
+LBB1_429:
+	MOVL  R9, R13
+	CMPL  -44(BP), $0
+	SETEQ CX
+	CMPL  R11, $1
+	SETEQ BX
+	CMPQ  R12, DX
+	JB    LBB1_479
+	CMPL  R11, $4
+	JE    LBB1_479
+	ORB   BX, CX
+	JNE   LBB1_515
+	JMP   LBB1_479
+
+LBB1_450:
+	CMPB CX, $110
+	JNE  LBB1_486
+
+LBB1_432:
+	MOVQ SI, R12
+
+LBB1_433:
+	CMPQ R12, DX
+	JAE  LBB1_476
+
+LBB1_434:
+	LEAQ    1(R12), CX
+	MOVBLZX 0(R12), SI
+	CMPB    SI, $92
+	JNE     LBB1_446
+	TESTL   R8, R8
+	JE      LBB1_448
+	LEAQ    2(R12), SI
+	MOVB    $-1, R13
+	CMPQ    SI, DX
+	JA      LBB1_477
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $113
+	JLE     LBB1_450
+	CMPB    CX, $114
+	JE      LBB1_432
+	CMPB    CX, $117
+	JNE     LBB1_488
+	MOVQ    DX, AX
+	SUBQ    SI, AX
+	CMPQ    AX, $4
+	JL      LBB1_488
+	MOVL    0(SI), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), AX
+	ANDL    $-2139062144, DI
+	TESTL   AX, DI
+	JNE     LBB1_488
+	LEAL    421075225(BX), AX
+	ORL     BX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_488
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R11
+	ANDL    DI, AX
+	TESTL   R11, AX
+	JNE     LBB1_488
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_488
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, SI
+	SHRL    $4, SI
+	ORL     BX, SI
+	MOVL    SI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    SI, CX
+	ANDL    $128, CX
+	ADDQ    $6, R12
+	ORL     AX, CX
+	JE      LBB1_447
+	JMP     LBB1_489
+
+LBB1_446:
+	MOVQ CX, R12
+
+LBB1_447:
+	CMPB SI, $13
+	JNE  LBB1_449
+	JMP  LBB1_433
+
+LBB1_448:
+	MOVQ CX, R12
+	CMPB SI, $13
+	JE   LBB1_433
+
+LBB1_449:
+	MOVL SI, R13
+	CMPB SI, $10
+	JE   LBB1_433
+	JMP  LBB1_489
+
+LBB1_452:
+	XORL R9, R9
+	XORL R15, R15
+	XORL R11, R11
+
+LBB1_453:
+	CMPL  -44(BP), $0
+	JNE   LBB1_515
+	CMPB  R13, $61
+	JNE   LBB1_515
+	TESTB AX, AX
+	JNE   LBB1_515
+	MOVL  R9, R13
+	CMPQ  R12, DX
+	JAE   LBB1_479
+	MOVQ  R12, BX
+	JMP   LBB1_460
+
+LBB1_475:
+	MOVQ SI, BX
+	CMPQ BX, DX
+	JB   LBB1_460
+	JMP  LBB1_478
+
+LBB1_458:
+	MOVQ R12, BX
+	CMPQ BX, DX
+	JAE  LBB1_478
+
+LBB1_460:
+	LEAQ    1(BX), SI
+	MOVBLZX 0(BX), DI
+	CMPB    DI, $92
+	JNE     LBB1_472
+	TESTL   R8, R8
+	JE      LBB1_472
+	LEAQ    2(BX), R12
+	CMPQ    R12, DX
+	JA      LBB1_514
+	MOVBLZX 0(SI), CX
+	CMPB    CX, $110
+	JE      LBB1_458
+	CMPB    CX, $114
+	JE      LBB1_458
+	CMPB    CX, $117
+	JNE     LBB1_515
+	MOVQ    DX, AX
+	SUBQ    R12, AX
+	CMPQ    AX, $4
+	JL      LBB1_515
+	MOVL    0(R12), CX
+	MOVL    CX, SI
+	NOTL    SI
+	LEAL    -808464432(CX), AX
+	ANDL    $-2139062144, SI
+	TESTL   AX, SI
+	JNE     LBB1_515
+	LEAL    421075225(CX), AX
+	ORL     CX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_515
+	MOVL    CX, DI
+	ANDL    $2139062143, DI
+	MOVL    $-1061109568, AX
+	SUBL    DI, AX
+	LEAL    1179010630(DI), R9
+	ANDL    SI, AX
+	TESTL   R9, AX
+	JNE     LBB1_515
+	MOVL    $-522133280, AX
+	SUBL    DI, AX
+	ADDL    $960051513, DI
+	ANDL    AX, SI
+	TESTL   DI, SI
+	JNE     LBB1_515
+	BSWAPL  CX
+	MOVL    CX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, CX
+	ADDL    AX, CX
+	MOVL    CX, DI
+	SHRL    $4, DI
+	ORL     CX, DI
+	MOVL    DI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    DI, CX
+	ANDL    $128, CX
+	ADDQ    $6, BX
+	ORL     AX, CX
+	MOVQ    BX, SI
+	MOVQ    BX, R12
+	JNE     LBB1_515
+
+LBB1_472:
+	CMPB  DI, $10
+	JE    LBB1_475
+	CMPB  DI, $13
+	JE    LBB1_475
+	CMPB  DI, $61
+	JNE   LBB1_514
+	TESTB R15, R15
+	JE    LBB1_521
+
+LBB1_514:
+	MOVQ SI, R12
+
+LBB1_515:
+	XORL  CX, CX
+	CMPQ  R12, DX
+	SETEQ CX
+	ADDQ  R12, CX
+	CMPQ  CX, R10
+	MOVQ  -88(BP), R15
+	JNE   LBB1_762
+
+LBB1_516:
+	CMPQ R10, R14
+	JA   LBB1_581
+
+LBB1_517:
+	CMPQ -64(BP), R15
+	JBE  LBB1_396
+	JMP  LBB1_581
+
+LBB1_476:
+	MOVL $1, R11
+	XORL CX, CX
+	JMP  LBB1_421
+
+LBB1_477:
+	MOVQ CX, R12
+	JMP  LBB1_489
+
+LBB1_478:
+	MOVQ BX, R12
+
+LBB1_479:
+	MOVB    $4, AX
+	SUBB    R11, AX
+	MOVBLZX AX, AX
+	ADDL    AX, AX
+	LEAL    0(AX)(AX*2), CX
+	MOVL    R13, AX
+	SHLL    CX, AX
+	CMPL    R11, $2
+	MOVQ    -64(BP), CX
+	JE      LBB1_484
+	CMPL    R11, $3
+	JE      LBB1_483
+	CMPL    R11, $4
+	JNE     LBB1_485
+	MOVB    AX, 2(CX)
+
+LBB1_483:
+	MOVB AH, 1(CX)
+
+LBB1_484:
+	SHRL $16, AX
+	MOVB AX, 0(CX)
+
+LBB1_485:
+	MOVL R11, AX
+	ADDQ AX, CX
+	ADDQ $-1, CX
+	MOVQ CX, -64(BP)
+	MOVQ R12, R10
+	MOVQ -88(BP), R15
+	CMPQ R10, R14
+	JBE  LBB1_517
+	JMP  LBB1_581
+
+LBB1_486:
+	CMPB CX, $47
+	JNE  LBB1_488
+	MOVL CX, R13
+
+LBB1_488:
+	MOVQ SI, R12
+
+LBB1_489:
+	MOVBLZX R13, AX
+	MOVQ    -56(BP), CX
+	MOVBLZX 0(CX)(AX*1), CX
+	CMPL    CX, $255
+	JE      LBB1_511
+	SHLL    $6, R9
+	ORL     CX, R9
+	MOVL    $2, R11
+	CMPQ    R12, DX
+	JB      LBB1_493
+	JMP     LBB1_429
+
+LBB1_509:
+	CMPB CX, $110
+	JNE  LBB1_543
+
+LBB1_491:
+	MOVQ SI, R12
+
+LBB1_492:
+	CMPQ R12, DX
+	JAE  LBB1_518
+
+LBB1_493:
+	LEAQ    1(R12), CX
+	MOVBLZX 0(R12), SI
+	CMPB    SI, $92
+	JNE     LBB1_505
+	TESTL   R8, R8
+	JE      LBB1_507
+	LEAQ    2(R12), SI
+	MOVB    $-1, R13
+	CMPQ    SI, DX
+	JA      LBB1_520
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $113
+	JLE     LBB1_509
+	CMPB    CX, $114
+	JE      LBB1_491
+	CMPB    CX, $117
+	JNE     LBB1_545
+	MOVQ    DX, AX
+	SUBQ    SI, AX
+	CMPQ    AX, $4
+	JL      LBB1_545
+	MOVL    R9, R11
+	MOVL    0(SI), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), AX
+	ANDL    $-2139062144, DI
+	TESTL   AX, DI
+	JNE     LBB1_519
+	LEAL    421075225(BX), AX
+	ORL     BX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_519
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R9
+	ANDL    DI, AX
+	TESTL   R9, AX
+	JNE     LBB1_519
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_519
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, SI
+	SHRL    $4, SI
+	ORL     BX, SI
+	MOVL    SI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    SI, CX
+	ANDL    $128, CX
+	ADDQ    $6, R12
+	ORL     AX, CX
+	MOVL    R11, R9
+	JE      LBB1_506
+	JMP     LBB1_546
+
+LBB1_505:
+	MOVQ CX, R12
+
+LBB1_506:
+	CMPB SI, $13
+	JNE  LBB1_508
+	JMP  LBB1_492
+
+LBB1_507:
+	MOVQ CX, R12
+	CMPB SI, $13
+	JE   LBB1_492
+
+LBB1_508:
+	MOVL SI, R13
+	CMPB SI, $10
+	JE   LBB1_492
+	JMP  LBB1_546
+
+LBB1_511:
+	XORL R15, R15
+	MOVL $1, R11
+	MOVB $1, AX
+	JMP  LBB1_453
+
+LBB1_518:
+	MOVL $2, R11
+	XORL CX, CX
+	JMP  LBB1_421
+
+LBB1_519:
+	MOVQ SI, R12
+	MOVL R11, R9
+	JMP  LBB1_546
+
+LBB1_520:
+	MOVQ CX, R12
+	JMP  LBB1_546
+
+LBB1_521:
+	CMPQ SI, DX
+	JB   LBB1_525
+
+LBB1_522:
+	MOVQ SI, R12
+	JMP  LBB1_479
+
+LBB1_523:
+	MOVQ R12, SI
+
+LBB1_524:
+	CMPQ SI, DX
+	JAE  LBB1_522
+
+LBB1_525:
+	LEAQ    1(SI), CX
+	MOVBLZX 0(SI), DI
+	CMPB    DI, $92
+	JNE     LBB1_538
+	TESTL   R8, R8
+	JE      LBB1_538
+	LEAQ    2(SI), R12
+	CMPQ    R12, DX
+	JA      LBB1_578
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $110
+	JE      LBB1_523
+	CMPB    CX, $114
+	JE      LBB1_523
+	CMPB    CX, $117
+	JNE     LBB1_515
+	MOVQ    DX, AX
+	SUBQ    R12, AX
+	CMPQ    AX, $4
+	JL      LBB1_515
+	MOVL    0(R12), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), AX
+	ANDL    $-2139062144, DI
+	TESTL   AX, DI
+	JNE     LBB1_515
+	LEAL    421075225(BX), AX
+	ORL     BX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_515
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R9
+	ANDL    DI, AX
+	TESTL   R9, AX
+	JNE     LBB1_515
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_515
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, DI
+	SHRL    $4, DI
+	ORL     BX, DI
+	MOVL    DI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    DI, CX
+	ANDL    $128, CX
+	ADDQ    $6, SI
+	ORL     AX, CX
+	MOVQ    SI, R12
+	JE      LBB1_539
+	JMP     LBB1_515
+
+LBB1_538:
+	MOVQ CX, R12
+
+LBB1_539:
+	CMPB DI, $13
+	JE   LBB1_523
+	MOVQ R12, SI
+	CMPB DI, $10
+	JE   LBB1_524
+	JMP  LBB1_515
+
+LBB1_543:
+	CMPB CX, $47
+	JNE  LBB1_545
+	MOVL CX, R13
+
+LBB1_545:
+	MOVQ SI, R12
+
+LBB1_546:
+	MOVBLZX R13, AX
+	MOVQ    -56(BP), CX
+	MOVBLZX 0(CX)(AX*1), CX
+	CMPL    CX, $255
+	JE      LBB1_568
+	SHLL    $6, R9
+	ORL     CX, R9
+	MOVL    $3, R11
+	CMPQ    R12, DX
+	JB      LBB1_550
+	JMP     LBB1_429
+
+LBB1_566:
+	CMPB CX, $110
+	JNE  LBB1_571
+
+LBB1_548:
+	MOVQ SI, R12
+
+LBB1_549:
+	MOVL $3, R11
+	XORL CX, CX
+	CMPQ R12, DX
+	JAE  LBB1_421
+
+LBB1_550:
+	LEAQ    1(R12), CX
+	MOVBLZX 0(R12), SI
+	CMPB    SI, $92
+	JNE     LBB1_562
+	TESTL   R8, R8
+	JE      LBB1_564
+	LEAQ    2(R12), SI
+	MOVB    $-1, R13
+	CMPQ    SI, DX
+	JA      LBB1_570
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $113
+	JLE     LBB1_566
+	CMPB    CX, $114
+	JE      LBB1_548
+	CMPB    CX, $117
+	JNE     LBB1_573
+	MOVQ    DX, AX
+	SUBQ    SI, AX
+	CMPQ    AX, $4
+	JL      LBB1_573
+	MOVL    R9, R11
+	MOVL    0(SI), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), AX
+	ANDL    $-2139062144, DI
+	TESTL   AX, DI
+	JNE     LBB1_569
+	LEAL    421075225(BX), AX
+	ORL     BX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_569
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R9
+	ANDL    DI, AX
+	TESTL   R9, AX
+	JNE     LBB1_569
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_569
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, SI
+	SHRL    $4, SI
+	ORL     BX, SI
+	MOVL    SI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    SI, CX
+	ANDL    $128, CX
+	ADDQ    $6, R12
+	ORL     AX, CX
+	MOVL    R11, R9
+	JE      LBB1_563
+	JMP     LBB1_574
+
+LBB1_562:
+	MOVQ CX, R12
+
+LBB1_563:
+	CMPB SI, $13
+	JNE  LBB1_565
+	JMP  LBB1_549
+
+LBB1_564:
+	MOVQ CX, R12
+	CMPB SI, $13
+	JE   LBB1_549
+
+LBB1_565:
+	MOVL SI, R13
+	CMPB SI, $10
+	JE   LBB1_549
+	JMP  LBB1_574
+
+LBB1_568:
+	XORL AX, AX
+	MOVL $2, R11
+	XORL R15, R15
+	JMP  LBB1_453
+
+LBB1_569:
+	MOVQ SI, R12
+	MOVL R11, R9
+	JMP  LBB1_574
+
+LBB1_570:
+	MOVQ CX, R12
+	JMP  LBB1_574
+
+LBB1_571:
+	CMPB CX, $47
+	JNE  LBB1_573
+	MOVL CX, R13
+
+LBB1_573:
+	MOVQ SI, R12
+
+LBB1_574:
+	MOVBLZX R13, AX
+	MOVQ    -56(BP), CX
+	MOVBLZX 0(CX)(AX*1), CX
+	CMPL    CX, $255
+	JE      LBB1_576
+	SHLL    $6, R9
+	ORL     CX, R9
+	MOVL    $4, R11
+	JMP     LBB1_429
+
+LBB1_576:
+	XORL AX, AX
+	MOVL $3, R11
+	MOVB $1, R15
+	JMP  LBB1_453
+
+LBB1_578:
+	MOVQ CX, R12
+	JMP  LBB1_515
+
+LBB1_579:
+	MOVQ BX, R12
+
+LBB1_580:
+	XORL  CX, CX
+	CMPQ  R12, DX
+	SETEQ CX
+	ADDQ  R12, CX
+	SUBQ  R10, CX
+	TESTQ CX, CX
+	JNE   LBB1_761
+
+LBB1_581:
+	CMPQ R10, DX
+	JAE  LBB1_760
+	MOVQ R10, R12
+	JMP  LBB1_585
+
+LBB1_601:
+	CMPB CX, $110
+	JNE  LBB1_606
+
+LBB1_583:
+	MOVQ SI, R12
+
+LBB1_584:
+	CMPQ R12, DX
+	JAE  LBB1_603
+
+LBB1_585:
+	LEAQ    1(R12), CX
+	MOVBLZX 0(R12), SI
+	CMPB    SI, $92
+	JNE     LBB1_597
+	TESTL   R8, R8
+	JE      LBB1_599
+	LEAQ    2(R12), SI
+	MOVB    $-1, R15
+	CMPQ    SI, DX
+	JA      LBB1_605
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $113
+	JLE     LBB1_601
+	CMPB    CX, $114
+	JE      LBB1_583
+	CMPB    CX, $117
+	JNE     LBB1_608
+	MOVQ    DX, CX
+	SUBQ    SI, CX
+	CMPQ    CX, $4
+	JL      LBB1_608
+	MOVL    0(SI), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), CX
+	ANDL    $-2139062144, DI
+	TESTL   CX, DI
+	JNE     LBB1_608
+	LEAL    421075225(BX), CX
+	ORL     BX, CX
+	TESTL   $-2139062144, CX
+	JNE     LBB1_608
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R9
+	ANDL    DI, AX
+	TESTL   R9, AX
+	JNE     LBB1_608
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_608
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, SI
+	SHRL    $4, SI
+	ORL     BX, SI
+	MOVL    SI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    SI, CX
+	ANDL    $128, CX
+	ADDQ    $6, R12
+	ORL     AX, CX
+	JNE     LBB1_609
+	CMPB    SI, $13
+	JNE     LBB1_600
+	JMP     LBB1_584
+
+LBB1_597:
+	MOVQ CX, R12
+	CMPB SI, $13
+	JNE  LBB1_600
+	JMP  LBB1_584
+
+LBB1_599:
+	MOVQ CX, R12
+	CMPB SI, $13
+	JE   LBB1_584
+
+LBB1_600:
+	MOVL SI, R15
+	CMPB SI, $10
+	JE   LBB1_584
+	JMP  LBB1_609
+
+LBB1_603:
+	MOVB $1, CX
+	XORL BX, BX
+	XORL R11, R11
+
+LBB1_604:
+	TESTB CX, CX
+	JE    LBB1_611
+	MOVQ  R12, R10
+	XORL  CX, CX
+	TESTQ CX, CX
+	JE    LBB1_581
+	JMP   LBB1_761
+
+LBB1_605:
+	MOVQ CX, R12
+	JMP  LBB1_609
+
+LBB1_606:
+	CMPB CX, $47
+	JNE  LBB1_608
+	MOVL CX, R15
+
+LBB1_608:
+	MOVQ SI, R12
+
+LBB1_609:
+	MOVBLZX R15, AX
+	MOVQ    -56(BP), CX
+	MOVBLZX 0(CX)(AX*1), BX
+	MOVB    $1, R14
+	CMPL    BX, $255
+	JE      LBB1_635
+	MOVL    $1, R11
+	CMPQ    R12, DX
+	JB      LBB1_617
+
+LBB1_611:
+	MOVL BX, R15
+
+LBB1_612:
+	CMPL  -44(BP), $0
+	SETEQ CX
+	CMPL  R11, $1
+	SETEQ BX
+	CMPQ  R12, DX
+	JB    LBB1_663
+	CMPL  R11, $4
+	JE    LBB1_663
+	ORB   BX, CX
+	JNE   LBB1_580
+	JMP   LBB1_663
+
+LBB1_633:
+	CMPB CX, $110
+	JNE  LBB1_671
+
+LBB1_615:
+	MOVQ DI, R12
+
+LBB1_616:
+	CMPQ R12, DX
+	JAE  LBB1_659
+
+LBB1_617:
+	LEAQ    1(R12), CX
+	MOVBLZX 0(R12), DI
+	CMPB    DI, $92
+	JNE     LBB1_629
+	TESTL   R8, R8
+	JE      LBB1_631
+	LEAQ    2(R12), DI
+	MOVB    $-1, R15
+	CMPQ    DI, DX
+	JA      LBB1_661
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $113
+	JLE     LBB1_633
+	CMPB    CX, $114
+	JE      LBB1_615
+	CMPB    CX, $117
+	JNE     LBB1_673
+	MOVQ    DX, AX
+	SUBQ    DI, AX
+	CMPQ    AX, $4
+	JL      LBB1_673
+	MOVL    BX, R11
+	MOVL    0(DI), BX
+	MOVL    BX, SI
+	NOTL    SI
+	LEAL    -808464432(BX), AX
+	ANDL    $-2139062144, SI
+	TESTL   AX, SI
+	JNE     LBB1_660
+	LEAL    421075225(BX), AX
+	ORL     BX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_660
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R9
+	ANDL    SI, AX
+	TESTL   R9, AX
+	JNE     LBB1_660
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, SI
+	TESTL   CX, SI
+	JNE     LBB1_660
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, DI
+	SHRL    $4, DI
+	ORL     BX, DI
+	MOVL    DI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    DI, CX
+	ANDL    $128, CX
+	ADDQ    $6, R12
+	ORL     AX, CX
+	MOVL    R11, BX
+	JNE     LBB1_674
+	CMPB    DI, $13
+	JNE     LBB1_632
+	JMP     LBB1_616
+
+LBB1_629:
+	MOVQ CX, R12
+	CMPB DI, $13
+	JNE  LBB1_632
+	JMP  LBB1_616
+
+LBB1_631:
+	MOVQ CX, R12
+	CMPB DI, $13
+	JE   LBB1_616
+
+LBB1_632:
+	MOVL DI, R15
+	CMPB DI, $10
+	JE   LBB1_616
+	JMP  LBB1_674
+
+LBB1_635:
+	XORL BX, BX
+	XORL R9, R9
+	XORL R11, R11
+
+LBB1_636:
+	CMPL  -44(BP), $0
+	JNE   LBB1_580
+	CMPB  R15, $61
+	JNE   LBB1_580
+	TESTB R14, R14
+	JNE   LBB1_580
+	MOVL  BX, R15
+	CMPQ  R12, DX
+	JAE   LBB1_663
+	MOVQ  R12, SI
+	JMP   LBB1_643
+
+LBB1_658:
+	MOVQ BX, SI
+	CMPQ SI, DX
+	JB   LBB1_643
+	JMP  LBB1_662
+
+LBB1_641:
+	MOVQ R12, SI
+	CMPQ SI, DX
+	JAE  LBB1_662
+
+LBB1_643:
+	LEAQ    1(SI), BX
+	MOVBLZX 0(SI), DI
+	CMPB    DI, $92
+	JNE     LBB1_655
+	TESTL   R8, R8
+	JE      LBB1_655
+	LEAQ    2(SI), R12
+	CMPQ    R12, DX
+	JA      LBB1_579
+	MOVBLZX 0(BX), CX
+	CMPB    CX, $110
+	JE      LBB1_641
+	CMPB    CX, $114
+	JE      LBB1_641
+	CMPB    CX, $117
+	JNE     LBB1_580
+	MOVQ    DX, AX
+	SUBQ    R12, AX
+	CMPQ    AX, $4
+	JL      LBB1_580
+	MOVL    0(R12), CX
+	MOVL    CX, DI
+	NOTL    DI
+	LEAL    -808464432(CX), AX
+	ANDL    $-2139062144, DI
+	TESTL   AX, DI
+	JNE     LBB1_580
+	LEAL    421075225(CX), AX
+	ORL     CX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_580
+	MOVL    CX, BX
+	ANDL    $2139062143, BX
+	MOVL    $-1061109568, AX
+	SUBL    BX, AX
+	LEAL    1179010630(BX), R14
+	ANDL    DI, AX
+	TESTL   R14, AX
+	JNE     LBB1_580
+	MOVL    $-522133280, AX
+	SUBL    BX, AX
+	ADDL    $960051513, BX
+	ANDL    AX, DI
+	TESTL   BX, DI
+	JNE     LBB1_580
+	BSWAPL  CX
+	MOVL    CX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, CX
+	ADDL    AX, CX
+	MOVL    CX, DI
+	SHRL    $4, DI
+	ORL     CX, DI
+	MOVL    DI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    DI, CX
+	ANDL    $128, CX
+	ADDQ    $6, SI
+	ORL     AX, CX
+	MOVQ    SI, BX
+	MOVQ    SI, R12
+	JNE     LBB1_580
+
+LBB1_655:
+	CMPB  DI, $10
+	JE    LBB1_658
+	CMPB  DI, $13
+	JE    LBB1_658
+	CMPB  DI, $61
+	JNE   LBB1_579
+	TESTB R9, R9
+	JNE   LBB1_579
+	CMPQ  BX, DX
+	JB    LBB1_706
+
+LBB1_700:
+	MOVQ BX, R12
+	JMP  LBB1_663
+
+LBB1_659:
+	MOVL $1, R11
+	XORL CX, CX
+	JMP  LBB1_604
+
+LBB1_660:
+	MOVQ DI, R12
+	MOVL R11, BX
+	JMP  LBB1_674
+
+LBB1_661:
+	MOVQ CX, R12
+	JMP  LBB1_674
+
+LBB1_662:
+	MOVQ SI, R12
+
+LBB1_663:
+	MOVB    $4, AX
+	SUBB    R11, AX
+	MOVBLZX AX, AX
+	ADDL    AX, AX
+	LEAL    0(AX)(AX*2), CX
+	MOVL    R15, AX
+	SHLL    CX, AX
+	CMPL    R11, $2
+	MOVQ    -64(BP), CX
+	JE      LBB1_668
+	CMPL    R11, $3
+	JE      LBB1_667
+	CMPL    R11, $4
+	JNE     LBB1_669
+	MOVB    AX, 2(CX)
+
+LBB1_667:
+	MOVB AH, 1(CX)
+
+LBB1_668:
+	SHRL $16, AX
+	MOVB AX, 0(CX)
+
+LBB1_669:
+	MOVL  R11, AX
+	ADDQ  AX, CX
+	ADDQ  $-1, CX
+	MOVQ  CX, -64(BP)
+	MOVQ  R12, R10
+	XORL  CX, CX
+	TESTQ CX, CX
+	JE    LBB1_581
+	JMP   LBB1_761
+
+LBB1_671:
+	CMPB CX, $47
+	JNE  LBB1_673
+	MOVL CX, R15
+
+LBB1_673:
+	MOVQ DI, R12
+
+LBB1_674:
+	MOVBLZX R15, AX
+	MOVQ    -56(BP), CX
+	MOVBLZX 0(CX)(AX*1), CX
+	CMPL    CX, $255
+	JE      LBB1_696
+	SHLL    $6, BX
+	ORL     CX, BX
+	MOVL    $2, R11
+	CMPQ    R12, DX
+	JB      LBB1_678
+	JMP     LBB1_611
+
+LBB1_694:
+	CMPB CX, $110
+	JNE  LBB1_724
+
+LBB1_676:
+	MOVQ SI, R12
+
+LBB1_677:
+	CMPQ R12, DX
+	JAE  LBB1_701
+
+LBB1_678:
+	LEAQ    1(R12), CX
+	MOVBLZX 0(R12), SI
+	CMPB    SI, $92
+	JNE     LBB1_690
+	TESTL   R8, R8
+	JE      LBB1_692
+	LEAQ    2(R12), SI
+	MOVB    $-1, R15
+	CMPQ    SI, DX
+	JA      LBB1_703
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $113
+	JLE     LBB1_694
+	CMPB    CX, $114
+	JE      LBB1_676
+	CMPB    CX, $117
+	JNE     LBB1_726
+	MOVQ    DX, AX
+	SUBQ    SI, AX
+	CMPQ    AX, $4
+	JL      LBB1_726
+	MOVL    BX, R11
+	MOVL    0(SI), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), AX
+	ANDL    $-2139062144, DI
+	TESTL   AX, DI
+	JNE     LBB1_702
+	LEAL    421075225(BX), AX
+	ORL     BX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_702
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R9
+	ANDL    DI, AX
+	TESTL   R9, AX
+	JNE     LBB1_702
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_702
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, SI
+	SHRL    $4, SI
+	ORL     BX, SI
+	MOVL    SI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    SI, CX
+	ANDL    $128, CX
+	ADDQ    $6, R12
+	ORL     AX, CX
+	MOVL    R11, BX
+	JE      LBB1_691
+	JMP     LBB1_727
+
+LBB1_690:
+	MOVQ CX, R12
+
+LBB1_691:
+	CMPB SI, $13
+	JNE  LBB1_693
+	JMP  LBB1_677
+
+LBB1_692:
+	MOVQ CX, R12
+	CMPB SI, $13
+	JE   LBB1_677
+
+LBB1_693:
+	MOVL SI, R15
+	CMPB SI, $10
+	JE   LBB1_677
+	JMP  LBB1_727
+
+LBB1_696:
+	XORL R9, R9
+	MOVL $1, R11
+	JMP  LBB1_636
+
+LBB1_704:
+	MOVQ R12, BX
+
+LBB1_705:
+	CMPQ BX, DX
+	JAE  LBB1_700
+
+LBB1_706:
+	LEAQ    1(BX), CX
+	MOVBLZX 0(BX), SI
+	CMPB    SI, $92
+	JNE     LBB1_718
+	TESTL   R8, R8
+	JE      LBB1_720
+	LEAQ    2(BX), R12
+	CMPQ    R12, DX
+	JA      LBB1_759
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $110
+	JE      LBB1_704
+	CMPB    CX, $114
+	JE      LBB1_704
+	CMPB    CX, $117
+	JNE     LBB1_580
+	MOVQ    DX, AX
+	SUBQ    R12, AX
+	CMPQ    AX, $4
+	JL      LBB1_580
+	MOVL    0(R12), CX
+	MOVL    CX, SI
+	NOTL    SI
+	LEAL    -808464432(CX), AX
+	ANDL    $-2139062144, SI
+	TESTL   AX, SI
+	JNE     LBB1_580
+	LEAL    421075225(CX), AX
+	ORL     CX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_580
+	MOVL    CX, DI
+	ANDL    $2139062143, DI
+	MOVL    $-1061109568, AX
+	SUBL    DI, AX
+	LEAL    1179010630(DI), R9
+	ANDL    SI, AX
+	TESTL   R9, AX
+	JNE     LBB1_580
+	MOVL    $-522133280, AX
+	SUBL    DI, AX
+	ADDL    $960051513, DI
+	ANDL    AX, SI
+	TESTL   DI, SI
+	JNE     LBB1_580
+	BSWAPL  CX
+	MOVL    CX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, CX
+	ADDL    AX, CX
+	MOVL    CX, SI
+	SHRL    $4, SI
+	ORL     CX, SI
+	MOVL    SI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    SI, CX
+	ANDL    $128, CX
+	ADDQ    $6, BX
+	ORL     AX, CX
+	MOVQ    BX, R12
+	JE      LBB1_719
+	JMP     LBB1_580
+
+LBB1_718:
+	MOVQ CX, R12
+
+LBB1_719:
+	CMPB SI, $13
+	JNE  LBB1_721
+	JMP  LBB1_704
+
+LBB1_720:
+	MOVQ CX, R12
+	CMPB SI, $13
+	JE   LBB1_704
+
+LBB1_721:
+	MOVQ R12, BX
+	CMPB SI, $10
+	JE   LBB1_705
+	JMP  LBB1_580
+
+LBB1_701:
+	MOVL $2, R11
+	XORL CX, CX
+	JMP  LBB1_604
+
+LBB1_702:
+	MOVQ SI, R12
+	MOVL R11, BX
+	JMP  LBB1_727
+
+LBB1_703:
+	MOVQ CX, R12
+	JMP  LBB1_727
+
+LBB1_724:
+	CMPB CX, $47
+	JNE  LBB1_726
+	MOVL CX, R15
+
+LBB1_726:
+	MOVQ SI, R12
+
+LBB1_727:
+	MOVBLZX R15, AX
+	MOVQ    -56(BP), CX
+	MOVBLZX 0(CX)(AX*1), CX
+	CMPL    CX, $255
+	JE      LBB1_749
+	SHLL    $6, BX
+	ORL     CX, BX
+	MOVL    $3, R11
+	CMPQ    R12, DX
+	JB      LBB1_731
+	JMP     LBB1_611
+
+LBB1_747:
+	CMPB CX, $110
+	JNE  LBB1_752
+
+LBB1_729:
+	MOVQ SI, R12
+
+LBB1_730:
+	MOVL $3, R11
+	XORL CX, CX
+	CMPQ R12, DX
+	JAE  LBB1_604
+
+LBB1_731:
+	LEAQ    1(R12), CX
+	MOVBLZX 0(R12), SI
+	CMPB    SI, $92
+	JNE     LBB1_743
+	TESTL   R8, R8
+	JE      LBB1_745
+	LEAQ    2(R12), SI
+	MOVB    $-1, R15
+	CMPQ    SI, DX
+	JA      LBB1_751
+	MOVBLZX 0(CX), CX
+	CMPB    CX, $113
+	JLE     LBB1_747
+	CMPB    CX, $114
+	JE      LBB1_729
+	CMPB    CX, $117
+	JNE     LBB1_754
+	MOVQ    DX, AX
+	SUBQ    SI, AX
+	CMPQ    AX, $4
+	JL      LBB1_754
+	MOVL    BX, R11
+	MOVL    0(SI), BX
+	MOVL    BX, DI
+	NOTL    DI
+	LEAL    -808464432(BX), AX
+	ANDL    $-2139062144, DI
+	TESTL   AX, DI
+	JNE     LBB1_750
+	LEAL    421075225(BX), AX
+	ORL     BX, AX
+	TESTL   $-2139062144, AX
+	JNE     LBB1_750
+	MOVL    BX, CX
+	ANDL    $2139062143, CX
+	MOVL    $-1061109568, AX
+	SUBL    CX, AX
+	LEAL    1179010630(CX), R9
+	ANDL    DI, AX
+	TESTL   R9, AX
+	JNE     LBB1_750
+	MOVL    $-522133280, AX
+	SUBL    CX, AX
+	ADDL    $960051513, CX
+	ANDL    AX, DI
+	TESTL   CX, DI
+	JNE     LBB1_750
+	BSWAPL  BX
+	MOVL    BX, AX
+	SHRL    $4, AX
+	NOTL    AX
+	ANDL    $16843009, AX
+	LEAL    0(AX)(AX*8), AX
+	ANDL    $252645135, BX
+	ADDL    AX, BX
+	MOVL    BX, SI
+	SHRL    $4, SI
+	ORL     BX, SI
+	MOVL    SI, AX
+	SHRL    $8, AX
+	ANDL    $65280, AX
+	MOVL    SI, CX
+	ANDL    $128, CX
+	ADDQ    $6, R12
+	ORL     AX, CX
+	MOVL    R11, BX
+	JE      LBB1_744
+	JMP     LBB1_755
+
+LBB1_743:
+	MOVQ CX, R12
+
+LBB1_744:
+	CMPB SI, $13
+	JNE  LBB1_746
+	JMP  LBB1_730
+
+LBB1_745:
+	MOVQ CX, R12
+	CMPB SI, $13
+	JE   LBB1_730
+
+LBB1_746:
+	MOVL SI, R15
+	CMPB SI, $10
+	JE   LBB1_730
+	JMP  LBB1_755
+
+LBB1_749:
+	XORL R14, R14
+	MOVL $2, R11
+	XORL R9, R9
+	JMP  LBB1_636
+
+LBB1_750:
+	MOVQ SI, R12
+	MOVL R11, BX
+	JMP  LBB1_755
+
+LBB1_751:
+	MOVQ CX, R12
+	JMP  LBB1_755
+
+LBB1_752:
+	CMPB CX, $47
+	JNE  LBB1_754
+	MOVL CX, R15
+
+LBB1_754:
+	MOVQ SI, R12
+
+LBB1_755:
+	MOVBLZX R15, AX
+	MOVQ    -56(BP), CX
+	MOVBLZX 0(CX)(AX*1), CX
+	CMPL    CX, $255
+	JE      LBB1_757
+	SHLL    $6, BX
+	ORL     CX, BX
+	MOVL    BX, R15
+	MOVL    $4, R11
+	JMP     LBB1_612
+
+LBB1_757:
+	XORL R14, R14
+	MOVL $3, R11
+	MOVB $1, R9
+	JMP  LBB1_636
+
+LBB1_759:
+	MOVQ CX, R12
+	JMP  LBB1_580
+
+LBB1_760:
+	MOVQ -64(BP), CX
+	SUBQ -112(BP), CX
+	MOVQ -120(BP), AX
+	ADDQ CX, 8(AX)
+	MOVQ CX, AX
+	JMP  LBB1_763
+
+LBB1_761:
+	ADDQ R10, CX
+
+LBB1_762:
+	MOVQ -96(BP), AX
+	SUBQ CX, AX
+
+LBB1_763:
+	ADDQ $80, SP
+	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
+	RET
+
+_TabEncodeCharsetStd:
+	QUAD $0x4847464544434241; QUAD $0x504f4e4d4c4b4a49 // .ascii 16, 'ABCDEFGHIJKLMNOP'
+	QUAD $0x5857565554535251; QUAD $0x6665646362615a59 // .ascii 16, 'QRSTUVWXYZabcdef'
+	QUAD $0x6e6d6c6b6a696867; QUAD $0x767574737271706f // .ascii 16, 'ghijklmnopqrstuv'
+	QUAD $0x333231307a797877; QUAD $0x2f2b393837363534 // .ascii 16, 'wxyz0123456789+/'
+
+_TabEncodeCharsetURL:
+	QUAD $0x4847464544434241; QUAD $0x504f4e4d4c4b4a49 // .ascii 16, 'ABCDEFGHIJKLMNOP'
+	QUAD $0x5857565554535251; QUAD $0x6665646362615a59 // .ascii 16, 'QRSTUVWXYZabcdef'
+	QUAD $0x6e6d6c6b6a696867; QUAD $0x767574737271706f // .ascii 16, 'ghijklmnopqrstuv'
+	QUAD $0x333231307a797877; QUAD $0x5f2d393837363534 // .ascii 16, 'wxyz0123456789-_'
+
+_VecDecodeCharsetStd:
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0x3fffffff3effffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff>\xff\xff\xff?'
+	QUAD $0x3b3a393837363534; QUAD $0xffffffffffff3d3c // .ascii 16, '456789:;<=\xff\xff\xff\xff\xff\xff'
+	QUAD $0x06050403020100ff; QUAD $0x0e0d0c0b0a090807 // .ascii 16, '\xff\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e'
+	QUAD $0x161514131211100f; QUAD $0xffffffffff191817 // .ascii 16, '\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\xff\xff\xff\xff\xff'
+	QUAD $0x201f1e1d1c1b1aff; QUAD $0x2827262524232221 // .ascii 16, '\xff\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'('
+	QUAD $0x302f2e2d2c2b2a29; QUAD $0xffffffffff333231 // .ascii 16, ')*+,-./0123\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+
+_VecDecodeCharsetURL:
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffff3effffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff>\xff\xff'
+	QUAD $0x3b3a393837363534; QUAD $0xffffffffffff3d3c // .ascii 16, '456789:;<=\xff\xff\xff\xff\xff\xff'
+	QUAD $0x06050403020100ff; QUAD $0x0e0d0c0b0a090807 // .ascii 16, '\xff\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e'
+	QUAD $0x161514131211100f; QUAD $0x3fffffffff191817 // .ascii 16, '\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\xff\xff\xff\xff?'
+	QUAD $0x201f1e1d1c1b1aff; QUAD $0x2827262524232221 // .ascii 16, '\xff\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'('
+	QUAD $0x302f2e2d2c2b2a29; QUAD $0xffffffffff333231 // .ascii 16, ')*+,-./0123\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+	QUAD $0xffffffffffffffff; QUAD $0xffffffffffffffff // .ascii 16, '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
+
+TEXT ·__b64decode(SB), NOSPLIT | NOFRAME, $0 - 40
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -128(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_b64decode:
+	MOVQ out+0(FP), DI
+	MOVQ src+8(FP), SI
+	MOVQ len+16(FP), DX
+	MOVQ mode+24(FP), CX
+	CALL ·__native_entry__+1563(SB) // _b64decode
+	MOVQ AX, ret+32(FP)
+	RET
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
+
+TEXT ·__b64encode(SB), NOSPLIT | NOFRAME, $0 - 24
+	NO_LOCAL_POINTERS
+
+_entry:
+	MOVQ (TLS), R14
+	LEAQ -40(SP), R12
+	CMPQ R12, 16(R14)
+	JBE  _stack_grow
+
+_b64encode:
+	MOVQ out+0(FP), DI
+	MOVQ src+8(FP), SI
+	MOVQ mode+16(FP), DX
+	LEAQ ·__native_entry__+301(SB), AX // _b64encode
+	JMP  AX
+
+_stack_grow:
+	CALL runtime·morestack_noctxt<>(SB)
+	JMP  _entry
diff --git a/vendor/github.com/chenzhuoyu/base64x/native_subr_amd64.go b/vendor/github.com/chenzhuoyu/base64x/native_subr_amd64.go
new file mode 100644
index 000000000..f18de543e
--- /dev/null
+++ b/vendor/github.com/chenzhuoyu/base64x/native_subr_amd64.go
@@ -0,0 +1,29 @@
+// +build !noasm !appengine
+// Code generated by asm2asm, DO NOT EDIT.
+
+package base64x
+
+//go:nosplit
+//go:noescape
+//goland:noinspection ALL
+func __native_entry__() uintptr
+
+var (
+    _subr__b64decode = __native_entry__() + 1563
+    _subr__b64encode = __native_entry__() + 301
+)
+
+const (
+    _stack__b64decode = 128
+    _stack__b64encode = 40
+)
+
+var (
+    _ = _subr__b64decode
+    _ = _subr__b64encode
+)
+
+const (
+    _ = _stack__b64decode
+    _ = _stack__b64encode
+)
diff --git a/vendor/github.com/gin-gonic/gin/CHANGELOG.md b/vendor/github.com/gin-gonic/gin/CHANGELOG.md
index af8bfb1e1..cf24ec286 100644
--- a/vendor/github.com/gin-gonic/gin/CHANGELOG.md
+++ b/vendor/github.com/gin-gonic/gin/CHANGELOG.md
@@ -1,13 +1,49 @@
 # Gin ChangeLog
 
+## Gin v1.9.0
+
+### BREAK CHANGES
+
+* Stop useless panicking in context and render [#2150](https://github.com/gin-gonic/gin/pull/2150)
+
+### BUG FIXES
+
+* fix(router): tree bug where loop index is not decremented. [#3460](https://github.com/gin-gonic/gin/pull/3460)
+* fix(context): panic on NegotiateFormat - index out of range [#3397](https://github.com/gin-gonic/gin/pull/3397)
+* Add escape logic for header [#3500](https://github.com/gin-gonic/gin/pull/3500) and [#3503](https://github.com/gin-gonic/gin/pull/3503)
+
+### SECURITY
+
+* Fix the GO-2022-0969 and GO-2022-0288 vulnerabilities [#3333](https://github.com/gin-gonic/gin/pull/3333)
+* fix(security): vulnerability GO-2023-1571 [#3505](https://github.com/gin-gonic/gin/pull/3505)
+
+### ENHANCEMENTS
+
+* feat: add sonic json support [#3184](https://github.com/gin-gonic/gin/pull/3184)
+* chore(file): Creates a directory named path [#3316](https://github.com/gin-gonic/gin/pull/3316)
+* fix: modify interface check way [#3327](https://github.com/gin-gonic/gin/pull/3327)
+* remove deprecated of package io/ioutil [#3395](https://github.com/gin-gonic/gin/pull/3395)
+* refactor: avoid calling strings.ToLower twice [#3343](https://github.com/gin-gonic/gin/pull/3433)
+* console logger HTTP status code bug fixed [#3453](https://github.com/gin-gonic/gin/pull/3453)
+* chore(yaml): upgrade dependency to v3 version [#3456](https://github.com/gin-gonic/gin/pull/3456)
+* chore(router): match method added to routergroup for multiple HTTP methods supporting [#3464](https://github.com/gin-gonic/gin/pull/3464)
+* chore(http): add support for go1.20 http.rwUnwrapper to gin.responseWriter [#3489](https://github.com/gin-gonic/gin/pull/3489)
+
+### DOCS
+
+* docs: update markdown format [#3260](https://github.com/gin-gonic/gin/pull/3260)
+* docs(readme): Add the TOML rendering example [#3400](https://github.com/gin-gonic/gin/pull/3400)
+* docs(readme): move more example to docs/doc.md [#3449](https://github.com/gin-gonic/gin/pull/3449)
+* docs: update markdown format [#3446](https://github.com/gin-gonic/gin/pull/3446)
+
 ## Gin v1.8.2
 
-### Bugs
+### BUG FIXES
 
 * fix(route): redirectSlash bug ([#3227]((https://github.com/gin-gonic/gin/pull/3227)))
 * fix(engine): missing route params for CreateTestContext ([#2778]((https://github.com/gin-gonic/gin/pull/2778))) ([#2803]((https://github.com/gin-gonic/gin/pull/2803)))
 
-### Security
+### SECURITY
 
 * Fix the GO-2022-1144 vulnerability ([#3432]((https://github.com/gin-gonic/gin/pull/3432)))
 
@@ -19,12 +55,12 @@
 
 ## Gin v1.8.0
 
-## Break Changes
+### BREAK CHANGES
 
 * TrustedProxies: Add default IPv6 support and refactor [#2967](https://github.com/gin-gonic/gin/pull/2967). Please replace `RemoteIP() (net.IP, bool)` with `RemoteIP() net.IP`
 * gin.Context with fallback value from gin.Context.Request.Context() [#2751](https://github.com/gin-gonic/gin/pull/2751)
 
-### BUGFIXES
+### BUG FIXES
 
 * Fixed SetOutput() panics on go 1.17 [#2861](https://github.com/gin-gonic/gin/pull/2861)
 * Fix: wrong when wildcard follows named param [#2983](https://github.com/gin-gonic/gin/pull/2983)
@@ -61,7 +97,7 @@
 
 ## Gin v1.7.7
 
-### BUGFIXES
+### BUG FIXES
 
 * Fixed X-Forwarded-For unsafe handling of CVE-2020-28483 [#2844](https://github.com/gin-gonic/gin/pull/2844), closed issue [#2862](https://github.com/gin-gonic/gin/issues/2862).
 * Tree: updated the code logic for `latestNode` [#2897](https://github.com/gin-gonic/gin/pull/2897), closed issue [#2894](https://github.com/gin-gonic/gin/issues/2894) [#2878](https://github.com/gin-gonic/gin/issues/2878).
@@ -79,37 +115,37 @@
 
 ## Gin v1.7.6
 
-### BUGFIXES
+### BUG FIXES
 
 * bump new release to fix v1.7.5 release error by using v1.7.4 codes.
 
 ## Gin v1.7.4
 
-### BUGFIXES
+### BUG FIXES
 
 * bump new release to fix checksum mismatch
 
 ## Gin v1.7.3
 
-### BUGFIXES
+### BUG FIXES
 
 * fix level 1 router match [#2767](https://github.com/gin-gonic/gin/issues/2767), [#2796](https://github.com/gin-gonic/gin/issues/2796)
 
 ## Gin v1.7.2
 
-### BUGFIXES
+### BUG FIXES
 
 * Fix conflict between param and exact path [#2706](https://github.com/gin-gonic/gin/issues/2706). Close issue [#2682](https://github.com/gin-gonic/gin/issues/2682) [#2696](https://github.com/gin-gonic/gin/issues/2696).
 
 ## Gin v1.7.1
 
-### BUGFIXES
+### BUG FIXES
 
 * fix: data race with trustedCIDRs from [#2674](https://github.com/gin-gonic/gin/issues/2674)([#2675](https://github.com/gin-gonic/gin/pull/2675))
 
 ## Gin v1.7.0
 
-### BUGFIXES
+### BUG FIXES
 
 * fix compile error from [#2572](https://github.com/gin-gonic/gin/pull/2572) ([#2600](https://github.com/gin-gonic/gin/pull/2600))
 * fix: print headers without Authorization header on broken pipe ([#2528](https://github.com/gin-gonic/gin/pull/2528))
@@ -124,7 +160,7 @@
 * chore(performance): improve countParams ([#2378](https://github.com/gin-gonic/gin/pull/2378))
 * Remove some functions that have the same effect as the bytes package ([#2387](https://github.com/gin-gonic/gin/pull/2387))
 * update:SetMode function ([#2321](https://github.com/gin-gonic/gin/pull/2321))
-* remove a unused type SecureJSONPrefix ([#2391](https://github.com/gin-gonic/gin/pull/2391))
+* remove an unused type SecureJSONPrefix ([#2391](https://github.com/gin-gonic/gin/pull/2391))
 * Add a redirect sample for POST method ([#2389](https://github.com/gin-gonic/gin/pull/2389))
 * Add CustomRecovery builtin middleware ([#2322](https://github.com/gin-gonic/gin/pull/2322))
 * binding: avoid 2038 problem on 32-bit architectures ([#2450](https://github.com/gin-gonic/gin/pull/2450))
@@ -148,33 +184,44 @@
 
 ## Gin v1.6.2
 
-### BUGFIXES
+### BUG FIXES
+
   * fix missing initial sync.RWMutex [#2305](https://github.com/gin-gonic/gin/pull/2305)
+
 ### ENHANCEMENTS
+
   * Add set samesite in cookie. [#2306](https://github.com/gin-gonic/gin/pull/2306)
 
 ## Gin v1.6.1
 
-### BUGFIXES
+### BUG FIXES
+
   * Revert "fix accept incoming network connections" [#2294](https://github.com/gin-gonic/gin/pull/2294)
 
 ## Gin v1.6.0
 
 ### BREAKING
+
   * chore(performance): Improve performance for adding RemoveExtraSlash flag [#2159](https://github.com/gin-gonic/gin/pull/2159)
   * drop support govendor [#2148](https://github.com/gin-gonic/gin/pull/2148)
   * Added support for SameSite cookie flag [#1615](https://github.com/gin-gonic/gin/pull/1615)
+
 ### FEATURES
+
   * add yaml negotiation [#2220](https://github.com/gin-gonic/gin/pull/2220)
   * FileFromFS [#2112](https://github.com/gin-gonic/gin/pull/2112)
-### BUGFIXES
+
+### BUG FIXES
+
   * Unix Socket Handling [#2280](https://github.com/gin-gonic/gin/pull/2280)
   * Use json marshall in context json to fix breaking new line issue. Fixes #2209 [#2228](https://github.com/gin-gonic/gin/pull/2228)
   * fix accept incoming network connections [#2216](https://github.com/gin-gonic/gin/pull/2216)
   * Fixed a bug in the calculation of the maximum number of parameters [#2166](https://github.com/gin-gonic/gin/pull/2166)
   * [FIX] allow empty headers on DataFromReader [#2121](https://github.com/gin-gonic/gin/pull/2121)
   * Add mutex for protect Context.Keys map [#1391](https://github.com/gin-gonic/gin/pull/1391)
+
 ### ENHANCEMENTS
+
   * Add mitigation for log injection [#2277](https://github.com/gin-gonic/gin/pull/2277)
   * tree: range over nodes values [#2229](https://github.com/gin-gonic/gin/pull/2229)
   * tree: remove duplicate assignment [#2222](https://github.com/gin-gonic/gin/pull/2222)
@@ -189,7 +236,9 @@
   * upgrade go-validator to v10 [#2149](https://github.com/gin-gonic/gin/pull/2149)
   * Refactor redirect request in gin.go [#1970](https://github.com/gin-gonic/gin/pull/1970)
   * Add build tag nomsgpack [#1852](https://github.com/gin-gonic/gin/pull/1852)
+
 ### DOCS
+
   * docs(path): improve comments [#2223](https://github.com/gin-gonic/gin/pull/2223)
   * Renew README to fit the modification of SetCookie method [#2217](https://github.com/gin-gonic/gin/pull/2217)
   * Fix spelling [#2202](https://github.com/gin-gonic/gin/pull/2202)
@@ -202,7 +251,9 @@
   * Add project to README [#2165](https://github.com/gin-gonic/gin/pull/2165)
   * docs(benchmarks): for gin v1.5 [#2153](https://github.com/gin-gonic/gin/pull/2153)
   * Changed wording for clarity in README.md [#2122](https://github.com/gin-gonic/gin/pull/2122)
+
 ### MISC
+
   * ci support go1.14 [#2262](https://github.com/gin-gonic/gin/pull/2262)
   * chore: upgrade depend version [#2231](https://github.com/gin-gonic/gin/pull/2231)
   * Drop support go1.10 [#2147](https://github.com/gin-gonic/gin/pull/2147)
diff --git a/vendor/github.com/gin-gonic/gin/Makefile b/vendor/github.com/gin-gonic/gin/Makefile
index 5d55b444c..ebde4ee84 100644
--- a/vendor/github.com/gin-gonic/gin/Makefile
+++ b/vendor/github.com/gin-gonic/gin/Makefile
@@ -11,7 +11,7 @@ TESTTAGS ?= ""
 test:
 	echo "mode: count" > coverage.out
 	for d in $(TESTFOLDER); do \
-		$(GO) test -tags $(TESTTAGS) -v -covermode=count -coverprofile=profile.out $$d > tmp.out; \
+		$(GO) test $(TESTTAGS) -v -covermode=count -coverprofile=profile.out $$d > tmp.out; \
 		cat tmp.out; \
 		if grep -q "^--- FAIL" tmp.out; then \
 			rm tmp.out; \
diff --git a/vendor/github.com/gin-gonic/gin/README.md b/vendor/github.com/gin-gonic/gin/README.md
index 5cc8321b6..336155a99 100644
--- a/vendor/github.com/gin-gonic/gin/README.md
+++ b/vendor/github.com/gin-gonic/gin/README.md
@@ -12,135 +12,109 @@
 [![Release](https://img.shields.io/github/release/gin-gonic/gin.svg?style=flat-square)](https://github.com/gin-gonic/gin/releases)
 [![TODOs](https://badgen.net/https/api.tickgit.com/badgen/github.com/gin-gonic/gin)](https://www.tickgit.com/browse?repo=github.com/gin-gonic/gin)
 
-Gin is a web framework written in Go (Golang). It features a martini-like API with performance that is up to 40 times faster thanks to [httprouter](https://github.com/julienschmidt/httprouter). If you need performance and good productivity, you will love Gin.
+Gin is a web framework written in [Go](https://go.dev/). It features a martini-like API with performance that is up to 40 times faster thanks to [httprouter](https://github.com/julienschmidt/httprouter). If you need performance and good productivity, you will love Gin.
 
+**The key features of Gin are:**
 
-## Contents
+- Zero allocation router
+- Fast
+- Middleware support
+- Crash-free
+- JSON validation
+- Routes grouping
+- Error management
+- Rendering built-in
+- Extendable
 
-- [Gin Web Framework](#gin-web-framework)
-  - [Contents](#contents)
-  - [Installation](#installation)
-  - [Quick start](#quick-start)
-  - [Benchmarks](#benchmarks)
-  - [Gin v1. stable](#gin-v1-stable)
-  - [Build with jsoniter/go-json](#build-with-json-replacement)
-  - [Build without `MsgPack` rendering feature](#build-without-msgpack-rendering-feature)
-  - [API Examples](#api-examples)
-    - [Using GET, POST, PUT, PATCH, DELETE and OPTIONS](#using-get-post-put-patch-delete-and-options)
-    - [Parameters in path](#parameters-in-path)
-    - [Querystring parameters](#querystring-parameters)
-    - [Multipart/Urlencoded Form](#multiparturlencoded-form)
-    - [Another example: query + post form](#another-example-query--post-form)
-    - [Map as querystring or postform parameters](#map-as-querystring-or-postform-parameters)
-    - [Upload files](#upload-files)
-      - [Single file](#single-file)
-      - [Multiple files](#multiple-files)
-    - [Grouping routes](#grouping-routes)
-    - [Blank Gin without middleware by default](#blank-gin-without-middleware-by-default)
-    - [Using middleware](#using-middleware)
-    - [How to write log file](#how-to-write-log-file)
-    - [Custom Log Format](#custom-log-format)
-    - [Controlling Log output coloring](#controlling-log-output-coloring)
-    - [Model binding and validation](#model-binding-and-validation)
-    - [Custom Validators](#custom-validators)
-    - [Only Bind Query String](#only-bind-query-string)
-    - [Bind Query String or Post Data](#bind-query-string-or-post-data)
-    - [Bind Uri](#bind-uri)
-    - [Bind Header](#bind-header)
-    - [Bind HTML checkboxes](#bind-html-checkboxes)
-    - [Multipart/Urlencoded binding](#multiparturlencoded-binding)
-    - [XML, JSON, YAML and ProtoBuf rendering](#xml-json-yaml-and-protobuf-rendering)
-      - [SecureJSON](#securejson)
-      - [JSONP](#jsonp)
-      - [AsciiJSON](#asciijson)
-      - [PureJSON](#purejson)
-    - [Serving static files](#serving-static-files)
-    - [Serving data from file](#serving-data-from-file)
-    - [Serving data from reader](#serving-data-from-reader)
-    - [HTML rendering](#html-rendering)
-      - [Custom Template renderer](#custom-template-renderer)
-      - [Custom Delimiters](#custom-delimiters)
-      - [Custom Template Funcs](#custom-template-funcs)
-    - [Multitemplate](#multitemplate)
-    - [Redirects](#redirects)
-    - [Custom Middleware](#custom-middleware)
-    - [Using BasicAuth() middleware](#using-basicauth-middleware)
-    - [Goroutines inside a middleware](#goroutines-inside-a-middleware)
-    - [Custom HTTP configuration](#custom-http-configuration)
-    - [Support Let's Encrypt](#support-lets-encrypt)
-    - [Run multiple service using Gin](#run-multiple-service-using-gin)
-    - [Graceful shutdown or restart](#graceful-shutdown-or-restart)
-      - [Third-party packages](#third-party-packages)
-      - [Manually](#manually)
-    - [Build a single binary with templates](#build-a-single-binary-with-templates)
-    - [Bind form-data request with custom struct](#bind-form-data-request-with-custom-struct)
-    - [Try to bind body into different structs](#try-to-bind-body-into-different-structs)
-    - [http2 server push](#http2-server-push)
-    - [Define format for the log of routes](#define-format-for-the-log-of-routes)
-    - [Set and get a cookie](#set-and-get-a-cookie)
-  - [Don't trust all proxies](#dont-trust-all-proxies)
-  - [Testing](#testing)
-  - [Users](#users)
 
-## Installation
+## Getting started
 
-To install Gin package, you need to install Go and set your Go workspace first.
+### Prerequisites
 
-1. You first need [Go](https://golang.org/) installed (**version 1.14+ is required**), then you can use the below Go command to install Gin.
+- **[Go](https://go.dev/)**: ~~any one of the **three latest major** [releases](https://go.dev/doc/devel/release)~~ (now version **1.16+** is required).
 
-```sh
-$ go get -u github.com/gin-gonic/gin
-```
+### Getting Gin
 
-2. Import it in your code:
+With [Go module](https://github.com/golang/go/wiki/Modules) support, simply add the following import
 
-```go
+```
 import "github.com/gin-gonic/gin"
 ```
 
-3. (Optional) Import `net/http`. This is required for example if using constants such as `http.StatusOK`.
-
-```go
-import "net/http"
-```
+to your code, and then `go [build|run|test]` will automatically fetch the necessary dependencies.
 
-## Quick start
+Otherwise, run the following Go command to install the `gin` package:
 
 ```sh
-# assume the following codes in example.go file
-$ cat example.go
+$ go get -u github.com/gin-gonic/gin
 ```
 
+### Running Gin
+
+First you need to import Gin package for using Gin, one simplest example likes the follow `example.go`:
+
 ```go
 package main
 
 import (
-	"net/http"
+  "net/http"
 
-	"github.com/gin-gonic/gin"
+  "github.com/gin-gonic/gin"
 )
 
 func main() {
-	r := gin.Default()
-	r.GET("/ping", func(c *gin.Context) {
-		c.JSON(http.StatusOK, gin.H{
-			"message": "pong",
-		})
-	})
-	r.Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
+  r := gin.Default()
+  r.GET("/ping", func(c *gin.Context) {
+    c.JSON(http.StatusOK, gin.H{
+      "message": "pong",
+    })
+  })
+  r.Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
 }
 ```
 
+And use the Go command to run the demo:
+
 ```
-# run example.go and visit 0.0.0.0:8080/ping (for windows "localhost:8080/ping") on browser
+# run example.go and visit 0.0.0.0:8080/ping on browser
 $ go run example.go
 ```
 
-## Benchmarks
+### Learn more examples
+
+#### Quick Start
+
+Learn and practice more examples, please read the [Gin Quick Start](docs/doc.md) which includes API examples and builds tag.
+
+#### Examples
+
+A number of ready-to-run examples demonstrating various use cases of Gin on the [Gin examples](https://github.com/gin-gonic/examples) repository.
+
+
+## Documentation
+
+See [API documentation and descriptions](https://godoc.org/github.com/gin-gonic/gin) for package.
+
+All documentation is available on the Gin website.
+
+- [English](https://gin-gonic.com/docs/)
+- [简体中文](https://gin-gonic.com/zh-cn/docs/)
+- [繁體中文](https://gin-gonic.com/zh-tw/docs/)
+- [日本語](https://gin-gonic.com/ja/docs/)
+- [Español](https://gin-gonic.com/es/docs/)
+- [한국어](https://gin-gonic.com/ko-kr/docs/)
+- [Turkish](https://gin-gonic.com/tr/docs/)
+- [Persian](https://gin-gonic.com/fa/docs/)
+
+### Articles about Gin
+
+A curated list of awesome Gin framework.
+
+- [Tutorial: Developing a RESTful API with Go and Gin](https://go.dev/doc/tutorial/web-service-gin)
 
-Gin uses a custom version of [HttpRouter](https://github.com/julienschmidt/httprouter)
+## Benchmarks
 
-[See all benchmarks](/BENCHMARKS.md)
+Gin uses a custom version of [HttpRouter](https://github.com/julienschmidt/httprouter), [see all benchmarks details](/BENCHMARKS.md).
 
 | Benchmark name                 |       (1) |             (2) |          (3) |             (4) |
 | ------------------------------ | ---------:| ---------------:| ------------:| ---------------:|
@@ -180,2159 +154,11 @@ Gin uses a custom version of [HttpRouter](https://github.com/julienschmidt/httpr
 - (3): Heap Memory (B/op), lower is better
 - (4): Average Allocations per Repetition (allocs/op), lower is better
 
-## Gin v1. stable
-
-- [x] Zero allocation router.
-- [x] Still the fastest http router and framework. From routing to writing.
-- [x] Complete suite of unit tests.
-- [x] Battle tested.
-- [x] API frozen, new releases will not break your code.
-
-## Build with json replacement
-
-Gin uses `encoding/json` as default json package but you can change it by build from other tags.
-
-[jsoniter](https://github.com/json-iterator/go)
-```sh
-$ go build -tags=jsoniter .
-```
-[go-json](https://github.com/goccy/go-json)
-```sh
-$ go build -tags=go_json .
-```
-
-## Build without `MsgPack` rendering feature
-
-Gin enables `MsgPack` rendering feature by default. But you can disable this feature by specifying `nomsgpack` build tag.
-
-```sh
-$ go build -tags=nomsgpack .
-```
-
-This is useful to reduce the binary size of executable files. See the [detail information](https://github.com/gin-gonic/gin/pull/1852).
-
-## API Examples
-
-You can find a number of ready-to-run examples at [Gin examples repository](https://github.com/gin-gonic/examples).
-
-### Using GET, POST, PUT, PATCH, DELETE and OPTIONS
-
-```go
-func main() {
-	// Creates a gin router with default middleware:
-	// logger and recovery (crash-free) middleware
-	router := gin.Default()
-
-	router.GET("/someGet", getting)
-	router.POST("/somePost", posting)
-	router.PUT("/somePut", putting)
-	router.DELETE("/someDelete", deleting)
-	router.PATCH("/somePatch", patching)
-	router.HEAD("/someHead", head)
-	router.OPTIONS("/someOptions", options)
-
-	// By default it serves on :8080 unless a
-	// PORT environment variable was defined.
-	router.Run()
-	// router.Run(":3000") for a hard coded port
-}
-```
-
-### Parameters in path
-
-```go
-func main() {
-	router := gin.Default()
-
-	// This handler will match /user/john but will not match /user/ or /user
-	router.GET("/user/:name", func(c *gin.Context) {
-		name := c.Param("name")
-		c.String(http.StatusOK, "Hello %s", name)
-	})
-
-	// However, this one will match /user/john/ and also /user/john/send
-	// If no other routers match /user/john, it will redirect to /user/john/
-	router.GET("/user/:name/*action", func(c *gin.Context) {
-		name := c.Param("name")
-		action := c.Param("action")
-		message := name + " is " + action
-		c.String(http.StatusOK, message)
-	})
-
-	// For each matched request Context will hold the route definition
-	router.POST("/user/:name/*action", func(c *gin.Context) {
-		b := c.FullPath() == "/user/:name/*action" // true
-		c.String(http.StatusOK, "%t", b)
-	})
-
-	// This handler will add a new router for /user/groups.
-	// Exact routes are resolved before param routes, regardless of the order they were defined.
-	// Routes starting with /user/groups are never interpreted as /user/:name/... routes
-	router.GET("/user/groups", func(c *gin.Context) {
-		c.String(http.StatusOK, "The available groups are [...]")
-	})
-
-	router.Run(":8080")
-}
-```
-
-### Querystring parameters
-
-```go
-func main() {
-	router := gin.Default()
-
-	// Query string parameters are parsed using the existing underlying request object.
-	// The request responds to a url matching:  /welcome?firstname=Jane&lastname=Doe
-	router.GET("/welcome", func(c *gin.Context) {
-		firstname := c.DefaultQuery("firstname", "Guest")
-		lastname := c.Query("lastname") // shortcut for c.Request.URL.Query().Get("lastname")
-
-		c.String(http.StatusOK, "Hello %s %s", firstname, lastname)
-	})
-	router.Run(":8080")
-}
-```
-
-### Multipart/Urlencoded Form
-
-```go
-func main() {
-	router := gin.Default()
-
-	router.POST("/form_post", func(c *gin.Context) {
-		message := c.PostForm("message")
-		nick := c.DefaultPostForm("nick", "anonymous")
-
-		c.JSON(http.StatusOK, gin.H{
-			"status":  "posted",
-			"message": message,
-			"nick":    nick,
-		})
-	})
-	router.Run(":8080")
-}
-```
-
-### Another example: query + post form
-
-```
-POST /post?id=1234&page=1 HTTP/1.1
-Content-Type: application/x-www-form-urlencoded
-
-name=manu&message=this_is_great
-```
-
-```go
-func main() {
-	router := gin.Default()
-
-	router.POST("/post", func(c *gin.Context) {
-
-		id := c.Query("id")
-		page := c.DefaultQuery("page", "0")
-		name := c.PostForm("name")
-		message := c.PostForm("message")
-
-		fmt.Printf("id: %s; page: %s; name: %s; message: %s", id, page, name, message)
-	})
-	router.Run(":8080")
-}
-```
-
-```
-id: 1234; page: 1; name: manu; message: this_is_great
-```
-
-### Map as querystring or postform parameters
-
-```
-POST /post?ids[a]=1234&ids[b]=hello HTTP/1.1
-Content-Type: application/x-www-form-urlencoded
-
-names[first]=thinkerou&names[second]=tianou
-```
-
-```go
-func main() {
-	router := gin.Default()
-
-	router.POST("/post", func(c *gin.Context) {
-
-		ids := c.QueryMap("ids")
-		names := c.PostFormMap("names")
-
-		fmt.Printf("ids: %v; names: %v", ids, names)
-	})
-	router.Run(":8080")
-}
-```
-
-```
-ids: map[b:hello a:1234]; names: map[second:tianou first:thinkerou]
-```
-
-### Upload files
-
-#### Single file
-
-References issue [#774](https://github.com/gin-gonic/gin/issues/774) and detail [example code](https://github.com/gin-gonic/examples/tree/master/upload-file/single).
-
-`file.Filename` **SHOULD NOT** be trusted. See [`Content-Disposition` on MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition#Directives) and [#1693](https://github.com/gin-gonic/gin/issues/1693)
-
-> The filename is always optional and must not be used blindly by the application: path information should be stripped, and conversion to the server file system rules should be done.
-
-```go
-func main() {
-	router := gin.Default()
-	// Set a lower memory limit for multipart forms (default is 32 MiB)
-	router.MaxMultipartMemory = 8 << 20  // 8 MiB
-	router.POST("/upload", func(c *gin.Context) {
-		// Single file
-		file, _ := c.FormFile("file")
-		log.Println(file.Filename)
-
-		// Upload the file to specific dst.
-		c.SaveUploadedFile(file, dst)
-
-		c.String(http.StatusOK, fmt.Sprintf("'%s' uploaded!", file.Filename))
-	})
-	router.Run(":8080")
-}
-```
-
-How to `curl`:
-
-```bash
-curl -X POST http://localhost:8080/upload \
-  -F "file=@/Users/appleboy/test.zip" \
-  -H "Content-Type: multipart/form-data"
-```
-
-#### Multiple files
-
-See the detail [example code](https://github.com/gin-gonic/examples/tree/master/upload-file/multiple).
-
-```go
-func main() {
-	router := gin.Default()
-	// Set a lower memory limit for multipart forms (default is 32 MiB)
-	router.MaxMultipartMemory = 8 << 20  // 8 MiB
-	router.POST("/upload", func(c *gin.Context) {
-		// Multipart form
-		form, _ := c.MultipartForm()
-		files := form.File["upload[]"]
-
-		for _, file := range files {
-			log.Println(file.Filename)
-
-			// Upload the file to specific dst.
-			c.SaveUploadedFile(file, dst)
-		}
-		c.String(http.StatusOK, fmt.Sprintf("%d files uploaded!", len(files)))
-	})
-	router.Run(":8080")
-}
-```
-
-How to `curl`:
-
-```bash
-curl -X POST http://localhost:8080/upload \
-  -F "upload[]=@/Users/appleboy/test1.zip" \
-  -F "upload[]=@/Users/appleboy/test2.zip" \
-  -H "Content-Type: multipart/form-data"
-```
-
-### Grouping routes
-
-```go
-func main() {
-	router := gin.Default()
-
-	// Simple group: v1
-	v1 := router.Group("/v1")
-	{
-		v1.POST("/login", loginEndpoint)
-		v1.POST("/submit", submitEndpoint)
-		v1.POST("/read", readEndpoint)
-	}
-
-	// Simple group: v2
-	v2 := router.Group("/v2")
-	{
-		v2.POST("/login", loginEndpoint)
-		v2.POST("/submit", submitEndpoint)
-		v2.POST("/read", readEndpoint)
-	}
-
-	router.Run(":8080")
-}
-```
-
-### Blank Gin without middleware by default
-
-Use
-
-```go
-r := gin.New()
-```
-
-instead of
-
-```go
-// Default With the Logger and Recovery middleware already attached
-r := gin.Default()
-```
-
-
-### Using middleware
-```go
-func main() {
-	// Creates a router without any middleware by default
-	r := gin.New()
-
-	// Global middleware
-	// Logger middleware will write the logs to gin.DefaultWriter even if you set with GIN_MODE=release.
-	// By default gin.DefaultWriter = os.Stdout
-	r.Use(gin.Logger())
-
-	// Recovery middleware recovers from any panics and writes a 500 if there was one.
-	r.Use(gin.Recovery())
-
-	// Per route middleware, you can add as many as you desire.
-	r.GET("/benchmark", MyBenchLogger(), benchEndpoint)
-
-	// Authorization group
-	// authorized := r.Group("/", AuthRequired())
-	// exactly the same as:
-	authorized := r.Group("/")
-	// per group middleware! in this case we use the custom created
-	// AuthRequired() middleware just in the "authorized" group.
-	authorized.Use(AuthRequired())
-	{
-		authorized.POST("/login", loginEndpoint)
-		authorized.POST("/submit", submitEndpoint)
-		authorized.POST("/read", readEndpoint)
-
-		// nested group
-		testing := authorized.Group("testing")
-		// visit 0.0.0.0:8080/testing/analytics
-		testing.GET("/analytics", analyticsEndpoint)
-	}
-
-	// Listen and serve on 0.0.0.0:8080
-	r.Run(":8080")
-}
-```
-
-### Custom Recovery behavior
-```go
-func main() {
-	// Creates a router without any middleware by default
-	r := gin.New()
-
-	// Global middleware
-	// Logger middleware will write the logs to gin.DefaultWriter even if you set with GIN_MODE=release.
-	// By default gin.DefaultWriter = os.Stdout
-	r.Use(gin.Logger())
-
-	// Recovery middleware recovers from any panics and writes a 500 if there was one.
-	r.Use(gin.CustomRecovery(func(c *gin.Context, recovered interface{}) {
-		if err, ok := recovered.(string); ok {
-			c.String(http.StatusInternalServerError, fmt.Sprintf("error: %s", err))
-		}
-		c.AbortWithStatus(http.StatusInternalServerError)
-	}))
-
-	r.GET("/panic", func(c *gin.Context) {
-		// panic with a string -- the custom middleware could save this to a database or report it to the user
-		panic("foo")
-	})
-
-	r.GET("/", func(c *gin.Context) {
-		c.String(http.StatusOK, "ohai")
-	})
-
-	// Listen and serve on 0.0.0.0:8080
-	r.Run(":8080")
-}
-```
-
-### How to write log file
-```go
-func main() {
-    // Disable Console Color, you don't need console color when writing the logs to file.
-    gin.DisableConsoleColor()
-
-    // Logging to a file.
-    f, _ := os.Create("gin.log")
-    gin.DefaultWriter = io.MultiWriter(f)
-
-    // Use the following code if you need to write the logs to file and console at the same time.
-    // gin.DefaultWriter = io.MultiWriter(f, os.Stdout)
-
-    router := gin.Default()
-    router.GET("/ping", func(c *gin.Context) {
-        c.String(http.StatusOK, "pong")
-    })
-
-    router.Run(":8080")
-}
-```
-
-### Custom Log Format
-```go
-func main() {
-	router := gin.New()
-
-	// LoggerWithFormatter middleware will write the logs to gin.DefaultWriter
-	// By default gin.DefaultWriter = os.Stdout
-	router.Use(gin.LoggerWithFormatter(func(param gin.LogFormatterParams) string {
-
-		// your custom format
-		return fmt.Sprintf("%s - [%s] \"%s %s %s %d %s \"%s\" %s\"\n",
-				param.ClientIP,
-				param.TimeStamp.Format(time.RFC1123),
-				param.Method,
-				param.Path,
-				param.Request.Proto,
-				param.StatusCode,
-				param.Latency,
-				param.Request.UserAgent(),
-				param.ErrorMessage,
-		)
-	}))
-	router.Use(gin.Recovery())
-
-	router.GET("/ping", func(c *gin.Context) {
-		c.String(http.StatusOK, "pong")
-	})
-
-	router.Run(":8080")
-}
-```
-
-**Sample Output**
-```
-::1 - [Fri, 07 Dec 2018 17:04:38 JST] "GET /ping HTTP/1.1 200 122.767µs "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.80 Safari/537.36" "
-```
-
-### Controlling Log output coloring
-
-By default, logs output on console should be colorized depending on the detected TTY.
-
-Never colorize logs:
-
-```go
-func main() {
-    // Disable log's color
-    gin.DisableConsoleColor()
-
-    // Creates a gin router with default middleware:
-    // logger and recovery (crash-free) middleware
-    router := gin.Default()
-
-    router.GET("/ping", func(c *gin.Context) {
-        c.String(http.StatusOK, "pong")
-    })
-
-    router.Run(":8080")
-}
-```
-
-Always colorize logs:
-
-```go
-func main() {
-    // Force log's color
-    gin.ForceConsoleColor()
-
-    // Creates a gin router with default middleware:
-    // logger and recovery (crash-free) middleware
-    router := gin.Default()
-
-    router.GET("/ping", func(c *gin.Context) {
-        c.String(http.StatusOK, "pong")
-    })
-
-    router.Run(":8080")
-}
-```
-
-### Model binding and validation
-
-To bind a request body into a type, use model binding. We currently support binding of JSON, XML, YAML, TOML and standard form values (foo=bar&boo=baz).
-
-Gin uses [**go-playground/validator/v10**](https://github.com/go-playground/validator) for validation. Check the full docs on tags usage [here](https://godoc.org/github.com/go-playground/validator#hdr-Baked_In_Validators_and_Tags).
-
-Note that you need to set the corresponding binding tag on all fields you want to bind. For example, when binding from JSON, set `json:"fieldname"`.
-
-Also, Gin provides two sets of methods for binding:
-- **Type** - Must bind
-  - **Methods** - `Bind`, `BindJSON`, `BindXML`, `BindQuery`, `BindYAML`, `BindHeader`, `BindTOML`
-  - **Behavior** - These methods use `MustBindWith` under the hood. If there is a binding error, the request is aborted with `c.AbortWithError(400, err).SetType(ErrorTypeBind)`. This sets the response status code to 400 and the `Content-Type` header is set to `text/plain; charset=utf-8`. Note that if you try to set the response code after this, it will result in a warning `[GIN-debug] [WARNING] Headers were already written. Wanted to override status code 400 with 422`. If you wish to have greater control over the behavior, consider using the `ShouldBind` equivalent method.
-- **Type** - Should bind
-  - **Methods** - `ShouldBind`, `ShouldBindJSON`, `ShouldBindXML`, `ShouldBindQuery`, `ShouldBindYAML`, `ShouldBindHeader`, `ShouldBindTOML`,
-  - **Behavior** - These methods use `ShouldBindWith` under the hood. If there is a binding error, the error is returned and it is the developer's responsibility to handle the request and error appropriately.
-
-When using the Bind-method, Gin tries to infer the binder depending on the Content-Type header. If you are sure what you are binding, you can use `MustBindWith` or `ShouldBindWith`.
-
-You can also specify that specific fields are required. If a field is decorated with `binding:"required"` and has a empty value when binding, an error will be returned.
-
-```go
-// Binding from JSON
-type Login struct {
-	User     string `form:"user" json:"user" xml:"user"  binding:"required"`
-	Password string `form:"password" json:"password" xml:"password" binding:"required"`
-}
-
-func main() {
-	router := gin.Default()
-
-	// Example for binding JSON ({"user": "manu", "password": "123"})
-	router.POST("/loginJSON", func(c *gin.Context) {
-		var json Login
-		if err := c.ShouldBindJSON(&json); err != nil {
-			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-			return
-		}
-
-		if json.User != "manu" || json.Password != "123" {
-			c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
-			return
-		}
-
-		c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
-	})
-
-	// Example for binding XML (
-	//	<?xml version="1.0" encoding="UTF-8"?>
-	//	<root>
-	//		<user>manu</user>
-	//		<password>123</password>
-	//	</root>)
-	router.POST("/loginXML", func(c *gin.Context) {
-		var xml Login
-		if err := c.ShouldBindXML(&xml); err != nil {
-			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-			return
-		}
-
-		if xml.User != "manu" || xml.Password != "123" {
-			c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
-			return
-		}
-
-		c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
-	})
-
-	// Example for binding a HTML form (user=manu&password=123)
-	router.POST("/loginForm", func(c *gin.Context) {
-		var form Login
-		// This will infer what binder to use depending on the content-type header.
-		if err := c.ShouldBind(&form); err != nil {
-			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-			return
-		}
-
-		if form.User != "manu" || form.Password != "123" {
-			c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
-			return
-		}
-
-		c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
-	})
-
-	// Listen and serve on 0.0.0.0:8080
-	router.Run(":8080")
-}
-```
-
-**Sample request**
-```shell
-$ curl -v -X POST \
-  http://localhost:8080/loginJSON \
-  -H 'content-type: application/json' \
-  -d '{ "user": "manu" }'
-> POST /loginJSON HTTP/1.1
-> Host: localhost:8080
-> User-Agent: curl/7.51.0
-> Accept: */*
-> content-type: application/json
-> Content-Length: 18
->
-* upload completely sent off: 18 out of 18 bytes
-< HTTP/1.1 400 Bad Request
-< Content-Type: application/json; charset=utf-8
-< Date: Fri, 04 Aug 2017 03:51:31 GMT
-< Content-Length: 100
-<
-{"error":"Key: 'Login.Password' Error:Field validation for 'Password' failed on the 'required' tag"}
-```
-
-**Skip validate**
-
-When running the above example using the above the `curl` command, it returns error. Because the example use `binding:"required"` for `Password`. If use `binding:"-"` for `Password`, then it will not return error when running the above example again.
-
-### Custom Validators
-
-It is also possible to register custom validators. See the [example code](https://github.com/gin-gonic/examples/tree/master/custom-validation/server.go).
-
-```go
-package main
-
-import (
-	"net/http"
-	"time"
-
-	"github.com/gin-gonic/gin"
-	"github.com/gin-gonic/gin/binding"
-	"github.com/go-playground/validator/v10"
-)
-
-// Booking contains binded and validated data.
-type Booking struct {
-	CheckIn  time.Time `form:"check_in" binding:"required,bookabledate" time_format:"2006-01-02"`
-	CheckOut time.Time `form:"check_out" binding:"required,gtfield=CheckIn" time_format:"2006-01-02"`
-}
-
-var bookableDate validator.Func = func(fl validator.FieldLevel) bool {
-	date, ok := fl.Field().Interface().(time.Time)
-	if ok {
-		today := time.Now()
-		if today.After(date) {
-			return false
-		}
-	}
-	return true
-}
-
-func main() {
-	route := gin.Default()
-
-	if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
-		v.RegisterValidation("bookabledate", bookableDate)
-	}
-
-	route.GET("/bookable", getBookable)
-	route.Run(":8085")
-}
-
-func getBookable(c *gin.Context) {
-	var b Booking
-	if err := c.ShouldBindWith(&b, binding.Query); err == nil {
-		c.JSON(http.StatusOK, gin.H{"message": "Booking dates are valid!"})
-	} else {
-		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-	}
-}
-```
-
-```console
-$ curl "localhost:8085/bookable?check_in=2030-04-16&check_out=2030-04-17"
-{"message":"Booking dates are valid!"}
-
-$ curl "localhost:8085/bookable?check_in=2030-03-10&check_out=2030-03-09"
-{"error":"Key: 'Booking.CheckOut' Error:Field validation for 'CheckOut' failed on the 'gtfield' tag"}
-
-$ curl "localhost:8085/bookable?check_in=2000-03-09&check_out=2000-03-10"
-{"error":"Key: 'Booking.CheckIn' Error:Field validation for 'CheckIn' failed on the 'bookabledate' tag"}%
-```
-
-[Struct level validations](https://github.com/go-playground/validator/releases/tag/v8.7) can also be registered this way.
-See the [struct-lvl-validation example](https://github.com/gin-gonic/examples/tree/master/struct-lvl-validations) to learn more.
-
-### Only Bind Query String
-
-`ShouldBindQuery` function only binds the query params and not the post data. See the [detail information](https://github.com/gin-gonic/gin/issues/742#issuecomment-315953017).
-
-```go
-package main
-
-import (
-	"log"
-	"net/http"
-
-	"github.com/gin-gonic/gin"
-)
-
-type Person struct {
-	Name    string `form:"name"`
-	Address string `form:"address"`
-}
-
-func main() {
-	route := gin.Default()
-	route.Any("/testing", startPage)
-	route.Run(":8085")
-}
-
-func startPage(c *gin.Context) {
-	var person Person
-	if c.ShouldBindQuery(&person) == nil {
-		log.Println("====== Only Bind By Query String ======")
-		log.Println(person.Name)
-		log.Println(person.Address)
-	}
-	c.String(http.StatusOK, "Success")
-}
-
-```
-
-### Bind Query String or Post Data
-
-See the [detail information](https://github.com/gin-gonic/gin/issues/742#issuecomment-264681292).
-
-```go
-package main
-
-import (
-	"log"
-	"net/http"
-	"time"
-
-	"github.com/gin-gonic/gin"
-)
-
-type Person struct {
-        Name       string    `form:"name"`
-        Address    string    `form:"address"`
-        Birthday   time.Time `form:"birthday" time_format:"2006-01-02" time_utc:"1"`
-        CreateTime time.Time `form:"createTime" time_format:"unixNano"`
-        UnixTime   time.Time `form:"unixTime" time_format:"unix"`
-}
-
-func main() {
-	route := gin.Default()
-	route.GET("/testing", startPage)
-	route.Run(":8085")
-}
-
-func startPage(c *gin.Context) {
-	var person Person
-	// If `GET`, only `Form` binding engine (`query`) used.
-	// If `POST`, first checks the `content-type` for `JSON` or `XML`, then uses `Form` (`form-data`).
-	// See more at https://github.com/gin-gonic/gin/blob/master/binding/binding.go#L88
-        if c.ShouldBind(&person) == nil {
-                log.Println(person.Name)
-                log.Println(person.Address)
-                log.Println(person.Birthday)
-                log.Println(person.CreateTime)
-                log.Println(person.UnixTime)
-        }
-
-	c.String(http.StatusOK, "Success")
-}
-```
-
-Test it with:
-```sh
-$ curl -X GET "localhost:8085/testing?name=appleboy&address=xyz&birthday=1992-03-15&createTime=1562400033000000123&unixTime=1562400033"
-```
-
-### Bind Uri
-
-See the [detail information](https://github.com/gin-gonic/gin/issues/846).
-
-```go
-package main
-
-import (
-	"net/http"
-
-	"github.com/gin-gonic/gin"
-)
-
-type Person struct {
-	ID string `uri:"id" binding:"required,uuid"`
-	Name string `uri:"name" binding:"required"`
-}
-
-func main() {
-	route := gin.Default()
-	route.GET("/:name/:id", func(c *gin.Context) {
-		var person Person
-		if err := c.ShouldBindUri(&person); err != nil {
-			c.JSON(http.StatusBadRequest, gin.H{"msg": err.Error()})
-			return
-		}
-		c.JSON(http.StatusOK, gin.H{"name": person.Name, "uuid": person.ID})
-	})
-	route.Run(":8088")
-}
-```
-
-Test it with:
-```sh
-$ curl -v localhost:8088/thinkerou/987fbc97-4bed-5078-9f07-9141ba07c9f3
-$ curl -v localhost:8088/thinkerou/not-uuid
-```
-
-### Bind Header
-
-```go
-package main
-
-import (
-	"fmt"
-	"net/http"
-
-	"github.com/gin-gonic/gin"
-)
-
-type testHeader struct {
-	Rate   int    `header:"Rate"`
-	Domain string `header:"Domain"`
-}
-
-func main() {
-	r := gin.Default()
-	r.GET("/", func(c *gin.Context) {
-		h := testHeader{}
-
-		if err := c.ShouldBindHeader(&h); err != nil {
-			c.JSON(http.StatusOK, err)
-		}
-
-		fmt.Printf("%#v\n", h)
-		c.JSON(http.StatusOK, gin.H{"Rate": h.Rate, "Domain": h.Domain})
-	})
-
-	r.Run()
-
-// client
-// curl -H "rate:300" -H "domain:music" 127.0.0.1:8080/
-// output
-// {"Domain":"music","Rate":300}
-}
-```
-
-### Bind HTML checkboxes
-
-See the [detail information](https://github.com/gin-gonic/gin/issues/129#issuecomment-124260092)
-
-main.go
-
-```go
-...
-
-type myForm struct {
-    Colors []string `form:"colors[]"`
-}
-
-...
-
-func formHandler(c *gin.Context) {
-    var fakeForm myForm
-    c.ShouldBind(&fakeForm)
-    c.JSON(http.StatusOK, gin.H{"color": fakeForm.Colors})
-}
-
-...
-
-```
-
-form.html
-
-```html
-<form action="/" method="POST">
-    <p>Check some colors</p>
-    <label for="red">Red</label>
-    <input type="checkbox" name="colors[]" value="red" id="red">
-    <label for="green">Green</label>
-    <input type="checkbox" name="colors[]" value="green" id="green">
-    <label for="blue">Blue</label>
-    <input type="checkbox" name="colors[]" value="blue" id="blue">
-    <input type="submit">
-</form>
-```
-
-result:
-
-```
-{"color":["red","green","blue"]}
-```
-
-### Multipart/Urlencoded binding
-
-```go
-type ProfileForm struct {
-	Name   string                `form:"name" binding:"required"`
-	Avatar *multipart.FileHeader `form:"avatar" binding:"required"`
-
-	// or for multiple files
-	// Avatars []*multipart.FileHeader `form:"avatar" binding:"required"`
-}
-
-func main() {
-	router := gin.Default()
-	router.POST("/profile", func(c *gin.Context) {
-		// you can bind multipart form with explicit binding declaration:
-		// c.ShouldBindWith(&form, binding.Form)
-		// or you can simply use autobinding with ShouldBind method:
-		var form ProfileForm
-		// in this case proper binding will be automatically selected
-		if err := c.ShouldBind(&form); err != nil {
-			c.String(http.StatusBadRequest, "bad request")
-			return
-		}
-
-		err := c.SaveUploadedFile(form.Avatar, form.Avatar.Filename)
-		if err != nil {
-			c.String(http.StatusInternalServerError, "unknown error")
-			return
-		}
-
-		// db.Save(&form)
-
-		c.String(http.StatusOK, "ok")
-	})
-	router.Run(":8080")
-}
-```
-
-Test it with:
-```sh
-$ curl -X POST -v --form name=user --form "avatar=@./avatar.png" http://localhost:8080/profile
-```
-
-### XML, JSON, YAML and ProtoBuf rendering
-
-```go
-func main() {
-	r := gin.Default()
-
-	// gin.H is a shortcut for map[string]interface{}
-	r.GET("/someJSON", func(c *gin.Context) {
-		c.JSON(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
-	})
-
-	r.GET("/moreJSON", func(c *gin.Context) {
-		// You also can use a struct
-		var msg struct {
-			Name    string `json:"user"`
-			Message string
-			Number  int
-		}
-		msg.Name = "Lena"
-		msg.Message = "hey"
-		msg.Number = 123
-		// Note that msg.Name becomes "user" in the JSON
-		// Will output  :   {"user": "Lena", "Message": "hey", "Number": 123}
-		c.JSON(http.StatusOK, msg)
-	})
-
-	r.GET("/someXML", func(c *gin.Context) {
-		c.XML(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
-	})
-
-	r.GET("/someYAML", func(c *gin.Context) {
-		c.YAML(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})
-	})
-
-	r.GET("/someProtoBuf", func(c *gin.Context) {
-		reps := []int64{int64(1), int64(2)}
-		label := "test"
-		// The specific definition of protobuf is written in the testdata/protoexample file.
-		data := &protoexample.Test{
-			Label: &label,
-			Reps:  reps,
-		}
-		// Note that data becomes binary data in the response
-		// Will output protoexample.Test protobuf serialized data
-		c.ProtoBuf(http.StatusOK, data)
-	})
-
-	// Listen and serve on 0.0.0.0:8080
-	r.Run(":8080")
-}
-```
-
-#### SecureJSON
-
-Using SecureJSON to prevent json hijacking. Default prepends `"while(1),"` to response body if the given struct is array values.
-
-```go
-func main() {
-	r := gin.Default()
-
-	// You can also use your own secure json prefix
-	// r.SecureJsonPrefix(")]}',\n")
-
-	r.GET("/someJSON", func(c *gin.Context) {
-		names := []string{"lena", "austin", "foo"}
-
-		// Will output  :   while(1);["lena","austin","foo"]
-		c.SecureJSON(http.StatusOK, names)
-	})
-
-	// Listen and serve on 0.0.0.0:8080
-	r.Run(":8080")
-}
-```
-#### JSONP
-
-Using JSONP to request data from a server  in a different domain. Add callback to response body if the query parameter callback exists.
-
-```go
-func main() {
-	r := gin.Default()
-
-	r.GET("/JSONP", func(c *gin.Context) {
-		data := gin.H{
-			"foo": "bar",
-		}
-
-		//callback is x
-		// Will output  :   x({\"foo\":\"bar\"})
-		c.JSONP(http.StatusOK, data)
-	})
-
-	// Listen and serve on 0.0.0.0:8080
-	r.Run(":8080")
-
-        // client
-        // curl http://127.0.0.1:8080/JSONP?callback=x
-}
-```
-
-#### AsciiJSON
-
-Using AsciiJSON to Generates ASCII-only JSON with escaped non-ASCII characters.
-
-```go
-func main() {
-	r := gin.Default()
-
-	r.GET("/someJSON", func(c *gin.Context) {
-		data := gin.H{
-			"lang": "GO语言",
-			"tag":  "<br>",
-		}
-
-		// will output : {"lang":"GO\u8bed\u8a00","tag":"\u003cbr\u003e"}
-		c.AsciiJSON(http.StatusOK, data)
-	})
-
-	// Listen and serve on 0.0.0.0:8080
-	r.Run(":8080")
-}
-```
-
-#### PureJSON
-
-Normally, JSON replaces special HTML characters with their unicode entities, e.g. `<` becomes  `\u003c`. If you want to encode such characters literally, you can use PureJSON instead.
-This feature is unavailable in Go 1.6 and lower.
-
-```go
-func main() {
-	r := gin.Default()
-
-	// Serves unicode entities
-	r.GET("/json", func(c *gin.Context) {
-		c.JSON(http.StatusOK, gin.H{
-			"html": "<b>Hello, world!</b>",
-		})
-	})
-
-	// Serves literal characters
-	r.GET("/purejson", func(c *gin.Context) {
-		c.PureJSON(http.StatusOK, gin.H{
-			"html": "<b>Hello, world!</b>",
-		})
-	})
-
-	// listen and serve on 0.0.0.0:8080
-	r.Run(":8080")
-}
-```
-
-### Serving static files
-
-```go
-func main() {
-	router := gin.Default()
-	router.Static("/assets", "./assets")
-	router.StaticFS("/more_static", http.Dir("my_file_system"))
-	router.StaticFile("/favicon.ico", "./resources/favicon.ico")
-	router.StaticFileFS("/more_favicon.ico", "more_favicon.ico", http.Dir("my_file_system"))
-	
-	// Listen and serve on 0.0.0.0:8080
-	router.Run(":8080")
-}
-```
-
-### Serving data from file
-
-```go
-func main() {
-	router := gin.Default()
-
-	router.GET("/local/file", func(c *gin.Context) {
-		c.File("local/file.go")
-	})
-
-	var fs http.FileSystem = // ...
-	router.GET("/fs/file", func(c *gin.Context) {
-		c.FileFromFS("fs/file.go", fs)
-	})
-}
-
-```
-
-### Serving data from reader
-
-```go
-func main() {
-	router := gin.Default()
-	router.GET("/someDataFromReader", func(c *gin.Context) {
-		response, err := http.Get("https://raw.githubusercontent.com/gin-gonic/logo/master/color.png")
-		if err != nil || response.StatusCode != http.StatusOK {
-			c.Status(http.StatusServiceUnavailable)
-			return
-		}
-
-		reader := response.Body
- 		defer reader.Close()
-		contentLength := response.ContentLength
-		contentType := response.Header.Get("Content-Type")
-
-		extraHeaders := map[string]string{
-			"Content-Disposition": `attachment; filename="gopher.png"`,
-		}
-
-		c.DataFromReader(http.StatusOK, contentLength, contentType, reader, extraHeaders)
-	})
-	router.Run(":8080")
-}
-```
-
-### HTML rendering
-
-Using LoadHTMLGlob() or LoadHTMLFiles()
-
-```go
-func main() {
-	router := gin.Default()
-	router.LoadHTMLGlob("templates/*")
-	//router.LoadHTMLFiles("templates/template1.html", "templates/template2.html")
-	router.GET("/index", func(c *gin.Context) {
-		c.HTML(http.StatusOK, "index.tmpl", gin.H{
-			"title": "Main website",
-		})
-	})
-	router.Run(":8080")
-}
-```
-
-templates/index.tmpl
-
-```html
-<html>
-	<h1>
-		{{ .title }}
-	</h1>
-</html>
-```
-
-Using templates with same name in different directories
-
-```go
-func main() {
-	router := gin.Default()
-	router.LoadHTMLGlob("templates/**/*")
-	router.GET("/posts/index", func(c *gin.Context) {
-		c.HTML(http.StatusOK, "posts/index.tmpl", gin.H{
-			"title": "Posts",
-		})
-	})
-	router.GET("/users/index", func(c *gin.Context) {
-		c.HTML(http.StatusOK, "users/index.tmpl", gin.H{
-			"title": "Users",
-		})
-	})
-	router.Run(":8080")
-}
-```
-
-templates/posts/index.tmpl
-
-```html
-{{ define "posts/index.tmpl" }}
-<html><h1>
-	{{ .title }}
-</h1>
-<p>Using posts/index.tmpl</p>
-</html>
-{{ end }}
-```
-
-templates/users/index.tmpl
-
-```html
-{{ define "users/index.tmpl" }}
-<html><h1>
-	{{ .title }}
-</h1>
-<p>Using users/index.tmpl</p>
-</html>
-{{ end }}
-```
-
-#### Custom Template renderer
-
-You can also use your own html template render
-
-```go
-import "html/template"
-
-func main() {
-	router := gin.Default()
-	html := template.Must(template.ParseFiles("file1", "file2"))
-	router.SetHTMLTemplate(html)
-	router.Run(":8080")
-}
-```
-
-#### Custom Delimiters
-
-You may use custom delims
-
-```go
-	r := gin.Default()
-	r.Delims("{[{", "}]}")
-	r.LoadHTMLGlob("/path/to/templates")
-```
-
-#### Custom Template Funcs
-
-See the detail [example code](https://github.com/gin-gonic/examples/tree/master/template).
-
-main.go
-
-```go
-import (
-    "fmt"
-    "html/template"
-    "net/http"
-    "time"
-
-    "github.com/gin-gonic/gin"
-)
-
-func formatAsDate(t time.Time) string {
-    year, month, day := t.Date()
-    return fmt.Sprintf("%d/%02d/%02d", year, month, day)
-}
-
-func main() {
-    router := gin.Default()
-    router.Delims("{[{", "}]}")
-    router.SetFuncMap(template.FuncMap{
-        "formatAsDate": formatAsDate,
-    })
-    router.LoadHTMLFiles("./testdata/template/raw.tmpl")
-
-    router.GET("/raw", func(c *gin.Context) {
-        c.HTML(http.StatusOK, "raw.tmpl", gin.H{
-            "now": time.Date(2017, 07, 01, 0, 0, 0, 0, time.UTC),
-        })
-    })
-
-    router.Run(":8080")
-}
-
-```
-
-raw.tmpl
-
-```html
-Date: {[{.now | formatAsDate}]}
-```
-
-Result:
-```
-Date: 2017/07/01
-```
-
-### Multitemplate
-
-Gin allow by default use only one html.Template. Check [a multitemplate render](https://github.com/gin-contrib/multitemplate) for using features like go 1.6 `block template`.
-
-### Redirects
-
-Issuing a HTTP redirect is easy. Both internal and external locations are supported.
-
-```go
-r.GET("/test", func(c *gin.Context) {
-	c.Redirect(http.StatusMovedPermanently, "http://www.google.com/")
-})
-```
-
-Issuing a HTTP redirect from POST. Refer to issue: [#444](https://github.com/gin-gonic/gin/issues/444)
-```go
-r.POST("/test", func(c *gin.Context) {
-	c.Redirect(http.StatusFound, "/foo")
-})
-```
-
-Issuing a Router redirect, use `HandleContext` like below.
 
-``` go
-r.GET("/test", func(c *gin.Context) {
-    c.Request.URL.Path = "/test2"
-    r.HandleContext(c)
-})
-r.GET("/test2", func(c *gin.Context) {
-    c.JSON(http.StatusOK, gin.H{"hello": "world"})
-})
-```
-
-
-### Custom Middleware
-
-```go
-func Logger() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		t := time.Now()
-
-		// Set example variable
-		c.Set("example", "12345")
-
-		// before request
-
-		c.Next()
-
-		// after request
-		latency := time.Since(t)
-		log.Print(latency)
-
-		// access the status we are sending
-		status := c.Writer.Status()
-		log.Println(status)
-	}
-}
-
-func main() {
-	r := gin.New()
-	r.Use(Logger())
-
-	r.GET("/test", func(c *gin.Context) {
-		example := c.MustGet("example").(string)
-
-		// it would print: "12345"
-		log.Println(example)
-	})
-
-	// Listen and serve on 0.0.0.0:8080
-	r.Run(":8080")
-}
-```
-
-### Using BasicAuth() middleware
-
-```go
-// simulate some private data
-var secrets = gin.H{
-	"foo":    gin.H{"email": "foo@bar.com", "phone": "123433"},
-	"austin": gin.H{"email": "austin@example.com", "phone": "666"},
-	"lena":   gin.H{"email": "lena@guapa.com", "phone": "523443"},
-}
-
-func main() {
-	r := gin.Default()
-
-	// Group using gin.BasicAuth() middleware
-	// gin.Accounts is a shortcut for map[string]string
-	authorized := r.Group("/admin", gin.BasicAuth(gin.Accounts{
-		"foo":    "bar",
-		"austin": "1234",
-		"lena":   "hello2",
-		"manu":   "4321",
-	}))
-
-	// /admin/secrets endpoint
-	// hit "localhost:8080/admin/secrets
-	authorized.GET("/secrets", func(c *gin.Context) {
-		// get user, it was set by the BasicAuth middleware
-		user := c.MustGet(gin.AuthUserKey).(string)
-		if secret, ok := secrets[user]; ok {
-			c.JSON(http.StatusOK, gin.H{"user": user, "secret": secret})
-		} else {
-			c.JSON(http.StatusOK, gin.H{"user": user, "secret": "NO SECRET :("})
-		}
-	})
-
-	// Listen and serve on 0.0.0.0:8080
-	r.Run(":8080")
-}
-```
-
-### Goroutines inside a middleware
-
-When starting new Goroutines inside a middleware or handler, you **SHOULD NOT** use the original context inside it, you have to use a read-only copy.
-
-```go
-func main() {
-	r := gin.Default()
-
-	r.GET("/long_async", func(c *gin.Context) {
-		// create copy to be used inside the goroutine
-		cCp := c.Copy()
-		go func() {
-			// simulate a long task with time.Sleep(). 5 seconds
-			time.Sleep(5 * time.Second)
-
-			// note that you are using the copied context "cCp", IMPORTANT
-			log.Println("Done! in path " + cCp.Request.URL.Path)
-		}()
-	})
-
-	r.GET("/long_sync", func(c *gin.Context) {
-		// simulate a long task with time.Sleep(). 5 seconds
-		time.Sleep(5 * time.Second)
-
-		// since we are NOT using a goroutine, we do not have to copy the context
-		log.Println("Done! in path " + c.Request.URL.Path)
-	})
-
-	// Listen and serve on 0.0.0.0:8080
-	r.Run(":8080")
-}
-```
-
-### Custom HTTP configuration
-
-Use `http.ListenAndServe()` directly, like this:
-
-```go
-func main() {
-	router := gin.Default()
-	http.ListenAndServe(":8080", router)
-}
-```
-or
-
-```go
-func main() {
-	router := gin.Default()
-
-	s := &http.Server{
-		Addr:           ":8080",
-		Handler:        router,
-		ReadTimeout:    10 * time.Second,
-		WriteTimeout:   10 * time.Second,
-		MaxHeaderBytes: 1 << 20,
-	}
-	s.ListenAndServe()
-}
-```
+## Middlewares
 
-### Support Let's Encrypt
+You can find many useful Gin middlewares at [gin-contrib](https://github.com/gin-contrib).
 
-example for 1-line LetsEncrypt HTTPS servers.
-
-```go
-package main
-
-import (
-	"log"
-	"net/http"
-
-	"github.com/gin-gonic/autotls"
-	"github.com/gin-gonic/gin"
-)
-
-func main() {
-	r := gin.Default()
-
-	// Ping handler
-	r.GET("/ping", func(c *gin.Context) {
-		c.String(http.StatusOK, "pong")
-	})
-
-	log.Fatal(autotls.Run(r, "example1.com", "example2.com"))
-}
-```
-
-example for custom autocert manager.
-
-```go
-package main
-
-import (
-	"log"
-	"net/http"
-
-	"github.com/gin-gonic/autotls"
-	"github.com/gin-gonic/gin"
-	"golang.org/x/crypto/acme/autocert"
-)
-
-func main() {
-	r := gin.Default()
-
-	// Ping handler
-	r.GET("/ping", func(c *gin.Context) {
-		c.String(http.StatusOK, "pong")
-	})
-
-	m := autocert.Manager{
-		Prompt:     autocert.AcceptTOS,
-		HostPolicy: autocert.HostWhitelist("example1.com", "example2.com"),
-		Cache:      autocert.DirCache("/var/www/.cache"),
-	}
-
-	log.Fatal(autotls.RunWithManager(r, &m))
-}
-```
-
-### Run multiple service using Gin
-
-See the [question](https://github.com/gin-gonic/gin/issues/346) and try the following example:
-
-```go
-package main
-
-import (
-	"log"
-	"net/http"
-	"time"
-
-	"github.com/gin-gonic/gin"
-	"golang.org/x/sync/errgroup"
-)
-
-var (
-	g errgroup.Group
-)
-
-func router01() http.Handler {
-	e := gin.New()
-	e.Use(gin.Recovery())
-	e.GET("/", func(c *gin.Context) {
-		c.JSON(
-			http.StatusOK,
-			gin.H{
-				"code":  http.StatusOK,
-				"error": "Welcome server 01",
-			},
-		)
-	})
-
-	return e
-}
-
-func router02() http.Handler {
-	e := gin.New()
-	e.Use(gin.Recovery())
-	e.GET("/", func(c *gin.Context) {
-		c.JSON(
-			http.StatusOK,
-			gin.H{
-				"code":  http.StatusOK,
-				"error": "Welcome server 02",
-			},
-		)
-	})
-
-	return e
-}
-
-func main() {
-	server01 := &http.Server{
-		Addr:         ":8080",
-		Handler:      router01(),
-		ReadTimeout:  5 * time.Second,
-		WriteTimeout: 10 * time.Second,
-	}
-
-	server02 := &http.Server{
-		Addr:         ":8081",
-		Handler:      router02(),
-		ReadTimeout:  5 * time.Second,
-		WriteTimeout: 10 * time.Second,
-	}
-
-	g.Go(func() error {
-		err := server01.ListenAndServe()
-		if err != nil && err != http.ErrServerClosed {
-			log.Fatal(err)
-		}
-		return err
-	})
-
-	g.Go(func() error {
-		err := server02.ListenAndServe()
-		if err != nil && err != http.ErrServerClosed {
-			log.Fatal(err)
-		}
-		return err
-	})
-
-	if err := g.Wait(); err != nil {
-		log.Fatal(err)
-	}
-}
-```
-
-### Graceful shutdown or restart
-
-There are a few approaches you can use to perform a graceful shutdown or restart. You can make use of third-party packages specifically built for that, or you can manually do the same with the functions and methods from the built-in packages.
-
-#### Third-party packages
-
-We can use [fvbock/endless](https://github.com/fvbock/endless) to replace the default `ListenAndServe`. Refer to issue [#296](https://github.com/gin-gonic/gin/issues/296) for more details.
-
-```go
-router := gin.Default()
-router.GET("/", handler)
-// [...]
-endless.ListenAndServe(":4242", router)
-```
-
-Alternatives:
-
-* [manners](https://github.com/braintree/manners): A polite Go HTTP server that shuts down gracefully.
-* [graceful](https://github.com/tylerb/graceful): Graceful is a Go package enabling graceful shutdown of an http.Handler server.
-* [grace](https://github.com/facebookgo/grace): Graceful restart & zero downtime deploy for Go servers.
-
-#### Manually
-
-In case you are using Go 1.8 or a later version, you may not need to use those libraries. Consider using `http.Server`'s built-in [Shutdown()](https://golang.org/pkg/net/http/#Server.Shutdown) method for graceful shutdowns. The example below describes its usage, and we've got more examples using gin [here](https://github.com/gin-gonic/examples/tree/master/graceful-shutdown).
-
-```go
-// +build go1.8
-
-package main
-
-import (
-	"context"
-	"log"
-	"net/http"
-	"os"
-	"os/signal"
-	"syscall"
-	"time"
-
-	"github.com/gin-gonic/gin"
-)
-
-func main() {
-	router := gin.Default()
-	router.GET("/", func(c *gin.Context) {
-		time.Sleep(5 * time.Second)
-		c.String(http.StatusOK, "Welcome Gin Server")
-	})
-
-	srv := &http.Server{
-		Addr:    ":8080",
-		Handler: router,
-	}
-
-	// Initializing the server in a goroutine so that
-	// it won't block the graceful shutdown handling below
-	go func() {
-		if err := srv.ListenAndServe(); err != nil && errors.Is(err, http.ErrServerClosed) {
-			log.Printf("listen: %s\n", err)
-		}
-	}()
-
-	// Wait for interrupt signal to gracefully shutdown the server with
-	// a timeout of 5 seconds.
-	quit := make(chan os.Signal)
-	// kill (no param) default send syscall.SIGTERM
-	// kill -2 is syscall.SIGINT
-	// kill -9 is syscall.SIGKILL but can't be caught, so don't need to add it
-	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
-	<-quit
-	log.Println("Shutting down server...")
-
-	// The context is used to inform the server it has 5 seconds to finish
-	// the request it is currently handling
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	if err := srv.Shutdown(ctx); err != nil {
-		log.Fatal("Server forced to shutdown:", err)
-	}
-
-	log.Println("Server exiting")
-}
-```
-
-### Build a single binary with templates
-
-You can build a server into a single binary containing templates by using [go-assets][].
-
-[go-assets]: https://github.com/jessevdk/go-assets
-
-```go
-func main() {
-	r := gin.New()
-
-	t, err := loadTemplate()
-	if err != nil {
-		panic(err)
-	}
-	r.SetHTMLTemplate(t)
-
-	r.GET("/", func(c *gin.Context) {
-		c.HTML(http.StatusOK, "/html/index.tmpl",nil)
-	})
-	r.Run(":8080")
-}
-
-// loadTemplate loads templates embedded by go-assets-builder
-func loadTemplate() (*template.Template, error) {
-	t := template.New("")
-	for name, file := range Assets.Files {
-		defer file.Close()
-		if file.IsDir() || !strings.HasSuffix(name, ".tmpl") {
-			continue
-		}
-		h, err := ioutil.ReadAll(file)
-		if err != nil {
-			return nil, err
-		}
-		t, err = t.New(name).Parse(string(h))
-		if err != nil {
-			return nil, err
-		}
-	}
-	return t, nil
-}
-```
-
-See a complete example in the `https://github.com/gin-gonic/examples/tree/master/assets-in-binary` directory.
-
-### Bind form-data request with custom struct
-
-The follow example using custom struct:
-
-```go
-type StructA struct {
-    FieldA string `form:"field_a"`
-}
-
-type StructB struct {
-    NestedStruct StructA
-    FieldB string `form:"field_b"`
-}
-
-type StructC struct {
-    NestedStructPointer *StructA
-    FieldC string `form:"field_c"`
-}
-
-type StructD struct {
-    NestedAnonyStruct struct {
-        FieldX string `form:"field_x"`
-    }
-    FieldD string `form:"field_d"`
-}
-
-func GetDataB(c *gin.Context) {
-    var b StructB
-    c.Bind(&b)
-    c.JSON(http.StatusOK, gin.H{
-        "a": b.NestedStruct,
-        "b": b.FieldB,
-    })
-}
-
-func GetDataC(c *gin.Context) {
-    var b StructC
-    c.Bind(&b)
-    c.JSON(http.StatusOK, gin.H{
-        "a": b.NestedStructPointer,
-        "c": b.FieldC,
-    })
-}
-
-func GetDataD(c *gin.Context) {
-    var b StructD
-    c.Bind(&b)
-    c.JSON(http.StatusOK, gin.H{
-        "x": b.NestedAnonyStruct,
-        "d": b.FieldD,
-    })
-}
-
-func main() {
-    r := gin.Default()
-    r.GET("/getb", GetDataB)
-    r.GET("/getc", GetDataC)
-    r.GET("/getd", GetDataD)
-
-    r.Run()
-}
-```
-
-Using the command `curl` command result:
-
-```
-$ curl "http://localhost:8080/getb?field_a=hello&field_b=world"
-{"a":{"FieldA":"hello"},"b":"world"}
-$ curl "http://localhost:8080/getc?field_a=hello&field_c=world"
-{"a":{"FieldA":"hello"},"c":"world"}
-$ curl "http://localhost:8080/getd?field_x=hello&field_d=world"
-{"d":"world","x":{"FieldX":"hello"}}
-```
-
-### Try to bind body into different structs
-
-The normal methods for binding request body consumes `c.Request.Body` and they
-cannot be called multiple times.
-
-```go
-type formA struct {
-  Foo string `json:"foo" xml:"foo" binding:"required"`
-}
-
-type formB struct {
-  Bar string `json:"bar" xml:"bar" binding:"required"`
-}
-
-func SomeHandler(c *gin.Context) {
-  objA := formA{}
-  objB := formB{}
-  // This c.ShouldBind consumes c.Request.Body and it cannot be reused.
-  if errA := c.ShouldBind(&objA); errA == nil {
-    c.String(http.StatusOK, `the body should be formA`)
-  // Always an error is occurred by this because c.Request.Body is EOF now.
-  } else if errB := c.ShouldBind(&objB); errB == nil {
-    c.String(http.StatusOK, `the body should be formB`)
-  } else {
-    ...
-  }
-}
-```
-
-For this, you can use `c.ShouldBindBodyWith`.
-
-```go
-func SomeHandler(c *gin.Context) {
-  objA := formA{}
-  objB := formB{}
-  // This reads c.Request.Body and stores the result into the context.
-  if errA := c.ShouldBindBodyWith(&objA, binding.Form); errA == nil {
-    c.String(http.StatusOK, `the body should be formA`)
-  // At this time, it reuses body stored in the context.
-  } else if errB := c.ShouldBindBodyWith(&objB, binding.JSON); errB == nil {
-    c.String(http.StatusOK, `the body should be formB JSON`)
-  // And it can accepts other formats
-  } else if errB2 := c.ShouldBindBodyWith(&objB, binding.XML); errB2 == nil {
-    c.String(http.StatusOK, `the body should be formB XML`)
-  } else {
-    ...
-  }
-}
-```
-
-* `c.ShouldBindBodyWith` stores body into the context before binding. This has
-a slight impact to performance, so you should not use this method if you are
-enough to call binding at once.
-* This feature is only needed for some formats -- `JSON`, `XML`, `MsgPack`,
-`ProtoBuf`. For other formats, `Query`, `Form`, `FormPost`, `FormMultipart`,
-can be called by `c.ShouldBind()` multiple times without any damage to
-performance (See [#1341](https://github.com/gin-gonic/gin/pull/1341)).
-
-### Bind form-data request with custom struct and custom tag
-
-```go
-const (
-	customerTag = "url"
-	defaultMemory = 32 << 20
-)
-
-type customerBinding struct {}
-
-func (customerBinding) Name() string {
-	return "form"
-}
-
-func (customerBinding) Bind(req *http.Request, obj interface{}) error {
-	if err := req.ParseForm(); err != nil {
-		return err
-	}
-	if err := req.ParseMultipartForm(defaultMemory); err != nil {
-		if err != http.ErrNotMultipart {
-			return err
-		}
-	}
-	if err := binding.MapFormWithTag(obj, req.Form, customerTag); err != nil {
-		return err
-	}
-	return validate(obj)
-}
-
-func validate(obj interface{}) error {
-	if binding.Validator == nil {
-		return nil
-	}
-	return binding.Validator.ValidateStruct(obj)
-}
-
-// Now we can do this!!!
-// FormA is a external type that we can't modify it's tag
-type FormA struct {
-	FieldA string `url:"field_a"`
-}
-
-func ListHandler(s *Service) func(ctx *gin.Context) {
-	return func(ctx *gin.Context) {
-		var urlBinding = customerBinding{}
-		var opt FormA
-		err := ctx.MustBindWith(&opt, urlBinding)
-		if err != nil {
-			...
-		}
-		...
-	}
-}
-```
-
-### http2 server push
-
-http.Pusher is supported only **go1.8+**. See the [golang blog](https://blog.golang.org/h2push) for detail information.
-
-```go
-package main
-
-import (
-	"html/template"
-	"log"
-	"net/http"
-
-	"github.com/gin-gonic/gin"
-)
-
-var html = template.Must(template.New("https").Parse(`
-<html>
-<head>
-  <title>Https Test</title>
-  <script src="/assets/app.js"></script>
-</head>
-<body>
-  <h1 style="color:red;">Welcome, Ginner!</h1>
-</body>
-</html>
-`))
-
-func main() {
-	r := gin.Default()
-	r.Static("/assets", "./assets")
-	r.SetHTMLTemplate(html)
-
-	r.GET("/", func(c *gin.Context) {
-		if pusher := c.Writer.Pusher(); pusher != nil {
-			// use pusher.Push() to do server push
-			if err := pusher.Push("/assets/app.js", nil); err != nil {
-				log.Printf("Failed to push: %v", err)
-			}
-		}
-		c.HTML(http.StatusOK, "https", gin.H{
-			"status": "success",
-		})
-	})
-
-	// Listen and Server in https://127.0.0.1:8080
-	r.RunTLS(":8080", "./testdata/server.pem", "./testdata/server.key")
-}
-```
-
-### Define format for the log of routes
-
-The default log of routes is:
-```
-[GIN-debug] POST   /foo                      --> main.main.func1 (3 handlers)
-[GIN-debug] GET    /bar                      --> main.main.func2 (3 handlers)
-[GIN-debug] GET    /status                   --> main.main.func3 (3 handlers)
-```
-
-If you want to log this information in given format (e.g. JSON, key values or something else), then you can define this format with `gin.DebugPrintRouteFunc`.
-In the example below, we log all routes with standard log package but you can use another log tools that suits of your needs.
-```go
-import (
-	"log"
-	"net/http"
-
-	"github.com/gin-gonic/gin"
-)
-
-func main() {
-	r := gin.Default()
-	gin.DebugPrintRouteFunc = func(httpMethod, absolutePath, handlerName string, nuHandlers int) {
-		log.Printf("endpoint %v %v %v %v\n", httpMethod, absolutePath, handlerName, nuHandlers)
-	}
-
-	r.POST("/foo", func(c *gin.Context) {
-		c.JSON(http.StatusOK, "foo")
-	})
-
-	r.GET("/bar", func(c *gin.Context) {
-		c.JSON(http.StatusOK, "bar")
-	})
-
-	r.GET("/status", func(c *gin.Context) {
-		c.JSON(http.StatusOK, "ok")
-	})
-
-	// Listen and Server in http://0.0.0.0:8080
-	r.Run()
-}
-```
-
-### Set and get a cookie
-
-```go
-import (
-    "fmt"
-
-    "github.com/gin-gonic/gin"
-)
-
-func main() {
-
-    router := gin.Default()
-
-    router.GET("/cookie", func(c *gin.Context) {
-
-        cookie, err := c.Cookie("gin_cookie")
-
-        if err != nil {
-            cookie = "NotSet"
-            c.SetCookie("gin_cookie", "test", 3600, "/", "localhost", false, true)
-        }
-
-        fmt.Printf("Cookie value: %s \n", cookie)
-    })
-
-    router.Run()
-}
-```
-
-## Don't trust all proxies
-
-Gin lets you specify which headers to hold the real client IP (if any),
-as well as specifying which proxies (or direct clients) you trust to
-specify one of these headers.
-
-Use function `SetTrustedProxies()` on your `gin.Engine` to specify network addresses
-or network CIDRs from where clients which their request headers related to client
-IP can be trusted. They can be IPv4 addresses, IPv4 CIDRs, IPv6 addresses or
-IPv6 CIDRs.
-
-**Attention:** Gin trust all proxies by default if you don't specify a trusted 
-proxy using the function above, **this is NOT safe**. At the same time, if you don't
-use any proxy, you can disable this feature by using `Engine.SetTrustedProxies(nil)`,
-then `Context.ClientIP()` will return the remote address directly to avoid some
-unnecessary computation.
-
-```go
-import (
-	"fmt"
-
-	"github.com/gin-gonic/gin"
-)
-
-func main() {
-
-	router := gin.Default()
-	router.SetTrustedProxies([]string{"192.168.1.2"})
-
-	router.GET("/", func(c *gin.Context) {
-		// If the client is 192.168.1.2, use the X-Forwarded-For
-		// header to deduce the original client IP from the trust-
-		// worthy parts of that header.
-		// Otherwise, simply return the direct client IP
-		fmt.Printf("ClientIP: %s\n", c.ClientIP())
-	})
-	router.Run()
-}
-```
-
-**Notice:** If you are using a CDN service, you can set the `Engine.TrustedPlatform`
-to skip TrustedProxies check, it has a higher priority than TrustedProxies. 
-Look at the example below:
-```go
-import (
-	"fmt"
-
-	"github.com/gin-gonic/gin"
-)
-
-func main() {
-
-	router := gin.Default()
-	// Use predefined header gin.PlatformXXX
-	router.TrustedPlatform = gin.PlatformGoogleAppEngine
-	// Or set your own trusted request header for another trusted proxy service
-	// Don't set it to any suspect request header, it's unsafe
-	router.TrustedPlatform = "X-CDN-IP"
-
-	router.GET("/", func(c *gin.Context) {
-		// If you set TrustedPlatform, ClientIP() will resolve the
-		// corresponding header and return IP directly
-		fmt.Printf("ClientIP: %s\n", c.ClientIP())
-	})
-	router.Run()
-}
-```
-
-## Testing
-
-The `net/http/httptest` package is preferable way for HTTP testing.
-
-```go
-package main
-
-import (
-	"net/http"
-
-	"github.com/gin-gonic/gin"
-)
-
-func setupRouter() *gin.Engine {
-	r := gin.Default()
-	r.GET("/ping", func(c *gin.Context) {
-		c.String(http.StatusOK, "pong")
-	})
-	return r
-}
-
-func main() {
-	r := setupRouter()
-	r.Run(":8080")
-}
-```
-
-Test for code example above:
-
-```go
-package main
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestPingRoute(t *testing.T) {
-	router := setupRouter()
-
-	w := httptest.NewRecorder()
-	req, _ := http.NewRequest(http.MethodGet, "/ping", nil)
-	router.ServeHTTP(w, req)
-
-	assert.Equal(t, http.StatusOK, w.Code)
-	assert.Equal(t, "pong", w.Body.String())
-}
-```
 
 ## Users
 
@@ -2341,8 +167,13 @@ Awesome project lists using [Gin](https://github.com/gin-gonic/gin) web framewor
 * [gorush](https://github.com/appleboy/gorush): A push notification server written in Go.
 * [fnproject](https://github.com/fnproject/fn): The container native, cloud agnostic serverless platform.
 * [photoprism](https://github.com/photoprism/photoprism): Personal photo management powered by Go and Google TensorFlow.
-* [krakend](https://github.com/devopsfaith/krakend): Ultra performant API Gateway with middlewares.
+* [lura](https://github.com/luraproject/lura): Ultra performant API Gateway with middlewares.
 * [picfit](https://github.com/thoas/picfit): An image resizing server written in Go.
-* [brigade](https://github.com/brigadecore/brigade): Event-based Scripting for Kubernetes.
 * [dkron](https://github.com/distribworks/dkron): Distributed, fault tolerant job scheduling system.
 
+
+## Contributing
+
+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
diff --git a/vendor/github.com/gin-gonic/gin/binding/default_validator.go b/vendor/github.com/gin-gonic/gin/binding/default_validator.go
index c03afe75b..e216b8546 100644
--- a/vendor/github.com/gin-gonic/gin/binding/default_validator.go
+++ b/vendor/github.com/gin-gonic/gin/binding/default_validator.go
@@ -43,7 +43,7 @@ func (err SliceValidationError) Error() string {
 	}
 }
 
-var _ StructValidator = &defaultValidator{}
+var _ StructValidator = (*defaultValidator)(nil)
 
 // ValidateStruct receives any kind of type, but only performed struct or pointer to struct type.
 func (v *defaultValidator) ValidateStruct(obj any) error {
diff --git a/vendor/github.com/gin-gonic/gin/binding/form_mapping.go b/vendor/github.com/gin-gonic/gin/binding/form_mapping.go
index 98cebfecf..540bbbb84 100644
--- a/vendor/github.com/gin-gonic/gin/binding/form_mapping.go
+++ b/vendor/github.com/gin-gonic/gin/binding/form_mapping.go
@@ -19,7 +19,7 @@ import (
 var (
 	errUnknownType = errors.New("unknown type")
 
-	// ErrConvertMapStringSlice can not covert to map[string][]string
+	// ErrConvertMapStringSlice can not convert to map[string][]string
 	ErrConvertMapStringSlice = errors.New("can not convert to map slices of strings")
 
 	// ErrConvertToMapString can not convert to map[string]string
diff --git a/vendor/github.com/gin-gonic/gin/binding/protobuf.go b/vendor/github.com/gin-gonic/gin/binding/protobuf.go
index 44f2fdb93..57721fc9f 100644
--- a/vendor/github.com/gin-gonic/gin/binding/protobuf.go
+++ b/vendor/github.com/gin-gonic/gin/binding/protobuf.go
@@ -6,7 +6,7 @@ package binding
 
 import (
 	"errors"
-	"io/ioutil"
+	"io"
 	"net/http"
 
 	"google.golang.org/protobuf/proto"
@@ -19,7 +19,7 @@ func (protobufBinding) Name() string {
 }
 
 func (b protobufBinding) Bind(req *http.Request, obj any) error {
-	buf, err := ioutil.ReadAll(req.Body)
+	buf, err := io.ReadAll(req.Body)
 	if err != nil {
 		return err
 	}
diff --git a/vendor/github.com/gin-gonic/gin/binding/toml.go b/vendor/github.com/gin-gonic/gin/binding/toml.go
index a6b8a90ab..a66b93aaf 100644
--- a/vendor/github.com/gin-gonic/gin/binding/toml.go
+++ b/vendor/github.com/gin-gonic/gin/binding/toml.go
@@ -18,14 +18,6 @@ func (tomlBinding) Name() string {
 	return "toml"
 }
 
-func decodeToml(r io.Reader, obj any) error {
-	decoder := toml.NewDecoder(r)
-	if err := decoder.Decode(obj); err != nil {
-		return err
-	}
-	return decoder.Decode(obj)
-}
-
 func (tomlBinding) Bind(req *http.Request, obj any) error {
 	return decodeToml(req.Body, obj)
 }
@@ -33,3 +25,11 @@ func (tomlBinding) Bind(req *http.Request, obj any) error {
 func (tomlBinding) BindBody(body []byte, obj any) error {
 	return decodeToml(bytes.NewReader(body), obj)
 }
+
+func decodeToml(r io.Reader, obj any) error {
+	decoder := toml.NewDecoder(r)
+	if err := decoder.Decode(obj); err != nil {
+		return err
+	}
+	return decoder.Decode(obj)
+}
diff --git a/vendor/github.com/gin-gonic/gin/binding/yaml.go b/vendor/github.com/gin-gonic/gin/binding/yaml.go
index b0d36a358..2535f8c33 100644
--- a/vendor/github.com/gin-gonic/gin/binding/yaml.go
+++ b/vendor/github.com/gin-gonic/gin/binding/yaml.go
@@ -9,7 +9,7 @@ import (
 	"io"
 	"net/http"
 
-	"gopkg.in/yaml.v2"
+	"gopkg.in/yaml.v3"
 )
 
 type yamlBinding struct{}
diff --git a/vendor/github.com/gin-gonic/gin/context.go b/vendor/github.com/gin-gonic/gin/context.go
index b1ad95e62..556f8ac9c 100644
--- a/vendor/github.com/gin-gonic/gin/context.go
+++ b/vendor/github.com/gin-gonic/gin/context.go
@@ -7,7 +7,6 @@ package gin
 import (
 	"errors"
 	"io"
-	"io/ioutil"
 	"log"
 	"math"
 	"mime/multipart"
@@ -15,6 +14,7 @@ import (
 	"net/http"
 	"net/url"
 	"os"
+	"path/filepath"
 	"strings"
 	"sync"
 	"time"
@@ -153,9 +153,10 @@ func (c *Context) Handler() HandlerFunc {
 
 // FullPath returns a matched route full path. For not found routes
 // returns an empty string.
-//     router.GET("/user/:id", func(c *gin.Context) {
-//         c.FullPath() == "/user/:id" // true
-//     })
+//
+//	router.GET("/user/:id", func(c *gin.Context) {
+//	    c.FullPath() == "/user/:id" // true
+//	})
 func (c *Context) FullPath() string {
 	return c.fullPath
 }
@@ -247,20 +248,20 @@ func (c *Context) Error(err error) *Error {
 // It also lazy initializes  c.Keys if it was not used previously.
 func (c *Context) Set(key string, value any) {
 	c.mu.Lock()
+	defer c.mu.Unlock()
 	if c.Keys == nil {
 		c.Keys = make(map[string]any)
 	}
 
 	c.Keys[key] = value
-	c.mu.Unlock()
 }
 
 // Get returns the value for the given key, ie: (value, true).
 // If the value does not exist it returns (nil, false)
 func (c *Context) Get(key string) (value any, exists bool) {
 	c.mu.RLock()
+	defer c.mu.RUnlock()
 	value, exists = c.Keys[key]
-	c.mu.RUnlock()
 	return
 }
 
@@ -382,10 +383,13 @@ func (c *Context) GetStringMapStringSlice(key string) (smss map[string][]string)
 
 // Param returns the value of the URL param.
 // It is a shortcut for c.Params.ByName(key)
-//     router.GET("/user/:id", func(c *gin.Context) {
-//         // a GET request to /user/john
-//         id := c.Param("id") // id == "john"
-//     })
+//
+//	router.GET("/user/:id", func(c *gin.Context) {
+//	    // a GET request to /user/john
+//	    id := c.Param("id") // id == "/john"
+//	    // a GET request to /user/john/
+//	    id := c.Param("id") // id == "/john/"
+//	})
 func (c *Context) Param(key string) string {
 	return c.Params.ByName(key)
 }
@@ -402,11 +406,12 @@ func (c *Context) AddParam(key, value string) {
 // Query returns the keyed url query value if it exists,
 // otherwise it returns an empty string `("")`.
 // It is shortcut for `c.Request.URL.Query().Get(key)`
-//     GET /path?id=1234&name=Manu&value=
-// 	   c.Query("id") == "1234"
-// 	   c.Query("name") == "Manu"
-// 	   c.Query("value") == ""
-// 	   c.Query("wtf") == ""
+//
+//	    GET /path?id=1234&name=Manu&value=
+//		   c.Query("id") == "1234"
+//		   c.Query("name") == "Manu"
+//		   c.Query("value") == ""
+//		   c.Query("wtf") == ""
 func (c *Context) Query(key string) (value string) {
 	value, _ = c.GetQuery(key)
 	return
@@ -415,10 +420,11 @@ func (c *Context) Query(key string) (value string) {
 // DefaultQuery returns the keyed url query value if it exists,
 // otherwise it returns the specified defaultValue string.
 // See: Query() and GetQuery() for further information.
-//     GET /?name=Manu&lastname=
-//     c.DefaultQuery("name", "unknown") == "Manu"
-//     c.DefaultQuery("id", "none") == "none"
-//     c.DefaultQuery("lastname", "none") == ""
+//
+//	GET /?name=Manu&lastname=
+//	c.DefaultQuery("name", "unknown") == "Manu"
+//	c.DefaultQuery("id", "none") == "none"
+//	c.DefaultQuery("lastname", "none") == ""
 func (c *Context) DefaultQuery(key, defaultValue string) string {
 	if value, ok := c.GetQuery(key); ok {
 		return value
@@ -430,10 +436,11 @@ func (c *Context) DefaultQuery(key, defaultValue string) string {
 // if it exists `(value, true)` (even when the value is an empty string),
 // otherwise it returns `("", false)`.
 // It is shortcut for `c.Request.URL.Query().Get(key)`
-//     GET /?name=Manu&lastname=
-//     ("Manu", true) == c.GetQuery("name")
-//     ("", false) == c.GetQuery("id")
-//     ("", true) == c.GetQuery("lastname")
+//
+//	GET /?name=Manu&lastname=
+//	("Manu", true) == c.GetQuery("name")
+//	("", false) == c.GetQuery("id")
+//	("", true) == c.GetQuery("lastname")
 func (c *Context) GetQuery(key string) (string, bool) {
 	if values, ok := c.GetQueryArray(key); ok {
 		return values[0], ok
@@ -500,9 +507,10 @@ func (c *Context) DefaultPostForm(key, defaultValue string) string {
 // form or multipart form when it exists `(value, true)` (even when the value is an empty string),
 // otherwise it returns ("", false).
 // For example, during a PATCH request to update the user's email:
-//     email=mail@example.com  -->  ("mail@example.com", true) := GetPostForm("email") // set email to "mail@example.com"
-// 	   email=                  -->  ("", true) := GetPostForm("email") // set email to ""
-//                             -->  ("", false) := GetPostForm("email") // do nothing with email
+//
+//	    email=mail@example.com  -->  ("mail@example.com", true) := GetPostForm("email") // set email to "mail@example.com"
+//		   email=                  -->  ("", true) := GetPostForm("email") // set email to ""
+//	                            -->  ("", false) := GetPostForm("email") // do nothing with email
 func (c *Context) GetPostForm(key string) (string, bool) {
 	if values, ok := c.GetPostFormArray(key); ok {
 		return values[0], ok
@@ -551,7 +559,7 @@ func (c *Context) GetPostFormMap(key string) (map[string]string, bool) {
 	return c.get(c.formCache, key)
 }
 
-// get is an internal method and returns a map which satisfy conditions.
+// get is an internal method and returns a map which satisfies conditions.
 func (c *Context) get(m map[string][]string, key string) (map[string]string, bool) {
 	dicts := make(map[string]string)
 	exist := false
@@ -595,6 +603,10 @@ func (c *Context) SaveUploadedFile(file *multipart.FileHeader, dst string) error
 	}
 	defer src.Close()
 
+	if err = os.MkdirAll(filepath.Dir(dst), 0750); err != nil {
+		return err
+	}
+
 	out, err := os.Create(dst)
 	if err != nil {
 		return err
@@ -607,8 +619,10 @@ func (c *Context) SaveUploadedFile(file *multipart.FileHeader, dst string) error
 
 // Bind checks the Method and Content-Type to select a binding engine automatically,
 // Depending on the "Content-Type" header different bindings are used, for example:
-//     "application/json" --> JSON binding
-//     "application/xml"  --> XML binding
+//
+//	"application/json" --> JSON binding
+//	"application/xml"  --> XML binding
+//
 // It parses the request's body as JSON if Content-Type == "application/json" using JSON or XML as a JSON input.
 // It decodes the json payload into the struct specified as a pointer.
 // It writes a 400 error and sets Content-Type header "text/plain" in the response if input is not valid.
@@ -651,7 +665,7 @@ func (c *Context) BindHeader(obj any) error {
 // It will abort the request with HTTP 400 if any error occurs.
 func (c *Context) BindUri(obj any) error {
 	if err := c.ShouldBindUri(obj); err != nil {
-		c.AbortWithError(http.StatusBadRequest, err).SetType(ErrorTypeBind) // nolint: errcheck
+		c.AbortWithError(http.StatusBadRequest, err).SetType(ErrorTypeBind) //nolint: errcheck
 		return err
 	}
 	return nil
@@ -662,7 +676,7 @@ func (c *Context) BindUri(obj any) error {
 // See the binding package.
 func (c *Context) MustBindWith(obj any, b binding.Binding) error {
 	if err := c.ShouldBindWith(obj, b); err != nil {
-		c.AbortWithError(http.StatusBadRequest, err).SetType(ErrorTypeBind) // nolint: errcheck
+		c.AbortWithError(http.StatusBadRequest, err).SetType(ErrorTypeBind) //nolint: errcheck
 		return err
 	}
 	return nil
@@ -670,8 +684,10 @@ func (c *Context) MustBindWith(obj any, b binding.Binding) error {
 
 // ShouldBind checks the Method and Content-Type to select a binding engine automatically,
 // Depending on the "Content-Type" header different bindings are used, for example:
-//     "application/json" --> JSON binding
-//     "application/xml"  --> XML binding
+//
+//	"application/json" --> JSON binding
+//	"application/xml"  --> XML binding
+//
 // It parses the request's body as JSON if Content-Type == "application/json" using JSON or XML as a JSON input.
 // It decodes the json payload into the struct specified as a pointer.
 // Like c.Bind() but this method does not set the response status code to 400 or abort if input is not valid.
@@ -738,7 +754,7 @@ func (c *Context) ShouldBindBodyWith(obj any, bb binding.BindingBody) (err error
 		}
 	}
 	if body == nil {
-		body, err = ioutil.ReadAll(c.Request.Body)
+		body, err = io.ReadAll(c.Request.Body)
 		if err != nil {
 			return err
 		}
@@ -748,7 +764,7 @@ func (c *Context) ShouldBindBodyWith(obj any, bb binding.BindingBody) (err error
 }
 
 // ClientIP implements one best effort algorithm to return the real client IP.
-// It called c.RemoteIP() under the hood, to check if the remote IP is a trusted proxy or not.
+// It calls c.RemoteIP() under the hood, to check if the remote IP is a trusted proxy or not.
 // If it is it will then try to parse the headers defined in Engine.RemoteIPHeaders (defaulting to [X-Forwarded-For, X-Real-Ip]).
 // If the headers are not syntactically valid OR the remote IP does not correspond to a trusted proxy,
 // the remote IP (coming from Request.RemoteAddr) is returned.
@@ -857,7 +873,7 @@ func (c *Context) GetHeader(key string) string {
 
 // GetRawData returns stream data.
 func (c *Context) GetRawData() ([]byte, error) {
-	return ioutil.ReadAll(c.Request.Body)
+	return io.ReadAll(c.Request.Body)
 }
 
 // SetSameSite with cookie
@@ -908,7 +924,9 @@ func (c *Context) Render(code int, r render.Render) {
 	}
 
 	if err := r.Render(c.Writer); err != nil {
-		panic(err)
+		// Pushing error to c.Errors
+		_ = c.Error(err)
+		c.Abort()
 	}
 }
 
@@ -1112,7 +1130,7 @@ func (c *Context) Negotiate(code int, config Negotiate) {
 		c.TOML(code, data)
 
 	default:
-		c.AbortWithError(http.StatusNotAcceptable, errors.New("the accepted formats are not offered by the server")) // nolint: errcheck
+		c.AbortWithError(http.StatusNotAcceptable, errors.New("the accepted formats are not offered by the server")) //nolint: errcheck
 	}
 }
 
@@ -1131,7 +1149,7 @@ func (c *Context) NegotiateFormat(offered ...string) string {
 			// According to RFC 2616 and RFC 2396, non-ASCII characters are not allowed in headers,
 			// therefore we can just iterate over the string without casting it into []rune
 			i := 0
-			for ; i < len(accepted); i++ {
+			for ; i < len(accepted) && i < len(offer); i++ {
 				if accepted[i] == '*' || offer[i] == '*' {
 					return offer
 				}
diff --git a/vendor/github.com/gin-gonic/gin/debug.go b/vendor/github.com/gin-gonic/gin/debug.go
index 25fd7c87f..cbcedbc98 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 = 14
+const ginSupportMinGoVer = 16
 
 // IsDebugging returns true if the framework is running in debug mode.
 // Use SetMode(gin.ReleaseMode) to disable debug mode.
@@ -66,8 +66,8 @@ 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.14+.
+	if v, e := getMinVer(runtime.Version()); e == nil && v < ginSupportMinGoVer {
+		debugPrint(`[WARNING] Now Gin requires Go 1.16+.
 
 `)
 	}
diff --git a/vendor/github.com/gin-gonic/gin/errors.go b/vendor/github.com/gin-gonic/gin/errors.go
index 2853ce8ed..06b53c28b 100644
--- a/vendor/github.com/gin-gonic/gin/errors.go
+++ b/vendor/github.com/gin-gonic/gin/errors.go
@@ -39,7 +39,7 @@ type Error struct {
 
 type errorMsgs []*Error
 
-var _ error = &Error{}
+var _ error = (*Error)(nil)
 
 // SetType sets the error's type.
 func (msg *Error) SetType(flags ErrorType) *Error {
@@ -124,10 +124,11 @@ func (a errorMsgs) Last() *Error {
 
 // Errors returns an array with all the error messages.
 // Example:
-// 		c.Error(errors.New("first"))
-// 		c.Error(errors.New("second"))
-// 		c.Error(errors.New("third"))
-// 		c.Errors.Errors() // == []string{"first", "second", "third"}
+//
+//	c.Error(errors.New("first"))
+//	c.Error(errors.New("second"))
+//	c.Error(errors.New("third"))
+//	c.Errors.Errors() // == []string{"first", "second", "third"}
 func (a errorMsgs) Errors() []string {
 	if len(a) == 0 {
 		return nil
diff --git a/vendor/github.com/gin-gonic/gin/gin.go b/vendor/github.com/gin-gonic/gin/gin.go
index 551356974..f95e5dda5 100644
--- a/vendor/github.com/gin-gonic/gin/gin.go
+++ b/vendor/github.com/gin-gonic/gin/gin.go
@@ -11,6 +11,7 @@ import (
 	"net/http"
 	"os"
 	"path"
+	"regexp"
 	"strings"
 	"sync"
 
@@ -40,6 +41,9 @@ var defaultTrustedCIDRs = []*net.IPNet{
 	},
 }
 
+var regSafePrefix = regexp.MustCompile("[^a-zA-Z0-9/-]+")
+var regRemoveRepeatedChar = regexp.MustCompile("/{2,}")
+
 // HandlerFunc defines the handler used by gin middleware as return value.
 type HandlerFunc func(*Context)
 
@@ -166,7 +170,7 @@ type Engine struct {
 	trustedCIDRs     []*net.IPNet
 }
 
-var _ IRouter = &Engine{}
+var _ IRouter = (*Engine)(nil)
 
 // New returns a new blank Engine instance without any middleware attached.
 // By default, the configuration is:
@@ -668,6 +672,9 @@ func redirectTrailingSlash(c *Context) {
 	req := c.Request
 	p := req.URL.Path
 	if prefix := path.Clean(c.Request.Header.Get("X-Forwarded-Prefix")); prefix != "." {
+		prefix = regSafePrefix.ReplaceAllString(prefix, "")
+		prefix = regRemoveRepeatedChar.ReplaceAllString(prefix, "/")
+
 		p = prefix + "/" + req.URL.Path
 	}
 	req.URL.Path = p + "/"
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 a26d7db2e..c5f3efc88 100644
--- a/vendor/github.com/gin-gonic/gin/internal/json/json.go
+++ b/vendor/github.com/gin-gonic/gin/internal/json/json.go
@@ -2,8 +2,10 @@
 // Use of this source code is governed by a MIT style
 // license that can be found in the LICENSE file.
 
-//go:build !jsoniter && !go_json
-// +build !jsoniter,!go_json
+//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/sonic.go b/vendor/github.com/gin-gonic/gin/internal/json/sonic.go
new file mode 100644
index 000000000..5a9ca4b2d
--- /dev/null
+++ b/vendor/github.com/gin-gonic/gin/internal/json/sonic.go
@@ -0,0 +1,27 @@
+// 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 sonic && avx && (linux || windows || darwin) && amd64
+// +build sonic
+// +build avx
+// +build linux windows darwin
+// +build amd64
+
+package json
+
+import "github.com/bytedance/sonic"
+
+var (
+	json = sonic.ConfigStd
+	// Marshal is exported by gin/json package.
+	Marshal = json.Marshal
+	// Unmarshal is exported by gin/json package.
+	Unmarshal = json.Unmarshal
+	// MarshalIndent is exported by gin/json package.
+	MarshalIndent = json.MarshalIndent
+	// NewDecoder is exported by gin/json package.
+	NewDecoder = json.NewDecoder
+	// NewEncoder is exported by gin/json package.
+	NewEncoder = json.NewEncoder
+)
diff --git a/vendor/github.com/gin-gonic/gin/mode.go b/vendor/github.com/gin-gonic/gin/mode.go
index 545fdaaf8..fd26d907c 100644
--- a/vendor/github.com/gin-gonic/gin/mode.go
+++ b/vendor/github.com/gin-gonic/gin/mode.go
@@ -35,8 +35,9 @@ const (
 // Note that both Logger and Recovery provides custom ways to configure their
 // output io.Writer.
 // To support coloring in Windows use:
-// 		import "github.com/mattn/go-colorable"
-// 		gin.DefaultWriter = colorable.NewColorableStdout()
+//
+//	import "github.com/mattn/go-colorable"
+//	gin.DefaultWriter = colorable.NewColorableStdout()
 var DefaultWriter io.Writer = os.Stdout
 
 // DefaultErrorWriter is the default io.Writer used by Gin to debug errors
diff --git a/vendor/github.com/gin-gonic/gin/path.go b/vendor/github.com/gin-gonic/gin/path.go
index d42d6b9d0..82438c137 100644
--- a/vendor/github.com/gin-gonic/gin/path.go
+++ b/vendor/github.com/gin-gonic/gin/path.go
@@ -10,12 +10,12 @@ package gin
 //
 // The following rules are applied iteratively until no further processing can
 // be done:
-//	1. Replace multiple slashes with a single slash.
-//	2. Eliminate each . path name element (the current directory).
-//	3. Eliminate each inner .. path name element (the parent directory)
-//	   along with the non-.. element that precedes it.
-//	4. Eliminate .. elements that begin a rooted path:
-//	   that is, replace "/.." by "/" at the beginning of a path.
+//  1. Replace multiple slashes with a single slash.
+//  2. Eliminate each . path name element (the current directory).
+//  3. Eliminate each inner .. path name element (the parent directory)
+//     along with the non-.. element that precedes it.
+//  4. Eliminate .. elements that begin a rooted path:
+//     that is, replace "/.." by "/" at the beginning of a path.
 //
 // If the result of this process is an empty string, "/" is returned.
 func cleanPath(p string) string {
diff --git a/vendor/github.com/gin-gonic/gin/recovery.go b/vendor/github.com/gin-gonic/gin/recovery.go
index abb645105..2955c03a0 100644
--- a/vendor/github.com/gin-gonic/gin/recovery.go
+++ b/vendor/github.com/gin-gonic/gin/recovery.go
@@ -9,7 +9,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"log"
 	"net"
 	"net/http"
@@ -63,7 +62,9 @@ func CustomRecoveryWithWriter(out io.Writer, handle RecoveryFunc) HandlerFunc {
 				if ne, ok := err.(*net.OpError); ok {
 					var se *os.SyscallError
 					if errors.As(ne, &se) {
-						if strings.Contains(strings.ToLower(se.Error()), "broken pipe") || strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
+						seStr := strings.ToLower(se.Error())
+						if strings.Contains(seStr, "broken pipe") ||
+							strings.Contains(seStr, "connection reset by peer") {
 							brokenPipe = true
 						}
 					}
@@ -91,7 +92,7 @@ func CustomRecoveryWithWriter(out io.Writer, handle RecoveryFunc) HandlerFunc {
 				}
 				if brokenPipe {
 					// If the connection is dead, we can't write a status to it.
-					c.Error(err.(error)) // nolint: errcheck
+					c.Error(err.(error)) //nolint: errcheck
 					c.Abort()
 				} else {
 					handle(c, err)
@@ -121,7 +122,7 @@ func stack(skip int) []byte {
 		// Print this much at least.  If we can't find the source, it won't show.
 		fmt.Fprintf(buf, "%s:%d (0x%x)\n", file, line, pc)
 		if file != lastFile {
-			data, err := ioutil.ReadFile(file)
+			data, err := os.ReadFile(file)
 			if err != nil {
 				continue
 			}
diff --git a/vendor/github.com/gin-gonic/gin/render/json.go b/vendor/github.com/gin-gonic/gin/render/json.go
index af678e80d..fc8dea453 100644
--- a/vendor/github.com/gin-gonic/gin/render/json.go
+++ b/vendor/github.com/gin-gonic/gin/render/json.go
@@ -53,11 +53,8 @@ var (
 )
 
 // Render (JSON) writes data with custom ContentType.
-func (r JSON) Render(w http.ResponseWriter) (err error) {
-	if err = WriteJSON(w, r.Data); err != nil {
-		panic(err)
-	}
-	return
+func (r JSON) Render(w http.ResponseWriter) error {
+	return WriteJSON(w, r.Data)
 }
 
 // WriteContentType (JSON) writes JSON ContentType.
diff --git a/vendor/github.com/gin-gonic/gin/render/yaml.go b/vendor/github.com/gin-gonic/gin/render/yaml.go
index 4f0ac01f6..fc927c1f2 100644
--- a/vendor/github.com/gin-gonic/gin/render/yaml.go
+++ b/vendor/github.com/gin-gonic/gin/render/yaml.go
@@ -7,7 +7,7 @@ package render
 import (
 	"net/http"
 
-	"gopkg.in/yaml.v2"
+	"gopkg.in/yaml.v3"
 )
 
 // YAML contains the given interface object.
diff --git a/vendor/github.com/gin-gonic/gin/response_writer.go b/vendor/github.com/gin-gonic/gin/response_writer.go
index 77c7ed8fd..753a0b09a 100644
--- a/vendor/github.com/gin-gonic/gin/response_writer.go
+++ b/vendor/github.com/gin-gonic/gin/response_writer.go
@@ -49,7 +49,11 @@ type responseWriter struct {
 	status int
 }
 
-var _ ResponseWriter = &responseWriter{}
+var _ ResponseWriter = (*responseWriter)(nil)
+
+func (w *responseWriter) Unwrap() http.ResponseWriter {
+	return w.ResponseWriter
+}
 
 func (w *responseWriter) reset(writer http.ResponseWriter) {
 	w.ResponseWriter = writer
@@ -61,6 +65,7 @@ func (w *responseWriter) WriteHeader(code int) {
 	if code > 0 && w.status != code {
 		if w.Written() {
 			debugPrint("[WARNING] Headers were already written. Wanted to override status code %d with %d", w.status, code)
+			return
 		}
 		w.status = code
 	}
diff --git a/vendor/github.com/gin-gonic/gin/routergroup.go b/vendor/github.com/gin-gonic/gin/routergroup.go
index 3c082d932..c833fe8fe 100644
--- a/vendor/github.com/gin-gonic/gin/routergroup.go
+++ b/vendor/github.com/gin-gonic/gin/routergroup.go
@@ -42,6 +42,7 @@ type IRoutes interface {
 	PUT(string, ...HandlerFunc) IRoutes
 	OPTIONS(string, ...HandlerFunc) IRoutes
 	HEAD(string, ...HandlerFunc) IRoutes
+	Match([]string, string, ...HandlerFunc) IRoutes
 
 	StaticFile(string, string) IRoutes
 	StaticFileFS(string, string, http.FileSystem) IRoutes
@@ -58,7 +59,7 @@ type RouterGroup struct {
 	root     bool
 }
 
-var _ IRouter = &RouterGroup{}
+var _ IRouter = (*RouterGroup)(nil)
 
 // Use adds middleware to the group, see example code in GitHub.
 func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
@@ -106,37 +107,37 @@ func (group *RouterGroup) Handle(httpMethod, relativePath string, handlers ...Ha
 	return group.handle(httpMethod, relativePath, handlers)
 }
 
-// POST is a shortcut for router.Handle("POST", path, handle).
+// POST is a shortcut for router.Handle("POST", path, handlers).
 func (group *RouterGroup) POST(relativePath string, handlers ...HandlerFunc) IRoutes {
 	return group.handle(http.MethodPost, relativePath, handlers)
 }
 
-// GET is a shortcut for router.Handle("GET", path, handle).
+// GET is a shortcut for router.Handle("GET", path, handlers).
 func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) IRoutes {
 	return group.handle(http.MethodGet, relativePath, handlers)
 }
 
-// DELETE is a shortcut for router.Handle("DELETE", path, handle).
+// DELETE is a shortcut for router.Handle("DELETE", path, handlers).
 func (group *RouterGroup) DELETE(relativePath string, handlers ...HandlerFunc) IRoutes {
 	return group.handle(http.MethodDelete, relativePath, handlers)
 }
 
-// PATCH is a shortcut for router.Handle("PATCH", path, handle).
+// PATCH is a shortcut for router.Handle("PATCH", path, handlers).
 func (group *RouterGroup) PATCH(relativePath string, handlers ...HandlerFunc) IRoutes {
 	return group.handle(http.MethodPatch, relativePath, handlers)
 }
 
-// PUT is a shortcut for router.Handle("PUT", path, handle).
+// PUT is a shortcut for router.Handle("PUT", path, handlers).
 func (group *RouterGroup) PUT(relativePath string, handlers ...HandlerFunc) IRoutes {
 	return group.handle(http.MethodPut, relativePath, handlers)
 }
 
-// OPTIONS is a shortcut for router.Handle("OPTIONS", path, handle).
+// OPTIONS is a shortcut for router.Handle("OPTIONS", path, handlers).
 func (group *RouterGroup) OPTIONS(relativePath string, handlers ...HandlerFunc) IRoutes {
 	return group.handle(http.MethodOptions, relativePath, handlers)
 }
 
-// HEAD is a shortcut for router.Handle("HEAD", path, handle).
+// HEAD is a shortcut for router.Handle("HEAD", path, handlers).
 func (group *RouterGroup) HEAD(relativePath string, handlers ...HandlerFunc) IRoutes {
 	return group.handle(http.MethodHead, relativePath, handlers)
 }
@@ -151,6 +152,15 @@ func (group *RouterGroup) Any(relativePath string, handlers ...HandlerFunc) IRou
 	return group.returnObj()
 }
 
+// Match registers a route that matches the specified methods that you declared.
+func (group *RouterGroup) Match(methods []string, relativePath string, handlers ...HandlerFunc) IRoutes {
+	for _, method := range methods {
+		group.handle(method, relativePath, handlers)
+	}
+
+	return group.returnObj()
+}
+
 // StaticFile registers a single route in order to serve a single file of the local filesystem.
 // router.StaticFile("favicon.ico", "./resources/favicon.ico")
 func (group *RouterGroup) StaticFile(relativePath, filepath string) IRoutes {
@@ -161,7 +171,7 @@ func (group *RouterGroup) StaticFile(relativePath, filepath string) IRoutes {
 
 // StaticFileFS works just like `StaticFile` but a custom `http.FileSystem` can be used instead..
 // router.StaticFileFS("favicon.ico", "./resources/favicon.ico", Dir{".", false})
-// Gin by default user: gin.Dir()
+// Gin by default uses: gin.Dir()
 func (group *RouterGroup) StaticFileFS(relativePath, filepath string, fs http.FileSystem) IRoutes {
 	return group.staticFileHandler(relativePath, func(c *Context) {
 		c.FileFromFS(filepath, fs)
@@ -182,13 +192,14 @@ func (group *RouterGroup) staticFileHandler(relativePath string, handler Handler
 // of the Router's NotFound handler.
 // To use the operating system's file system implementation,
 // use :
-//     router.Static("/static", "/var/www")
+//
+//	router.Static("/static", "/var/www")
 func (group *RouterGroup) Static(relativePath, root string) IRoutes {
 	return group.StaticFS(relativePath, Dir(root, false))
 }
 
 // StaticFS works just like `Static()` but a custom `http.FileSystem` can be used instead.
-// Gin by default user: gin.Dir()
+// Gin by default uses: gin.Dir()
 func (group *RouterGroup) StaticFS(relativePath string, fs http.FileSystem) IRoutes {
 	if strings.Contains(relativePath, ":") || strings.Contains(relativePath, "*") {
 		panic("URL parameters can not be used when serving a static folder")
diff --git a/vendor/github.com/gin-gonic/gin/tree.go b/vendor/github.com/gin-gonic/gin/tree.go
index 0179aa085..dda8f4f7b 100644
--- a/vendor/github.com/gin-gonic/gin/tree.go
+++ b/vendor/github.com/gin-gonic/gin/tree.go
@@ -457,11 +457,11 @@ walk: // Outer loop for walking the tree
 
 				if !n.wildChild {
 					// If the path at the end of the loop is not equal to '/' and the current node has no child nodes
-					// the current node needs to roll back to last vaild skippedNode
+					// the current node needs to roll back to last valid skippedNode
 					if path != "/" {
-						for l := len(*skippedNodes); l > 0; {
-							skippedNode := (*skippedNodes)[l-1]
-							*skippedNodes = (*skippedNodes)[:l-1]
+						for length := len(*skippedNodes); length > 0; length-- {
+							skippedNode := (*skippedNodes)[length-1]
+							*skippedNodes = (*skippedNodes)[:length-1]
 							if strings.HasSuffix(skippedNode.path, path) {
 								path = skippedNode.path
 								n = skippedNode.node
@@ -574,11 +574,11 @@ walk: // Outer loop for walking the tree
 
 		if path == prefix {
 			// If the current path does not equal '/' and the node does not have a registered handle and the most recently matched node has a child node
-			// the current node needs to roll back to last vaild skippedNode
+			// the current node needs to roll back to last valid skippedNode
 			if n.handlers == nil && path != "/" {
-				for l := len(*skippedNodes); l > 0; {
-					skippedNode := (*skippedNodes)[l-1]
-					*skippedNodes = (*skippedNodes)[:l-1]
+				for length := len(*skippedNodes); length > 0; length-- {
+					skippedNode := (*skippedNodes)[length-1]
+					*skippedNodes = (*skippedNodes)[:length-1]
 					if strings.HasSuffix(skippedNode.path, path) {
 						path = skippedNode.path
 						n = skippedNode.node
@@ -633,9 +633,9 @@ walk: // Outer loop for walking the tree
 
 		// roll back to last valid skippedNode
 		if !value.tsr && path != "/" {
-			for l := len(*skippedNodes); l > 0; {
-				skippedNode := (*skippedNodes)[l-1]
-				*skippedNodes = (*skippedNodes)[:l-1]
+			for length := len(*skippedNodes); length > 0; length-- {
+				skippedNode := (*skippedNodes)[length-1]
+				*skippedNodes = (*skippedNodes)[:length-1]
 				if strings.HasSuffix(skippedNode.path, path) {
 					path = skippedNode.path
 					n = skippedNode.node
diff --git a/vendor/github.com/gin-gonic/gin/version.go b/vendor/github.com/gin-gonic/gin/version.go
index 37e27f27a..390da4f3e 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.8.2"
+const Version = "v1.9.0"
diff --git a/vendor/github.com/goccy/go-json/Makefile b/vendor/github.com/goccy/go-json/Makefile
index 363563ab9..5bbfc4c9a 100644
--- a/vendor/github.com/goccy/go-json/Makefile
+++ b/vendor/github.com/goccy/go-json/Makefile
@@ -22,7 +22,7 @@ cover-html: cover
 
 .PHONY: lint
 lint: golangci-lint
-	golangci-lint run
+	$(BIN_DIR)/golangci-lint run
 
 golangci-lint: | $(BIN_DIR)
 	@{ \
@@ -30,7 +30,7 @@ golangci-lint: | $(BIN_DIR)
 		GOLANGCI_LINT_TMP_DIR=$$(mktemp -d); \
 		cd $$GOLANGCI_LINT_TMP_DIR; \
 		go mod init tmp; \
-		GOBIN=$(BIN_DIR) go get github.com/golangci/golangci-lint/cmd/golangci-lint@v1.36.0; \
+		GOBIN=$(BIN_DIR) go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.48.0; \
 		rm -rf $$GOLANGCI_LINT_TMP_DIR; \
 	}
 
diff --git a/vendor/github.com/goccy/go-json/README.md b/vendor/github.com/goccy/go-json/README.md
index 568623773..7bacc54f9 100644
--- a/vendor/github.com/goccy/go-json/README.md
+++ b/vendor/github.com/goccy/go-json/README.md
@@ -184,7 +184,7 @@ func Marshal(v interface{}) ([]byte, error) {
 `json.Marshal` and `json.Unmarshal` receive `interface{}` value and they perform type determination dynamically to process.
 In normal case, you need to use the `reflect` library to determine the type dynamically, but since `reflect.Type` is defined as `interface`, when you call the method of `reflect.Type`, The reflect's argument is escaped.
 
-Therefore, the arguments for `Marshal` and `Unmarshal` are always escape to the heap.
+Therefore, the arguments for `Marshal` and `Unmarshal` are always escaped to the heap.
 However, `go-json` can use the feature of `reflect.Type` while avoiding escaping.
 
 `reflect.Type` is defined as `interface`, but in reality `reflect.Type` is implemented only by the structure `rtype` defined in the `reflect` package.
diff --git a/vendor/github.com/goccy/go-json/decode.go b/vendor/github.com/goccy/go-json/decode.go
index d99749d05..74c6ac3bc 100644
--- a/vendor/github.com/goccy/go-json/decode.go
+++ b/vendor/github.com/goccy/go-json/decode.go
@@ -83,6 +83,37 @@ func unmarshalContext(ctx context.Context, data []byte, v interface{}, optFuncs
 	return validateEndBuf(src, cursor)
 }
 
+var (
+	pathDecoder = decoder.NewPathDecoder()
+)
+
+func extractFromPath(path *Path, data []byte, optFuncs ...DecodeOptionFunc) ([][]byte, error) {
+	if path.path.RootSelectorOnly {
+		return [][]byte{data}, nil
+	}
+	src := make([]byte, len(data)+1) // append nul byte to the end
+	copy(src, data)
+
+	ctx := decoder.TakeRuntimeContext()
+	ctx.Buf = src
+	ctx.Option.Flags = 0
+	ctx.Option.Flags |= decoder.PathOption
+	ctx.Option.Path = path.path
+	for _, optFunc := range optFuncs {
+		optFunc(ctx.Option)
+	}
+	paths, cursor, err := pathDecoder.DecodePath(ctx, 0, 0)
+	if err != nil {
+		decoder.ReleaseRuntimeContext(ctx)
+		return nil, err
+	}
+	decoder.ReleaseRuntimeContext(ctx)
+	if err := validateEndBuf(src, cursor); err != nil {
+		return nil, err
+	}
+	return paths, nil
+}
+
 func unmarshalNoEscape(data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error {
 	src := make([]byte, len(data)+1) // append nul byte to the end
 	copy(src, data)
diff --git a/vendor/github.com/goccy/go-json/error.go b/vendor/github.com/goccy/go-json/error.go
index 94c1339a0..5b2dcee50 100644
--- a/vendor/github.com/goccy/go-json/error.go
+++ b/vendor/github.com/goccy/go-json/error.go
@@ -37,3 +37,5 @@ type UnmarshalTypeError = errors.UnmarshalTypeError
 type UnsupportedTypeError = errors.UnsupportedTypeError
 
 type UnsupportedValueError = errors.UnsupportedValueError
+
+type PathError = errors.PathError
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go b/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go
index 030cb7a97..b6876cf0d 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go
@@ -35,3 +35,7 @@ func (d *anonymousFieldDecoder) Decode(ctx *RuntimeContext, cursor, depth int64,
 	p = *(*unsafe.Pointer)(p)
 	return d.dec.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+d.offset))
 }
+
+func (d *anonymousFieldDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	return d.dec.DecodePath(ctx, cursor, depth)
+}
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 21f1fd585..8ef91cfa1 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/array.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/array.go
@@ -1,6 +1,7 @@
 package decoder
 
 import (
+	"fmt"
 	"unsafe"
 
 	"github.com/goccy/go-json/internal/errors"
@@ -167,3 +168,7 @@ func (d *arrayDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe
 		}
 	}
 }
+
+func (d *arrayDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	return nil, 0, fmt.Errorf("json: array decoder does not support decode path")
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/assign.go b/vendor/github.com/goccy/go-json/internal/decoder/assign.go
new file mode 100644
index 000000000..c53e6ad9f
--- /dev/null
+++ b/vendor/github.com/goccy/go-json/internal/decoder/assign.go
@@ -0,0 +1,438 @@
+package decoder
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+)
+
+var (
+	nilValue = reflect.ValueOf(nil)
+)
+
+func AssignValue(src, dst reflect.Value) error {
+	if dst.Type().Kind() != reflect.Ptr {
+		return fmt.Errorf("invalid dst type. required pointer type: %T", dst.Type())
+	}
+	casted, err := castValue(dst.Elem().Type(), src)
+	if err != nil {
+		return err
+	}
+	dst.Elem().Set(casted)
+	return nil
+}
+
+func castValue(t reflect.Type, v reflect.Value) (reflect.Value, error) {
+	switch t.Kind() {
+	case reflect.Int:
+		vv, err := castInt(v)
+		if err != nil {
+			return nilValue, err
+		}
+		return reflect.ValueOf(int(vv.Int())), nil
+	case reflect.Int8:
+		vv, err := castInt(v)
+		if err != nil {
+			return nilValue, err
+		}
+		return reflect.ValueOf(int8(vv.Int())), nil
+	case reflect.Int16:
+		vv, err := castInt(v)
+		if err != nil {
+			return nilValue, err
+		}
+		return reflect.ValueOf(int16(vv.Int())), nil
+	case reflect.Int32:
+		vv, err := castInt(v)
+		if err != nil {
+			return nilValue, err
+		}
+		return reflect.ValueOf(int32(vv.Int())), nil
+	case reflect.Int64:
+		return castInt(v)
+	case reflect.Uint:
+		vv, err := castUint(v)
+		if err != nil {
+			return nilValue, err
+		}
+		return reflect.ValueOf(uint(vv.Uint())), nil
+	case reflect.Uint8:
+		vv, err := castUint(v)
+		if err != nil {
+			return nilValue, err
+		}
+		return reflect.ValueOf(uint8(vv.Uint())), nil
+	case reflect.Uint16:
+		vv, err := castUint(v)
+		if err != nil {
+			return nilValue, err
+		}
+		return reflect.ValueOf(uint16(vv.Uint())), nil
+	case reflect.Uint32:
+		vv, err := castUint(v)
+		if err != nil {
+			return nilValue, err
+		}
+		return reflect.ValueOf(uint32(vv.Uint())), nil
+	case reflect.Uint64:
+		return castUint(v)
+	case reflect.Uintptr:
+		vv, err := castUint(v)
+		if err != nil {
+			return nilValue, err
+		}
+		return reflect.ValueOf(uintptr(vv.Uint())), nil
+	case reflect.String:
+		return castString(v)
+	case reflect.Bool:
+		return castBool(v)
+	case reflect.Float32:
+		vv, err := castFloat(v)
+		if err != nil {
+			return nilValue, err
+		}
+		return reflect.ValueOf(float32(vv.Float())), nil
+	case reflect.Float64:
+		return castFloat(v)
+	case reflect.Array:
+		return castArray(t, v)
+	case reflect.Slice:
+		return castSlice(t, v)
+	case reflect.Map:
+		return castMap(t, v)
+	case reflect.Struct:
+		return castStruct(t, v)
+	}
+	return v, nil
+}
+
+func castInt(v reflect.Value) (reflect.Value, error) {
+	switch v.Type().Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return v, nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return reflect.ValueOf(int64(v.Uint())), nil
+	case reflect.String:
+		i64, err := strconv.ParseInt(v.String(), 10, 64)
+		if err != nil {
+			return nilValue, err
+		}
+		return reflect.ValueOf(i64), nil
+	case reflect.Bool:
+		if v.Bool() {
+			return reflect.ValueOf(int64(1)), nil
+		}
+		return reflect.ValueOf(int64(0)), nil
+	case reflect.Float32, reflect.Float64:
+		return reflect.ValueOf(int64(v.Float())), nil
+	case reflect.Array:
+		if v.Len() > 0 {
+			return castInt(v.Index(0))
+		}
+		return nilValue, fmt.Errorf("failed to cast to int64 from empty array")
+	case reflect.Slice:
+		if v.Len() > 0 {
+			return castInt(v.Index(0))
+		}
+		return nilValue, fmt.Errorf("failed to cast to int64 from empty slice")
+	case reflect.Interface:
+		return castInt(reflect.ValueOf(v.Interface()))
+	case reflect.Map:
+		return nilValue, fmt.Errorf("failed to cast to int64 from map")
+	case reflect.Struct:
+		return nilValue, fmt.Errorf("failed to cast to int64 from struct")
+	case reflect.Ptr:
+		return castInt(v.Elem())
+	}
+	return nilValue, fmt.Errorf("failed to cast to int64 from %s", v.Type().Kind())
+}
+
+func castUint(v reflect.Value) (reflect.Value, error) {
+	switch v.Type().Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return reflect.ValueOf(uint64(v.Int())), nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return v, nil
+	case reflect.String:
+		u64, err := strconv.ParseUint(v.String(), 10, 64)
+		if err != nil {
+			return nilValue, err
+		}
+		return reflect.ValueOf(u64), nil
+	case reflect.Bool:
+		if v.Bool() {
+			return reflect.ValueOf(uint64(1)), nil
+		}
+		return reflect.ValueOf(uint64(0)), nil
+	case reflect.Float32, reflect.Float64:
+		return reflect.ValueOf(uint64(v.Float())), nil
+	case reflect.Array:
+		if v.Len() > 0 {
+			return castUint(v.Index(0))
+		}
+		return nilValue, fmt.Errorf("failed to cast to uint64 from empty array")
+	case reflect.Slice:
+		if v.Len() > 0 {
+			return castUint(v.Index(0))
+		}
+		return nilValue, fmt.Errorf("failed to cast to uint64 from empty slice")
+	case reflect.Interface:
+		return castUint(reflect.ValueOf(v.Interface()))
+	case reflect.Map:
+		return nilValue, fmt.Errorf("failed to cast to uint64 from map")
+	case reflect.Struct:
+		return nilValue, fmt.Errorf("failed to cast to uint64 from struct")
+	case reflect.Ptr:
+		return castUint(v.Elem())
+	}
+	return nilValue, fmt.Errorf("failed to cast to uint64 from %s", v.Type().Kind())
+}
+
+func castString(v reflect.Value) (reflect.Value, error) {
+	switch v.Type().Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return reflect.ValueOf(fmt.Sprint(v.Int())), nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return reflect.ValueOf(fmt.Sprint(v.Uint())), nil
+	case reflect.String:
+		return v, nil
+	case reflect.Bool:
+		if v.Bool() {
+			return reflect.ValueOf("true"), nil
+		}
+		return reflect.ValueOf("false"), nil
+	case reflect.Float32, reflect.Float64:
+		return reflect.ValueOf(fmt.Sprint(v.Float())), nil
+	case reflect.Array:
+		if v.Len() > 0 {
+			return castString(v.Index(0))
+		}
+		return nilValue, fmt.Errorf("failed to cast to string from empty array")
+	case reflect.Slice:
+		if v.Len() > 0 {
+			return castString(v.Index(0))
+		}
+		return nilValue, fmt.Errorf("failed to cast to string from empty slice")
+	case reflect.Interface:
+		return castString(reflect.ValueOf(v.Interface()))
+	case reflect.Map:
+		return nilValue, fmt.Errorf("failed to cast to string from map")
+	case reflect.Struct:
+		return nilValue, fmt.Errorf("failed to cast to string from struct")
+	case reflect.Ptr:
+		return castString(v.Elem())
+	}
+	return nilValue, fmt.Errorf("failed to cast to string from %s", v.Type().Kind())
+}
+
+func castBool(v reflect.Value) (reflect.Value, error) {
+	switch v.Type().Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		switch v.Int() {
+		case 0:
+			return reflect.ValueOf(false), nil
+		case 1:
+			return reflect.ValueOf(true), nil
+		}
+		return nilValue, fmt.Errorf("failed to cast to bool from %d", v.Int())
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		switch v.Uint() {
+		case 0:
+			return reflect.ValueOf(false), nil
+		case 1:
+			return reflect.ValueOf(true), nil
+		}
+		return nilValue, fmt.Errorf("failed to cast to bool from %d", v.Uint())
+	case reflect.String:
+		b, err := strconv.ParseBool(v.String())
+		if err != nil {
+			return nilValue, err
+		}
+		return reflect.ValueOf(b), nil
+	case reflect.Bool:
+		return v, nil
+	case reflect.Float32, reflect.Float64:
+		switch v.Float() {
+		case 0:
+			return reflect.ValueOf(false), nil
+		case 1:
+			return reflect.ValueOf(true), nil
+		}
+		return nilValue, fmt.Errorf("failed to cast to bool from %f", v.Float())
+	case reflect.Array:
+		if v.Len() > 0 {
+			return castBool(v.Index(0))
+		}
+		return nilValue, fmt.Errorf("failed to cast to string from empty array")
+	case reflect.Slice:
+		if v.Len() > 0 {
+			return castBool(v.Index(0))
+		}
+		return nilValue, fmt.Errorf("failed to cast to string from empty slice")
+	case reflect.Interface:
+		return castBool(reflect.ValueOf(v.Interface()))
+	case reflect.Map:
+		return nilValue, fmt.Errorf("failed to cast to string from map")
+	case reflect.Struct:
+		return nilValue, fmt.Errorf("failed to cast to string from struct")
+	case reflect.Ptr:
+		return castBool(v.Elem())
+	}
+	return nilValue, fmt.Errorf("failed to cast to bool from %s", v.Type().Kind())
+}
+
+func castFloat(v reflect.Value) (reflect.Value, error) {
+	switch v.Type().Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return reflect.ValueOf(float64(v.Int())), nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return reflect.ValueOf(float64(v.Uint())), nil
+	case reflect.String:
+		f64, err := strconv.ParseFloat(v.String(), 64)
+		if err != nil {
+			return nilValue, err
+		}
+		return reflect.ValueOf(f64), nil
+	case reflect.Bool:
+		if v.Bool() {
+			return reflect.ValueOf(float64(1)), nil
+		}
+		return reflect.ValueOf(float64(0)), nil
+	case reflect.Float32, reflect.Float64:
+		return v, nil
+	case reflect.Array:
+		if v.Len() > 0 {
+			return castFloat(v.Index(0))
+		}
+		return nilValue, fmt.Errorf("failed to cast to float64 from empty array")
+	case reflect.Slice:
+		if v.Len() > 0 {
+			return castFloat(v.Index(0))
+		}
+		return nilValue, fmt.Errorf("failed to cast to float64 from empty slice")
+	case reflect.Interface:
+		return castFloat(reflect.ValueOf(v.Interface()))
+	case reflect.Map:
+		return nilValue, fmt.Errorf("failed to cast to float64 from map")
+	case reflect.Struct:
+		return nilValue, fmt.Errorf("failed to cast to float64 from struct")
+	case reflect.Ptr:
+		return castFloat(v.Elem())
+	}
+	return nilValue, fmt.Errorf("failed to cast to float64 from %s", v.Type().Kind())
+}
+
+func castArray(t reflect.Type, v reflect.Value) (reflect.Value, error) {
+	kind := v.Type().Kind()
+	if kind == reflect.Interface {
+		return castArray(t, reflect.ValueOf(v.Interface()))
+	}
+	if kind != reflect.Slice && kind != reflect.Array {
+		return nilValue, fmt.Errorf("failed to cast to array from %s", kind)
+	}
+	if t.Elem() == v.Type().Elem() {
+		return v, nil
+	}
+	if t.Len() != v.Len() {
+		return nilValue, fmt.Errorf("failed to cast [%d]array from slice of %d length", t.Len(), v.Len())
+	}
+	ret := reflect.New(t).Elem()
+	for i := 0; i < v.Len(); i++ {
+		vv, err := castValue(t.Elem(), v.Index(i))
+		if err != nil {
+			return nilValue, err
+		}
+		ret.Index(i).Set(vv)
+	}
+	return ret, nil
+}
+
+func castSlice(t reflect.Type, v reflect.Value) (reflect.Value, error) {
+	kind := v.Type().Kind()
+	if kind == reflect.Interface {
+		return castSlice(t, reflect.ValueOf(v.Interface()))
+	}
+	if kind != reflect.Slice && kind != reflect.Array {
+		return nilValue, fmt.Errorf("failed to cast to slice from %s", kind)
+	}
+	if t.Elem() == v.Type().Elem() {
+		return v, nil
+	}
+	ret := reflect.MakeSlice(t, v.Len(), v.Len())
+	for i := 0; i < v.Len(); i++ {
+		vv, err := castValue(t.Elem(), v.Index(i))
+		if err != nil {
+			return nilValue, err
+		}
+		ret.Index(i).Set(vv)
+	}
+	return ret, nil
+}
+
+func castMap(t reflect.Type, v reflect.Value) (reflect.Value, error) {
+	ret := reflect.MakeMap(t)
+	switch v.Type().Kind() {
+	case reflect.Map:
+		iter := v.MapRange()
+		for iter.Next() {
+			key, err := castValue(t.Key(), iter.Key())
+			if err != nil {
+				return nilValue, err
+			}
+			value, err := castValue(t.Elem(), iter.Value())
+			if err != nil {
+				return nilValue, err
+			}
+			ret.SetMapIndex(key, value)
+		}
+		return ret, nil
+	case reflect.Interface:
+		return castMap(t, reflect.ValueOf(v.Interface()))
+	case reflect.Slice:
+		if v.Len() > 0 {
+			return castMap(t, v.Index(0))
+		}
+		return nilValue, fmt.Errorf("failed to cast to map from empty slice")
+	}
+	return nilValue, fmt.Errorf("failed to cast to map from %s", v.Type().Kind())
+}
+
+func castStruct(t reflect.Type, v reflect.Value) (reflect.Value, error) {
+	ret := reflect.New(t).Elem()
+	switch v.Type().Kind() {
+	case reflect.Map:
+		iter := v.MapRange()
+		for iter.Next() {
+			key := iter.Key()
+			k, err := castString(key)
+			if err != nil {
+				return nilValue, err
+			}
+			fieldName := k.String()
+			field, ok := t.FieldByName(fieldName)
+			if ok {
+				value, err := castValue(field.Type, iter.Value())
+				if err != nil {
+					return nilValue, err
+				}
+				ret.FieldByName(fieldName).Set(value)
+			}
+		}
+		return ret, nil
+	case reflect.Struct:
+		for i := 0; i < v.Type().NumField(); i++ {
+			name := v.Type().Field(i).Name
+			ret.FieldByName(name).Set(v.FieldByName(name))
+		}
+		return ret, nil
+	case reflect.Interface:
+		return castStruct(t, reflect.ValueOf(v.Interface()))
+	case reflect.Slice:
+		if v.Len() > 0 {
+			return castStruct(t, v.Index(0))
+		}
+		return nilValue, fmt.Errorf("failed to cast to struct from empty slice")
+	default:
+		return nilValue, fmt.Errorf("failed to cast to struct from %s", v.Type().Kind())
+	}
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/bool.go b/vendor/github.com/goccy/go-json/internal/decoder/bool.go
index 455042a53..ba6cf5bc4 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/bool.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/bool.go
@@ -1,6 +1,7 @@
 package decoder
 
 import (
+	"fmt"
 	"unsafe"
 
 	"github.com/goccy/go-json/internal/errors"
@@ -76,3 +77,7 @@ func (d *boolDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.
 	}
 	return 0, errors.ErrUnexpectedEndOfJSON("bool", cursor)
 }
+
+func (d *boolDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	return nil, 0, fmt.Errorf("json: bool decoder does not support decode path")
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/bytes.go b/vendor/github.com/goccy/go-json/internal/decoder/bytes.go
index 92c7dcf64..939bf4327 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/bytes.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/bytes.go
@@ -2,6 +2,7 @@ package decoder
 
 import (
 	"encoding/base64"
+	"fmt"
 	"unsafe"
 
 	"github.com/goccy/go-json/internal/errors"
@@ -78,6 +79,10 @@ func (d *bytesDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe
 	return cursor, nil
 }
 
+func (d *bytesDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	return nil, 0, fmt.Errorf("json: []byte decoder does not support decode path")
+}
+
 func (d *bytesDecoder) decodeStreamBinary(s *Stream, depth int64, p unsafe.Pointer) ([]byte, error) {
 	c := s.skipWhiteSpace()
 	if c == '[' {
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/float.go b/vendor/github.com/goccy/go-json/internal/decoder/float.go
index dfb7168da..9b2eb8b35 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/float.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/float.go
@@ -156,3 +156,15 @@ func (d *floatDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe
 	d.op(p, f64)
 	return cursor, nil
 }
+
+func (d *floatDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	buf := ctx.Buf
+	bytes, c, err := d.decodeByte(buf, cursor)
+	if err != nil {
+		return nil, 0, err
+	}
+	if bytes == nil {
+		return [][]byte{nullbytes}, c, nil
+	}
+	return [][]byte{bytes}, c, nil
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/func.go b/vendor/github.com/goccy/go-json/internal/decoder/func.go
index ee3563711..4cc12ca81 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/func.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/func.go
@@ -2,6 +2,7 @@ package decoder
 
 import (
 	"bytes"
+	"fmt"
 	"unsafe"
 
 	"github.com/goccy/go-json/internal/errors"
@@ -139,3 +140,7 @@ func (d *funcDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.
 	}
 	return cursor, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor)
 }
+
+func (d *funcDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	return nil, 0, fmt.Errorf("json: func decoder does not support decode path")
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/int.go b/vendor/github.com/goccy/go-json/internal/decoder/int.go
index 509b753d6..1a7f08199 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/int.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/int.go
@@ -240,3 +240,7 @@ func (d *intDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.P
 	d.op(p, i64)
 	return cursor, nil
 }
+
+func (d *intDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	return nil, 0, fmt.Errorf("json: int decoder does not support decode path")
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/interface.go b/vendor/github.com/goccy/go-json/internal/decoder/interface.go
index 4dbb4be4a..45c69ab8c 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/interface.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/interface.go
@@ -94,6 +94,7 @@ func (d *interfaceDecoder) numDecoder(s *Stream) Decoder {
 
 var (
 	emptyInterfaceType = runtime.Type2RType(reflect.TypeOf((*interface{})(nil)).Elem())
+	EmptyInterfaceType = emptyInterfaceType
 	interfaceMapType   = runtime.Type2RType(
 		reflect.TypeOf((*map[string]interface{})(nil)).Elem(),
 	)
@@ -456,3 +457,72 @@ func (d *interfaceDecoder) decodeEmptyInterface(ctx *RuntimeContext, cursor, dep
 	}
 	return cursor, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor)
 }
+
+func NewPathDecoder() Decoder {
+	ifaceDecoder := &interfaceDecoder{
+		typ:        emptyInterfaceType,
+		structName: "",
+		fieldName:  "",
+		floatDecoder: newFloatDecoder("", "", func(p unsafe.Pointer, v float64) {
+			*(*interface{})(p) = v
+		}),
+		numberDecoder: newNumberDecoder("", "", func(p unsafe.Pointer, v json.Number) {
+			*(*interface{})(p) = v
+		}),
+		stringDecoder: newStringDecoder("", ""),
+	}
+	ifaceDecoder.sliceDecoder = newSliceDecoder(
+		ifaceDecoder,
+		emptyInterfaceType,
+		emptyInterfaceType.Size(),
+		"", "",
+	)
+	ifaceDecoder.mapDecoder = newMapDecoder(
+		interfaceMapType,
+		stringType,
+		ifaceDecoder.stringDecoder,
+		interfaceMapType.Elem(),
+		ifaceDecoder,
+		"", "",
+	)
+	return ifaceDecoder
+}
+
+var (
+	truebytes  = []byte("true")
+	falsebytes = []byte("false")
+)
+
+func (d *interfaceDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	buf := ctx.Buf
+	cursor = skipWhiteSpace(buf, cursor)
+	switch buf[cursor] {
+	case '{':
+		return d.mapDecoder.DecodePath(ctx, cursor, depth)
+	case '[':
+		return d.sliceDecoder.DecodePath(ctx, cursor, depth)
+	case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+		return d.floatDecoder.DecodePath(ctx, cursor, depth)
+	case '"':
+		return d.stringDecoder.DecodePath(ctx, cursor, depth)
+	case 't':
+		if err := validateTrue(buf, cursor); err != nil {
+			return nil, 0, err
+		}
+		cursor += 4
+		return [][]byte{truebytes}, cursor, nil
+	case 'f':
+		if err := validateFalse(buf, cursor); err != nil {
+			return nil, 0, err
+		}
+		cursor += 5
+		return [][]byte{falsebytes}, cursor, nil
+	case 'n':
+		if err := validateNull(buf, cursor); err != nil {
+			return nil, 0, err
+		}
+		cursor += 4
+		return [][]byte{nullbytes}, cursor, nil
+	}
+	return nil, cursor, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor)
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/invalid.go b/vendor/github.com/goccy/go-json/internal/decoder/invalid.go
index 1ef50a7d3..4c9721b09 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/invalid.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/invalid.go
@@ -43,3 +43,13 @@ func (d *invalidDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsa
 		Field:  d.fieldName,
 	}
 }
+
+func (d *invalidDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	return nil, 0, &errors.UnmarshalTypeError{
+		Value:  "object",
+		Type:   runtime.RType2Type(d.typ),
+		Offset: cursor,
+		Struct: d.structName,
+		Field:  d.fieldName,
+	}
+}
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 cb55ef006..7a6eea34f 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/map.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/map.go
@@ -185,3 +185,96 @@ func (d *mapDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.P
 		cursor++
 	}
 }
+
+func (d *mapDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	buf := ctx.Buf
+	depth++
+	if depth > maxDecodeNestingDepth {
+		return nil, 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
+	}
+
+	cursor = skipWhiteSpace(buf, cursor)
+	buflen := int64(len(buf))
+	if buflen < 2 {
+		return nil, 0, errors.ErrExpected("{} for map", cursor)
+	}
+	switch buf[cursor] {
+	case 'n':
+		if err := validateNull(buf, cursor); err != nil {
+			return nil, 0, err
+		}
+		cursor += 4
+		return [][]byte{nullbytes}, cursor, nil
+	case '{':
+	default:
+		return nil, 0, errors.ErrExpected("{ character for map value", cursor)
+	}
+	cursor++
+	cursor = skipWhiteSpace(buf, cursor)
+	if buf[cursor] == '}' {
+		cursor++
+		return nil, cursor, nil
+	}
+	keyDecoder, ok := d.keyDecoder.(*stringDecoder)
+	if !ok {
+		return nil, 0, &errors.UnmarshalTypeError{
+			Value:  "string",
+			Type:   reflect.TypeOf(""),
+			Offset: cursor,
+			Struct: d.structName,
+			Field:  d.fieldName,
+		}
+	}
+	ret := [][]byte{}
+	for {
+		key, keyCursor, err := keyDecoder.decodeByte(buf, cursor)
+		if err != nil {
+			return nil, 0, err
+		}
+		cursor = skipWhiteSpace(buf, keyCursor)
+		if buf[cursor] != ':' {
+			return nil, 0, errors.ErrExpected("colon after object key", cursor)
+		}
+		cursor++
+		child, found, err := ctx.Option.Path.Field(string(key))
+		if err != nil {
+			return nil, 0, err
+		}
+		if found {
+			if child != nil {
+				oldPath := ctx.Option.Path.node
+				ctx.Option.Path.node = child
+				paths, c, err := d.valueDecoder.DecodePath(ctx, cursor, depth)
+				if err != nil {
+					return nil, 0, err
+				}
+				ctx.Option.Path.node = oldPath
+				ret = append(ret, paths...)
+				cursor = c
+			} else {
+				start := cursor
+				end, err := skipValue(buf, cursor, depth)
+				if err != nil {
+					return nil, 0, err
+				}
+				ret = append(ret, buf[start:end])
+				cursor = end
+			}
+		} else {
+			c, err := skipValue(buf, cursor, depth)
+			if err != nil {
+				return nil, 0, err
+			}
+			cursor = c
+		}
+		cursor = skipWhiteSpace(buf, cursor)
+		if buf[cursor] == '}' {
+			cursor++
+			return ret, cursor, nil
+		}
+		if buf[cursor] != ',' {
+			return nil, 0, errors.ErrExpected("comma after object value", cursor)
+		}
+		cursor++
+	}
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/number.go b/vendor/github.com/goccy/go-json/internal/decoder/number.go
index bf63773e3..10e5435e6 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/number.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/number.go
@@ -51,6 +51,17 @@ func (d *numberDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsaf
 	return cursor, nil
 }
 
+func (d *numberDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	bytes, c, err := d.decodeByte(ctx.Buf, cursor)
+	if err != nil {
+		return nil, 0, err
+	}
+	if bytes == nil {
+		return [][]byte{nullbytes}, c, nil
+	}
+	return [][]byte{bytes}, c, nil
+}
+
 func (d *numberDecoder) decodeStreamByte(s *Stream) ([]byte, error) {
 	start := s.cursor
 	for {
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/option.go b/vendor/github.com/goccy/go-json/internal/decoder/option.go
index e41f876b0..502f772eb 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/option.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/option.go
@@ -7,9 +7,11 @@ type OptionFlags uint8
 const (
 	FirstWinOption OptionFlags = 1 << iota
 	ContextOption
+	PathOption
 )
 
 type Option struct {
 	Flags   OptionFlags
 	Context context.Context
+	Path    *Path
 }
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/path.go b/vendor/github.com/goccy/go-json/internal/decoder/path.go
new file mode 100644
index 000000000..a15ff69e3
--- /dev/null
+++ b/vendor/github.com/goccy/go-json/internal/decoder/path.go
@@ -0,0 +1,670 @@
+package decoder
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+
+	"github.com/goccy/go-json/internal/errors"
+	"github.com/goccy/go-json/internal/runtime"
+)
+
+type PathString string
+
+func (s PathString) Build() (*Path, error) {
+	builder := new(PathBuilder)
+	return builder.Build([]rune(s))
+}
+
+type PathBuilder struct {
+	root                    PathNode
+	node                    PathNode
+	singleQuotePathSelector bool
+	doubleQuotePathSelector bool
+}
+
+func (b *PathBuilder) Build(buf []rune) (*Path, error) {
+	node, err := b.build(buf)
+	if err != nil {
+		return nil, err
+	}
+	return &Path{
+		node:                    node,
+		RootSelectorOnly:        node == nil,
+		SingleQuotePathSelector: b.singleQuotePathSelector,
+		DoubleQuotePathSelector: b.doubleQuotePathSelector,
+	}, nil
+}
+
+func (b *PathBuilder) build(buf []rune) (PathNode, error) {
+	if len(buf) == 0 {
+		return nil, errors.ErrEmptyPath()
+	}
+	if buf[0] != '$' {
+		return nil, errors.ErrInvalidPath("JSON Path must start with a $ character")
+	}
+	if len(buf) == 1 {
+		return nil, nil
+	}
+	buf = buf[1:]
+	offset, err := b.buildNext(buf)
+	if err != nil {
+		return nil, err
+	}
+	if len(buf) > offset {
+		return nil, errors.ErrInvalidPath("remain invalid path %q", buf[offset:])
+	}
+	return b.root, nil
+}
+
+func (b *PathBuilder) buildNextCharIfExists(buf []rune, cursor int) (int, error) {
+	if len(buf) > cursor {
+		offset, err := b.buildNext(buf[cursor:])
+		if err != nil {
+			return 0, err
+		}
+		return cursor + 1 + offset, nil
+	}
+	return cursor, nil
+}
+
+func (b *PathBuilder) buildNext(buf []rune) (int, error) {
+	switch buf[0] {
+	case '.':
+		if len(buf) == 1 {
+			return 0, errors.ErrInvalidPath("JSON Path ends with dot character")
+		}
+		offset, err := b.buildSelector(buf[1:])
+		if err != nil {
+			return 0, err
+		}
+		return offset + 1, nil
+	case '[':
+		if len(buf) == 1 {
+			return 0, errors.ErrInvalidPath("JSON Path ends with left bracket character")
+		}
+		offset, err := b.buildIndex(buf[1:])
+		if err != nil {
+			return 0, err
+		}
+		return offset + 1, nil
+	default:
+		return 0, errors.ErrInvalidPath("expect dot or left bracket character. but found %c character", buf[0])
+	}
+}
+
+func (b *PathBuilder) buildSelector(buf []rune) (int, error) {
+	switch buf[0] {
+	case '.':
+		if len(buf) == 1 {
+			return 0, errors.ErrInvalidPath("JSON Path ends with double dot character")
+		}
+		offset, err := b.buildPathRecursive(buf[1:])
+		if err != nil {
+			return 0, err
+		}
+		return 1 + offset, nil
+	case '[', ']', '$', '*':
+		return 0, errors.ErrInvalidPath("found invalid path character %c after dot", buf[0])
+	}
+	for cursor := 0; cursor < len(buf); cursor++ {
+		switch buf[cursor] {
+		case '$', '*', ']':
+			return 0, errors.ErrInvalidPath("found %c character in field selector context", buf[cursor])
+		case '.':
+			if cursor+1 >= len(buf) {
+				return 0, errors.ErrInvalidPath("JSON Path ends with dot character")
+			}
+			selector := buf[:cursor]
+			b.addSelectorNode(string(selector))
+			offset, err := b.buildSelector(buf[cursor+1:])
+			if err != nil {
+				return 0, err
+			}
+			return cursor + 1 + offset, nil
+		case '[':
+			if cursor+1 >= len(buf) {
+				return 0, errors.ErrInvalidPath("JSON Path ends with left bracket character")
+			}
+			selector := buf[:cursor]
+			b.addSelectorNode(string(selector))
+			offset, err := b.buildIndex(buf[cursor+1:])
+			if err != nil {
+				return 0, err
+			}
+			return cursor + 1 + offset, nil
+		case '"':
+			if cursor+1 >= len(buf) {
+				return 0, errors.ErrInvalidPath("JSON Path ends with double quote character")
+			}
+			offset, err := b.buildQuoteSelector(buf[cursor+1:], DoubleQuotePathSelector)
+			if err != nil {
+				return 0, err
+			}
+			return cursor + 1 + offset, nil
+		}
+	}
+	b.addSelectorNode(string(buf))
+	return len(buf), nil
+}
+
+func (b *PathBuilder) buildQuoteSelector(buf []rune, sel QuotePathSelector) (int, error) {
+	switch buf[0] {
+	case '[', ']', '$', '.', '*', '\'', '"':
+		return 0, errors.ErrInvalidPath("found invalid path character %c after quote", buf[0])
+	}
+	for cursor := 0; cursor < len(buf); cursor++ {
+		switch buf[cursor] {
+		case '\'':
+			if sel != SingleQuotePathSelector {
+				return 0, errors.ErrInvalidPath("found double quote character in field selector with single quote context")
+			}
+			if len(buf) <= cursor+1 {
+				return 0, errors.ErrInvalidPath("JSON Path ends with single quote character in field selector context")
+			}
+			if buf[cursor+1] != ']' {
+				return 0, errors.ErrInvalidPath("expect right bracket for field selector with single quote but found %c", buf[cursor+1])
+			}
+			selector := buf[:cursor]
+			b.addSelectorNode(string(selector))
+			b.singleQuotePathSelector = true
+			return b.buildNextCharIfExists(buf, cursor+2)
+		case '"':
+			if sel != DoubleQuotePathSelector {
+				return 0, errors.ErrInvalidPath("found single quote character in field selector with double quote context")
+			}
+			selector := buf[:cursor]
+			b.addSelectorNode(string(selector))
+			b.doubleQuotePathSelector = true
+			return b.buildNextCharIfExists(buf, cursor+1)
+		}
+	}
+	return 0, errors.ErrInvalidPath("couldn't find quote character in selector quote path context")
+}
+
+func (b *PathBuilder) buildPathRecursive(buf []rune) (int, error) {
+	switch buf[0] {
+	case '.', '[', ']', '$', '*':
+		return 0, errors.ErrInvalidPath("found invalid path character %c after double dot", buf[0])
+	}
+	for cursor := 0; cursor < len(buf); cursor++ {
+		switch buf[cursor] {
+		case '$', '*', ']':
+			return 0, errors.ErrInvalidPath("found %c character in field selector context", buf[cursor])
+		case '.':
+			if cursor+1 >= len(buf) {
+				return 0, errors.ErrInvalidPath("JSON Path ends with dot character")
+			}
+			selector := buf[:cursor]
+			b.addRecursiveNode(string(selector))
+			offset, err := b.buildSelector(buf[cursor+1:])
+			if err != nil {
+				return 0, err
+			}
+			return cursor + 1 + offset, nil
+		case '[':
+			if cursor+1 >= len(buf) {
+				return 0, errors.ErrInvalidPath("JSON Path ends with left bracket character")
+			}
+			selector := buf[:cursor]
+			b.addRecursiveNode(string(selector))
+			offset, err := b.buildIndex(buf[cursor+1:])
+			if err != nil {
+				return 0, err
+			}
+			return cursor + 1 + offset, nil
+		}
+	}
+	b.addRecursiveNode(string(buf))
+	return len(buf), nil
+}
+
+func (b *PathBuilder) buildIndex(buf []rune) (int, error) {
+	switch buf[0] {
+	case '.', '[', ']', '$':
+		return 0, errors.ErrInvalidPath("found invalid path character %c after left bracket", buf[0])
+	case '\'':
+		if len(buf) == 1 {
+			return 0, errors.ErrInvalidPath("JSON Path ends with single quote character")
+		}
+		offset, err := b.buildQuoteSelector(buf[1:], SingleQuotePathSelector)
+		if err != nil {
+			return 0, err
+		}
+		return 1 + offset, nil
+	case '*':
+		if len(buf) == 1 {
+			return 0, errors.ErrInvalidPath("JSON Path ends with star character")
+		}
+		if buf[1] != ']' {
+			return 0, errors.ErrInvalidPath("expect right bracket character for index all path but found %c character", buf[1])
+		}
+		b.addIndexAllNode()
+		offset := len("*]")
+		if len(buf) > 2 {
+			buildOffset, err := b.buildNext(buf[2:])
+			if err != nil {
+				return 0, err
+			}
+			return offset + buildOffset, nil
+		}
+		return offset, nil
+	}
+
+	for cursor := 0; cursor < len(buf); cursor++ {
+		switch buf[cursor] {
+		case ']':
+			index, err := strconv.ParseInt(string(buf[:cursor]), 10, 64)
+			if err != nil {
+				return 0, errors.ErrInvalidPath("%q is unexpected index path", buf[:cursor])
+			}
+			b.addIndexNode(int(index))
+			return b.buildNextCharIfExists(buf, cursor+1)
+		}
+	}
+	return 0, errors.ErrInvalidPath("couldn't find right bracket character in index path context")
+}
+
+func (b *PathBuilder) addIndexAllNode() {
+	node := newPathIndexAllNode()
+	if b.root == nil {
+		b.root = node
+		b.node = node
+	} else {
+		b.node = b.node.chain(node)
+	}
+}
+
+func (b *PathBuilder) addRecursiveNode(selector string) {
+	node := newPathRecursiveNode(selector)
+	if b.root == nil {
+		b.root = node
+		b.node = node
+	} else {
+		b.node = b.node.chain(node)
+	}
+}
+
+func (b *PathBuilder) addSelectorNode(name string) {
+	node := newPathSelectorNode(name)
+	if b.root == nil {
+		b.root = node
+		b.node = node
+	} else {
+		b.node = b.node.chain(node)
+	}
+}
+
+func (b *PathBuilder) addIndexNode(idx int) {
+	node := newPathIndexNode(idx)
+	if b.root == nil {
+		b.root = node
+		b.node = node
+	} else {
+		b.node = b.node.chain(node)
+	}
+}
+
+type QuotePathSelector int
+
+const (
+	SingleQuotePathSelector QuotePathSelector = 1
+	DoubleQuotePathSelector QuotePathSelector = 2
+)
+
+type Path struct {
+	node                    PathNode
+	RootSelectorOnly        bool
+	SingleQuotePathSelector bool
+	DoubleQuotePathSelector bool
+}
+
+func (p *Path) Field(sel string) (PathNode, bool, error) {
+	if p.node == nil {
+		return nil, false, nil
+	}
+	return p.node.Field(sel)
+}
+
+func (p *Path) Get(src, dst reflect.Value) error {
+	if p.node == nil {
+		return nil
+	}
+	return p.node.Get(src, dst)
+}
+
+func (p *Path) String() string {
+	if p.node == nil {
+		return "$"
+	}
+	return p.node.String()
+}
+
+type PathNode interface {
+	fmt.Stringer
+	Index(idx int) (PathNode, bool, error)
+	Field(fieldName string) (PathNode, bool, error)
+	Get(src, dst reflect.Value) error
+	chain(PathNode) PathNode
+	target() bool
+	single() bool
+}
+
+type BasePathNode struct {
+	child PathNode
+}
+
+func (n *BasePathNode) chain(node PathNode) PathNode {
+	n.child = node
+	return node
+}
+
+func (n *BasePathNode) target() bool {
+	return n.child == nil
+}
+
+func (n *BasePathNode) single() bool {
+	return true
+}
+
+type PathSelectorNode struct {
+	*BasePathNode
+	selector string
+}
+
+func newPathSelectorNode(selector string) *PathSelectorNode {
+	return &PathSelectorNode{
+		BasePathNode: &BasePathNode{},
+		selector:     selector,
+	}
+}
+
+func (n *PathSelectorNode) Index(idx int) (PathNode, bool, error) {
+	return nil, false, &errors.PathError{}
+}
+
+func (n *PathSelectorNode) Field(fieldName string) (PathNode, bool, error) {
+	if n.selector == fieldName {
+		return n.child, true, nil
+	}
+	return nil, false, nil
+}
+
+func (n *PathSelectorNode) Get(src, dst reflect.Value) error {
+	switch src.Type().Kind() {
+	case reflect.Map:
+		iter := src.MapRange()
+		for iter.Next() {
+			key, ok := iter.Key().Interface().(string)
+			if !ok {
+				return fmt.Errorf("invalid map key type %T", src.Type().Key())
+			}
+			child, found, err := n.Field(key)
+			if err != nil {
+				return err
+			}
+			if found {
+				if child != nil {
+					return child.Get(iter.Value(), dst)
+				}
+				return AssignValue(iter.Value(), dst)
+			}
+		}
+	case reflect.Struct:
+		typ := src.Type()
+		for i := 0; i < typ.Len(); i++ {
+			tag := runtime.StructTagFromField(typ.Field(i))
+			child, found, err := n.Field(tag.Key)
+			if err != nil {
+				return err
+			}
+			if found {
+				if child != nil {
+					return child.Get(src.Field(i), dst)
+				}
+				return AssignValue(src.Field(i), dst)
+			}
+		}
+	case reflect.Ptr:
+		return n.Get(src.Elem(), dst)
+	case reflect.Interface:
+		return n.Get(reflect.ValueOf(src.Interface()), dst)
+	case reflect.Float64, reflect.String, reflect.Bool:
+		return AssignValue(src, dst)
+	}
+	return fmt.Errorf("failed to get %s value from %s", n.selector, src.Type())
+}
+
+func (n *PathSelectorNode) String() string {
+	s := fmt.Sprintf(".%s", n.selector)
+	if n.child != nil {
+		s += n.child.String()
+	}
+	return s
+}
+
+type PathIndexNode struct {
+	*BasePathNode
+	selector int
+}
+
+func newPathIndexNode(selector int) *PathIndexNode {
+	return &PathIndexNode{
+		BasePathNode: &BasePathNode{},
+		selector:     selector,
+	}
+}
+
+func (n *PathIndexNode) Index(idx int) (PathNode, bool, error) {
+	if n.selector == idx {
+		return n.child, true, nil
+	}
+	return nil, false, nil
+}
+
+func (n *PathIndexNode) Field(fieldName string) (PathNode, bool, error) {
+	return nil, false, &errors.PathError{}
+}
+
+func (n *PathIndexNode) Get(src, dst reflect.Value) error {
+	switch src.Type().Kind() {
+	case reflect.Array, reflect.Slice:
+		if src.Len() > n.selector {
+			if n.child != nil {
+				return n.child.Get(src.Index(n.selector), dst)
+			}
+			return AssignValue(src.Index(n.selector), dst)
+		}
+	case reflect.Ptr:
+		return n.Get(src.Elem(), dst)
+	case reflect.Interface:
+		return n.Get(reflect.ValueOf(src.Interface()), dst)
+	}
+	return fmt.Errorf("failed to get [%d] value from %s", n.selector, src.Type())
+}
+
+func (n *PathIndexNode) String() string {
+	s := fmt.Sprintf("[%d]", n.selector)
+	if n.child != nil {
+		s += n.child.String()
+	}
+	return s
+}
+
+type PathIndexAllNode struct {
+	*BasePathNode
+}
+
+func newPathIndexAllNode() *PathIndexAllNode {
+	return &PathIndexAllNode{
+		BasePathNode: &BasePathNode{},
+	}
+}
+
+func (n *PathIndexAllNode) Index(idx int) (PathNode, bool, error) {
+	return n.child, true, nil
+}
+
+func (n *PathIndexAllNode) Field(fieldName string) (PathNode, bool, error) {
+	return nil, false, &errors.PathError{}
+}
+
+func (n *PathIndexAllNode) Get(src, dst reflect.Value) error {
+	switch src.Type().Kind() {
+	case reflect.Array, reflect.Slice:
+		var arr []interface{}
+		for i := 0; i < src.Len(); i++ {
+			var v interface{}
+			rv := reflect.ValueOf(&v)
+			if n.child != nil {
+				if err := n.child.Get(src.Index(i), rv); err != nil {
+					return err
+				}
+			} else {
+				if err := AssignValue(src.Index(i), rv); err != nil {
+					return err
+				}
+			}
+			arr = append(arr, v)
+		}
+		if err := AssignValue(reflect.ValueOf(arr), dst); err != nil {
+			return err
+		}
+		return nil
+	case reflect.Ptr:
+		return n.Get(src.Elem(), dst)
+	case reflect.Interface:
+		return n.Get(reflect.ValueOf(src.Interface()), dst)
+	}
+	return fmt.Errorf("failed to get all value from %s", src.Type())
+}
+
+func (n *PathIndexAllNode) String() string {
+	s := "[*]"
+	if n.child != nil {
+		s += n.child.String()
+	}
+	return s
+}
+
+type PathRecursiveNode struct {
+	*BasePathNode
+	selector string
+}
+
+func newPathRecursiveNode(selector string) *PathRecursiveNode {
+	node := newPathSelectorNode(selector)
+	return &PathRecursiveNode{
+		BasePathNode: &BasePathNode{
+			child: node,
+		},
+		selector: selector,
+	}
+}
+
+func (n *PathRecursiveNode) Field(fieldName string) (PathNode, bool, error) {
+	if n.selector == fieldName {
+		return n.child, true, nil
+	}
+	return nil, false, nil
+}
+
+func (n *PathRecursiveNode) Index(_ int) (PathNode, bool, error) {
+	return n, true, nil
+}
+
+func valueToSliceValue(v interface{}) []interface{} {
+	rv := reflect.ValueOf(v)
+	ret := []interface{}{}
+	if rv.Type().Kind() == reflect.Slice || rv.Type().Kind() == reflect.Array {
+		for i := 0; i < rv.Len(); i++ {
+			ret = append(ret, rv.Index(i).Interface())
+		}
+		return ret
+	}
+	return []interface{}{v}
+}
+
+func (n *PathRecursiveNode) Get(src, dst reflect.Value) error {
+	if n.child == nil {
+		return fmt.Errorf("failed to get by recursive path ..%s", n.selector)
+	}
+	var arr []interface{}
+	switch src.Type().Kind() {
+	case reflect.Map:
+		iter := src.MapRange()
+		for iter.Next() {
+			key, ok := iter.Key().Interface().(string)
+			if !ok {
+				return fmt.Errorf("invalid map key type %T", src.Type().Key())
+			}
+			child, found, err := n.Field(key)
+			if err != nil {
+				return err
+			}
+			if found {
+				var v interface{}
+				rv := reflect.ValueOf(&v)
+				_ = child.Get(iter.Value(), rv)
+				arr = append(arr, valueToSliceValue(v)...)
+			} else {
+				var v interface{}
+				rv := reflect.ValueOf(&v)
+				_ = n.Get(iter.Value(), rv)
+				if v != nil {
+					arr = append(arr, valueToSliceValue(v)...)
+				}
+			}
+		}
+		_ = AssignValue(reflect.ValueOf(arr), dst)
+		return nil
+	case reflect.Struct:
+		typ := src.Type()
+		for i := 0; i < typ.Len(); i++ {
+			tag := runtime.StructTagFromField(typ.Field(i))
+			child, found, err := n.Field(tag.Key)
+			if err != nil {
+				return err
+			}
+			if found {
+				var v interface{}
+				rv := reflect.ValueOf(&v)
+				_ = child.Get(src.Field(i), rv)
+				arr = append(arr, valueToSliceValue(v)...)
+			} else {
+				var v interface{}
+				rv := reflect.ValueOf(&v)
+				_ = n.Get(src.Field(i), rv)
+				if v != nil {
+					arr = append(arr, valueToSliceValue(v)...)
+				}
+			}
+		}
+		_ = AssignValue(reflect.ValueOf(arr), dst)
+		return nil
+	case reflect.Array, reflect.Slice:
+		for i := 0; i < src.Len(); i++ {
+			var v interface{}
+			rv := reflect.ValueOf(&v)
+			_ = n.Get(src.Index(i), rv)
+			if v != nil {
+				arr = append(arr, valueToSliceValue(v)...)
+			}
+		}
+		_ = AssignValue(reflect.ValueOf(arr), dst)
+		return nil
+	case reflect.Ptr:
+		return n.Get(src.Elem(), dst)
+	case reflect.Interface:
+		return n.Get(reflect.ValueOf(src.Interface()), dst)
+	}
+	return fmt.Errorf("failed to get %s value from %s", n.selector, src.Type())
+}
+
+func (n *PathRecursiveNode) String() string {
+	s := fmt.Sprintf("..%s", n.selector)
+	if n.child != nil {
+		s += n.child.String()
+	}
+	return s
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/ptr.go b/vendor/github.com/goccy/go-json/internal/decoder/ptr.go
index 2c83b9c44..de12e105c 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/ptr.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/ptr.go
@@ -1,6 +1,7 @@
 package decoder
 
 import (
+	"fmt"
 	"unsafe"
 
 	"github.com/goccy/go-json/internal/runtime"
@@ -34,6 +35,10 @@ func (d *ptrDecoder) contentDecoder() Decoder {
 //go:linkname unsafe_New reflect.unsafe_New
 func unsafe_New(*runtime.Type) unsafe.Pointer
 
+func UnsafeNew(t *runtime.Type) unsafe.Pointer {
+	return unsafe_New(t)
+}
+
 func (d *ptrDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
 	if s.skipWhiteSpace() == nul {
 		s.read()
@@ -85,3 +90,7 @@ func (d *ptrDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.P
 	cursor = c
 	return cursor, nil
 }
+
+func (d *ptrDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	return nil, 0, fmt.Errorf("json: ptr decoder does not support decode path")
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/slice.go b/vendor/github.com/goccy/go-json/internal/decoder/slice.go
index 85b6e1119..30a23e4b5 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/slice.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/slice.go
@@ -299,3 +299,82 @@ func (d *sliceDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe
 		}
 	}
 }
+
+func (d *sliceDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	buf := ctx.Buf
+	depth++
+	if depth > maxDecodeNestingDepth {
+		return nil, 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
+	}
+
+	ret := [][]byte{}
+	for {
+		switch buf[cursor] {
+		case ' ', '\n', '\t', '\r':
+			cursor++
+			continue
+		case 'n':
+			if err := validateNull(buf, cursor); err != nil {
+				return nil, 0, err
+			}
+			cursor += 4
+			return [][]byte{nullbytes}, cursor, nil
+		case '[':
+			cursor++
+			cursor = skipWhiteSpace(buf, cursor)
+			if buf[cursor] == ']' {
+				cursor++
+				return ret, cursor, nil
+			}
+			idx := 0
+			for {
+				child, found, err := ctx.Option.Path.node.Index(idx)
+				if err != nil {
+					return nil, 0, err
+				}
+				if found {
+					if child != nil {
+						oldPath := ctx.Option.Path.node
+						ctx.Option.Path.node = child
+						paths, c, err := d.valueDecoder.DecodePath(ctx, cursor, depth)
+						if err != nil {
+							return nil, 0, err
+						}
+						ctx.Option.Path.node = oldPath
+						ret = append(ret, paths...)
+						cursor = c
+					} else {
+						start := cursor
+						end, err := skipValue(buf, cursor, depth)
+						if err != nil {
+							return nil, 0, err
+						}
+						ret = append(ret, buf[start:end])
+						cursor = end
+					}
+				} else {
+					c, err := skipValue(buf, cursor, depth)
+					if err != nil {
+						return nil, 0, err
+					}
+					cursor = c
+				}
+				cursor = skipWhiteSpace(buf, cursor)
+				switch buf[cursor] {
+				case ']':
+					cursor++
+					return ret, cursor, nil
+				case ',':
+					idx++
+				default:
+					return nil, 0, errors.ErrInvalidCharacter(buf[cursor], "slice", cursor)
+				}
+				cursor++
+			}
+		case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+			return nil, 0, d.errNumber(cursor)
+		default:
+			return nil, 0, errors.ErrUnexpectedEndOfJSON("slice", cursor)
+		}
+	}
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/string.go b/vendor/github.com/goccy/go-json/internal/decoder/string.go
index d07ad7101..32602c908 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/string.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/string.go
@@ -60,6 +60,17 @@ func (d *stringDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsaf
 	return cursor, nil
 }
 
+func (d *stringDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	bytes, c, err := d.decodeByte(ctx.Buf, cursor)
+	if err != nil {
+		return nil, 0, err
+	}
+	if bytes == nil {
+		return [][]byte{nullbytes}, c, nil
+	}
+	return [][]byte{bytes}, c, nil
+}
+
 var (
 	hexToInt = [256]int{
 		'0': 0,
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 2c6468045..6d3265489 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/struct.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/struct.go
@@ -817,3 +817,7 @@ func (d *structDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsaf
 		cursor++
 	}
 }
+
+func (d *structDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	return nil, 0, fmt.Errorf("json: struct decoder does not support decode path")
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/type.go b/vendor/github.com/goccy/go-json/internal/decoder/type.go
index 70e9907c8..beaf3ab86 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/type.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/type.go
@@ -10,6 +10,7 @@ import (
 
 type Decoder interface {
 	Decode(*RuntimeContext, int64, int64, unsafe.Pointer) (int64, error)
+	DecodePath(*RuntimeContext, int64, int64) ([][]byte, int64, error)
 	DecodeStream(*Stream, int64, unsafe.Pointer) error
 }
 
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/uint.go b/vendor/github.com/goccy/go-json/internal/decoder/uint.go
index a62c51492..4131731b8 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/uint.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/uint.go
@@ -188,3 +188,7 @@ func (d *uintDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.
 	d.op(p, u64)
 	return cursor, nil
 }
+
+func (d *uintDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	return nil, 0, fmt.Errorf("json: uint decoder does not support decode path")
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go
index e9b25c68f..4cd6dbd57 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go
@@ -3,6 +3,7 @@ package decoder
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"unsafe"
 
 	"github.com/goccy/go-json/internal/errors"
@@ -97,3 +98,7 @@ func (d *unmarshalJSONDecoder) Decode(ctx *RuntimeContext, cursor, depth int64,
 	}
 	return end, nil
 }
+
+func (d *unmarshalJSONDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	return nil, 0, fmt.Errorf("json: unmarshal json decoder does not support decode path")
+}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go
index 1ef287782..6d37993f0 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go
@@ -3,6 +3,7 @@ package decoder
 import (
 	"bytes"
 	"encoding"
+	"fmt"
 	"unicode"
 	"unicode/utf16"
 	"unicode/utf8"
@@ -142,6 +143,10 @@ func (d *unmarshalTextDecoder) Decode(ctx *RuntimeContext, cursor, depth int64,
 	return end, nil
 }
 
+func (d *unmarshalTextDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	return nil, 0, fmt.Errorf("json: unmarshal text decoder does not support decode path")
+}
+
 func unquoteBytes(s []byte) (t []byte, ok bool) {
 	length := len(s)
 	if length < 2 || s[0] != '"' || s[length-1] != '"' {
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go b/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go
index 66227ae02..0c4e2e6ea 100644
--- a/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go
+++ b/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go
@@ -1,6 +1,7 @@
 package decoder
 
 import (
+	"fmt"
 	"reflect"
 	"unsafe"
 
@@ -66,3 +67,7 @@ func (d *wrappedStringDecoder) Decode(ctx *RuntimeContext, cursor, depth int64,
 	ctx.Buf = oldBuf
 	return c, nil
 }
+
+func (d *wrappedStringDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
+	return nil, 0, fmt.Errorf("json: wrapped string decoder does not support decode path")
+}
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 bf5e0f947..3b3ff3fde 100644
--- a/vendor/github.com/goccy/go-json/internal/encoder/compiler.go
+++ b/vendor/github.com/goccy/go-json/internal/encoder/compiler.go
@@ -506,8 +506,6 @@ func (c *Compiler) listElemCode(typ *runtime.Type) (Code, error) {
 
 func (c *Compiler) mapKeyCode(typ *runtime.Type) (Code, error) {
 	switch {
-	case c.implementsMarshalJSON(typ):
-		return c.marshalJSONCode(typ)
 	case c.implementsMarshalText(typ):
 		return c.marshalTextCode(typ)
 	}
diff --git a/vendor/github.com/goccy/go-json/internal/errors/error.go b/vendor/github.com/goccy/go-json/internal/errors/error.go
index d58e39f4e..9207d0ff2 100644
--- a/vendor/github.com/goccy/go-json/internal/errors/error.go
+++ b/vendor/github.com/goccy/go-json/internal/errors/error.go
@@ -162,3 +162,22 @@ func ErrInvalidBeginningOfValue(c byte, cursor int64) *SyntaxError {
 		Offset: cursor,
 	}
 }
+
+type PathError struct {
+	msg string
+}
+
+func (e *PathError) Error() string {
+	return fmt.Sprintf("json: invalid path format: %s", e.msg)
+}
+
+func ErrInvalidPath(msg string, args ...interface{}) *PathError {
+	if len(args) != 0 {
+		return &PathError{msg: fmt.Sprintf(msg, args...)}
+	}
+	return &PathError{msg: msg}
+}
+
+func ErrEmptyPath() *PathError {
+	return &PathError{msg: "path is empty"}
+}
diff --git a/vendor/github.com/goccy/go-json/path.go b/vendor/github.com/goccy/go-json/path.go
new file mode 100644
index 000000000..38abce78f
--- /dev/null
+++ b/vendor/github.com/goccy/go-json/path.go
@@ -0,0 +1,84 @@
+package json
+
+import (
+	"reflect"
+
+	"github.com/goccy/go-json/internal/decoder"
+)
+
+// CreatePath creates JSON Path.
+//
+// JSON Path rule
+// $   : root object or element. The JSON Path format must start with this operator, which refers to the outermost level of the JSON-formatted string.
+// .   : child operator. You can identify child values using dot-notation.
+// ..  : recursive descent.
+// []  : subscript operator. If the JSON object is an array, you can use brackets to specify the array index.
+// [*] : all objects/elements for array.
+//
+// Reserved words must be properly escaped when included in Path.
+//
+// Escape Rule
+// single quote style escape: e.g.) `$['a.b'].c`
+// double quote style escape: e.g.) `$."a.b".c`
+func CreatePath(p string) (*Path, error) {
+	path, err := decoder.PathString(p).Build()
+	if err != nil {
+		return nil, err
+	}
+	return &Path{path: path}, nil
+}
+
+// Path represents JSON Path.
+type Path struct {
+	path *decoder.Path
+}
+
+// RootSelectorOnly whether only the root selector ($) is used.
+func (p *Path) RootSelectorOnly() bool {
+	return p.path.RootSelectorOnly
+}
+
+// UsedSingleQuotePathSelector whether single quote-based escaping was done when building the JSON Path.
+func (p *Path) UsedSingleQuotePathSelector() bool {
+	return p.path.SingleQuotePathSelector
+}
+
+// UsedSingleQuotePathSelector whether double quote-based escaping was done when building the JSON Path.
+func (p *Path) UsedDoubleQuotePathSelector() bool {
+	return p.path.DoubleQuotePathSelector
+}
+
+// Extract extracts a specific JSON string.
+func (p *Path) Extract(data []byte, optFuncs ...DecodeOptionFunc) ([][]byte, error) {
+	return extractFromPath(p, data, optFuncs...)
+}
+
+// PathString returns original JSON Path string.
+func (p *Path) PathString() string {
+	return p.path.String()
+}
+
+// Unmarshal extract and decode the value of the part corresponding to JSON Path from the input data.
+func (p *Path) Unmarshal(data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error {
+	contents, err := extractFromPath(p, data, optFuncs...)
+	if err != nil {
+		return err
+	}
+	results := make([]interface{}, 0, len(contents))
+	for _, content := range contents {
+		var result interface{}
+		if err := Unmarshal(content, &result); err != nil {
+			return err
+		}
+		results = append(results, result)
+	}
+	if err := decoder.AssignValue(reflect.ValueOf(results), reflect.ValueOf(v)); err != nil {
+		return err
+	}
+	return nil
+}
+
+// Get extract and substitute the value of the part corresponding to JSON Path from the input value.
+func (p *Path) Get(src, dst interface{}) error {
+	return p.path.Get(reflect.ValueOf(src), reflect.ValueOf(dst))
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/LICENSE b/vendor/github.com/twitchyliquid64/golang-asm/LICENSE
new file mode 100644
index 000000000..6a66aea5e
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2009 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/arch.go b/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/arch.go
new file mode 100644
index 000000000..b8ddbc99d
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/arch.go
@@ -0,0 +1,716 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package arch defines architecture-specific information and support functions.
+package arch
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/obj/arm"
+	"github.com/twitchyliquid64/golang-asm/obj/arm64"
+	"github.com/twitchyliquid64/golang-asm/obj/mips"
+	"github.com/twitchyliquid64/golang-asm/obj/ppc64"
+	"github.com/twitchyliquid64/golang-asm/obj/riscv"
+	"github.com/twitchyliquid64/golang-asm/obj/s390x"
+	"github.com/twitchyliquid64/golang-asm/obj/wasm"
+	"github.com/twitchyliquid64/golang-asm/obj/x86"
+	"fmt"
+	"strings"
+)
+
+// Pseudo-registers whose names are the constant name without the leading R.
+const (
+	RFP = -(iota + 1)
+	RSB
+	RSP
+	RPC
+)
+
+// Arch wraps the link architecture object with more architecture-specific information.
+type Arch struct {
+	*obj.LinkArch
+	// Map of instruction names to enumeration.
+	Instructions map[string]obj.As
+	// Map of register names to enumeration.
+	Register map[string]int16
+	// Table of register prefix names. These are things like R for R(0) and SPR for SPR(268).
+	RegisterPrefix map[string]bool
+	// RegisterNumber converts R(10) into arm.REG_R10.
+	RegisterNumber func(string, int16) (int16, bool)
+	// Instruction is a jump.
+	IsJump func(word string) bool
+}
+
+// nilRegisterNumber is the register number function for architectures
+// that do not accept the R(N) notation. It always returns failure.
+func nilRegisterNumber(name string, n int16) (int16, bool) {
+	return 0, false
+}
+
+// Set configures the architecture specified by GOARCH and returns its representation.
+// It returns nil if GOARCH is not recognized.
+func Set(GOARCH string) *Arch {
+	switch GOARCH {
+	case "386":
+		return archX86(&x86.Link386)
+	case "amd64":
+		return archX86(&x86.Linkamd64)
+	case "arm":
+		return archArm()
+	case "arm64":
+		return archArm64()
+	case "mips":
+		return archMips(&mips.Linkmips)
+	case "mipsle":
+		return archMips(&mips.Linkmipsle)
+	case "mips64":
+		return archMips64(&mips.Linkmips64)
+	case "mips64le":
+		return archMips64(&mips.Linkmips64le)
+	case "ppc64":
+		return archPPC64(&ppc64.Linkppc64)
+	case "ppc64le":
+		return archPPC64(&ppc64.Linkppc64le)
+	case "riscv64":
+		return archRISCV64()
+	case "s390x":
+		return archS390x()
+	case "wasm":
+		return archWasm()
+	}
+	return nil
+}
+
+func jumpX86(word string) bool {
+	return word[0] == 'J' || word == "CALL" || strings.HasPrefix(word, "LOOP") || word == "XBEGIN"
+}
+
+func jumpRISCV(word string) bool {
+	switch word {
+	case "BEQ", "BEQZ", "BGE", "BGEU", "BGEZ", "BGT", "BGTU", "BGTZ", "BLE", "BLEU", "BLEZ",
+		"BLT", "BLTU", "BLTZ", "BNE", "BNEZ", "CALL", "JAL", "JALR", "JMP":
+		return true
+	}
+	return false
+}
+
+func jumpWasm(word string) bool {
+	return word == "JMP" || word == "CALL" || word == "Call" || word == "Br" || word == "BrIf"
+}
+
+func archX86(linkArch *obj.LinkArch) *Arch {
+	register := make(map[string]int16)
+	// Create maps for easy lookup of instruction names etc.
+	for i, s := range x86.Register {
+		register[s] = int16(i + x86.REG_AL)
+	}
+	// Pseudo-registers.
+	register["SB"] = RSB
+	register["FP"] = RFP
+	register["PC"] = RPC
+	// Register prefix not used on this architecture.
+
+	instructions := make(map[string]obj.As)
+	for i, s := range obj.Anames {
+		instructions[s] = obj.As(i)
+	}
+	for i, s := range x86.Anames {
+		if obj.As(i) >= obj.A_ARCHSPECIFIC {
+			instructions[s] = obj.As(i) + obj.ABaseAMD64
+		}
+	}
+	// Annoying aliases.
+	instructions["JA"] = x86.AJHI   /* alternate */
+	instructions["JAE"] = x86.AJCC  /* alternate */
+	instructions["JB"] = x86.AJCS   /* alternate */
+	instructions["JBE"] = x86.AJLS  /* alternate */
+	instructions["JC"] = x86.AJCS   /* alternate */
+	instructions["JCC"] = x86.AJCC  /* carry clear (CF = 0) */
+	instructions["JCS"] = x86.AJCS  /* carry set (CF = 1) */
+	instructions["JE"] = x86.AJEQ   /* alternate */
+	instructions["JEQ"] = x86.AJEQ  /* equal (ZF = 1) */
+	instructions["JG"] = x86.AJGT   /* alternate */
+	instructions["JGE"] = x86.AJGE  /* greater than or equal (signed) (SF = OF) */
+	instructions["JGT"] = x86.AJGT  /* greater than (signed) (ZF = 0 && SF = OF) */
+	instructions["JHI"] = x86.AJHI  /* higher (unsigned) (CF = 0 && ZF = 0) */
+	instructions["JHS"] = x86.AJCC  /* alternate */
+	instructions["JL"] = x86.AJLT   /* alternate */
+	instructions["JLE"] = x86.AJLE  /* less than or equal (signed) (ZF = 1 || SF != OF) */
+	instructions["JLO"] = x86.AJCS  /* alternate */
+	instructions["JLS"] = x86.AJLS  /* lower or same (unsigned) (CF = 1 || ZF = 1) */
+	instructions["JLT"] = x86.AJLT  /* less than (signed) (SF != OF) */
+	instructions["JMI"] = x86.AJMI  /* negative (minus) (SF = 1) */
+	instructions["JNA"] = x86.AJLS  /* alternate */
+	instructions["JNAE"] = x86.AJCS /* alternate */
+	instructions["JNB"] = x86.AJCC  /* alternate */
+	instructions["JNBE"] = x86.AJHI /* alternate */
+	instructions["JNC"] = x86.AJCC  /* alternate */
+	instructions["JNE"] = x86.AJNE  /* not equal (ZF = 0) */
+	instructions["JNG"] = x86.AJLE  /* alternate */
+	instructions["JNGE"] = x86.AJLT /* alternate */
+	instructions["JNL"] = x86.AJGE  /* alternate */
+	instructions["JNLE"] = x86.AJGT /* alternate */
+	instructions["JNO"] = x86.AJOC  /* alternate */
+	instructions["JNP"] = x86.AJPC  /* alternate */
+	instructions["JNS"] = x86.AJPL  /* alternate */
+	instructions["JNZ"] = x86.AJNE  /* alternate */
+	instructions["JO"] = x86.AJOS   /* alternate */
+	instructions["JOC"] = x86.AJOC  /* overflow clear (OF = 0) */
+	instructions["JOS"] = x86.AJOS  /* overflow set (OF = 1) */
+	instructions["JP"] = x86.AJPS   /* alternate */
+	instructions["JPC"] = x86.AJPC  /* parity clear (PF = 0) */
+	instructions["JPE"] = x86.AJPS  /* alternate */
+	instructions["JPL"] = x86.AJPL  /* non-negative (plus) (SF = 0) */
+	instructions["JPO"] = x86.AJPC  /* alternate */
+	instructions["JPS"] = x86.AJPS  /* parity set (PF = 1) */
+	instructions["JS"] = x86.AJMI   /* alternate */
+	instructions["JZ"] = x86.AJEQ   /* alternate */
+	instructions["MASKMOVDQU"] = x86.AMASKMOVOU
+	instructions["MOVD"] = x86.AMOVQ
+	instructions["MOVDQ2Q"] = x86.AMOVQ
+	instructions["MOVNTDQ"] = x86.AMOVNTO
+	instructions["MOVOA"] = x86.AMOVO
+	instructions["PSLLDQ"] = x86.APSLLO
+	instructions["PSRLDQ"] = x86.APSRLO
+	instructions["PADDD"] = x86.APADDL
+
+	return &Arch{
+		LinkArch:       linkArch,
+		Instructions:   instructions,
+		Register:       register,
+		RegisterPrefix: nil,
+		RegisterNumber: nilRegisterNumber,
+		IsJump:         jumpX86,
+	}
+}
+
+func archArm() *Arch {
+	register := make(map[string]int16)
+	// Create maps for easy lookup of instruction names etc.
+	// Note that there is no list of names as there is for x86.
+	for i := arm.REG_R0; i < arm.REG_SPSR; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	// Avoid unintentionally clobbering g using R10.
+	delete(register, "R10")
+	register["g"] = arm.REG_R10
+	for i := 0; i < 16; i++ {
+		register[fmt.Sprintf("C%d", i)] = int16(i)
+	}
+
+	// Pseudo-registers.
+	register["SB"] = RSB
+	register["FP"] = RFP
+	register["PC"] = RPC
+	register["SP"] = RSP
+	registerPrefix := map[string]bool{
+		"F": true,
+		"R": true,
+	}
+
+	// special operands for DMB/DSB instructions
+	register["MB_SY"] = arm.REG_MB_SY
+	register["MB_ST"] = arm.REG_MB_ST
+	register["MB_ISH"] = arm.REG_MB_ISH
+	register["MB_ISHST"] = arm.REG_MB_ISHST
+	register["MB_NSH"] = arm.REG_MB_NSH
+	register["MB_NSHST"] = arm.REG_MB_NSHST
+	register["MB_OSH"] = arm.REG_MB_OSH
+	register["MB_OSHST"] = arm.REG_MB_OSHST
+
+	instructions := make(map[string]obj.As)
+	for i, s := range obj.Anames {
+		instructions[s] = obj.As(i)
+	}
+	for i, s := range arm.Anames {
+		if obj.As(i) >= obj.A_ARCHSPECIFIC {
+			instructions[s] = obj.As(i) + obj.ABaseARM
+		}
+	}
+	// Annoying aliases.
+	instructions["B"] = obj.AJMP
+	instructions["BL"] = obj.ACALL
+	// MCR differs from MRC by the way fields of the word are encoded.
+	// (Details in arm.go). Here we add the instruction so parse will find
+	// it, but give it an opcode number known only to us.
+	instructions["MCR"] = aMCR
+
+	return &Arch{
+		LinkArch:       &arm.Linkarm,
+		Instructions:   instructions,
+		Register:       register,
+		RegisterPrefix: registerPrefix,
+		RegisterNumber: armRegisterNumber,
+		IsJump:         jumpArm,
+	}
+}
+
+func archArm64() *Arch {
+	register := make(map[string]int16)
+	// Create maps for easy lookup of instruction names etc.
+	// Note that there is no list of names as there is for 386 and amd64.
+	register[obj.Rconv(arm64.REGSP)] = int16(arm64.REGSP)
+	for i := arm64.REG_R0; i <= arm64.REG_R31; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	// Rename R18 to R18_PLATFORM to avoid accidental use.
+	register["R18_PLATFORM"] = register["R18"]
+	delete(register, "R18")
+	for i := arm64.REG_F0; i <= arm64.REG_F31; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	for i := arm64.REG_V0; i <= arm64.REG_V31; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+
+	// System registers.
+	for i := 0; i < len(arm64.SystemReg); i++ {
+		register[arm64.SystemReg[i].Name] = arm64.SystemReg[i].Reg
+	}
+
+	register["LR"] = arm64.REGLINK
+	register["DAIFSet"] = arm64.REG_DAIFSet
+	register["DAIFClr"] = arm64.REG_DAIFClr
+	register["PLDL1KEEP"] = arm64.REG_PLDL1KEEP
+	register["PLDL1STRM"] = arm64.REG_PLDL1STRM
+	register["PLDL2KEEP"] = arm64.REG_PLDL2KEEP
+	register["PLDL2STRM"] = arm64.REG_PLDL2STRM
+	register["PLDL3KEEP"] = arm64.REG_PLDL3KEEP
+	register["PLDL3STRM"] = arm64.REG_PLDL3STRM
+	register["PLIL1KEEP"] = arm64.REG_PLIL1KEEP
+	register["PLIL1STRM"] = arm64.REG_PLIL1STRM
+	register["PLIL2KEEP"] = arm64.REG_PLIL2KEEP
+	register["PLIL2STRM"] = arm64.REG_PLIL2STRM
+	register["PLIL3KEEP"] = arm64.REG_PLIL3KEEP
+	register["PLIL3STRM"] = arm64.REG_PLIL3STRM
+	register["PSTL1KEEP"] = arm64.REG_PSTL1KEEP
+	register["PSTL1STRM"] = arm64.REG_PSTL1STRM
+	register["PSTL2KEEP"] = arm64.REG_PSTL2KEEP
+	register["PSTL2STRM"] = arm64.REG_PSTL2STRM
+	register["PSTL3KEEP"] = arm64.REG_PSTL3KEEP
+	register["PSTL3STRM"] = arm64.REG_PSTL3STRM
+
+	// Conditional operators, like EQ, NE, etc.
+	register["EQ"] = arm64.COND_EQ
+	register["NE"] = arm64.COND_NE
+	register["HS"] = arm64.COND_HS
+	register["CS"] = arm64.COND_HS
+	register["LO"] = arm64.COND_LO
+	register["CC"] = arm64.COND_LO
+	register["MI"] = arm64.COND_MI
+	register["PL"] = arm64.COND_PL
+	register["VS"] = arm64.COND_VS
+	register["VC"] = arm64.COND_VC
+	register["HI"] = arm64.COND_HI
+	register["LS"] = arm64.COND_LS
+	register["GE"] = arm64.COND_GE
+	register["LT"] = arm64.COND_LT
+	register["GT"] = arm64.COND_GT
+	register["LE"] = arm64.COND_LE
+	register["AL"] = arm64.COND_AL
+	register["NV"] = arm64.COND_NV
+	// Pseudo-registers.
+	register["SB"] = RSB
+	register["FP"] = RFP
+	register["PC"] = RPC
+	register["SP"] = RSP
+	// Avoid unintentionally clobbering g using R28.
+	delete(register, "R28")
+	register["g"] = arm64.REG_R28
+	registerPrefix := map[string]bool{
+		"F": true,
+		"R": true,
+		"V": true,
+	}
+
+	instructions := make(map[string]obj.As)
+	for i, s := range obj.Anames {
+		instructions[s] = obj.As(i)
+	}
+	for i, s := range arm64.Anames {
+		if obj.As(i) >= obj.A_ARCHSPECIFIC {
+			instructions[s] = obj.As(i) + obj.ABaseARM64
+		}
+	}
+	// Annoying aliases.
+	instructions["B"] = arm64.AB
+	instructions["BL"] = arm64.ABL
+
+	return &Arch{
+		LinkArch:       &arm64.Linkarm64,
+		Instructions:   instructions,
+		Register:       register,
+		RegisterPrefix: registerPrefix,
+		RegisterNumber: arm64RegisterNumber,
+		IsJump:         jumpArm64,
+	}
+
+}
+
+func archPPC64(linkArch *obj.LinkArch) *Arch {
+	register := make(map[string]int16)
+	// Create maps for easy lookup of instruction names etc.
+	// Note that there is no list of names as there is for x86.
+	for i := ppc64.REG_R0; i <= ppc64.REG_R31; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	for i := ppc64.REG_F0; i <= ppc64.REG_F31; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	for i := ppc64.REG_V0; i <= ppc64.REG_V31; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	for i := ppc64.REG_VS0; i <= ppc64.REG_VS63; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	for i := ppc64.REG_CR0; i <= ppc64.REG_CR7; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	for i := ppc64.REG_MSR; i <= ppc64.REG_CR; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	register["CR"] = ppc64.REG_CR
+	register["XER"] = ppc64.REG_XER
+	register["LR"] = ppc64.REG_LR
+	register["CTR"] = ppc64.REG_CTR
+	register["FPSCR"] = ppc64.REG_FPSCR
+	register["MSR"] = ppc64.REG_MSR
+	// Pseudo-registers.
+	register["SB"] = RSB
+	register["FP"] = RFP
+	register["PC"] = RPC
+	// Avoid unintentionally clobbering g using R30.
+	delete(register, "R30")
+	register["g"] = ppc64.REG_R30
+	registerPrefix := map[string]bool{
+		"CR":  true,
+		"F":   true,
+		"R":   true,
+		"SPR": true,
+	}
+
+	instructions := make(map[string]obj.As)
+	for i, s := range obj.Anames {
+		instructions[s] = obj.As(i)
+	}
+	for i, s := range ppc64.Anames {
+		if obj.As(i) >= obj.A_ARCHSPECIFIC {
+			instructions[s] = obj.As(i) + obj.ABasePPC64
+		}
+	}
+	// Annoying aliases.
+	instructions["BR"] = ppc64.ABR
+	instructions["BL"] = ppc64.ABL
+
+	return &Arch{
+		LinkArch:       linkArch,
+		Instructions:   instructions,
+		Register:       register,
+		RegisterPrefix: registerPrefix,
+		RegisterNumber: ppc64RegisterNumber,
+		IsJump:         jumpPPC64,
+	}
+}
+
+func archMips(linkArch *obj.LinkArch) *Arch {
+	register := make(map[string]int16)
+	// Create maps for easy lookup of instruction names etc.
+	// Note that there is no list of names as there is for x86.
+	for i := mips.REG_R0; i <= mips.REG_R31; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+
+	for i := mips.REG_F0; i <= mips.REG_F31; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	for i := mips.REG_M0; i <= mips.REG_M31; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	for i := mips.REG_FCR0; i <= mips.REG_FCR31; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	register["HI"] = mips.REG_HI
+	register["LO"] = mips.REG_LO
+	// Pseudo-registers.
+	register["SB"] = RSB
+	register["FP"] = RFP
+	register["PC"] = RPC
+	// Avoid unintentionally clobbering g using R30.
+	delete(register, "R30")
+	register["g"] = mips.REG_R30
+
+	registerPrefix := map[string]bool{
+		"F":   true,
+		"FCR": true,
+		"M":   true,
+		"R":   true,
+	}
+
+	instructions := make(map[string]obj.As)
+	for i, s := range obj.Anames {
+		instructions[s] = obj.As(i)
+	}
+	for i, s := range mips.Anames {
+		if obj.As(i) >= obj.A_ARCHSPECIFIC {
+			instructions[s] = obj.As(i) + obj.ABaseMIPS
+		}
+	}
+	// Annoying alias.
+	instructions["JAL"] = mips.AJAL
+
+	return &Arch{
+		LinkArch:       linkArch,
+		Instructions:   instructions,
+		Register:       register,
+		RegisterPrefix: registerPrefix,
+		RegisterNumber: mipsRegisterNumber,
+		IsJump:         jumpMIPS,
+	}
+}
+
+func archMips64(linkArch *obj.LinkArch) *Arch {
+	register := make(map[string]int16)
+	// Create maps for easy lookup of instruction names etc.
+	// Note that there is no list of names as there is for x86.
+	for i := mips.REG_R0; i <= mips.REG_R31; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	for i := mips.REG_F0; i <= mips.REG_F31; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	for i := mips.REG_M0; i <= mips.REG_M31; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	for i := mips.REG_FCR0; i <= mips.REG_FCR31; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	for i := mips.REG_W0; i <= mips.REG_W31; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	register["HI"] = mips.REG_HI
+	register["LO"] = mips.REG_LO
+	// Pseudo-registers.
+	register["SB"] = RSB
+	register["FP"] = RFP
+	register["PC"] = RPC
+	// Avoid unintentionally clobbering g using R30.
+	delete(register, "R30")
+	register["g"] = mips.REG_R30
+	// Avoid unintentionally clobbering RSB using R28.
+	delete(register, "R28")
+	register["RSB"] = mips.REG_R28
+	registerPrefix := map[string]bool{
+		"F":   true,
+		"FCR": true,
+		"M":   true,
+		"R":   true,
+		"W":   true,
+	}
+
+	instructions := make(map[string]obj.As)
+	for i, s := range obj.Anames {
+		instructions[s] = obj.As(i)
+	}
+	for i, s := range mips.Anames {
+		if obj.As(i) >= obj.A_ARCHSPECIFIC {
+			instructions[s] = obj.As(i) + obj.ABaseMIPS
+		}
+	}
+	// Annoying alias.
+	instructions["JAL"] = mips.AJAL
+
+	return &Arch{
+		LinkArch:       linkArch,
+		Instructions:   instructions,
+		Register:       register,
+		RegisterPrefix: registerPrefix,
+		RegisterNumber: mipsRegisterNumber,
+		IsJump:         jumpMIPS,
+	}
+}
+
+func archRISCV64() *Arch {
+	register := make(map[string]int16)
+
+	// Standard register names.
+	for i := riscv.REG_X0; i <= riscv.REG_X31; i++ {
+		name := fmt.Sprintf("X%d", i-riscv.REG_X0)
+		register[name] = int16(i)
+	}
+	for i := riscv.REG_F0; i <= riscv.REG_F31; i++ {
+		name := fmt.Sprintf("F%d", i-riscv.REG_F0)
+		register[name] = int16(i)
+	}
+
+	// General registers with ABI names.
+	register["ZERO"] = riscv.REG_ZERO
+	register["RA"] = riscv.REG_RA
+	register["SP"] = riscv.REG_SP
+	register["GP"] = riscv.REG_GP
+	register["TP"] = riscv.REG_TP
+	register["T0"] = riscv.REG_T0
+	register["T1"] = riscv.REG_T1
+	register["T2"] = riscv.REG_T2
+	register["S0"] = riscv.REG_S0
+	register["S1"] = riscv.REG_S1
+	register["A0"] = riscv.REG_A0
+	register["A1"] = riscv.REG_A1
+	register["A2"] = riscv.REG_A2
+	register["A3"] = riscv.REG_A3
+	register["A4"] = riscv.REG_A4
+	register["A5"] = riscv.REG_A5
+	register["A6"] = riscv.REG_A6
+	register["A7"] = riscv.REG_A7
+	register["S2"] = riscv.REG_S2
+	register["S3"] = riscv.REG_S3
+	register["S4"] = riscv.REG_S4
+	register["S5"] = riscv.REG_S5
+	register["S6"] = riscv.REG_S6
+	register["S7"] = riscv.REG_S7
+	register["S8"] = riscv.REG_S8
+	register["S9"] = riscv.REG_S9
+	register["S10"] = riscv.REG_S10
+	register["S11"] = riscv.REG_S11
+	register["T3"] = riscv.REG_T3
+	register["T4"] = riscv.REG_T4
+	register["T5"] = riscv.REG_T5
+	register["T6"] = riscv.REG_T6
+
+	// Go runtime register names.
+	register["g"] = riscv.REG_G
+	register["CTXT"] = riscv.REG_CTXT
+	register["TMP"] = riscv.REG_TMP
+
+	// ABI names for floating point register.
+	register["FT0"] = riscv.REG_FT0
+	register["FT1"] = riscv.REG_FT1
+	register["FT2"] = riscv.REG_FT2
+	register["FT3"] = riscv.REG_FT3
+	register["FT4"] = riscv.REG_FT4
+	register["FT5"] = riscv.REG_FT5
+	register["FT6"] = riscv.REG_FT6
+	register["FT7"] = riscv.REG_FT7
+	register["FS0"] = riscv.REG_FS0
+	register["FS1"] = riscv.REG_FS1
+	register["FA0"] = riscv.REG_FA0
+	register["FA1"] = riscv.REG_FA1
+	register["FA2"] = riscv.REG_FA2
+	register["FA3"] = riscv.REG_FA3
+	register["FA4"] = riscv.REG_FA4
+	register["FA5"] = riscv.REG_FA5
+	register["FA6"] = riscv.REG_FA6
+	register["FA7"] = riscv.REG_FA7
+	register["FS2"] = riscv.REG_FS2
+	register["FS3"] = riscv.REG_FS3
+	register["FS4"] = riscv.REG_FS4
+	register["FS5"] = riscv.REG_FS5
+	register["FS6"] = riscv.REG_FS6
+	register["FS7"] = riscv.REG_FS7
+	register["FS8"] = riscv.REG_FS8
+	register["FS9"] = riscv.REG_FS9
+	register["FS10"] = riscv.REG_FS10
+	register["FS11"] = riscv.REG_FS11
+	register["FT8"] = riscv.REG_FT8
+	register["FT9"] = riscv.REG_FT9
+	register["FT10"] = riscv.REG_FT10
+	register["FT11"] = riscv.REG_FT11
+
+	// Pseudo-registers.
+	register["SB"] = RSB
+	register["FP"] = RFP
+	register["PC"] = RPC
+
+	instructions := make(map[string]obj.As)
+	for i, s := range obj.Anames {
+		instructions[s] = obj.As(i)
+	}
+	for i, s := range riscv.Anames {
+		if obj.As(i) >= obj.A_ARCHSPECIFIC {
+			instructions[s] = obj.As(i) + obj.ABaseRISCV
+		}
+	}
+
+	return &Arch{
+		LinkArch:       &riscv.LinkRISCV64,
+		Instructions:   instructions,
+		Register:       register,
+		RegisterPrefix: nil,
+		RegisterNumber: nilRegisterNumber,
+		IsJump:         jumpRISCV,
+	}
+}
+
+func archS390x() *Arch {
+	register := make(map[string]int16)
+	// Create maps for easy lookup of instruction names etc.
+	// Note that there is no list of names as there is for x86.
+	for i := s390x.REG_R0; i <= s390x.REG_R15; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	for i := s390x.REG_F0; i <= s390x.REG_F15; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	for i := s390x.REG_V0; i <= s390x.REG_V31; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	for i := s390x.REG_AR0; i <= s390x.REG_AR15; i++ {
+		register[obj.Rconv(i)] = int16(i)
+	}
+	register["LR"] = s390x.REG_LR
+	// Pseudo-registers.
+	register["SB"] = RSB
+	register["FP"] = RFP
+	register["PC"] = RPC
+	// Avoid unintentionally clobbering g using R13.
+	delete(register, "R13")
+	register["g"] = s390x.REG_R13
+	registerPrefix := map[string]bool{
+		"AR": true,
+		"F":  true,
+		"R":  true,
+	}
+
+	instructions := make(map[string]obj.As)
+	for i, s := range obj.Anames {
+		instructions[s] = obj.As(i)
+	}
+	for i, s := range s390x.Anames {
+		if obj.As(i) >= obj.A_ARCHSPECIFIC {
+			instructions[s] = obj.As(i) + obj.ABaseS390X
+		}
+	}
+	// Annoying aliases.
+	instructions["BR"] = s390x.ABR
+	instructions["BL"] = s390x.ABL
+
+	return &Arch{
+		LinkArch:       &s390x.Links390x,
+		Instructions:   instructions,
+		Register:       register,
+		RegisterPrefix: registerPrefix,
+		RegisterNumber: s390xRegisterNumber,
+		IsJump:         jumpS390x,
+	}
+}
+
+func archWasm() *Arch {
+	instructions := make(map[string]obj.As)
+	for i, s := range obj.Anames {
+		instructions[s] = obj.As(i)
+	}
+	for i, s := range wasm.Anames {
+		if obj.As(i) >= obj.A_ARCHSPECIFIC {
+			instructions[s] = obj.As(i) + obj.ABaseWasm
+		}
+	}
+
+	return &Arch{
+		LinkArch:       &wasm.Linkwasm,
+		Instructions:   instructions,
+		Register:       wasm.Register,
+		RegisterPrefix: nil,
+		RegisterNumber: nilRegisterNumber,
+		IsJump:         jumpWasm,
+	}
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/arm.go b/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/arm.go
new file mode 100644
index 000000000..645e98a57
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/arm.go
@@ -0,0 +1,257 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file encapsulates some of the odd characteristics of the ARM
+// instruction set, to minimize its interaction with the core of the
+// assembler.
+
+package arch
+
+import (
+	"strings"
+
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/obj/arm"
+)
+
+var armLS = map[string]uint8{
+	"U":  arm.C_UBIT,
+	"S":  arm.C_SBIT,
+	"W":  arm.C_WBIT,
+	"P":  arm.C_PBIT,
+	"PW": arm.C_WBIT | arm.C_PBIT,
+	"WP": arm.C_WBIT | arm.C_PBIT,
+}
+
+var armSCOND = map[string]uint8{
+	"EQ":  arm.C_SCOND_EQ,
+	"NE":  arm.C_SCOND_NE,
+	"CS":  arm.C_SCOND_HS,
+	"HS":  arm.C_SCOND_HS,
+	"CC":  arm.C_SCOND_LO,
+	"LO":  arm.C_SCOND_LO,
+	"MI":  arm.C_SCOND_MI,
+	"PL":  arm.C_SCOND_PL,
+	"VS":  arm.C_SCOND_VS,
+	"VC":  arm.C_SCOND_VC,
+	"HI":  arm.C_SCOND_HI,
+	"LS":  arm.C_SCOND_LS,
+	"GE":  arm.C_SCOND_GE,
+	"LT":  arm.C_SCOND_LT,
+	"GT":  arm.C_SCOND_GT,
+	"LE":  arm.C_SCOND_LE,
+	"AL":  arm.C_SCOND_NONE,
+	"U":   arm.C_UBIT,
+	"S":   arm.C_SBIT,
+	"W":   arm.C_WBIT,
+	"P":   arm.C_PBIT,
+	"PW":  arm.C_WBIT | arm.C_PBIT,
+	"WP":  arm.C_WBIT | arm.C_PBIT,
+	"F":   arm.C_FBIT,
+	"IBW": arm.C_WBIT | arm.C_PBIT | arm.C_UBIT,
+	"IAW": arm.C_WBIT | arm.C_UBIT,
+	"DBW": arm.C_WBIT | arm.C_PBIT,
+	"DAW": arm.C_WBIT,
+	"IB":  arm.C_PBIT | arm.C_UBIT,
+	"IA":  arm.C_UBIT,
+	"DB":  arm.C_PBIT,
+	"DA":  0,
+}
+
+var armJump = map[string]bool{
+	"B":    true,
+	"BL":   true,
+	"BX":   true,
+	"BEQ":  true,
+	"BNE":  true,
+	"BCS":  true,
+	"BHS":  true,
+	"BCC":  true,
+	"BLO":  true,
+	"BMI":  true,
+	"BPL":  true,
+	"BVS":  true,
+	"BVC":  true,
+	"BHI":  true,
+	"BLS":  true,
+	"BGE":  true,
+	"BLT":  true,
+	"BGT":  true,
+	"BLE":  true,
+	"CALL": true,
+	"JMP":  true,
+}
+
+func jumpArm(word string) bool {
+	return armJump[word]
+}
+
+// IsARMCMP reports whether the op (as defined by an arm.A* constant) is
+// one of the comparison instructions that require special handling.
+func IsARMCMP(op obj.As) bool {
+	switch op {
+	case arm.ACMN, arm.ACMP, arm.ATEQ, arm.ATST:
+		return true
+	}
+	return false
+}
+
+// IsARMSTREX reports whether the op (as defined by an arm.A* constant) is
+// one of the STREX-like instructions that require special handling.
+func IsARMSTREX(op obj.As) bool {
+	switch op {
+	case arm.ASTREX, arm.ASTREXD, arm.ASWPW, arm.ASWPBU:
+		return true
+	}
+	return false
+}
+
+// MCR is not defined by the obj/arm; instead we define it privately here.
+// It is encoded as an MRC with a bit inside the instruction word,
+// passed to arch.ARMMRCOffset.
+const aMCR = arm.ALAST + 1
+
+// IsARMMRC reports whether the op (as defined by an arm.A* constant) is
+// MRC or MCR
+func IsARMMRC(op obj.As) bool {
+	switch op {
+	case arm.AMRC, aMCR: // Note: aMCR is defined in this package.
+		return true
+	}
+	return false
+}
+
+// IsARMBFX reports whether the op (as defined by an arm.A* constant) is one the
+// BFX-like instructions which are in the form of "op $width, $LSB, (Reg,) Reg".
+func IsARMBFX(op obj.As) bool {
+	switch op {
+	case arm.ABFX, arm.ABFXU, arm.ABFC, arm.ABFI:
+		return true
+	}
+	return false
+}
+
+// IsARMFloatCmp reports whether the op is a floating comparison instruction.
+func IsARMFloatCmp(op obj.As) bool {
+	switch op {
+	case arm.ACMPF, arm.ACMPD:
+		return true
+	}
+	return false
+}
+
+// ARMMRCOffset implements the peculiar encoding of the MRC and MCR instructions.
+// The difference between MRC and MCR is represented by a bit high in the word, not
+// in the usual way by the opcode itself. Asm must use AMRC for both instructions, so
+// we return the opcode for MRC so that asm doesn't need to import obj/arm.
+func ARMMRCOffset(op obj.As, cond string, x0, x1, x2, x3, x4, x5 int64) (offset int64, op0 obj.As, ok bool) {
+	op1 := int64(0)
+	if op == arm.AMRC {
+		op1 = 1
+	}
+	bits, ok := ParseARMCondition(cond)
+	if !ok {
+		return
+	}
+	offset = (0xe << 24) | // opcode
+		(op1 << 20) | // MCR/MRC
+		((int64(bits) ^ arm.C_SCOND_XOR) << 28) | // scond
+		((x0 & 15) << 8) | //coprocessor number
+		((x1 & 7) << 21) | // coprocessor operation
+		((x2 & 15) << 12) | // ARM register
+		((x3 & 15) << 16) | // Crn
+		((x4 & 15) << 0) | // Crm
+		((x5 & 7) << 5) | // coprocessor information
+		(1 << 4) /* must be set */
+	return offset, arm.AMRC, true
+}
+
+// IsARMMULA reports whether the op (as defined by an arm.A* constant) is
+// MULA, MULS, MMULA, MMULS, MULABB, MULAWB or MULAWT, the 4-operand instructions.
+func IsARMMULA(op obj.As) bool {
+	switch op {
+	case arm.AMULA, arm.AMULS, arm.AMMULA, arm.AMMULS, arm.AMULABB, arm.AMULAWB, arm.AMULAWT:
+		return true
+	}
+	return false
+}
+
+var bcode = []obj.As{
+	arm.ABEQ,
+	arm.ABNE,
+	arm.ABCS,
+	arm.ABCC,
+	arm.ABMI,
+	arm.ABPL,
+	arm.ABVS,
+	arm.ABVC,
+	arm.ABHI,
+	arm.ABLS,
+	arm.ABGE,
+	arm.ABLT,
+	arm.ABGT,
+	arm.ABLE,
+	arm.AB,
+	obj.ANOP,
+}
+
+// ARMConditionCodes handles the special condition code situation for the ARM.
+// It returns a boolean to indicate success; failure means cond was unrecognized.
+func ARMConditionCodes(prog *obj.Prog, cond string) bool {
+	if cond == "" {
+		return true
+	}
+	bits, ok := ParseARMCondition(cond)
+	if !ok {
+		return false
+	}
+	/* hack to make B.NE etc. work: turn it into the corresponding conditional */
+	if prog.As == arm.AB {
+		prog.As = bcode[(bits^arm.C_SCOND_XOR)&0xf]
+		bits = (bits &^ 0xf) | arm.C_SCOND_NONE
+	}
+	prog.Scond = bits
+	return true
+}
+
+// ParseARMCondition parses the conditions attached to an ARM instruction.
+// The input is a single string consisting of period-separated condition
+// codes, such as ".P.W". An initial period is ignored.
+func ParseARMCondition(cond string) (uint8, bool) {
+	return parseARMCondition(cond, armLS, armSCOND)
+}
+
+func parseARMCondition(cond string, ls, scond map[string]uint8) (uint8, bool) {
+	cond = strings.TrimPrefix(cond, ".")
+	if cond == "" {
+		return arm.C_SCOND_NONE, true
+	}
+	names := strings.Split(cond, ".")
+	bits := uint8(0)
+	for _, name := range names {
+		if b, present := ls[name]; present {
+			bits |= b
+			continue
+		}
+		if b, present := scond[name]; present {
+			bits = (bits &^ arm.C_SCOND) | b
+			continue
+		}
+		return 0, false
+	}
+	return bits, true
+}
+
+func armRegisterNumber(name string, n int16) (int16, bool) {
+	if n < 0 || 15 < n {
+		return 0, false
+	}
+	switch name {
+	case "R":
+		return arm.REG_R0 + n, true
+	case "F":
+		return arm.REG_F0 + n, true
+	}
+	return 0, false
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/arm64.go b/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/arm64.go
new file mode 100644
index 000000000..b0606beb3
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/arm64.go
@@ -0,0 +1,350 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file encapsulates some of the odd characteristics of the ARM64
+// instruction set, to minimize its interaction with the core of the
+// assembler.
+
+package arch
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/obj/arm64"
+	"errors"
+)
+
+var arm64LS = map[string]uint8{
+	"P": arm64.C_XPOST,
+	"W": arm64.C_XPRE,
+}
+
+var arm64Jump = map[string]bool{
+	"B":     true,
+	"BL":    true,
+	"BEQ":   true,
+	"BNE":   true,
+	"BCS":   true,
+	"BHS":   true,
+	"BCC":   true,
+	"BLO":   true,
+	"BMI":   true,
+	"BPL":   true,
+	"BVS":   true,
+	"BVC":   true,
+	"BHI":   true,
+	"BLS":   true,
+	"BGE":   true,
+	"BLT":   true,
+	"BGT":   true,
+	"BLE":   true,
+	"CALL":  true,
+	"CBZ":   true,
+	"CBZW":  true,
+	"CBNZ":  true,
+	"CBNZW": true,
+	"JMP":   true,
+	"TBNZ":  true,
+	"TBZ":   true,
+}
+
+func jumpArm64(word string) bool {
+	return arm64Jump[word]
+}
+
+// IsARM64CMP reports whether the op (as defined by an arm.A* constant) is
+// one of the comparison instructions that require special handling.
+func IsARM64CMP(op obj.As) bool {
+	switch op {
+	case arm64.ACMN, arm64.ACMP, arm64.ATST,
+		arm64.ACMNW, arm64.ACMPW, arm64.ATSTW,
+		arm64.AFCMPS, arm64.AFCMPD,
+		arm64.AFCMPES, arm64.AFCMPED:
+		return true
+	}
+	return false
+}
+
+// IsARM64STLXR reports whether the op (as defined by an arm64.A*
+// constant) is one of the STLXR-like instructions that require special
+// handling.
+func IsARM64STLXR(op obj.As) bool {
+	switch op {
+	case arm64.ASTLXRB, arm64.ASTLXRH, arm64.ASTLXRW, arm64.ASTLXR,
+		arm64.ASTXRB, arm64.ASTXRH, arm64.ASTXRW, arm64.ASTXR,
+		arm64.ASTXP, arm64.ASTXPW, arm64.ASTLXP, arm64.ASTLXPW:
+		return true
+	}
+	// atomic instructions
+	if arm64.IsAtomicInstruction(op) {
+		return true
+	}
+	return false
+}
+
+// ARM64Suffix handles the special suffix for the ARM64.
+// It returns a boolean to indicate success; failure means
+// cond was unrecognized.
+func ARM64Suffix(prog *obj.Prog, cond string) bool {
+	if cond == "" {
+		return true
+	}
+	bits, ok := parseARM64Suffix(cond)
+	if !ok {
+		return false
+	}
+	prog.Scond = bits
+	return true
+}
+
+// parseARM64Suffix parses the suffix attached to an ARM64 instruction.
+// The input is a single string consisting of period-separated condition
+// codes, such as ".P.W". An initial period is ignored.
+func parseARM64Suffix(cond string) (uint8, bool) {
+	if cond == "" {
+		return 0, true
+	}
+	return parseARMCondition(cond, arm64LS, nil)
+}
+
+func arm64RegisterNumber(name string, n int16) (int16, bool) {
+	switch name {
+	case "F":
+		if 0 <= n && n <= 31 {
+			return arm64.REG_F0 + n, true
+		}
+	case "R":
+		if 0 <= n && n <= 30 { // not 31
+			return arm64.REG_R0 + n, true
+		}
+	case "V":
+		if 0 <= n && n <= 31 {
+			return arm64.REG_V0 + n, true
+		}
+	}
+	return 0, false
+}
+
+// IsARM64TBL reports whether the op (as defined by an arm64.A*
+// constant) is one of the table lookup instructions that require special
+// handling.
+func IsARM64TBL(op obj.As) bool {
+	return op == arm64.AVTBL
+}
+
+// ARM64RegisterExtension parses an ARM64 register with extension or arrangement.
+func ARM64RegisterExtension(a *obj.Addr, ext string, reg, num int16, isAmount, isIndex bool) error {
+	Rnum := (reg & 31) + int16(num<<5)
+	if isAmount {
+		if num < 0 || num > 7 {
+			return errors.New("index shift amount is out of range")
+		}
+	}
+	switch ext {
+	case "UXTB":
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		if a.Type == obj.TYPE_MEM {
+			return errors.New("invalid shift for the register offset addressing mode")
+		}
+		a.Reg = arm64.REG_UXTB + Rnum
+	case "UXTH":
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		if a.Type == obj.TYPE_MEM {
+			return errors.New("invalid shift for the register offset addressing mode")
+		}
+		a.Reg = arm64.REG_UXTH + Rnum
+	case "UXTW":
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		// effective address of memory is a base register value and an offset register value.
+		if a.Type == obj.TYPE_MEM {
+			a.Index = arm64.REG_UXTW + Rnum
+		} else {
+			a.Reg = arm64.REG_UXTW + Rnum
+		}
+	case "UXTX":
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		if a.Type == obj.TYPE_MEM {
+			return errors.New("invalid shift for the register offset addressing mode")
+		}
+		a.Reg = arm64.REG_UXTX + Rnum
+	case "SXTB":
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_SXTB + Rnum
+	case "SXTH":
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		if a.Type == obj.TYPE_MEM {
+			return errors.New("invalid shift for the register offset addressing mode")
+		}
+		a.Reg = arm64.REG_SXTH + Rnum
+	case "SXTW":
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		if a.Type == obj.TYPE_MEM {
+			a.Index = arm64.REG_SXTW + Rnum
+		} else {
+			a.Reg = arm64.REG_SXTW + Rnum
+		}
+	case "SXTX":
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		if a.Type == obj.TYPE_MEM {
+			a.Index = arm64.REG_SXTX + Rnum
+		} else {
+			a.Reg = arm64.REG_SXTX + Rnum
+		}
+	case "LSL":
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		a.Index = arm64.REG_LSL + Rnum
+	case "B8":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_8B & 15) << 5)
+	case "B16":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_16B & 15) << 5)
+	case "H4":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_4H & 15) << 5)
+	case "H8":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_8H & 15) << 5)
+	case "S2":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_2S & 15) << 5)
+	case "S4":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_4S & 15) << 5)
+	case "D1":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_1D & 15) << 5)
+	case "D2":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_2D & 15) << 5)
+	case "Q1":
+		if isIndex {
+			return errors.New("invalid register extension")
+		}
+		a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_1Q & 15) << 5)
+	case "B":
+		if !isIndex {
+			return nil
+		}
+		a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_B & 15) << 5)
+		a.Index = num
+	case "H":
+		if !isIndex {
+			return nil
+		}
+		a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_H & 15) << 5)
+		a.Index = num
+	case "S":
+		if !isIndex {
+			return nil
+		}
+		a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_S & 15) << 5)
+		a.Index = num
+	case "D":
+		if !isIndex {
+			return nil
+		}
+		a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_D & 15) << 5)
+		a.Index = num
+	default:
+		return errors.New("unsupported register extension type: " + ext)
+	}
+
+	return nil
+}
+
+// ARM64RegisterArrangement parses an ARM64 vector register arrangement.
+func ARM64RegisterArrangement(reg int16, name, arng string) (int64, error) {
+	var curQ, curSize uint16
+	if name[0] != 'V' {
+		return 0, errors.New("expect V0 through V31; found: " + name)
+	}
+	if reg < 0 {
+		return 0, errors.New("invalid register number: " + name)
+	}
+	switch arng {
+	case "B8":
+		curSize = 0
+		curQ = 0
+	case "B16":
+		curSize = 0
+		curQ = 1
+	case "H4":
+		curSize = 1
+		curQ = 0
+	case "H8":
+		curSize = 1
+		curQ = 1
+	case "S2":
+		curSize = 2
+		curQ = 0
+	case "S4":
+		curSize = 2
+		curQ = 1
+	case "D1":
+		curSize = 3
+		curQ = 0
+	case "D2":
+		curSize = 3
+		curQ = 1
+	default:
+		return 0, errors.New("invalid arrangement in ARM64 register list")
+	}
+	return (int64(curQ) & 1 << 30) | (int64(curSize&3) << 10), nil
+}
+
+// ARM64RegisterListOffset generates offset encoding according to AArch64 specification.
+func ARM64RegisterListOffset(firstReg, regCnt int, arrangement int64) (int64, error) {
+	offset := int64(firstReg)
+	switch regCnt {
+	case 1:
+		offset |= 0x7 << 12
+	case 2:
+		offset |= 0xa << 12
+	case 3:
+		offset |= 0x6 << 12
+	case 4:
+		offset |= 0x2 << 12
+	default:
+		return 0, errors.New("invalid register numbers in ARM64 register list")
+	}
+	offset |= arrangement
+	// arm64 uses the 60th bit to differentiate from other archs
+	// For more details, refer to: obj/arm64/list7.go
+	offset |= 1 << 60
+	return offset, nil
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/mips.go b/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/mips.go
new file mode 100644
index 000000000..7af9dbb23
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/mips.go
@@ -0,0 +1,72 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file encapsulates some of the odd characteristics of the
+// MIPS (MIPS64) instruction set, to minimize its interaction
+// with the core of the assembler.
+
+package arch
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/obj/mips"
+)
+
+func jumpMIPS(word string) bool {
+	switch word {
+	case "BEQ", "BFPF", "BFPT", "BGEZ", "BGEZAL", "BGTZ", "BLEZ", "BLTZ", "BLTZAL", "BNE", "JMP", "JAL", "CALL":
+		return true
+	}
+	return false
+}
+
+// IsMIPSCMP reports whether the op (as defined by an mips.A* constant) is
+// one of the CMP instructions that require special handling.
+func IsMIPSCMP(op obj.As) bool {
+	switch op {
+	case mips.ACMPEQF, mips.ACMPEQD, mips.ACMPGEF, mips.ACMPGED,
+		mips.ACMPGTF, mips.ACMPGTD:
+		return true
+	}
+	return false
+}
+
+// IsMIPSMUL reports whether the op (as defined by an mips.A* constant) is
+// one of the MUL/DIV/REM/MADD/MSUB instructions that require special handling.
+func IsMIPSMUL(op obj.As) bool {
+	switch op {
+	case mips.AMUL, mips.AMULU, mips.AMULV, mips.AMULVU,
+		mips.ADIV, mips.ADIVU, mips.ADIVV, mips.ADIVVU,
+		mips.AREM, mips.AREMU, mips.AREMV, mips.AREMVU,
+		mips.AMADD, mips.AMSUB:
+		return true
+	}
+	return false
+}
+
+func mipsRegisterNumber(name string, n int16) (int16, bool) {
+	switch name {
+	case "F":
+		if 0 <= n && n <= 31 {
+			return mips.REG_F0 + n, true
+		}
+	case "FCR":
+		if 0 <= n && n <= 31 {
+			return mips.REG_FCR0 + n, true
+		}
+	case "M":
+		if 0 <= n && n <= 31 {
+			return mips.REG_M0 + n, true
+		}
+	case "R":
+		if 0 <= n && n <= 31 {
+			return mips.REG_R0 + n, true
+		}
+	case "W":
+		if 0 <= n && n <= 31 {
+			return mips.REG_W0 + n, true
+		}
+	}
+	return 0, false
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/ppc64.go b/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/ppc64.go
new file mode 100644
index 000000000..8b2f097d5
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/ppc64.go
@@ -0,0 +1,102 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file encapsulates some of the odd characteristics of the
+// 64-bit PowerPC (PPC64) instruction set, to minimize its interaction
+// with the core of the assembler.
+
+package arch
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/obj/ppc64"
+)
+
+func jumpPPC64(word string) bool {
+	switch word {
+	case "BC", "BCL", "BEQ", "BGE", "BGT", "BL", "BLE", "BLT", "BNE", "BR", "BVC", "BVS", "CALL", "JMP":
+		return true
+	}
+	return false
+}
+
+// IsPPC64RLD reports whether the op (as defined by an ppc64.A* constant) is
+// one of the RLD-like instructions that require special handling.
+// The FMADD-like instructions behave similarly.
+func IsPPC64RLD(op obj.As) bool {
+	switch op {
+	case ppc64.ARLDC, ppc64.ARLDCCC, ppc64.ARLDCL, ppc64.ARLDCLCC,
+		ppc64.ARLDCR, ppc64.ARLDCRCC, ppc64.ARLDMI, ppc64.ARLDMICC,
+		ppc64.ARLWMI, ppc64.ARLWMICC, ppc64.ARLWNM, ppc64.ARLWNMCC:
+		return true
+	case ppc64.AFMADD, ppc64.AFMADDCC, ppc64.AFMADDS, ppc64.AFMADDSCC,
+		ppc64.AFMSUB, ppc64.AFMSUBCC, ppc64.AFMSUBS, ppc64.AFMSUBSCC,
+		ppc64.AFNMADD, ppc64.AFNMADDCC, ppc64.AFNMADDS, ppc64.AFNMADDSCC,
+		ppc64.AFNMSUB, ppc64.AFNMSUBCC, ppc64.AFNMSUBS, ppc64.AFNMSUBSCC:
+		return true
+	}
+	return false
+}
+
+func IsPPC64ISEL(op obj.As) bool {
+	return op == ppc64.AISEL
+}
+
+// IsPPC64CMP reports whether the op (as defined by an ppc64.A* constant) is
+// one of the CMP instructions that require special handling.
+func IsPPC64CMP(op obj.As) bool {
+	switch op {
+	case ppc64.ACMP, ppc64.ACMPU, ppc64.ACMPW, ppc64.ACMPWU, ppc64.AFCMPU:
+		return true
+	}
+	return false
+}
+
+// IsPPC64NEG reports whether the op (as defined by an ppc64.A* constant) is
+// one of the NEG-like instructions that require special handling.
+func IsPPC64NEG(op obj.As) bool {
+	switch op {
+	case ppc64.AADDMECC, ppc64.AADDMEVCC, ppc64.AADDMEV, ppc64.AADDME,
+		ppc64.AADDZECC, ppc64.AADDZEVCC, ppc64.AADDZEV, ppc64.AADDZE,
+		ppc64.ACNTLZDCC, ppc64.ACNTLZD, ppc64.ACNTLZWCC, ppc64.ACNTLZW,
+		ppc64.AEXTSBCC, ppc64.AEXTSB, ppc64.AEXTSHCC, ppc64.AEXTSH,
+		ppc64.AEXTSWCC, ppc64.AEXTSW, ppc64.ANEGCC, ppc64.ANEGVCC,
+		ppc64.ANEGV, ppc64.ANEG, ppc64.ASLBMFEE, ppc64.ASLBMFEV,
+		ppc64.ASLBMTE, ppc64.ASUBMECC, ppc64.ASUBMEVCC, ppc64.ASUBMEV,
+		ppc64.ASUBME, ppc64.ASUBZECC, ppc64.ASUBZEVCC, ppc64.ASUBZEV,
+		ppc64.ASUBZE:
+		return true
+	}
+	return false
+}
+
+func ppc64RegisterNumber(name string, n int16) (int16, bool) {
+	switch name {
+	case "CR":
+		if 0 <= n && n <= 7 {
+			return ppc64.REG_CR0 + n, true
+		}
+	case "VS":
+		if 0 <= n && n <= 63 {
+			return ppc64.REG_VS0 + n, true
+		}
+	case "V":
+		if 0 <= n && n <= 31 {
+			return ppc64.REG_V0 + n, true
+		}
+	case "F":
+		if 0 <= n && n <= 31 {
+			return ppc64.REG_F0 + n, true
+		}
+	case "R":
+		if 0 <= n && n <= 31 {
+			return ppc64.REG_R0 + n, true
+		}
+	case "SPR":
+		if 0 <= n && n <= 1024 {
+			return ppc64.REG_SPR0 + n, true
+		}
+	}
+	return 0, false
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/riscv64.go b/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/riscv64.go
new file mode 100644
index 000000000..e4f17536a
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/riscv64.go
@@ -0,0 +1,28 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file encapsulates some of the odd characteristics of the RISCV64
+// instruction set, to minimize its interaction with the core of the
+// assembler.
+
+package arch
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/obj/riscv"
+)
+
+// IsRISCV64AMO reports whether the op (as defined by a riscv.A*
+// constant) is one of the AMO instructions that requires special
+// handling.
+func IsRISCV64AMO(op obj.As) bool {
+	switch op {
+	case riscv.ASCW, riscv.ASCD, riscv.AAMOSWAPW, riscv.AAMOSWAPD, riscv.AAMOADDW, riscv.AAMOADDD,
+		riscv.AAMOANDW, riscv.AAMOANDD, riscv.AAMOORW, riscv.AAMOORD, riscv.AAMOXORW, riscv.AAMOXORD,
+		riscv.AAMOMINW, riscv.AAMOMIND, riscv.AAMOMINUW, riscv.AAMOMINUD,
+		riscv.AAMOMAXW, riscv.AAMOMAXD, riscv.AAMOMAXUW, riscv.AAMOMAXUD:
+		return true
+	}
+	return false
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/s390x.go b/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/s390x.go
new file mode 100644
index 000000000..1e33f1e32
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/asm/arch/s390x.go
@@ -0,0 +1,81 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file encapsulates some of the odd characteristics of the
+// s390x instruction set, to minimize its interaction
+// with the core of the assembler.
+
+package arch
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj/s390x"
+)
+
+func jumpS390x(word string) bool {
+	switch word {
+	case "BRC",
+		"BC",
+		"BCL",
+		"BEQ",
+		"BGE",
+		"BGT",
+		"BL",
+		"BLE",
+		"BLEU",
+		"BLT",
+		"BLTU",
+		"BNE",
+		"BR",
+		"BVC",
+		"BVS",
+		"BRCT",
+		"BRCTG",
+		"CMPBEQ",
+		"CMPBGE",
+		"CMPBGT",
+		"CMPBLE",
+		"CMPBLT",
+		"CMPBNE",
+		"CMPUBEQ",
+		"CMPUBGE",
+		"CMPUBGT",
+		"CMPUBLE",
+		"CMPUBLT",
+		"CMPUBNE",
+		"CRJ",
+		"CGRJ",
+		"CLRJ",
+		"CLGRJ",
+		"CIJ",
+		"CGIJ",
+		"CLIJ",
+		"CLGIJ",
+		"CALL",
+		"JMP":
+		return true
+	}
+	return false
+}
+
+func s390xRegisterNumber(name string, n int16) (int16, bool) {
+	switch name {
+	case "AR":
+		if 0 <= n && n <= 15 {
+			return s390x.REG_AR0 + n, true
+		}
+	case "F":
+		if 0 <= n && n <= 15 {
+			return s390x.REG_F0 + n, true
+		}
+	case "R":
+		if 0 <= n && n <= 15 {
+			return s390x.REG_R0 + n, true
+		}
+	case "V":
+		if 0 <= n && n <= 31 {
+			return s390x.REG_V0 + n, true
+		}
+	}
+	return 0, false
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/bio/buf.go b/vendor/github.com/twitchyliquid64/golang-asm/bio/buf.go
new file mode 100644
index 000000000..c4c251490
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/bio/buf.go
@@ -0,0 +1,148 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package bio implements common I/O abstractions used within the Go toolchain.
+package bio
+
+import (
+	"bufio"
+	"io"
+	"log"
+	"os"
+)
+
+// Reader implements a seekable buffered io.Reader.
+type Reader struct {
+	f *os.File
+	*bufio.Reader
+}
+
+// Writer implements a seekable buffered io.Writer.
+type Writer struct {
+	f *os.File
+	*bufio.Writer
+}
+
+// Create creates the file named name and returns a Writer
+// for that file.
+func Create(name string) (*Writer, error) {
+	f, err := os.Create(name)
+	if err != nil {
+		return nil, err
+	}
+	return &Writer{f: f, Writer: bufio.NewWriter(f)}, nil
+}
+
+// Open returns a Reader for the file named name.
+func Open(name string) (*Reader, error) {
+	f, err := os.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	return NewReader(f), nil
+}
+
+// NewReader returns a Reader from an open file.
+func NewReader(f *os.File) *Reader {
+	return &Reader{f: f, Reader: bufio.NewReader(f)}
+}
+
+func (r *Reader) MustSeek(offset int64, whence int) int64 {
+	if whence == 1 {
+		offset -= int64(r.Buffered())
+	}
+	off, err := r.f.Seek(offset, whence)
+	if err != nil {
+		log.Fatalf("seeking in output: %v", err)
+	}
+	r.Reset(r.f)
+	return off
+}
+
+func (w *Writer) MustSeek(offset int64, whence int) int64 {
+	if err := w.Flush(); err != nil {
+		log.Fatalf("writing output: %v", err)
+	}
+	off, err := w.f.Seek(offset, whence)
+	if err != nil {
+		log.Fatalf("seeking in output: %v", err)
+	}
+	return off
+}
+
+func (r *Reader) Offset() int64 {
+	off, err := r.f.Seek(0, 1)
+	if err != nil {
+		log.Fatalf("seeking in output [0, 1]: %v", err)
+	}
+	off -= int64(r.Buffered())
+	return off
+}
+
+func (w *Writer) Offset() int64 {
+	if err := w.Flush(); err != nil {
+		log.Fatalf("writing output: %v", err)
+	}
+	off, err := w.f.Seek(0, 1)
+	if err != nil {
+		log.Fatalf("seeking in output [0, 1]: %v", err)
+	}
+	return off
+}
+
+func (r *Reader) Close() error {
+	return r.f.Close()
+}
+
+func (w *Writer) Close() error {
+	err := w.Flush()
+	err1 := w.f.Close()
+	if err == nil {
+		err = err1
+	}
+	return err
+}
+
+func (r *Reader) File() *os.File {
+	return r.f
+}
+
+func (w *Writer) File() *os.File {
+	return w.f
+}
+
+// Slice reads the next length bytes of r into a slice.
+//
+// This slice may be backed by mmap'ed memory. Currently, this memory
+// will never be unmapped. The second result reports whether the
+// backing memory is read-only.
+func (r *Reader) Slice(length uint64) ([]byte, bool, error) {
+	if length == 0 {
+		return []byte{}, false, nil
+	}
+
+	data, ok := r.sliceOS(length)
+	if ok {
+		return data, true, nil
+	}
+
+	data = make([]byte, length)
+	_, err := io.ReadFull(r, data)
+	if err != nil {
+		return nil, false, err
+	}
+	return data, false, nil
+}
+
+// SliceRO returns a slice containing the next length bytes of r
+// backed by a read-only mmap'd data. If the mmap cannot be
+// established (limit exceeded, region too small, etc) a nil slice
+// will be returned. If mmap succeeds, it will never be unmapped.
+func (r *Reader) SliceRO(length uint64) []byte {
+	data, ok := r.sliceOS(length)
+	if ok {
+		return data
+	}
+	return nil
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/bio/buf_mmap.go b/vendor/github.com/twitchyliquid64/golang-asm/bio/buf_mmap.go
new file mode 100644
index 000000000..4b43d74f2
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/bio/buf_mmap.go
@@ -0,0 +1,62 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build darwin dragonfly freebsd linux netbsd openbsd
+
+package bio
+
+import (
+	"runtime"
+	"sync/atomic"
+	"syscall"
+)
+
+// mmapLimit is the maximum number of mmaped regions to create before
+// falling back to reading into a heap-allocated slice. This exists
+// because some operating systems place a limit on the number of
+// distinct mapped regions per process. As of this writing:
+//
+//  Darwin    unlimited
+//  DragonFly   1000000 (vm.max_proc_mmap)
+//  FreeBSD   unlimited
+//  Linux         65530 (vm.max_map_count) // TODO: query /proc/sys/vm/max_map_count?
+//  NetBSD    unlimited
+//  OpenBSD   unlimited
+var mmapLimit int32 = 1<<31 - 1
+
+func init() {
+	// Linux is the only practically concerning OS.
+	if runtime.GOOS == "linux" {
+		mmapLimit = 30000
+	}
+}
+
+func (r *Reader) sliceOS(length uint64) ([]byte, bool) {
+	// For small slices, don't bother with the overhead of a
+	// mapping, especially since we have no way to unmap it.
+	const threshold = 16 << 10
+	if length < threshold {
+		return nil, false
+	}
+
+	// Have we reached the mmap limit?
+	if atomic.AddInt32(&mmapLimit, -1) < 0 {
+		atomic.AddInt32(&mmapLimit, 1)
+		return nil, false
+	}
+
+	// Page-align the offset.
+	off := r.Offset()
+	align := syscall.Getpagesize()
+	aoff := off &^ int64(align-1)
+
+	data, err := syscall.Mmap(int(r.f.Fd()), aoff, int(length+uint64(off-aoff)), syscall.PROT_READ, syscall.MAP_SHARED|syscall.MAP_FILE)
+	if err != nil {
+		return nil, false
+	}
+
+	data = data[off-aoff:]
+	r.MustSeek(int64(length), 1)
+	return data, true
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/bio/buf_nommap.go b/vendor/github.com/twitchyliquid64/golang-asm/bio/buf_nommap.go
new file mode 100644
index 000000000..f43c67ac2
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/bio/buf_nommap.go
@@ -0,0 +1,11 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd
+
+package bio
+
+func (r *Reader) sliceOS(length uint64) ([]byte, bool) {
+	return nil, false
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/bio/must.go b/vendor/github.com/twitchyliquid64/golang-asm/bio/must.go
new file mode 100644
index 000000000..3604b2917
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/bio/must.go
@@ -0,0 +1,43 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package bio
+
+import (
+	"io"
+	"log"
+)
+
+// MustClose closes Closer c and calls log.Fatal if it returns a non-nil error.
+func MustClose(c io.Closer) {
+	if err := c.Close(); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// MustWriter returns a Writer that wraps the provided Writer,
+// except that it calls log.Fatal instead of returning a non-nil error.
+func MustWriter(w io.Writer) io.Writer {
+	return mustWriter{w}
+}
+
+type mustWriter struct {
+	w io.Writer
+}
+
+func (w mustWriter) Write(b []byte) (int, error) {
+	n, err := w.w.Write(b)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return n, nil
+}
+
+func (w mustWriter) WriteString(s string) (int, error) {
+	n, err := io.WriteString(w.w, s)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return n, nil
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/dwarf/dwarf.go b/vendor/github.com/twitchyliquid64/golang-asm/dwarf/dwarf.go
new file mode 100644
index 000000000..2fee79d38
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/dwarf/dwarf.go
@@ -0,0 +1,1650 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package dwarf generates DWARF debugging information.
+// DWARF generation is split between the compiler and the linker,
+// this package contains the shared code.
+package dwarf
+
+import (
+	"bytes"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"errors"
+	"fmt"
+	"os/exec"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// InfoPrefix is the prefix for all the symbols containing DWARF info entries.
+const InfoPrefix = "go.info."
+
+// ConstInfoPrefix is the prefix for all symbols containing DWARF info
+// entries that contain constants.
+const ConstInfoPrefix = "go.constinfo."
+
+// CUInfoPrefix is the prefix for symbols containing information to
+// populate the DWARF compilation unit info entries.
+const CUInfoPrefix = "go.cuinfo."
+
+// Used to form the symbol name assigned to the DWARF 'abstract subprogram"
+// info entry for a function
+const AbstractFuncSuffix = "$abstract"
+
+// Controls logging/debugging for selected aspects of DWARF subprogram
+// generation (functions, scopes).
+var logDwarf bool
+
+// Sym represents a symbol.
+type Sym interface {
+	Length(dwarfContext interface{}) int64
+}
+
+// A Var represents a local variable or a function parameter.
+type Var struct {
+	Name          string
+	Abbrev        int // Either DW_ABRV_AUTO[_LOCLIST] or DW_ABRV_PARAM[_LOCLIST]
+	IsReturnValue bool
+	IsInlFormal   bool
+	StackOffset   int32
+	// This package can't use the ssa package, so it can't mention ssa.FuncDebug,
+	// so indirect through a closure.
+	PutLocationList func(listSym, startPC Sym)
+	Scope           int32
+	Type            Sym
+	DeclFile        string
+	DeclLine        uint
+	DeclCol         uint
+	InlIndex        int32 // subtract 1 to form real index into InlTree
+	ChildIndex      int32 // child DIE index in abstract function
+	IsInAbstract    bool  // variable exists in abstract function
+}
+
+// A Scope represents a lexical scope. All variables declared within a
+// scope will only be visible to instructions covered by the scope.
+// Lexical scopes are contiguous in source files but can end up being
+// compiled to discontiguous blocks of instructions in the executable.
+// The Ranges field lists all the blocks of instructions that belong
+// in this scope.
+type Scope struct {
+	Parent int32
+	Ranges []Range
+	Vars   []*Var
+}
+
+// A Range represents a half-open interval [Start, End).
+type Range struct {
+	Start, End int64
+}
+
+// This container is used by the PutFunc* variants below when
+// creating the DWARF subprogram DIE(s) for a function.
+type FnState struct {
+	Name          string
+	Importpath    string
+	Info          Sym
+	Filesym       Sym
+	Loc           Sym
+	Ranges        Sym
+	Absfn         Sym
+	StartPC       Sym
+	Size          int64
+	External      bool
+	Scopes        []Scope
+	InlCalls      InlCalls
+	UseBASEntries bool
+}
+
+func EnableLogging(doit bool) {
+	logDwarf = doit
+}
+
+// UnifyRanges merges the list of ranges of c into the list of ranges of s
+func (s *Scope) UnifyRanges(c *Scope) {
+	out := make([]Range, 0, len(s.Ranges)+len(c.Ranges))
+
+	i, j := 0, 0
+	for {
+		var cur Range
+		if i < len(s.Ranges) && j < len(c.Ranges) {
+			if s.Ranges[i].Start < c.Ranges[j].Start {
+				cur = s.Ranges[i]
+				i++
+			} else {
+				cur = c.Ranges[j]
+				j++
+			}
+		} else if i < len(s.Ranges) {
+			cur = s.Ranges[i]
+			i++
+		} else if j < len(c.Ranges) {
+			cur = c.Ranges[j]
+			j++
+		} else {
+			break
+		}
+
+		if n := len(out); n > 0 && cur.Start <= out[n-1].End {
+			out[n-1].End = cur.End
+		} else {
+			out = append(out, cur)
+		}
+	}
+
+	s.Ranges = out
+}
+
+// AppendRange adds r to s, if r is non-empty.
+// If possible, it extends the last Range in s.Ranges; if not, it creates a new one.
+func (s *Scope) AppendRange(r Range) {
+	if r.End <= r.Start {
+		return
+	}
+	i := len(s.Ranges)
+	if i > 0 && s.Ranges[i-1].End == r.Start {
+		s.Ranges[i-1].End = r.End
+		return
+	}
+	s.Ranges = append(s.Ranges, r)
+}
+
+type InlCalls struct {
+	Calls []InlCall
+}
+
+type InlCall struct {
+	// index into ctx.InlTree describing the call inlined here
+	InlIndex int
+
+	// Symbol of file containing inlined call site (really *obj.LSym).
+	CallFile Sym
+
+	// Line number of inlined call site.
+	CallLine uint32
+
+	// Dwarf abstract subroutine symbol (really *obj.LSym).
+	AbsFunSym Sym
+
+	// Indices of child inlines within Calls array above.
+	Children []int
+
+	// entries in this list are PAUTO's created by the inliner to
+	// capture the promoted formals and locals of the inlined callee.
+	InlVars []*Var
+
+	// PC ranges for this inlined call.
+	Ranges []Range
+
+	// Root call (not a child of some other call).
+	Root bool
+}
+
+// A Context specifies how to add data to a Sym.
+type Context interface {
+	PtrSize() int
+	AddInt(s Sym, size int, i int64)
+	AddBytes(s Sym, b []byte)
+	AddAddress(s Sym, t interface{}, ofs int64)
+	AddCURelativeAddress(s Sym, t interface{}, ofs int64)
+	AddSectionOffset(s Sym, size int, t interface{}, ofs int64)
+	AddDWARFAddrSectionOffset(s Sym, t interface{}, ofs int64)
+	CurrentOffset(s Sym) int64
+	RecordDclReference(from Sym, to Sym, dclIdx int, inlIndex int)
+	RecordChildDieOffsets(s Sym, vars []*Var, offsets []int32)
+	AddString(s Sym, v string)
+	AddFileRef(s Sym, f interface{})
+	Logf(format string, args ...interface{})
+}
+
+// AppendUleb128 appends v to b using DWARF's unsigned LEB128 encoding.
+func AppendUleb128(b []byte, v uint64) []byte {
+	for {
+		c := uint8(v & 0x7f)
+		v >>= 7
+		if v != 0 {
+			c |= 0x80
+		}
+		b = append(b, c)
+		if c&0x80 == 0 {
+			break
+		}
+	}
+	return b
+}
+
+// AppendSleb128 appends v to b using DWARF's signed LEB128 encoding.
+func AppendSleb128(b []byte, v int64) []byte {
+	for {
+		c := uint8(v & 0x7f)
+		s := uint8(v & 0x40)
+		v >>= 7
+		if (v != -1 || s == 0) && (v != 0 || s != 0) {
+			c |= 0x80
+		}
+		b = append(b, c)
+		if c&0x80 == 0 {
+			break
+		}
+	}
+	return b
+}
+
+// sevenbits contains all unsigned seven bit numbers, indexed by their value.
+var sevenbits = [...]byte{
+	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+	0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
+	0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+	0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+	0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
+	0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
+	0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
+}
+
+// sevenBitU returns the unsigned LEB128 encoding of v if v is seven bits and nil otherwise.
+// The contents of the returned slice must not be modified.
+func sevenBitU(v int64) []byte {
+	if uint64(v) < uint64(len(sevenbits)) {
+		return sevenbits[v : v+1]
+	}
+	return nil
+}
+
+// sevenBitS returns the signed LEB128 encoding of v if v is seven bits and nil otherwise.
+// The contents of the returned slice must not be modified.
+func sevenBitS(v int64) []byte {
+	if uint64(v) <= 63 {
+		return sevenbits[v : v+1]
+	}
+	if uint64(-v) <= 64 {
+		return sevenbits[128+v : 128+v+1]
+	}
+	return nil
+}
+
+// Uleb128put appends v to s using DWARF's unsigned LEB128 encoding.
+func Uleb128put(ctxt Context, s Sym, v int64) {
+	b := sevenBitU(v)
+	if b == nil {
+		var encbuf [20]byte
+		b = AppendUleb128(encbuf[:0], uint64(v))
+	}
+	ctxt.AddBytes(s, b)
+}
+
+// Sleb128put appends v to s using DWARF's signed LEB128 encoding.
+func Sleb128put(ctxt Context, s Sym, v int64) {
+	b := sevenBitS(v)
+	if b == nil {
+		var encbuf [20]byte
+		b = AppendSleb128(encbuf[:0], v)
+	}
+	ctxt.AddBytes(s, b)
+}
+
+/*
+ * Defining Abbrevs. This is hardcoded on a per-platform basis (that is,
+ * each platform will see a fixed abbrev table for all objects); the number
+ * of abbrev entries is fairly small (compared to C++ objects).  The DWARF
+ * spec places no restriction on the ordering of attributes in the
+ * Abbrevs and DIEs, and we will always write them out in the order
+ * of declaration in the abbrev.
+ */
+type dwAttrForm struct {
+	attr uint16
+	form uint8
+}
+
+// Go-specific type attributes.
+const (
+	DW_AT_go_kind = 0x2900
+	DW_AT_go_key  = 0x2901
+	DW_AT_go_elem = 0x2902
+	// Attribute for DW_TAG_member of a struct type.
+	// Nonzero value indicates the struct field is an embedded field.
+	DW_AT_go_embedded_field = 0x2903
+	DW_AT_go_runtime_type   = 0x2904
+
+	DW_AT_go_package_name = 0x2905 // Attribute for DW_TAG_compile_unit
+
+	DW_AT_internal_location = 253 // params and locals; not emitted
+)
+
+// Index into the abbrevs table below.
+// Keep in sync with ispubname() and ispubtype() in ld/dwarf.go.
+// ispubtype considers >= NULLTYPE public
+const (
+	DW_ABRV_NULL = iota
+	DW_ABRV_COMPUNIT
+	DW_ABRV_COMPUNIT_TEXTLESS
+	DW_ABRV_FUNCTION
+	DW_ABRV_FUNCTION_ABSTRACT
+	DW_ABRV_FUNCTION_CONCRETE
+	DW_ABRV_INLINED_SUBROUTINE
+	DW_ABRV_INLINED_SUBROUTINE_RANGES
+	DW_ABRV_VARIABLE
+	DW_ABRV_INT_CONSTANT
+	DW_ABRV_AUTO
+	DW_ABRV_AUTO_LOCLIST
+	DW_ABRV_AUTO_ABSTRACT
+	DW_ABRV_AUTO_CONCRETE
+	DW_ABRV_AUTO_CONCRETE_LOCLIST
+	DW_ABRV_PARAM
+	DW_ABRV_PARAM_LOCLIST
+	DW_ABRV_PARAM_ABSTRACT
+	DW_ABRV_PARAM_CONCRETE
+	DW_ABRV_PARAM_CONCRETE_LOCLIST
+	DW_ABRV_LEXICAL_BLOCK_RANGES
+	DW_ABRV_LEXICAL_BLOCK_SIMPLE
+	DW_ABRV_STRUCTFIELD
+	DW_ABRV_FUNCTYPEPARAM
+	DW_ABRV_DOTDOTDOT
+	DW_ABRV_ARRAYRANGE
+	DW_ABRV_NULLTYPE
+	DW_ABRV_BASETYPE
+	DW_ABRV_ARRAYTYPE
+	DW_ABRV_CHANTYPE
+	DW_ABRV_FUNCTYPE
+	DW_ABRV_IFACETYPE
+	DW_ABRV_MAPTYPE
+	DW_ABRV_PTRTYPE
+	DW_ABRV_BARE_PTRTYPE // only for void*, no DW_AT_type attr to please gdb 6.
+	DW_ABRV_SLICETYPE
+	DW_ABRV_STRINGTYPE
+	DW_ABRV_STRUCTTYPE
+	DW_ABRV_TYPEDECL
+	DW_NABRV
+)
+
+type dwAbbrev struct {
+	tag      uint8
+	children uint8
+	attr     []dwAttrForm
+}
+
+var abbrevsFinalized bool
+
+// expandPseudoForm takes an input DW_FORM_xxx value and translates it
+// into a platform-appropriate concrete form. Existing concrete/real
+// DW_FORM values are left untouched. For the moment the only
+// pseudo-form is DW_FORM_udata_pseudo, which gets expanded to
+// DW_FORM_data4 on Darwin and DW_FORM_udata everywhere else. See
+// issue #31459 for more context.
+func expandPseudoForm(form uint8) uint8 {
+	// Is this a pseudo-form?
+	if form != DW_FORM_udata_pseudo {
+		return form
+	}
+	expandedForm := DW_FORM_udata
+	if objabi.GOOS == "darwin" {
+		expandedForm = DW_FORM_data4
+	}
+	return uint8(expandedForm)
+}
+
+// Abbrevs() returns the finalized abbrev array for the platform,
+// expanding any DW_FORM pseudo-ops to real values.
+func Abbrevs() []dwAbbrev {
+	if abbrevsFinalized {
+		return abbrevs[:]
+	}
+	for i := 1; i < DW_NABRV; i++ {
+		for j := 0; j < len(abbrevs[i].attr); j++ {
+			abbrevs[i].attr[j].form = expandPseudoForm(abbrevs[i].attr[j].form)
+		}
+	}
+	abbrevsFinalized = true
+	return abbrevs[:]
+}
+
+// abbrevs is a raw table of abbrev entries; it needs to be post-processed
+// by the Abbrevs() function above prior to being consumed, to expand
+// the 'pseudo-form' entries below to real DWARF form values.
+
+var abbrevs = [DW_NABRV]dwAbbrev{
+	/* The mandatory DW_ABRV_NULL entry. */
+	{0, 0, []dwAttrForm{}},
+
+	/* COMPUNIT */
+	{
+		DW_TAG_compile_unit,
+		DW_CHILDREN_yes,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_language, DW_FORM_data1},
+			{DW_AT_stmt_list, DW_FORM_sec_offset},
+			{DW_AT_low_pc, DW_FORM_addr},
+			{DW_AT_ranges, DW_FORM_sec_offset},
+			{DW_AT_comp_dir, DW_FORM_string},
+			{DW_AT_producer, DW_FORM_string},
+			{DW_AT_go_package_name, DW_FORM_string},
+		},
+	},
+
+	/* COMPUNIT_TEXTLESS */
+	{
+		DW_TAG_compile_unit,
+		DW_CHILDREN_yes,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_language, DW_FORM_data1},
+			{DW_AT_comp_dir, DW_FORM_string},
+			{DW_AT_producer, DW_FORM_string},
+			{DW_AT_go_package_name, DW_FORM_string},
+		},
+	},
+
+	/* FUNCTION */
+	{
+		DW_TAG_subprogram,
+		DW_CHILDREN_yes,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_low_pc, DW_FORM_addr},
+			{DW_AT_high_pc, DW_FORM_addr},
+			{DW_AT_frame_base, DW_FORM_block1},
+			{DW_AT_decl_file, DW_FORM_data4},
+			{DW_AT_external, DW_FORM_flag},
+		},
+	},
+
+	/* FUNCTION_ABSTRACT */
+	{
+		DW_TAG_subprogram,
+		DW_CHILDREN_yes,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_inline, DW_FORM_data1},
+			{DW_AT_external, DW_FORM_flag},
+		},
+	},
+
+	/* FUNCTION_CONCRETE */
+	{
+		DW_TAG_subprogram,
+		DW_CHILDREN_yes,
+		[]dwAttrForm{
+			{DW_AT_abstract_origin, DW_FORM_ref_addr},
+			{DW_AT_low_pc, DW_FORM_addr},
+			{DW_AT_high_pc, DW_FORM_addr},
+			{DW_AT_frame_base, DW_FORM_block1},
+		},
+	},
+
+	/* INLINED_SUBROUTINE */
+	{
+		DW_TAG_inlined_subroutine,
+		DW_CHILDREN_yes,
+		[]dwAttrForm{
+			{DW_AT_abstract_origin, DW_FORM_ref_addr},
+			{DW_AT_low_pc, DW_FORM_addr},
+			{DW_AT_high_pc, DW_FORM_addr},
+			{DW_AT_call_file, DW_FORM_data4},
+			{DW_AT_call_line, DW_FORM_udata_pseudo}, // pseudo-form
+		},
+	},
+
+	/* INLINED_SUBROUTINE_RANGES */
+	{
+		DW_TAG_inlined_subroutine,
+		DW_CHILDREN_yes,
+		[]dwAttrForm{
+			{DW_AT_abstract_origin, DW_FORM_ref_addr},
+			{DW_AT_ranges, DW_FORM_sec_offset},
+			{DW_AT_call_file, DW_FORM_data4},
+			{DW_AT_call_line, DW_FORM_udata_pseudo}, // pseudo-form
+		},
+	},
+
+	/* VARIABLE */
+	{
+		DW_TAG_variable,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_location, DW_FORM_block1},
+			{DW_AT_type, DW_FORM_ref_addr},
+			{DW_AT_external, DW_FORM_flag},
+		},
+	},
+
+	/* INT CONSTANT */
+	{
+		DW_TAG_constant,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_type, DW_FORM_ref_addr},
+			{DW_AT_const_value, DW_FORM_sdata},
+		},
+	},
+
+	/* AUTO */
+	{
+		DW_TAG_variable,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_decl_line, DW_FORM_udata},
+			{DW_AT_type, DW_FORM_ref_addr},
+			{DW_AT_location, DW_FORM_block1},
+		},
+	},
+
+	/* AUTO_LOCLIST */
+	{
+		DW_TAG_variable,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_decl_line, DW_FORM_udata},
+			{DW_AT_type, DW_FORM_ref_addr},
+			{DW_AT_location, DW_FORM_sec_offset},
+		},
+	},
+
+	/* AUTO_ABSTRACT */
+	{
+		DW_TAG_variable,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_decl_line, DW_FORM_udata},
+			{DW_AT_type, DW_FORM_ref_addr},
+		},
+	},
+
+	/* AUTO_CONCRETE */
+	{
+		DW_TAG_variable,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_abstract_origin, DW_FORM_ref_addr},
+			{DW_AT_location, DW_FORM_block1},
+		},
+	},
+
+	/* AUTO_CONCRETE_LOCLIST */
+	{
+		DW_TAG_variable,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_abstract_origin, DW_FORM_ref_addr},
+			{DW_AT_location, DW_FORM_sec_offset},
+		},
+	},
+
+	/* PARAM */
+	{
+		DW_TAG_formal_parameter,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_variable_parameter, DW_FORM_flag},
+			{DW_AT_decl_line, DW_FORM_udata},
+			{DW_AT_type, DW_FORM_ref_addr},
+			{DW_AT_location, DW_FORM_block1},
+		},
+	},
+
+	/* PARAM_LOCLIST */
+	{
+		DW_TAG_formal_parameter,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_variable_parameter, DW_FORM_flag},
+			{DW_AT_decl_line, DW_FORM_udata},
+			{DW_AT_type, DW_FORM_ref_addr},
+			{DW_AT_location, DW_FORM_sec_offset},
+		},
+	},
+
+	/* PARAM_ABSTRACT */
+	{
+		DW_TAG_formal_parameter,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_variable_parameter, DW_FORM_flag},
+			{DW_AT_type, DW_FORM_ref_addr},
+		},
+	},
+
+	/* PARAM_CONCRETE */
+	{
+		DW_TAG_formal_parameter,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_abstract_origin, DW_FORM_ref_addr},
+			{DW_AT_location, DW_FORM_block1},
+		},
+	},
+
+	/* PARAM_CONCRETE_LOCLIST */
+	{
+		DW_TAG_formal_parameter,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_abstract_origin, DW_FORM_ref_addr},
+			{DW_AT_location, DW_FORM_sec_offset},
+		},
+	},
+
+	/* LEXICAL_BLOCK_RANGES */
+	{
+		DW_TAG_lexical_block,
+		DW_CHILDREN_yes,
+		[]dwAttrForm{
+			{DW_AT_ranges, DW_FORM_sec_offset},
+		},
+	},
+
+	/* LEXICAL_BLOCK_SIMPLE */
+	{
+		DW_TAG_lexical_block,
+		DW_CHILDREN_yes,
+		[]dwAttrForm{
+			{DW_AT_low_pc, DW_FORM_addr},
+			{DW_AT_high_pc, DW_FORM_addr},
+		},
+	},
+
+	/* STRUCTFIELD */
+	{
+		DW_TAG_member,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_data_member_location, DW_FORM_udata},
+			{DW_AT_type, DW_FORM_ref_addr},
+			{DW_AT_go_embedded_field, DW_FORM_flag},
+		},
+	},
+
+	/* FUNCTYPEPARAM */
+	{
+		DW_TAG_formal_parameter,
+		DW_CHILDREN_no,
+
+		// No name!
+		[]dwAttrForm{
+			{DW_AT_type, DW_FORM_ref_addr},
+		},
+	},
+
+	/* DOTDOTDOT */
+	{
+		DW_TAG_unspecified_parameters,
+		DW_CHILDREN_no,
+		[]dwAttrForm{},
+	},
+
+	/* ARRAYRANGE */
+	{
+		DW_TAG_subrange_type,
+		DW_CHILDREN_no,
+
+		// No name!
+		[]dwAttrForm{
+			{DW_AT_type, DW_FORM_ref_addr},
+			{DW_AT_count, DW_FORM_udata},
+		},
+	},
+
+	// Below here are the types considered public by ispubtype
+	/* NULLTYPE */
+	{
+		DW_TAG_unspecified_type,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+		},
+	},
+
+	/* BASETYPE */
+	{
+		DW_TAG_base_type,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_encoding, DW_FORM_data1},
+			{DW_AT_byte_size, DW_FORM_data1},
+			{DW_AT_go_kind, DW_FORM_data1},
+			{DW_AT_go_runtime_type, DW_FORM_addr},
+		},
+	},
+
+	/* ARRAYTYPE */
+	// child is subrange with upper bound
+	{
+		DW_TAG_array_type,
+		DW_CHILDREN_yes,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_type, DW_FORM_ref_addr},
+			{DW_AT_byte_size, DW_FORM_udata},
+			{DW_AT_go_kind, DW_FORM_data1},
+			{DW_AT_go_runtime_type, DW_FORM_addr},
+		},
+	},
+
+	/* CHANTYPE */
+	{
+		DW_TAG_typedef,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_type, DW_FORM_ref_addr},
+			{DW_AT_go_kind, DW_FORM_data1},
+			{DW_AT_go_runtime_type, DW_FORM_addr},
+			{DW_AT_go_elem, DW_FORM_ref_addr},
+		},
+	},
+
+	/* FUNCTYPE */
+	{
+		DW_TAG_subroutine_type,
+		DW_CHILDREN_yes,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_byte_size, DW_FORM_udata},
+			{DW_AT_go_kind, DW_FORM_data1},
+			{DW_AT_go_runtime_type, DW_FORM_addr},
+		},
+	},
+
+	/* IFACETYPE */
+	{
+		DW_TAG_typedef,
+		DW_CHILDREN_yes,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_type, DW_FORM_ref_addr},
+			{DW_AT_go_kind, DW_FORM_data1},
+			{DW_AT_go_runtime_type, DW_FORM_addr},
+		},
+	},
+
+	/* MAPTYPE */
+	{
+		DW_TAG_typedef,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_type, DW_FORM_ref_addr},
+			{DW_AT_go_kind, DW_FORM_data1},
+			{DW_AT_go_runtime_type, DW_FORM_addr},
+			{DW_AT_go_key, DW_FORM_ref_addr},
+			{DW_AT_go_elem, DW_FORM_ref_addr},
+		},
+	},
+
+	/* PTRTYPE */
+	{
+		DW_TAG_pointer_type,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_type, DW_FORM_ref_addr},
+			{DW_AT_go_kind, DW_FORM_data1},
+			{DW_AT_go_runtime_type, DW_FORM_addr},
+		},
+	},
+
+	/* BARE_PTRTYPE */
+	{
+		DW_TAG_pointer_type,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+		},
+	},
+
+	/* SLICETYPE */
+	{
+		DW_TAG_structure_type,
+		DW_CHILDREN_yes,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_byte_size, DW_FORM_udata},
+			{DW_AT_go_kind, DW_FORM_data1},
+			{DW_AT_go_runtime_type, DW_FORM_addr},
+			{DW_AT_go_elem, DW_FORM_ref_addr},
+		},
+	},
+
+	/* STRINGTYPE */
+	{
+		DW_TAG_structure_type,
+		DW_CHILDREN_yes,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_byte_size, DW_FORM_udata},
+			{DW_AT_go_kind, DW_FORM_data1},
+			{DW_AT_go_runtime_type, DW_FORM_addr},
+		},
+	},
+
+	/* STRUCTTYPE */
+	{
+		DW_TAG_structure_type,
+		DW_CHILDREN_yes,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_byte_size, DW_FORM_udata},
+			{DW_AT_go_kind, DW_FORM_data1},
+			{DW_AT_go_runtime_type, DW_FORM_addr},
+		},
+	},
+
+	/* TYPEDECL */
+	{
+		DW_TAG_typedef,
+		DW_CHILDREN_no,
+		[]dwAttrForm{
+			{DW_AT_name, DW_FORM_string},
+			{DW_AT_type, DW_FORM_ref_addr},
+		},
+	},
+}
+
+// GetAbbrev returns the contents of the .debug_abbrev section.
+func GetAbbrev() []byte {
+	abbrevs := Abbrevs()
+	var buf []byte
+	for i := 1; i < DW_NABRV; i++ {
+		// See section 7.5.3
+		buf = AppendUleb128(buf, uint64(i))
+		buf = AppendUleb128(buf, uint64(abbrevs[i].tag))
+		buf = append(buf, abbrevs[i].children)
+		for _, f := range abbrevs[i].attr {
+			buf = AppendUleb128(buf, uint64(f.attr))
+			buf = AppendUleb128(buf, uint64(f.form))
+		}
+		buf = append(buf, 0, 0)
+	}
+	return append(buf, 0)
+}
+
+/*
+ * Debugging Information Entries and their attributes.
+ */
+
+// DWAttr represents an attribute of a DWDie.
+//
+// For DW_CLS_string and _block, value should contain the length, and
+// data the data, for _reference, value is 0 and data is a DWDie* to
+// the referenced instance, for all others, value is the whole thing
+// and data is null.
+type DWAttr struct {
+	Link  *DWAttr
+	Atr   uint16 // DW_AT_
+	Cls   uint8  // DW_CLS_
+	Value int64
+	Data  interface{}
+}
+
+// DWDie represents a DWARF debug info entry.
+type DWDie struct {
+	Abbrev int
+	Link   *DWDie
+	Child  *DWDie
+	Attr   *DWAttr
+	Sym    Sym
+}
+
+func putattr(ctxt Context, s Sym, abbrev int, form int, cls int, value int64, data interface{}) error {
+	switch form {
+	case DW_FORM_addr: // address
+		// Allow nil addresses for DW_AT_go_runtime_type.
+		if data == nil && value == 0 {
+			ctxt.AddInt(s, ctxt.PtrSize(), 0)
+			break
+		}
+		if cls == DW_CLS_GO_TYPEREF {
+			ctxt.AddSectionOffset(s, ctxt.PtrSize(), data, value)
+			break
+		}
+		ctxt.AddAddress(s, data, value)
+
+	case DW_FORM_block1: // block
+		if cls == DW_CLS_ADDRESS {
+			ctxt.AddInt(s, 1, int64(1+ctxt.PtrSize()))
+			ctxt.AddInt(s, 1, DW_OP_addr)
+			ctxt.AddAddress(s, data, 0)
+			break
+		}
+
+		value &= 0xff
+		ctxt.AddInt(s, 1, value)
+		p := data.([]byte)[:value]
+		ctxt.AddBytes(s, p)
+
+	case DW_FORM_block2: // block
+		value &= 0xffff
+
+		ctxt.AddInt(s, 2, value)
+		p := data.([]byte)[:value]
+		ctxt.AddBytes(s, p)
+
+	case DW_FORM_block4: // block
+		value &= 0xffffffff
+
+		ctxt.AddInt(s, 4, value)
+		p := data.([]byte)[:value]
+		ctxt.AddBytes(s, p)
+
+	case DW_FORM_block: // block
+		Uleb128put(ctxt, s, value)
+
+		p := data.([]byte)[:value]
+		ctxt.AddBytes(s, p)
+
+	case DW_FORM_data1: // constant
+		ctxt.AddInt(s, 1, value)
+
+	case DW_FORM_data2: // constant
+		ctxt.AddInt(s, 2, value)
+
+	case DW_FORM_data4: // constant, {line,loclist,mac,rangelist}ptr
+		if cls == DW_CLS_PTR { // DW_AT_stmt_list and DW_AT_ranges
+			ctxt.AddDWARFAddrSectionOffset(s, data, value)
+			break
+		}
+		ctxt.AddInt(s, 4, value)
+
+	case DW_FORM_data8: // constant, {line,loclist,mac,rangelist}ptr
+		ctxt.AddInt(s, 8, value)
+
+	case DW_FORM_sdata: // constant
+		Sleb128put(ctxt, s, value)
+
+	case DW_FORM_udata: // constant
+		Uleb128put(ctxt, s, value)
+
+	case DW_FORM_string: // string
+		str := data.(string)
+		ctxt.AddString(s, str)
+		// TODO(ribrdb): verify padded strings are never used and remove this
+		for i := int64(len(str)); i < value; i++ {
+			ctxt.AddInt(s, 1, 0)
+		}
+
+	case DW_FORM_flag: // flag
+		if value != 0 {
+			ctxt.AddInt(s, 1, 1)
+		} else {
+			ctxt.AddInt(s, 1, 0)
+		}
+
+	// As of DWARF 3 the ref_addr is always 32 bits, unless emitting a large
+	// (> 4 GB of debug info aka "64-bit") unit, which we don't implement.
+	case DW_FORM_ref_addr: // reference to a DIE in the .info section
+		fallthrough
+	case DW_FORM_sec_offset: // offset into a DWARF section other than .info
+		if data == nil {
+			return fmt.Errorf("dwarf: null reference in %d", abbrev)
+		}
+		ctxt.AddDWARFAddrSectionOffset(s, data, value)
+
+	case DW_FORM_ref1, // reference within the compilation unit
+		DW_FORM_ref2,      // reference
+		DW_FORM_ref4,      // reference
+		DW_FORM_ref8,      // reference
+		DW_FORM_ref_udata, // reference
+
+		DW_FORM_strp,     // string
+		DW_FORM_indirect: // (see Section 7.5.3)
+		fallthrough
+	default:
+		return fmt.Errorf("dwarf: unsupported attribute form %d / class %d", form, cls)
+	}
+	return nil
+}
+
+// PutAttrs writes the attributes for a DIE to symbol 's'.
+//
+// Note that we can (and do) add arbitrary attributes to a DIE, but
+// only the ones actually listed in the Abbrev will be written out.
+func PutAttrs(ctxt Context, s Sym, abbrev int, attr *DWAttr) {
+	abbrevs := Abbrevs()
+Outer:
+	for _, f := range abbrevs[abbrev].attr {
+		for ap := attr; ap != nil; ap = ap.Link {
+			if ap.Atr == f.attr {
+				putattr(ctxt, s, abbrev, int(f.form), int(ap.Cls), ap.Value, ap.Data)
+				continue Outer
+			}
+		}
+
+		putattr(ctxt, s, abbrev, int(f.form), 0, 0, nil)
+	}
+}
+
+// HasChildren reports whether 'die' uses an abbrev that supports children.
+func HasChildren(die *DWDie) bool {
+	abbrevs := Abbrevs()
+	return abbrevs[die.Abbrev].children != 0
+}
+
+// PutIntConst writes a DIE for an integer constant
+func PutIntConst(ctxt Context, info, typ Sym, name string, val int64) {
+	Uleb128put(ctxt, info, DW_ABRV_INT_CONSTANT)
+	putattr(ctxt, info, DW_ABRV_INT_CONSTANT, DW_FORM_string, DW_CLS_STRING, int64(len(name)), name)
+	putattr(ctxt, info, DW_ABRV_INT_CONSTANT, DW_FORM_ref_addr, DW_CLS_REFERENCE, 0, typ)
+	putattr(ctxt, info, DW_ABRV_INT_CONSTANT, DW_FORM_sdata, DW_CLS_CONSTANT, val, nil)
+}
+
+// PutBasedRanges writes a range table to sym. All addresses in ranges are
+// relative to some base address, which must be arranged by the caller
+// (e.g., with a DW_AT_low_pc attribute, or in a BASE-prefixed range).
+func PutBasedRanges(ctxt Context, sym Sym, ranges []Range) {
+	ps := ctxt.PtrSize()
+	// Write ranges.
+	for _, r := range ranges {
+		ctxt.AddInt(sym, ps, r.Start)
+		ctxt.AddInt(sym, ps, r.End)
+	}
+	// Write trailer.
+	ctxt.AddInt(sym, ps, 0)
+	ctxt.AddInt(sym, ps, 0)
+}
+
+// PutRanges writes a range table to s.Ranges.
+// All addresses in ranges are relative to s.base.
+func (s *FnState) PutRanges(ctxt Context, ranges []Range) {
+	ps := ctxt.PtrSize()
+	sym, base := s.Ranges, s.StartPC
+
+	if s.UseBASEntries {
+		// Using a Base Address Selection Entry reduces the number of relocations, but
+		// this is not done on macOS because it is not supported by dsymutil/dwarfdump/lldb
+		ctxt.AddInt(sym, ps, -1)
+		ctxt.AddAddress(sym, base, 0)
+		PutBasedRanges(ctxt, sym, ranges)
+		return
+	}
+
+	// Write ranges full of relocations
+	for _, r := range ranges {
+		ctxt.AddCURelativeAddress(sym, base, r.Start)
+		ctxt.AddCURelativeAddress(sym, base, r.End)
+	}
+	// Write trailer.
+	ctxt.AddInt(sym, ps, 0)
+	ctxt.AddInt(sym, ps, 0)
+}
+
+// Return TRUE if the inlined call in the specified slot is empty,
+// meaning it has a zero-length range (no instructions), and all
+// of its children are empty.
+func isEmptyInlinedCall(slot int, calls *InlCalls) bool {
+	ic := &calls.Calls[slot]
+	if ic.InlIndex == -2 {
+		return true
+	}
+	live := false
+	for _, k := range ic.Children {
+		if !isEmptyInlinedCall(k, calls) {
+			live = true
+		}
+	}
+	if len(ic.Ranges) > 0 {
+		live = true
+	}
+	if !live {
+		ic.InlIndex = -2
+	}
+	return !live
+}
+
+// Slot -1:    return top-level inlines
+// Slot >= 0:  return children of that slot
+func inlChildren(slot int, calls *InlCalls) []int {
+	var kids []int
+	if slot != -1 {
+		for _, k := range calls.Calls[slot].Children {
+			if !isEmptyInlinedCall(k, calls) {
+				kids = append(kids, k)
+			}
+		}
+	} else {
+		for k := 0; k < len(calls.Calls); k += 1 {
+			if calls.Calls[k].Root && !isEmptyInlinedCall(k, calls) {
+				kids = append(kids, k)
+			}
+		}
+	}
+	return kids
+}
+
+func inlinedVarTable(inlcalls *InlCalls) map[*Var]bool {
+	vars := make(map[*Var]bool)
+	for _, ic := range inlcalls.Calls {
+		for _, v := range ic.InlVars {
+			vars[v] = true
+		}
+	}
+	return vars
+}
+
+// The s.Scopes slice contains variables were originally part of the
+// function being emitted, as well as variables that were imported
+// from various callee functions during the inlining process. This
+// function prunes out any variables from the latter category (since
+// they will be emitted as part of DWARF inlined_subroutine DIEs) and
+// then generates scopes for vars in the former category.
+func putPrunedScopes(ctxt Context, s *FnState, fnabbrev int) error {
+	if len(s.Scopes) == 0 {
+		return nil
+	}
+	scopes := make([]Scope, len(s.Scopes), len(s.Scopes))
+	pvars := inlinedVarTable(&s.InlCalls)
+	for k, s := range s.Scopes {
+		var pruned Scope = Scope{Parent: s.Parent, Ranges: s.Ranges}
+		for i := 0; i < len(s.Vars); i++ {
+			_, found := pvars[s.Vars[i]]
+			if !found {
+				pruned.Vars = append(pruned.Vars, s.Vars[i])
+			}
+		}
+		sort.Sort(byChildIndex(pruned.Vars))
+		scopes[k] = pruned
+	}
+	var encbuf [20]byte
+	if putscope(ctxt, s, scopes, 0, fnabbrev, encbuf[:0]) < int32(len(scopes)) {
+		return errors.New("multiple toplevel scopes")
+	}
+	return nil
+}
+
+// Emit DWARF attributes and child DIEs for an 'abstract' subprogram.
+// The abstract subprogram DIE for a function contains its
+// location-independent attributes (name, type, etc). Other instances
+// of the function (any inlined copy of it, or the single out-of-line
+// 'concrete' instance) will contain a pointer back to this abstract
+// DIE (as a space-saving measure, so that name/type etc doesn't have
+// to be repeated for each inlined copy).
+func PutAbstractFunc(ctxt Context, s *FnState) error {
+
+	if logDwarf {
+		ctxt.Logf("PutAbstractFunc(%v)\n", s.Absfn)
+	}
+
+	abbrev := DW_ABRV_FUNCTION_ABSTRACT
+	Uleb128put(ctxt, s.Absfn, int64(abbrev))
+
+	fullname := s.Name
+	if strings.HasPrefix(s.Name, "\"\".") {
+		// Generate a fully qualified name for the function in the
+		// abstract case. This is so as to avoid the need for the
+		// linker to process the DIE with patchDWARFName(); we can't
+		// allow the name attribute of an abstract subprogram DIE to
+		// be rewritten, since it would change the offsets of the
+		// child DIEs (which we're relying on in order for abstract
+		// origin references to work).
+		fullname = objabi.PathToPrefix(s.Importpath) + "." + s.Name[3:]
+	}
+	putattr(ctxt, s.Absfn, abbrev, DW_FORM_string, DW_CLS_STRING, int64(len(fullname)), fullname)
+
+	// DW_AT_inlined value
+	putattr(ctxt, s.Absfn, abbrev, DW_FORM_data1, DW_CLS_CONSTANT, int64(DW_INL_inlined), nil)
+
+	var ev int64
+	if s.External {
+		ev = 1
+	}
+	putattr(ctxt, s.Absfn, abbrev, DW_FORM_flag, DW_CLS_FLAG, ev, 0)
+
+	// Child variables (may be empty)
+	var flattened []*Var
+
+	// This slice will hold the offset in bytes for each child var DIE
+	// with respect to the start of the parent subprogram DIE.
+	var offsets []int32
+
+	// Scopes/vars
+	if len(s.Scopes) > 0 {
+		// For abstract subprogram DIEs we want to flatten out scope info:
+		// lexical scope DIEs contain range and/or hi/lo PC attributes,
+		// which we explicitly don't want for the abstract subprogram DIE.
+		pvars := inlinedVarTable(&s.InlCalls)
+		for _, scope := range s.Scopes {
+			for i := 0; i < len(scope.Vars); i++ {
+				_, found := pvars[scope.Vars[i]]
+				if found || !scope.Vars[i].IsInAbstract {
+					continue
+				}
+				flattened = append(flattened, scope.Vars[i])
+			}
+		}
+		if len(flattened) > 0 {
+			sort.Sort(byChildIndex(flattened))
+
+			if logDwarf {
+				ctxt.Logf("putAbstractScope(%v): vars:", s.Info)
+				for i, v := range flattened {
+					ctxt.Logf(" %d:%s", i, v.Name)
+				}
+				ctxt.Logf("\n")
+			}
+
+			// This slice will hold the offset in bytes for each child
+			// variable DIE with respect to the start of the parent
+			// subprogram DIE.
+			for _, v := range flattened {
+				offsets = append(offsets, int32(ctxt.CurrentOffset(s.Absfn)))
+				putAbstractVar(ctxt, s.Absfn, v)
+			}
+		}
+	}
+	ctxt.RecordChildDieOffsets(s.Absfn, flattened, offsets)
+
+	Uleb128put(ctxt, s.Absfn, 0)
+	return nil
+}
+
+// Emit DWARF attributes and child DIEs for an inlined subroutine. The
+// first attribute of an inlined subroutine DIE is a reference back to
+// its corresponding 'abstract' DIE (containing location-independent
+// attributes such as name, type, etc). Inlined subroutine DIEs can
+// have other inlined subroutine DIEs as children.
+func PutInlinedFunc(ctxt Context, s *FnState, callersym Sym, callIdx int) error {
+	ic := s.InlCalls.Calls[callIdx]
+	callee := ic.AbsFunSym
+
+	abbrev := DW_ABRV_INLINED_SUBROUTINE_RANGES
+	if len(ic.Ranges) == 1 {
+		abbrev = DW_ABRV_INLINED_SUBROUTINE
+	}
+	Uleb128put(ctxt, s.Info, int64(abbrev))
+
+	if logDwarf {
+		ctxt.Logf("PutInlinedFunc(caller=%v,callee=%v,abbrev=%d)\n", callersym, callee, abbrev)
+	}
+
+	// Abstract origin.
+	putattr(ctxt, s.Info, abbrev, DW_FORM_ref_addr, DW_CLS_REFERENCE, 0, callee)
+
+	if abbrev == DW_ABRV_INLINED_SUBROUTINE_RANGES {
+		putattr(ctxt, s.Info, abbrev, DW_FORM_sec_offset, DW_CLS_PTR, s.Ranges.Length(ctxt), s.Ranges)
+		s.PutRanges(ctxt, ic.Ranges)
+	} else {
+		st := ic.Ranges[0].Start
+		en := ic.Ranges[0].End
+		putattr(ctxt, s.Info, abbrev, DW_FORM_addr, DW_CLS_ADDRESS, st, s.StartPC)
+		putattr(ctxt, s.Info, abbrev, DW_FORM_addr, DW_CLS_ADDRESS, en, s.StartPC)
+	}
+
+	// Emit call file, line attrs.
+	ctxt.AddFileRef(s.Info, ic.CallFile)
+	form := int(expandPseudoForm(DW_FORM_udata_pseudo))
+	putattr(ctxt, s.Info, abbrev, form, DW_CLS_CONSTANT, int64(ic.CallLine), nil)
+
+	// Variables associated with this inlined routine instance.
+	vars := ic.InlVars
+	sort.Sort(byChildIndex(vars))
+	inlIndex := ic.InlIndex
+	var encbuf [20]byte
+	for _, v := range vars {
+		if !v.IsInAbstract {
+			continue
+		}
+		putvar(ctxt, s, v, callee, abbrev, inlIndex, encbuf[:0])
+	}
+
+	// Children of this inline.
+	for _, sib := range inlChildren(callIdx, &s.InlCalls) {
+		absfn := s.InlCalls.Calls[sib].AbsFunSym
+		err := PutInlinedFunc(ctxt, s, absfn, sib)
+		if err != nil {
+			return err
+		}
+	}
+
+	Uleb128put(ctxt, s.Info, 0)
+	return nil
+}
+
+// Emit DWARF attributes and child DIEs for a 'concrete' subprogram,
+// meaning the out-of-line copy of a function that was inlined at some
+// point during the compilation of its containing package. The first
+// attribute for a concrete DIE is a reference to the 'abstract' DIE
+// for the function (which holds location-independent attributes such
+// as name, type), then the remainder of the attributes are specific
+// to this instance (location, frame base, etc).
+func PutConcreteFunc(ctxt Context, s *FnState) error {
+	if logDwarf {
+		ctxt.Logf("PutConcreteFunc(%v)\n", s.Info)
+	}
+	abbrev := DW_ABRV_FUNCTION_CONCRETE
+	Uleb128put(ctxt, s.Info, int64(abbrev))
+
+	// Abstract origin.
+	putattr(ctxt, s.Info, abbrev, DW_FORM_ref_addr, DW_CLS_REFERENCE, 0, s.Absfn)
+
+	// Start/end PC.
+	putattr(ctxt, s.Info, abbrev, DW_FORM_addr, DW_CLS_ADDRESS, 0, s.StartPC)
+	putattr(ctxt, s.Info, abbrev, DW_FORM_addr, DW_CLS_ADDRESS, s.Size, s.StartPC)
+
+	// cfa / frame base
+	putattr(ctxt, s.Info, abbrev, DW_FORM_block1, DW_CLS_BLOCK, 1, []byte{DW_OP_call_frame_cfa})
+
+	// Scopes
+	if err := putPrunedScopes(ctxt, s, abbrev); err != nil {
+		return err
+	}
+
+	// Inlined subroutines.
+	for _, sib := range inlChildren(-1, &s.InlCalls) {
+		absfn := s.InlCalls.Calls[sib].AbsFunSym
+		err := PutInlinedFunc(ctxt, s, absfn, sib)
+		if err != nil {
+			return err
+		}
+	}
+
+	Uleb128put(ctxt, s.Info, 0)
+	return nil
+}
+
+// Emit DWARF attributes and child DIEs for a subprogram. Here
+// 'default' implies that the function in question was not inlined
+// when its containing package was compiled (hence there is no need to
+// emit an abstract version for it to use as a base for inlined
+// routine records).
+func PutDefaultFunc(ctxt Context, s *FnState) error {
+	if logDwarf {
+		ctxt.Logf("PutDefaultFunc(%v)\n", s.Info)
+	}
+	abbrev := DW_ABRV_FUNCTION
+	Uleb128put(ctxt, s.Info, int64(abbrev))
+
+	// Expand '"".' to import path.
+	name := s.Name
+	if s.Importpath != "" {
+		name = strings.Replace(name, "\"\".", objabi.PathToPrefix(s.Importpath)+".", -1)
+	}
+
+	putattr(ctxt, s.Info, DW_ABRV_FUNCTION, DW_FORM_string, DW_CLS_STRING, int64(len(name)), name)
+	putattr(ctxt, s.Info, abbrev, DW_FORM_addr, DW_CLS_ADDRESS, 0, s.StartPC)
+	putattr(ctxt, s.Info, abbrev, DW_FORM_addr, DW_CLS_ADDRESS, s.Size, s.StartPC)
+	putattr(ctxt, s.Info, abbrev, DW_FORM_block1, DW_CLS_BLOCK, 1, []byte{DW_OP_call_frame_cfa})
+	ctxt.AddFileRef(s.Info, s.Filesym)
+
+	var ev int64
+	if s.External {
+		ev = 1
+	}
+	putattr(ctxt, s.Info, abbrev, DW_FORM_flag, DW_CLS_FLAG, ev, 0)
+
+	// Scopes
+	if err := putPrunedScopes(ctxt, s, abbrev); err != nil {
+		return err
+	}
+
+	// Inlined subroutines.
+	for _, sib := range inlChildren(-1, &s.InlCalls) {
+		absfn := s.InlCalls.Calls[sib].AbsFunSym
+		err := PutInlinedFunc(ctxt, s, absfn, sib)
+		if err != nil {
+			return err
+		}
+	}
+
+	Uleb128put(ctxt, s.Info, 0)
+	return nil
+}
+
+func putscope(ctxt Context, s *FnState, scopes []Scope, curscope int32, fnabbrev int, encbuf []byte) int32 {
+
+	if logDwarf {
+		ctxt.Logf("putscope(%v,%d): vars:", s.Info, curscope)
+		for i, v := range scopes[curscope].Vars {
+			ctxt.Logf(" %d:%d:%s", i, v.ChildIndex, v.Name)
+		}
+		ctxt.Logf("\n")
+	}
+
+	for _, v := range scopes[curscope].Vars {
+		putvar(ctxt, s, v, s.Absfn, fnabbrev, -1, encbuf)
+	}
+	this := curscope
+	curscope++
+	for curscope < int32(len(scopes)) {
+		scope := scopes[curscope]
+		if scope.Parent != this {
+			return curscope
+		}
+
+		if len(scopes[curscope].Vars) == 0 {
+			curscope = putscope(ctxt, s, scopes, curscope, fnabbrev, encbuf)
+			continue
+		}
+
+		if len(scope.Ranges) == 1 {
+			Uleb128put(ctxt, s.Info, DW_ABRV_LEXICAL_BLOCK_SIMPLE)
+			putattr(ctxt, s.Info, DW_ABRV_LEXICAL_BLOCK_SIMPLE, DW_FORM_addr, DW_CLS_ADDRESS, scope.Ranges[0].Start, s.StartPC)
+			putattr(ctxt, s.Info, DW_ABRV_LEXICAL_BLOCK_SIMPLE, DW_FORM_addr, DW_CLS_ADDRESS, scope.Ranges[0].End, s.StartPC)
+		} else {
+			Uleb128put(ctxt, s.Info, DW_ABRV_LEXICAL_BLOCK_RANGES)
+			putattr(ctxt, s.Info, DW_ABRV_LEXICAL_BLOCK_RANGES, DW_FORM_sec_offset, DW_CLS_PTR, s.Ranges.Length(ctxt), s.Ranges)
+
+			s.PutRanges(ctxt, scope.Ranges)
+		}
+
+		curscope = putscope(ctxt, s, scopes, curscope, fnabbrev, encbuf)
+
+		Uleb128put(ctxt, s.Info, 0)
+	}
+	return curscope
+}
+
+// Given a default var abbrev code, select corresponding concrete code.
+func concreteVarAbbrev(varAbbrev int) int {
+	switch varAbbrev {
+	case DW_ABRV_AUTO:
+		return DW_ABRV_AUTO_CONCRETE
+	case DW_ABRV_PARAM:
+		return DW_ABRV_PARAM_CONCRETE
+	case DW_ABRV_AUTO_LOCLIST:
+		return DW_ABRV_AUTO_CONCRETE_LOCLIST
+	case DW_ABRV_PARAM_LOCLIST:
+		return DW_ABRV_PARAM_CONCRETE_LOCLIST
+	default:
+		panic("should never happen")
+	}
+}
+
+// Pick the correct abbrev code for variable or parameter DIE.
+func determineVarAbbrev(v *Var, fnabbrev int) (int, bool, bool) {
+	abbrev := v.Abbrev
+
+	// If the variable was entirely optimized out, don't emit a location list;
+	// convert to an inline abbreviation and emit an empty location.
+	missing := false
+	switch {
+	case abbrev == DW_ABRV_AUTO_LOCLIST && v.PutLocationList == nil:
+		missing = true
+		abbrev = DW_ABRV_AUTO
+	case abbrev == DW_ABRV_PARAM_LOCLIST && v.PutLocationList == nil:
+		missing = true
+		abbrev = DW_ABRV_PARAM
+	}
+
+	// Determine whether to use a concrete variable or regular variable DIE.
+	concrete := true
+	switch fnabbrev {
+	case DW_ABRV_FUNCTION:
+		concrete = false
+		break
+	case DW_ABRV_FUNCTION_CONCRETE:
+		// If we're emitting a concrete subprogram DIE and the variable
+		// in question is not part of the corresponding abstract function DIE,
+		// then use the default (non-concrete) abbrev for this param.
+		if !v.IsInAbstract {
+			concrete = false
+		}
+	case DW_ABRV_INLINED_SUBROUTINE, DW_ABRV_INLINED_SUBROUTINE_RANGES:
+	default:
+		panic("should never happen")
+	}
+
+	// Select proper abbrev based on concrete/non-concrete
+	if concrete {
+		abbrev = concreteVarAbbrev(abbrev)
+	}
+
+	return abbrev, missing, concrete
+}
+
+func abbrevUsesLoclist(abbrev int) bool {
+	switch abbrev {
+	case DW_ABRV_AUTO_LOCLIST, DW_ABRV_AUTO_CONCRETE_LOCLIST,
+		DW_ABRV_PARAM_LOCLIST, DW_ABRV_PARAM_CONCRETE_LOCLIST:
+		return true
+	default:
+		return false
+	}
+}
+
+// Emit DWARF attributes for a variable belonging to an 'abstract' subprogram.
+func putAbstractVar(ctxt Context, info Sym, v *Var) {
+	// Remap abbrev
+	abbrev := v.Abbrev
+	switch abbrev {
+	case DW_ABRV_AUTO, DW_ABRV_AUTO_LOCLIST:
+		abbrev = DW_ABRV_AUTO_ABSTRACT
+	case DW_ABRV_PARAM, DW_ABRV_PARAM_LOCLIST:
+		abbrev = DW_ABRV_PARAM_ABSTRACT
+	}
+
+	Uleb128put(ctxt, info, int64(abbrev))
+	putattr(ctxt, info, abbrev, DW_FORM_string, DW_CLS_STRING, int64(len(v.Name)), v.Name)
+
+	// Isreturn attribute if this is a param
+	if abbrev == DW_ABRV_PARAM_ABSTRACT {
+		var isReturn int64
+		if v.IsReturnValue {
+			isReturn = 1
+		}
+		putattr(ctxt, info, abbrev, DW_FORM_flag, DW_CLS_FLAG, isReturn, nil)
+	}
+
+	// Line
+	if abbrev != DW_ABRV_PARAM_ABSTRACT {
+		// See issue 23374 for more on why decl line is skipped for abs params.
+		putattr(ctxt, info, abbrev, DW_FORM_udata, DW_CLS_CONSTANT, int64(v.DeclLine), nil)
+	}
+
+	// Type
+	putattr(ctxt, info, abbrev, DW_FORM_ref_addr, DW_CLS_REFERENCE, 0, v.Type)
+
+	// Var has no children => no terminator
+}
+
+func putvar(ctxt Context, s *FnState, v *Var, absfn Sym, fnabbrev, inlIndex int, encbuf []byte) {
+	// Remap abbrev according to parent DIE abbrev
+	abbrev, missing, concrete := determineVarAbbrev(v, fnabbrev)
+
+	Uleb128put(ctxt, s.Info, int64(abbrev))
+
+	// Abstract origin for concrete / inlined case
+	if concrete {
+		// Here we are making a reference to a child DIE of an abstract
+		// function subprogram DIE. The child DIE has no LSym, so instead
+		// after the call to 'putattr' below we make a call to register
+		// the child DIE reference.
+		putattr(ctxt, s.Info, abbrev, DW_FORM_ref_addr, DW_CLS_REFERENCE, 0, absfn)
+		ctxt.RecordDclReference(s.Info, absfn, int(v.ChildIndex), inlIndex)
+	} else {
+		// Var name, line for abstract and default cases
+		n := v.Name
+		putattr(ctxt, s.Info, abbrev, DW_FORM_string, DW_CLS_STRING, int64(len(n)), n)
+		if abbrev == DW_ABRV_PARAM || abbrev == DW_ABRV_PARAM_LOCLIST || abbrev == DW_ABRV_PARAM_ABSTRACT {
+			var isReturn int64
+			if v.IsReturnValue {
+				isReturn = 1
+			}
+			putattr(ctxt, s.Info, abbrev, DW_FORM_flag, DW_CLS_FLAG, isReturn, nil)
+		}
+		putattr(ctxt, s.Info, abbrev, DW_FORM_udata, DW_CLS_CONSTANT, int64(v.DeclLine), nil)
+		putattr(ctxt, s.Info, abbrev, DW_FORM_ref_addr, DW_CLS_REFERENCE, 0, v.Type)
+	}
+
+	if abbrevUsesLoclist(abbrev) {
+		putattr(ctxt, s.Info, abbrev, DW_FORM_sec_offset, DW_CLS_PTR, s.Loc.Length(ctxt), s.Loc)
+		v.PutLocationList(s.Loc, s.StartPC)
+	} else {
+		loc := encbuf[:0]
+		switch {
+		case missing:
+			break // no location
+		case v.StackOffset == 0:
+			loc = append(loc, DW_OP_call_frame_cfa)
+		default:
+			loc = append(loc, DW_OP_fbreg)
+			loc = AppendSleb128(loc, int64(v.StackOffset))
+		}
+		putattr(ctxt, s.Info, abbrev, DW_FORM_block1, DW_CLS_BLOCK, int64(len(loc)), loc)
+	}
+
+	// Var has no children => no terminator
+}
+
+// VarsByOffset attaches the methods of sort.Interface to []*Var,
+// sorting in increasing StackOffset.
+type VarsByOffset []*Var
+
+func (s VarsByOffset) Len() int           { return len(s) }
+func (s VarsByOffset) Less(i, j int) bool { return s[i].StackOffset < s[j].StackOffset }
+func (s VarsByOffset) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+// byChildIndex implements sort.Interface for []*dwarf.Var by child index.
+type byChildIndex []*Var
+
+func (s byChildIndex) Len() int           { return len(s) }
+func (s byChildIndex) Less(i, j int) bool { return s[i].ChildIndex < s[j].ChildIndex }
+func (s byChildIndex) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+// IsDWARFEnabledOnAIX returns true if DWARF is possible on the
+// current extld.
+// AIX ld doesn't support DWARF with -bnoobjreorder with version
+// prior to 7.2.2.
+func IsDWARFEnabledOnAIXLd(extld string) (bool, error) {
+	out, err := exec.Command(extld, "-Wl,-V").CombinedOutput()
+	if err != nil {
+		// The normal output should display ld version and
+		// then fails because ".main" is not defined:
+		// ld: 0711-317 ERROR: Undefined symbol: .main
+		if !bytes.Contains(out, []byte("0711-317")) {
+			return false, fmt.Errorf("%s -Wl,-V failed: %v\n%s", extld, err, out)
+		}
+	}
+	// gcc -Wl,-V output should be:
+	//   /usr/bin/ld: LD X.X.X(date)
+	//   ...
+	out = bytes.TrimPrefix(out, []byte("/usr/bin/ld: LD "))
+	vers := string(bytes.Split(out, []byte("("))[0])
+	subvers := strings.Split(vers, ".")
+	if len(subvers) != 3 {
+		return false, fmt.Errorf("cannot parse %s -Wl,-V (%s): %v\n", extld, out, err)
+	}
+	if v, err := strconv.Atoi(subvers[0]); err != nil || v < 7 {
+		return false, nil
+	} else if v > 7 {
+		return true, nil
+	}
+	if v, err := strconv.Atoi(subvers[1]); err != nil || v < 2 {
+		return false, nil
+	} else if v > 2 {
+		return true, nil
+	}
+	if v, err := strconv.Atoi(subvers[2]); err != nil || v < 2 {
+		return false, nil
+	}
+	return true, nil
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/dwarf/dwarf_defs.go b/vendor/github.com/twitchyliquid64/golang-asm/dwarf/dwarf_defs.go
new file mode 100644
index 000000000..e2716e506
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/dwarf/dwarf_defs.go
@@ -0,0 +1,493 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package dwarf
+
+// Cut, pasted, tr-and-awk'ed from tables in
+// http://dwarfstd.org/doc/Dwarf3.pdf
+
+// Table 18
+const (
+	DW_TAG_array_type               = 0x01
+	DW_TAG_class_type               = 0x02
+	DW_TAG_entry_point              = 0x03
+	DW_TAG_enumeration_type         = 0x04
+	DW_TAG_formal_parameter         = 0x05
+	DW_TAG_imported_declaration     = 0x08
+	DW_TAG_label                    = 0x0a
+	DW_TAG_lexical_block            = 0x0b
+	DW_TAG_member                   = 0x0d
+	DW_TAG_pointer_type             = 0x0f
+	DW_TAG_reference_type           = 0x10
+	DW_TAG_compile_unit             = 0x11
+	DW_TAG_string_type              = 0x12
+	DW_TAG_structure_type           = 0x13
+	DW_TAG_subroutine_type          = 0x15
+	DW_TAG_typedef                  = 0x16
+	DW_TAG_union_type               = 0x17
+	DW_TAG_unspecified_parameters   = 0x18
+	DW_TAG_variant                  = 0x19
+	DW_TAG_common_block             = 0x1a
+	DW_TAG_common_inclusion         = 0x1b
+	DW_TAG_inheritance              = 0x1c
+	DW_TAG_inlined_subroutine       = 0x1d
+	DW_TAG_module                   = 0x1e
+	DW_TAG_ptr_to_member_type       = 0x1f
+	DW_TAG_set_type                 = 0x20
+	DW_TAG_subrange_type            = 0x21
+	DW_TAG_with_stmt                = 0x22
+	DW_TAG_access_declaration       = 0x23
+	DW_TAG_base_type                = 0x24
+	DW_TAG_catch_block              = 0x25
+	DW_TAG_const_type               = 0x26
+	DW_TAG_constant                 = 0x27
+	DW_TAG_enumerator               = 0x28
+	DW_TAG_file_type                = 0x29
+	DW_TAG_friend                   = 0x2a
+	DW_TAG_namelist                 = 0x2b
+	DW_TAG_namelist_item            = 0x2c
+	DW_TAG_packed_type              = 0x2d
+	DW_TAG_subprogram               = 0x2e
+	DW_TAG_template_type_parameter  = 0x2f
+	DW_TAG_template_value_parameter = 0x30
+	DW_TAG_thrown_type              = 0x31
+	DW_TAG_try_block                = 0x32
+	DW_TAG_variant_part             = 0x33
+	DW_TAG_variable                 = 0x34
+	DW_TAG_volatile_type            = 0x35
+	// Dwarf3
+	DW_TAG_dwarf_procedure  = 0x36
+	DW_TAG_restrict_type    = 0x37
+	DW_TAG_interface_type   = 0x38
+	DW_TAG_namespace        = 0x39
+	DW_TAG_imported_module  = 0x3a
+	DW_TAG_unspecified_type = 0x3b
+	DW_TAG_partial_unit     = 0x3c
+	DW_TAG_imported_unit    = 0x3d
+	DW_TAG_condition        = 0x3f
+	DW_TAG_shared_type      = 0x40
+	// Dwarf4
+	DW_TAG_type_unit             = 0x41
+	DW_TAG_rvalue_reference_type = 0x42
+	DW_TAG_template_alias        = 0x43
+
+	// User defined
+	DW_TAG_lo_user = 0x4080
+	DW_TAG_hi_user = 0xffff
+)
+
+// Table 19
+const (
+	DW_CHILDREN_no  = 0x00
+	DW_CHILDREN_yes = 0x01
+)
+
+// Not from the spec, but logically belongs here
+const (
+	DW_CLS_ADDRESS = 0x01 + iota
+	DW_CLS_BLOCK
+	DW_CLS_CONSTANT
+	DW_CLS_FLAG
+	DW_CLS_PTR // lineptr, loclistptr, macptr, rangelistptr
+	DW_CLS_REFERENCE
+	DW_CLS_ADDRLOC
+	DW_CLS_STRING
+
+	// Go-specific internal hackery.
+	DW_CLS_GO_TYPEREF
+)
+
+// Table 20
+const (
+	DW_AT_sibling              = 0x01 // reference
+	DW_AT_location             = 0x02 // block, loclistptr
+	DW_AT_name                 = 0x03 // string
+	DW_AT_ordering             = 0x09 // constant
+	DW_AT_byte_size            = 0x0b // block, constant, reference
+	DW_AT_bit_offset           = 0x0c // block, constant, reference
+	DW_AT_bit_size             = 0x0d // block, constant, reference
+	DW_AT_stmt_list            = 0x10 // lineptr
+	DW_AT_low_pc               = 0x11 // address
+	DW_AT_high_pc              = 0x12 // address
+	DW_AT_language             = 0x13 // constant
+	DW_AT_discr                = 0x15 // reference
+	DW_AT_discr_value          = 0x16 // constant
+	DW_AT_visibility           = 0x17 // constant
+	DW_AT_import               = 0x18 // reference
+	DW_AT_string_length        = 0x19 // block, loclistptr
+	DW_AT_common_reference     = 0x1a // reference
+	DW_AT_comp_dir             = 0x1b // string
+	DW_AT_const_value          = 0x1c // block, constant, string
+	DW_AT_containing_type      = 0x1d // reference
+	DW_AT_default_value        = 0x1e // reference
+	DW_AT_inline               = 0x20 // constant
+	DW_AT_is_optional          = 0x21 // flag
+	DW_AT_lower_bound          = 0x22 // block, constant, reference
+	DW_AT_producer             = 0x25 // string
+	DW_AT_prototyped           = 0x27 // flag
+	DW_AT_return_addr          = 0x2a // block, loclistptr
+	DW_AT_start_scope          = 0x2c // constant
+	DW_AT_bit_stride           = 0x2e // constant
+	DW_AT_upper_bound          = 0x2f // block, constant, reference
+	DW_AT_abstract_origin      = 0x31 // reference
+	DW_AT_accessibility        = 0x32 // constant
+	DW_AT_address_class        = 0x33 // constant
+	DW_AT_artificial           = 0x34 // flag
+	DW_AT_base_types           = 0x35 // reference
+	DW_AT_calling_convention   = 0x36 // constant
+	DW_AT_count                = 0x37 // block, constant, reference
+	DW_AT_data_member_location = 0x38 // block, constant, loclistptr
+	DW_AT_decl_column          = 0x39 // constant
+	DW_AT_decl_file            = 0x3a // constant
+	DW_AT_decl_line            = 0x3b // constant
+	DW_AT_declaration          = 0x3c // flag
+	DW_AT_discr_list           = 0x3d // block
+	DW_AT_encoding             = 0x3e // constant
+	DW_AT_external             = 0x3f // flag
+	DW_AT_frame_base           = 0x40 // block, loclistptr
+	DW_AT_friend               = 0x41 // reference
+	DW_AT_identifier_case      = 0x42 // constant
+	DW_AT_macro_info           = 0x43 // macptr
+	DW_AT_namelist_item        = 0x44 // block
+	DW_AT_priority             = 0x45 // reference
+	DW_AT_segment              = 0x46 // block, loclistptr
+	DW_AT_specification        = 0x47 // reference
+	DW_AT_static_link          = 0x48 // block, loclistptr
+	DW_AT_type                 = 0x49 // reference
+	DW_AT_use_location         = 0x4a // block, loclistptr
+	DW_AT_variable_parameter   = 0x4b // flag
+	DW_AT_virtuality           = 0x4c // constant
+	DW_AT_vtable_elem_location = 0x4d // block, loclistptr
+	// Dwarf3
+	DW_AT_allocated      = 0x4e // block, constant, reference
+	DW_AT_associated     = 0x4f // block, constant, reference
+	DW_AT_data_location  = 0x50 // block
+	DW_AT_byte_stride    = 0x51 // block, constant, reference
+	DW_AT_entry_pc       = 0x52 // address
+	DW_AT_use_UTF8       = 0x53 // flag
+	DW_AT_extension      = 0x54 // reference
+	DW_AT_ranges         = 0x55 // rangelistptr
+	DW_AT_trampoline     = 0x56 // address, flag, reference, string
+	DW_AT_call_column    = 0x57 // constant
+	DW_AT_call_file      = 0x58 // constant
+	DW_AT_call_line      = 0x59 // constant
+	DW_AT_description    = 0x5a // string
+	DW_AT_binary_scale   = 0x5b // constant
+	DW_AT_decimal_scale  = 0x5c // constant
+	DW_AT_small          = 0x5d // reference
+	DW_AT_decimal_sign   = 0x5e // constant
+	DW_AT_digit_count    = 0x5f // constant
+	DW_AT_picture_string = 0x60 // string
+	DW_AT_mutable        = 0x61 // flag
+	DW_AT_threads_scaled = 0x62 // flag
+	DW_AT_explicit       = 0x63 // flag
+	DW_AT_object_pointer = 0x64 // reference
+	DW_AT_endianity      = 0x65 // constant
+	DW_AT_elemental      = 0x66 // flag
+	DW_AT_pure           = 0x67 // flag
+	DW_AT_recursive      = 0x68 // flag
+
+	DW_AT_lo_user = 0x2000 // ---
+	DW_AT_hi_user = 0x3fff // ---
+)
+
+// Table 21
+const (
+	DW_FORM_addr      = 0x01 // address
+	DW_FORM_block2    = 0x03 // block
+	DW_FORM_block4    = 0x04 // block
+	DW_FORM_data2     = 0x05 // constant
+	DW_FORM_data4     = 0x06 // constant, lineptr, loclistptr, macptr, rangelistptr
+	DW_FORM_data8     = 0x07 // constant, lineptr, loclistptr, macptr, rangelistptr
+	DW_FORM_string    = 0x08 // string
+	DW_FORM_block     = 0x09 // block
+	DW_FORM_block1    = 0x0a // block
+	DW_FORM_data1     = 0x0b // constant
+	DW_FORM_flag      = 0x0c // flag
+	DW_FORM_sdata     = 0x0d // constant
+	DW_FORM_strp      = 0x0e // string
+	DW_FORM_udata     = 0x0f // constant
+	DW_FORM_ref_addr  = 0x10 // reference
+	DW_FORM_ref1      = 0x11 // reference
+	DW_FORM_ref2      = 0x12 // reference
+	DW_FORM_ref4      = 0x13 // reference
+	DW_FORM_ref8      = 0x14 // reference
+	DW_FORM_ref_udata = 0x15 // reference
+	DW_FORM_indirect  = 0x16 // (see Section 7.5.3)
+	// Dwarf4
+	DW_FORM_sec_offset   = 0x17 // lineptr, loclistptr, macptr, rangelistptr
+	DW_FORM_exprloc      = 0x18 // exprloc
+	DW_FORM_flag_present = 0x19 // flag
+	DW_FORM_ref_sig8     = 0x20 // reference
+	// Pseudo-form: expanded to data4 on IOS, udata elsewhere.
+	DW_FORM_udata_pseudo = 0x99
+)
+
+// Table 24 (#operands, notes)
+const (
+	DW_OP_addr                = 0x03 // 1 constant address (size target specific)
+	DW_OP_deref               = 0x06 // 0
+	DW_OP_const1u             = 0x08 // 1 1-byte constant
+	DW_OP_const1s             = 0x09 // 1 1-byte constant
+	DW_OP_const2u             = 0x0a // 1 2-byte constant
+	DW_OP_const2s             = 0x0b // 1 2-byte constant
+	DW_OP_const4u             = 0x0c // 1 4-byte constant
+	DW_OP_const4s             = 0x0d // 1 4-byte constant
+	DW_OP_const8u             = 0x0e // 1 8-byte constant
+	DW_OP_const8s             = 0x0f // 1 8-byte constant
+	DW_OP_constu              = 0x10 // 1 ULEB128 constant
+	DW_OP_consts              = 0x11 // 1 SLEB128 constant
+	DW_OP_dup                 = 0x12 // 0
+	DW_OP_drop                = 0x13 // 0
+	DW_OP_over                = 0x14 // 0
+	DW_OP_pick                = 0x15 // 1 1-byte stack index
+	DW_OP_swap                = 0x16 // 0
+	DW_OP_rot                 = 0x17 // 0
+	DW_OP_xderef              = 0x18 // 0
+	DW_OP_abs                 = 0x19 // 0
+	DW_OP_and                 = 0x1a // 0
+	DW_OP_div                 = 0x1b // 0
+	DW_OP_minus               = 0x1c // 0
+	DW_OP_mod                 = 0x1d // 0
+	DW_OP_mul                 = 0x1e // 0
+	DW_OP_neg                 = 0x1f // 0
+	DW_OP_not                 = 0x20 // 0
+	DW_OP_or                  = 0x21 // 0
+	DW_OP_plus                = 0x22 // 0
+	DW_OP_plus_uconst         = 0x23 // 1 ULEB128 addend
+	DW_OP_shl                 = 0x24 // 0
+	DW_OP_shr                 = 0x25 // 0
+	DW_OP_shra                = 0x26 // 0
+	DW_OP_xor                 = 0x27 // 0
+	DW_OP_skip                = 0x2f // 1 signed 2-byte constant
+	DW_OP_bra                 = 0x28 // 1 signed 2-byte constant
+	DW_OP_eq                  = 0x29 // 0
+	DW_OP_ge                  = 0x2a // 0
+	DW_OP_gt                  = 0x2b // 0
+	DW_OP_le                  = 0x2c // 0
+	DW_OP_lt                  = 0x2d // 0
+	DW_OP_ne                  = 0x2e // 0
+	DW_OP_lit0                = 0x30 // 0 ...
+	DW_OP_lit31               = 0x4f // 0 literals 0..31 = (DW_OP_lit0 + literal)
+	DW_OP_reg0                = 0x50 // 0 ..
+	DW_OP_reg31               = 0x6f // 0 reg 0..31 = (DW_OP_reg0 + regnum)
+	DW_OP_breg0               = 0x70 // 1 ...
+	DW_OP_breg31              = 0x8f // 1 SLEB128 offset base register 0..31 = (DW_OP_breg0 + regnum)
+	DW_OP_regx                = 0x90 // 1 ULEB128 register
+	DW_OP_fbreg               = 0x91 // 1 SLEB128 offset
+	DW_OP_bregx               = 0x92 // 2 ULEB128 register followed by SLEB128 offset
+	DW_OP_piece               = 0x93 // 1 ULEB128 size of piece addressed
+	DW_OP_deref_size          = 0x94 // 1 1-byte size of data retrieved
+	DW_OP_xderef_size         = 0x95 // 1 1-byte size of data retrieved
+	DW_OP_nop                 = 0x96 // 0
+	DW_OP_push_object_address = 0x97 // 0
+	DW_OP_call2               = 0x98 // 1 2-byte offset of DIE
+	DW_OP_call4               = 0x99 // 1 4-byte offset of DIE
+	DW_OP_call_ref            = 0x9a // 1 4- or 8-byte offset of DIE
+	DW_OP_form_tls_address    = 0x9b // 0
+	DW_OP_call_frame_cfa      = 0x9c // 0
+	DW_OP_bit_piece           = 0x9d // 2
+	DW_OP_lo_user             = 0xe0
+	DW_OP_hi_user             = 0xff
+)
+
+// Table 25
+const (
+	DW_ATE_address         = 0x01
+	DW_ATE_boolean         = 0x02
+	DW_ATE_complex_float   = 0x03
+	DW_ATE_float           = 0x04
+	DW_ATE_signed          = 0x05
+	DW_ATE_signed_char     = 0x06
+	DW_ATE_unsigned        = 0x07
+	DW_ATE_unsigned_char   = 0x08
+	DW_ATE_imaginary_float = 0x09
+	DW_ATE_packed_decimal  = 0x0a
+	DW_ATE_numeric_string  = 0x0b
+	DW_ATE_edited          = 0x0c
+	DW_ATE_signed_fixed    = 0x0d
+	DW_ATE_unsigned_fixed  = 0x0e
+	DW_ATE_decimal_float   = 0x0f
+	DW_ATE_lo_user         = 0x80
+	DW_ATE_hi_user         = 0xff
+)
+
+// Table 26
+const (
+	DW_DS_unsigned           = 0x01
+	DW_DS_leading_overpunch  = 0x02
+	DW_DS_trailing_overpunch = 0x03
+	DW_DS_leading_separate   = 0x04
+	DW_DS_trailing_separate  = 0x05
+)
+
+// Table 27
+const (
+	DW_END_default = 0x00
+	DW_END_big     = 0x01
+	DW_END_little  = 0x02
+	DW_END_lo_user = 0x40
+	DW_END_hi_user = 0xff
+)
+
+// Table 28
+const (
+	DW_ACCESS_public    = 0x01
+	DW_ACCESS_protected = 0x02
+	DW_ACCESS_private   = 0x03
+)
+
+// Table 29
+const (
+	DW_VIS_local     = 0x01
+	DW_VIS_exported  = 0x02
+	DW_VIS_qualified = 0x03
+)
+
+// Table 30
+const (
+	DW_VIRTUALITY_none         = 0x00
+	DW_VIRTUALITY_virtual      = 0x01
+	DW_VIRTUALITY_pure_virtual = 0x02
+)
+
+// Table 31
+const (
+	DW_LANG_C89         = 0x0001
+	DW_LANG_C           = 0x0002
+	DW_LANG_Ada83       = 0x0003
+	DW_LANG_C_plus_plus = 0x0004
+	DW_LANG_Cobol74     = 0x0005
+	DW_LANG_Cobol85     = 0x0006
+	DW_LANG_Fortran77   = 0x0007
+	DW_LANG_Fortran90   = 0x0008
+	DW_LANG_Pascal83    = 0x0009
+	DW_LANG_Modula2     = 0x000a
+	// Dwarf3
+	DW_LANG_Java           = 0x000b
+	DW_LANG_C99            = 0x000c
+	DW_LANG_Ada95          = 0x000d
+	DW_LANG_Fortran95      = 0x000e
+	DW_LANG_PLI            = 0x000f
+	DW_LANG_ObjC           = 0x0010
+	DW_LANG_ObjC_plus_plus = 0x0011
+	DW_LANG_UPC            = 0x0012
+	DW_LANG_D              = 0x0013
+	// Dwarf4
+	DW_LANG_Python = 0x0014
+	// Dwarf5
+	DW_LANG_Go = 0x0016
+
+	DW_LANG_lo_user = 0x8000
+	DW_LANG_hi_user = 0xffff
+)
+
+// Table 32
+const (
+	DW_ID_case_sensitive   = 0x00
+	DW_ID_up_case          = 0x01
+	DW_ID_down_case        = 0x02
+	DW_ID_case_insensitive = 0x03
+)
+
+// Table 33
+const (
+	DW_CC_normal  = 0x01
+	DW_CC_program = 0x02
+	DW_CC_nocall  = 0x03
+	DW_CC_lo_user = 0x40
+	DW_CC_hi_user = 0xff
+)
+
+// Table 34
+const (
+	DW_INL_not_inlined          = 0x00
+	DW_INL_inlined              = 0x01
+	DW_INL_declared_not_inlined = 0x02
+	DW_INL_declared_inlined     = 0x03
+)
+
+// Table 35
+const (
+	DW_ORD_row_major = 0x00
+	DW_ORD_col_major = 0x01
+)
+
+// Table 36
+const (
+	DW_DSC_label = 0x00
+	DW_DSC_range = 0x01
+)
+
+// Table 37
+const (
+	DW_LNS_copy             = 0x01
+	DW_LNS_advance_pc       = 0x02
+	DW_LNS_advance_line     = 0x03
+	DW_LNS_set_file         = 0x04
+	DW_LNS_set_column       = 0x05
+	DW_LNS_negate_stmt      = 0x06
+	DW_LNS_set_basic_block  = 0x07
+	DW_LNS_const_add_pc     = 0x08
+	DW_LNS_fixed_advance_pc = 0x09
+	// Dwarf3
+	DW_LNS_set_prologue_end   = 0x0a
+	DW_LNS_set_epilogue_begin = 0x0b
+	DW_LNS_set_isa            = 0x0c
+)
+
+// Table 38
+const (
+	DW_LNE_end_sequence = 0x01
+	DW_LNE_set_address  = 0x02
+	DW_LNE_define_file  = 0x03
+	DW_LNE_lo_user      = 0x80
+	DW_LNE_hi_user      = 0xff
+)
+
+// Table 39
+const (
+	DW_MACINFO_define     = 0x01
+	DW_MACINFO_undef      = 0x02
+	DW_MACINFO_start_file = 0x03
+	DW_MACINFO_end_file   = 0x04
+	DW_MACINFO_vendor_ext = 0xff
+)
+
+// Table 40.
+const (
+	// operand,...
+	DW_CFA_nop              = 0x00
+	DW_CFA_set_loc          = 0x01 // address
+	DW_CFA_advance_loc1     = 0x02 // 1-byte delta
+	DW_CFA_advance_loc2     = 0x03 // 2-byte delta
+	DW_CFA_advance_loc4     = 0x04 // 4-byte delta
+	DW_CFA_offset_extended  = 0x05 // ULEB128 register, ULEB128 offset
+	DW_CFA_restore_extended = 0x06 // ULEB128 register
+	DW_CFA_undefined        = 0x07 // ULEB128 register
+	DW_CFA_same_value       = 0x08 // ULEB128 register
+	DW_CFA_register         = 0x09 // ULEB128 register, ULEB128 register
+	DW_CFA_remember_state   = 0x0a
+	DW_CFA_restore_state    = 0x0b
+
+	DW_CFA_def_cfa            = 0x0c // ULEB128 register, ULEB128 offset
+	DW_CFA_def_cfa_register   = 0x0d // ULEB128 register
+	DW_CFA_def_cfa_offset     = 0x0e // ULEB128 offset
+	DW_CFA_def_cfa_expression = 0x0f // BLOCK
+	DW_CFA_expression         = 0x10 // ULEB128 register, BLOCK
+	DW_CFA_offset_extended_sf = 0x11 // ULEB128 register, SLEB128 offset
+	DW_CFA_def_cfa_sf         = 0x12 // ULEB128 register, SLEB128 offset
+	DW_CFA_def_cfa_offset_sf  = 0x13 // SLEB128 offset
+	DW_CFA_val_offset         = 0x14 // ULEB128, ULEB128
+	DW_CFA_val_offset_sf      = 0x15 // ULEB128, SLEB128
+	DW_CFA_val_expression     = 0x16 // ULEB128, BLOCK
+
+	DW_CFA_lo_user = 0x1c
+	DW_CFA_hi_user = 0x3f
+
+	// Opcodes that take an addend operand.
+	DW_CFA_advance_loc = 0x1 << 6 // +delta
+	DW_CFA_offset      = 0x2 << 6 // +register (ULEB128 offset)
+	DW_CFA_restore     = 0x3 << 6 // +register
+)
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/goobj/builtin.go b/vendor/github.com/twitchyliquid64/golang-asm/goobj/builtin.go
new file mode 100644
index 000000000..e7d612aeb
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/goobj/builtin.go
@@ -0,0 +1,45 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package goobj
+
+// Builtin (compiler-generated) function references appear
+// frequently. We assign special indices for them, so they
+// don't need to be referenced by name.
+
+// NBuiltin returns the number of listed builtin
+// symbols.
+func NBuiltin() int {
+	return len(builtins)
+}
+
+// BuiltinName returns the name and ABI of the i-th
+// builtin symbol.
+func BuiltinName(i int) (string, int) {
+	return builtins[i].name, builtins[i].abi
+}
+
+// BuiltinIdx returns the index of the builtin with the
+// given name and abi, or -1 if it is not a builtin.
+func BuiltinIdx(name string, abi int) int {
+	i, ok := builtinMap[name]
+	if !ok {
+		return -1
+	}
+	if builtins[i].abi != abi {
+		return -1
+	}
+	return i
+}
+
+//go:generate go run mkbuiltin.go
+
+var builtinMap map[string]int
+
+func init() {
+	builtinMap = make(map[string]int, len(builtins))
+	for i, b := range builtins {
+		builtinMap[b.name] = i
+	}
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/goobj/builtinlist.go b/vendor/github.com/twitchyliquid64/golang-asm/goobj/builtinlist.go
new file mode 100644
index 000000000..0cca75233
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/goobj/builtinlist.go
@@ -0,0 +1,245 @@
+// Code generated by mkbuiltin.go. DO NOT EDIT.
+
+package goobj
+
+var builtins = [...]struct {
+	name string
+	abi  int
+}{
+	{"runtime.newobject", 1},
+	{"runtime.mallocgc", 1},
+	{"runtime.panicdivide", 1},
+	{"runtime.panicshift", 1},
+	{"runtime.panicmakeslicelen", 1},
+	{"runtime.panicmakeslicecap", 1},
+	{"runtime.throwinit", 1},
+	{"runtime.panicwrap", 1},
+	{"runtime.gopanic", 1},
+	{"runtime.gorecover", 1},
+	{"runtime.goschedguarded", 1},
+	{"runtime.goPanicIndex", 1},
+	{"runtime.goPanicIndexU", 1},
+	{"runtime.goPanicSliceAlen", 1},
+	{"runtime.goPanicSliceAlenU", 1},
+	{"runtime.goPanicSliceAcap", 1},
+	{"runtime.goPanicSliceAcapU", 1},
+	{"runtime.goPanicSliceB", 1},
+	{"runtime.goPanicSliceBU", 1},
+	{"runtime.goPanicSlice3Alen", 1},
+	{"runtime.goPanicSlice3AlenU", 1},
+	{"runtime.goPanicSlice3Acap", 1},
+	{"runtime.goPanicSlice3AcapU", 1},
+	{"runtime.goPanicSlice3B", 1},
+	{"runtime.goPanicSlice3BU", 1},
+	{"runtime.goPanicSlice3C", 1},
+	{"runtime.goPanicSlice3CU", 1},
+	{"runtime.printbool", 1},
+	{"runtime.printfloat", 1},
+	{"runtime.printint", 1},
+	{"runtime.printhex", 1},
+	{"runtime.printuint", 1},
+	{"runtime.printcomplex", 1},
+	{"runtime.printstring", 1},
+	{"runtime.printpointer", 1},
+	{"runtime.printiface", 1},
+	{"runtime.printeface", 1},
+	{"runtime.printslice", 1},
+	{"runtime.printnl", 1},
+	{"runtime.printsp", 1},
+	{"runtime.printlock", 1},
+	{"runtime.printunlock", 1},
+	{"runtime.concatstring2", 1},
+	{"runtime.concatstring3", 1},
+	{"runtime.concatstring4", 1},
+	{"runtime.concatstring5", 1},
+	{"runtime.concatstrings", 1},
+	{"runtime.cmpstring", 1},
+	{"runtime.intstring", 1},
+	{"runtime.slicebytetostring", 1},
+	{"runtime.slicebytetostringtmp", 1},
+	{"runtime.slicerunetostring", 1},
+	{"runtime.stringtoslicebyte", 1},
+	{"runtime.stringtoslicerune", 1},
+	{"runtime.slicecopy", 1},
+	{"runtime.slicestringcopy", 1},
+	{"runtime.decoderune", 1},
+	{"runtime.countrunes", 1},
+	{"runtime.convI2I", 1},
+	{"runtime.convT16", 1},
+	{"runtime.convT32", 1},
+	{"runtime.convT64", 1},
+	{"runtime.convTstring", 1},
+	{"runtime.convTslice", 1},
+	{"runtime.convT2E", 1},
+	{"runtime.convT2Enoptr", 1},
+	{"runtime.convT2I", 1},
+	{"runtime.convT2Inoptr", 1},
+	{"runtime.assertE2I", 1},
+	{"runtime.assertE2I2", 1},
+	{"runtime.assertI2I", 1},
+	{"runtime.assertI2I2", 1},
+	{"runtime.panicdottypeE", 1},
+	{"runtime.panicdottypeI", 1},
+	{"runtime.panicnildottype", 1},
+	{"runtime.ifaceeq", 1},
+	{"runtime.efaceeq", 1},
+	{"runtime.fastrand", 1},
+	{"runtime.makemap64", 1},
+	{"runtime.makemap", 1},
+	{"runtime.makemap_small", 1},
+	{"runtime.mapaccess1", 1},
+	{"runtime.mapaccess1_fast32", 1},
+	{"runtime.mapaccess1_fast64", 1},
+	{"runtime.mapaccess1_faststr", 1},
+	{"runtime.mapaccess1_fat", 1},
+	{"runtime.mapaccess2", 1},
+	{"runtime.mapaccess2_fast32", 1},
+	{"runtime.mapaccess2_fast64", 1},
+	{"runtime.mapaccess2_faststr", 1},
+	{"runtime.mapaccess2_fat", 1},
+	{"runtime.mapassign", 1},
+	{"runtime.mapassign_fast32", 1},
+	{"runtime.mapassign_fast32ptr", 1},
+	{"runtime.mapassign_fast64", 1},
+	{"runtime.mapassign_fast64ptr", 1},
+	{"runtime.mapassign_faststr", 1},
+	{"runtime.mapiterinit", 1},
+	{"runtime.mapdelete", 1},
+	{"runtime.mapdelete_fast32", 1},
+	{"runtime.mapdelete_fast64", 1},
+	{"runtime.mapdelete_faststr", 1},
+	{"runtime.mapiternext", 1},
+	{"runtime.mapclear", 1},
+	{"runtime.makechan64", 1},
+	{"runtime.makechan", 1},
+	{"runtime.chanrecv1", 1},
+	{"runtime.chanrecv2", 1},
+	{"runtime.chansend1", 1},
+	{"runtime.closechan", 1},
+	{"runtime.writeBarrier", 0},
+	{"runtime.typedmemmove", 1},
+	{"runtime.typedmemclr", 1},
+	{"runtime.typedslicecopy", 1},
+	{"runtime.selectnbsend", 1},
+	{"runtime.selectnbrecv", 1},
+	{"runtime.selectnbrecv2", 1},
+	{"runtime.selectsetpc", 1},
+	{"runtime.selectgo", 1},
+	{"runtime.block", 1},
+	{"runtime.makeslice", 1},
+	{"runtime.makeslice64", 1},
+	{"runtime.makeslicecopy", 1},
+	{"runtime.growslice", 1},
+	{"runtime.memmove", 1},
+	{"runtime.memclrNoHeapPointers", 1},
+	{"runtime.memclrHasPointers", 1},
+	{"runtime.memequal", 1},
+	{"runtime.memequal0", 1},
+	{"runtime.memequal8", 1},
+	{"runtime.memequal16", 1},
+	{"runtime.memequal32", 1},
+	{"runtime.memequal64", 1},
+	{"runtime.memequal128", 1},
+	{"runtime.f32equal", 1},
+	{"runtime.f64equal", 1},
+	{"runtime.c64equal", 1},
+	{"runtime.c128equal", 1},
+	{"runtime.strequal", 1},
+	{"runtime.interequal", 1},
+	{"runtime.nilinterequal", 1},
+	{"runtime.memhash", 1},
+	{"runtime.memhash0", 1},
+	{"runtime.memhash8", 1},
+	{"runtime.memhash16", 1},
+	{"runtime.memhash32", 1},
+	{"runtime.memhash64", 1},
+	{"runtime.memhash128", 1},
+	{"runtime.f32hash", 1},
+	{"runtime.f64hash", 1},
+	{"runtime.c64hash", 1},
+	{"runtime.c128hash", 1},
+	{"runtime.strhash", 1},
+	{"runtime.interhash", 1},
+	{"runtime.nilinterhash", 1},
+	{"runtime.int64div", 1},
+	{"runtime.uint64div", 1},
+	{"runtime.int64mod", 1},
+	{"runtime.uint64mod", 1},
+	{"runtime.float64toint64", 1},
+	{"runtime.float64touint64", 1},
+	{"runtime.float64touint32", 1},
+	{"runtime.int64tofloat64", 1},
+	{"runtime.uint64tofloat64", 1},
+	{"runtime.uint32tofloat64", 1},
+	{"runtime.complex128div", 1},
+	{"runtime.racefuncenter", 1},
+	{"runtime.racefuncenterfp", 1},
+	{"runtime.racefuncexit", 1},
+	{"runtime.raceread", 1},
+	{"runtime.racewrite", 1},
+	{"runtime.racereadrange", 1},
+	{"runtime.racewriterange", 1},
+	{"runtime.msanread", 1},
+	{"runtime.msanwrite", 1},
+	{"runtime.checkptrAlignment", 1},
+	{"runtime.checkptrArithmetic", 1},
+	{"runtime.libfuzzerTraceCmp1", 1},
+	{"runtime.libfuzzerTraceCmp2", 1},
+	{"runtime.libfuzzerTraceCmp4", 1},
+	{"runtime.libfuzzerTraceCmp8", 1},
+	{"runtime.libfuzzerTraceConstCmp1", 1},
+	{"runtime.libfuzzerTraceConstCmp2", 1},
+	{"runtime.libfuzzerTraceConstCmp4", 1},
+	{"runtime.libfuzzerTraceConstCmp8", 1},
+	{"runtime.x86HasPOPCNT", 0},
+	{"runtime.x86HasSSE41", 0},
+	{"runtime.x86HasFMA", 0},
+	{"runtime.armHasVFPv4", 0},
+	{"runtime.arm64HasATOMICS", 0},
+	{"runtime.deferproc", 1},
+	{"runtime.deferprocStack", 1},
+	{"runtime.deferreturn", 1},
+	{"runtime.newproc", 1},
+	{"runtime.panicoverflow", 1},
+	{"runtime.sigpanic", 1},
+	{"runtime.gcWriteBarrier", 0},
+	{"runtime.morestack", 0},
+	{"runtime.morestackc", 0},
+	{"runtime.morestack_noctxt", 0},
+	{"type.int8", 0},
+	{"type.*int8", 0},
+	{"type.uint8", 0},
+	{"type.*uint8", 0},
+	{"type.int16", 0},
+	{"type.*int16", 0},
+	{"type.uint16", 0},
+	{"type.*uint16", 0},
+	{"type.int32", 0},
+	{"type.*int32", 0},
+	{"type.uint32", 0},
+	{"type.*uint32", 0},
+	{"type.int64", 0},
+	{"type.*int64", 0},
+	{"type.uint64", 0},
+	{"type.*uint64", 0},
+	{"type.float32", 0},
+	{"type.*float32", 0},
+	{"type.float64", 0},
+	{"type.*float64", 0},
+	{"type.complex64", 0},
+	{"type.*complex64", 0},
+	{"type.complex128", 0},
+	{"type.*complex128", 0},
+	{"type.unsafe.Pointer", 0},
+	{"type.*unsafe.Pointer", 0},
+	{"type.uintptr", 0},
+	{"type.*uintptr", 0},
+	{"type.bool", 0},
+	{"type.*bool", 0},
+	{"type.string", 0},
+	{"type.*string", 0},
+	{"type.error", 0},
+	{"type.*error", 0},
+	{"type.func(error) string", 0},
+	{"type.*func(error) string", 0},
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/goobj/funcinfo.go b/vendor/github.com/twitchyliquid64/golang-asm/goobj/funcinfo.go
new file mode 100644
index 000000000..9e192330d
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/goobj/funcinfo.go
@@ -0,0 +1,233 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package goobj
+
+import (
+	"bytes"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"encoding/binary"
+)
+
+// CUFileIndex is used to index the filenames that are stored in the
+// per-package/per-CU FileList.
+type CUFileIndex uint32
+
+// FuncInfo is serialized as a symbol (aux symbol). The symbol data is
+// the binary encoding of the struct below.
+//
+// TODO: make each pcdata a separate symbol?
+type FuncInfo struct {
+	Args   uint32
+	Locals uint32
+	FuncID objabi.FuncID
+
+	Pcsp        uint32
+	Pcfile      uint32
+	Pcline      uint32
+	Pcinline    uint32
+	Pcdata      []uint32
+	PcdataEnd   uint32
+	Funcdataoff []uint32
+	File        []CUFileIndex
+
+	InlTree []InlTreeNode
+}
+
+func (a *FuncInfo) Write(w *bytes.Buffer) {
+	var b [4]byte
+	writeUint32 := func(x uint32) {
+		binary.LittleEndian.PutUint32(b[:], x)
+		w.Write(b[:])
+	}
+
+	writeUint32(a.Args)
+	writeUint32(a.Locals)
+	writeUint32(uint32(a.FuncID))
+
+	writeUint32(a.Pcsp)
+	writeUint32(a.Pcfile)
+	writeUint32(a.Pcline)
+	writeUint32(a.Pcinline)
+	writeUint32(uint32(len(a.Pcdata)))
+	for _, x := range a.Pcdata {
+		writeUint32(x)
+	}
+	writeUint32(a.PcdataEnd)
+	writeUint32(uint32(len(a.Funcdataoff)))
+	for _, x := range a.Funcdataoff {
+		writeUint32(x)
+	}
+	writeUint32(uint32(len(a.File)))
+	for _, f := range a.File {
+		writeUint32(uint32(f))
+	}
+	writeUint32(uint32(len(a.InlTree)))
+	for i := range a.InlTree {
+		a.InlTree[i].Write(w)
+	}
+}
+
+func (a *FuncInfo) Read(b []byte) {
+	readUint32 := func() uint32 {
+		x := binary.LittleEndian.Uint32(b)
+		b = b[4:]
+		return x
+	}
+
+	a.Args = readUint32()
+	a.Locals = readUint32()
+	a.FuncID = objabi.FuncID(readUint32())
+
+	a.Pcsp = readUint32()
+	a.Pcfile = readUint32()
+	a.Pcline = readUint32()
+	a.Pcinline = readUint32()
+	pcdatalen := readUint32()
+	a.Pcdata = make([]uint32, pcdatalen)
+	for i := range a.Pcdata {
+		a.Pcdata[i] = readUint32()
+	}
+	a.PcdataEnd = readUint32()
+	funcdataofflen := readUint32()
+	a.Funcdataoff = make([]uint32, funcdataofflen)
+	for i := range a.Funcdataoff {
+		a.Funcdataoff[i] = readUint32()
+	}
+	filelen := readUint32()
+	a.File = make([]CUFileIndex, filelen)
+	for i := range a.File {
+		a.File[i] = CUFileIndex(readUint32())
+	}
+	inltreelen := readUint32()
+	a.InlTree = make([]InlTreeNode, inltreelen)
+	for i := range a.InlTree {
+		b = a.InlTree[i].Read(b)
+	}
+}
+
+// FuncInfoLengths is a cache containing a roadmap of offsets and
+// lengths for things within a serialized FuncInfo. Each length field
+// stores the number of items (e.g. files, inltree nodes, etc), and the
+// corresponding "off" field stores the byte offset of the start of
+// the items in question.
+type FuncInfoLengths struct {
+	NumPcdata      uint32
+	PcdataOff      uint32
+	NumFuncdataoff uint32
+	FuncdataoffOff uint32
+	NumFile        uint32
+	FileOff        uint32
+	NumInlTree     uint32
+	InlTreeOff     uint32
+	Initialized    bool
+}
+
+func (*FuncInfo) ReadFuncInfoLengths(b []byte) FuncInfoLengths {
+	var result FuncInfoLengths
+
+	const numpcdataOff = 28
+	result.NumPcdata = binary.LittleEndian.Uint32(b[numpcdataOff:])
+	result.PcdataOff = numpcdataOff + 4
+
+	numfuncdataoffOff := result.PcdataOff + 4*(result.NumPcdata+1)
+	result.NumFuncdataoff = binary.LittleEndian.Uint32(b[numfuncdataoffOff:])
+	result.FuncdataoffOff = numfuncdataoffOff + 4
+
+	numfileOff := result.FuncdataoffOff + 4*result.NumFuncdataoff
+	result.NumFile = binary.LittleEndian.Uint32(b[numfileOff:])
+	result.FileOff = numfileOff + 4
+
+	numinltreeOff := result.FileOff + 4*result.NumFile
+	result.NumInlTree = binary.LittleEndian.Uint32(b[numinltreeOff:])
+	result.InlTreeOff = numinltreeOff + 4
+
+	result.Initialized = true
+
+	return result
+}
+
+func (*FuncInfo) ReadArgs(b []byte) uint32 { return binary.LittleEndian.Uint32(b) }
+
+func (*FuncInfo) ReadLocals(b []byte) uint32 { return binary.LittleEndian.Uint32(b[4:]) }
+
+func (*FuncInfo) ReadFuncID(b []byte) uint32 { return binary.LittleEndian.Uint32(b[8:]) }
+
+// return start and end offsets.
+func (*FuncInfo) ReadPcsp(b []byte) (uint32, uint32) {
+	return binary.LittleEndian.Uint32(b[12:]), binary.LittleEndian.Uint32(b[16:])
+}
+
+// return start and end offsets.
+func (*FuncInfo) ReadPcfile(b []byte) (uint32, uint32) {
+	return binary.LittleEndian.Uint32(b[16:]), binary.LittleEndian.Uint32(b[20:])
+}
+
+// return start and end offsets.
+func (*FuncInfo) ReadPcline(b []byte) (uint32, uint32) {
+	return binary.LittleEndian.Uint32(b[20:]), binary.LittleEndian.Uint32(b[24:])
+}
+
+// return start and end offsets.
+func (*FuncInfo) ReadPcinline(b []byte, pcdataoffset uint32) (uint32, uint32) {
+	return binary.LittleEndian.Uint32(b[24:]), binary.LittleEndian.Uint32(b[pcdataoffset:])
+}
+
+// return start and end offsets.
+func (*FuncInfo) ReadPcdata(b []byte, pcdataoffset uint32, k uint32) (uint32, uint32) {
+	return binary.LittleEndian.Uint32(b[pcdataoffset+4*k:]), binary.LittleEndian.Uint32(b[pcdataoffset+4+4*k:])
+}
+
+func (*FuncInfo) ReadFuncdataoff(b []byte, funcdataofffoff uint32, k uint32) int64 {
+	return int64(binary.LittleEndian.Uint32(b[funcdataofffoff+4*k:]))
+}
+
+func (*FuncInfo) ReadFile(b []byte, filesoff uint32, k uint32) CUFileIndex {
+	return CUFileIndex(binary.LittleEndian.Uint32(b[filesoff+4*k:]))
+}
+
+func (*FuncInfo) ReadInlTree(b []byte, inltreeoff uint32, k uint32) InlTreeNode {
+	const inlTreeNodeSize = 4 * 6
+	var result InlTreeNode
+	result.Read(b[inltreeoff+k*inlTreeNodeSize:])
+	return result
+}
+
+// InlTreeNode is the serialized form of FileInfo.InlTree.
+type InlTreeNode struct {
+	Parent   int32
+	File     CUFileIndex
+	Line     int32
+	Func     SymRef
+	ParentPC int32
+}
+
+func (inl *InlTreeNode) Write(w *bytes.Buffer) {
+	var b [4]byte
+	writeUint32 := func(x uint32) {
+		binary.LittleEndian.PutUint32(b[:], x)
+		w.Write(b[:])
+	}
+	writeUint32(uint32(inl.Parent))
+	writeUint32(uint32(inl.File))
+	writeUint32(uint32(inl.Line))
+	writeUint32(inl.Func.PkgIdx)
+	writeUint32(inl.Func.SymIdx)
+	writeUint32(uint32(inl.ParentPC))
+}
+
+// Read an InlTreeNode from b, return the remaining bytes.
+func (inl *InlTreeNode) Read(b []byte) []byte {
+	readUint32 := func() uint32 {
+		x := binary.LittleEndian.Uint32(b)
+		b = b[4:]
+		return x
+	}
+	inl.Parent = int32(readUint32())
+	inl.File = CUFileIndex(readUint32())
+	inl.Line = int32(readUint32())
+	inl.Func = SymRef{readUint32(), readUint32()}
+	inl.ParentPC = int32(readUint32())
+	return b
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/goobj/objfile.go b/vendor/github.com/twitchyliquid64/golang-asm/goobj/objfile.go
new file mode 100644
index 000000000..3303549aa
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/goobj/objfile.go
@@ -0,0 +1,871 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This package defines the Go object file format, and provide "low-level" functions
+// for reading and writing object files.
+
+// The object file is understood by the compiler, assembler, linker, and tools. They
+// have "high level" code that operates on object files, handling application-specific
+// logics, and use this package for the actual reading and writing. Specifically, the
+// code below:
+//
+// - cmd/internal/obj/objfile.go (used by cmd/asm and cmd/compile)
+// - cmd/internal/objfile/goobj.go (used cmd/nm, cmd/objdump)
+// - cmd/link/internal/loader package (used by cmd/link)
+//
+// If the object file format changes, they may (or may not) need to change.
+
+package goobj
+
+import (
+	"bytes"
+	"github.com/twitchyliquid64/golang-asm/bio"
+	"crypto/sha1"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"github.com/twitchyliquid64/golang-asm/unsafeheader"
+	"io"
+	"unsafe"
+)
+
+// New object file format.
+//
+//    Header struct {
+//       Magic       [...]byte   // "\x00go116ld"
+//       Fingerprint [8]byte
+//       Flags       uint32
+//       Offsets     [...]uint32 // byte offset of each block below
+//    }
+//
+//    Strings [...]struct {
+//       Data [...]byte
+//    }
+//
+//    Autolib  [...]struct { // imported packages (for file loading)
+//       Pkg         string
+//       Fingerprint [8]byte
+//    }
+//
+//    PkgIndex [...]string // referenced packages by index
+//
+//    Files [...]string
+//
+//    SymbolDefs [...]struct {
+//       Name  string
+//       ABI   uint16
+//       Type  uint8
+//       Flag  uint8
+//       Flag2 uint8
+//       Size  uint32
+//    }
+//    Hashed64Defs [...]struct { // short hashed (content-addressable) symbol definitions
+//       ... // same as SymbolDefs
+//    }
+//    HashedDefs [...]struct { // hashed (content-addressable) symbol definitions
+//       ... // same as SymbolDefs
+//    }
+//    NonPkgDefs [...]struct { // non-pkg symbol definitions
+//       ... // same as SymbolDefs
+//    }
+//    NonPkgRefs [...]struct { // non-pkg symbol references
+//       ... // same as SymbolDefs
+//    }
+//
+//    RefFlags [...]struct { // referenced symbol flags
+//       Sym   symRef
+//       Flag  uint8
+//       Flag2 uint8
+//    }
+//
+//    Hash64 [...][8]byte
+//    Hash   [...][N]byte
+//
+//    RelocIndex [...]uint32 // index to Relocs
+//    AuxIndex   [...]uint32 // index to Aux
+//    DataIndex  [...]uint32 // offset to Data
+//
+//    Relocs [...]struct {
+//       Off  int32
+//       Size uint8
+//       Type uint8
+//       Add  int64
+//       Sym  symRef
+//    }
+//
+//    Aux [...]struct {
+//       Type uint8
+//       Sym  symRef
+//    }
+//
+//    Data   [...]byte
+//    Pcdata [...]byte
+//
+//    // blocks only used by tools (objdump, nm)
+//
+//    RefNames [...]struct { // referenced symbol names
+//       Sym  symRef
+//       Name string
+//       // TODO: include ABI version as well?
+//    }
+//
+// string is encoded as is a uint32 length followed by a uint32 offset
+// that points to the corresponding string bytes.
+//
+// symRef is struct { PkgIdx, SymIdx uint32 }.
+//
+// Slice type (e.g. []symRef) is encoded as a length prefix (uint32)
+// followed by that number of elements.
+//
+// The types below correspond to the encoded data structure in the
+// object file.
+
+// Symbol indexing.
+//
+// Each symbol is referenced with a pair of indices, { PkgIdx, SymIdx },
+// as the symRef struct above.
+//
+// PkgIdx is either a predeclared index (see PkgIdxNone below) or
+// an index of an imported package. For the latter case, PkgIdx is the
+// index of the package in the PkgIndex array. 0 is an invalid index.
+//
+// SymIdx is the index of the symbol in the given package.
+// - If PkgIdx is PkgIdxSelf, SymIdx is the index of the symbol in the
+//   SymbolDefs array.
+// - If PkgIdx is PkgIdxHashed64, SymIdx is the index of the symbol in the
+//   Hashed64Defs array.
+// - If PkgIdx is PkgIdxHashed, SymIdx is the index of the symbol in the
+//   HashedDefs array.
+// - If PkgIdx is PkgIdxNone, SymIdx is the index of the symbol in the
+//   NonPkgDefs array (could natually overflow to NonPkgRefs array).
+// - Otherwise, SymIdx is the index of the symbol in some other package's
+//   SymbolDefs array.
+//
+// {0, 0} represents a nil symbol. Otherwise PkgIdx should not be 0.
+//
+// Hash contains the content hashes of content-addressable symbols, of
+// which PkgIdx is PkgIdxHashed, in the same order of HashedDefs array.
+// Hash64 is similar, for PkgIdxHashed64 symbols.
+//
+// RelocIndex, AuxIndex, and DataIndex contains indices/offsets to
+// Relocs/Aux/Data blocks, one element per symbol, first for all the
+// defined symbols, then all the defined hashed and non-package symbols,
+// in the same order of SymbolDefs/Hashed64Defs/HashedDefs/NonPkgDefs
+// arrays. For N total defined symbols, the array is of length N+1. The
+// last element is the total number of relocations (aux symbols, data
+// blocks, etc.).
+//
+// They can be accessed by index. For the i-th symbol, its relocations
+// are the RelocIndex[i]-th (inclusive) to RelocIndex[i+1]-th (exclusive)
+// elements in the Relocs array. Aux/Data are likewise. (The index is
+// 0-based.)
+
+// Auxiliary symbols.
+//
+// Each symbol may (or may not) be associated with a number of auxiliary
+// symbols. They are described in the Aux block. See Aux struct below.
+// Currently a symbol's Gotype, FuncInfo, and associated DWARF symbols
+// are auxiliary symbols.
+
+const stringRefSize = 8 // two uint32s
+
+type FingerprintType [8]byte
+
+func (fp FingerprintType) IsZero() bool { return fp == FingerprintType{} }
+
+// Package Index.
+const (
+	PkgIdxNone     = (1<<31 - 1) - iota // Non-package symbols
+	PkgIdxHashed64                      // Short hashed (content-addressable) symbols
+	PkgIdxHashed                        // Hashed (content-addressable) symbols
+	PkgIdxBuiltin                       // Predefined runtime symbols (ex: runtime.newobject)
+	PkgIdxSelf                          // Symbols defined in the current package
+	PkgIdxInvalid  = 0
+	// The index of other referenced packages starts from 1.
+)
+
+// Blocks
+const (
+	BlkAutolib = iota
+	BlkPkgIdx
+	BlkFile
+	BlkSymdef
+	BlkHashed64def
+	BlkHasheddef
+	BlkNonpkgdef
+	BlkNonpkgref
+	BlkRefFlags
+	BlkHash64
+	BlkHash
+	BlkRelocIdx
+	BlkAuxIdx
+	BlkDataIdx
+	BlkReloc
+	BlkAux
+	BlkData
+	BlkPcdata
+	BlkRefName
+	BlkEnd
+	NBlk
+)
+
+// File header.
+// TODO: probably no need to export this.
+type Header struct {
+	Magic       string
+	Fingerprint FingerprintType
+	Flags       uint32
+	Offsets     [NBlk]uint32
+}
+
+const Magic = "\x00go116ld"
+
+func (h *Header) Write(w *Writer) {
+	w.RawString(h.Magic)
+	w.Bytes(h.Fingerprint[:])
+	w.Uint32(h.Flags)
+	for _, x := range h.Offsets {
+		w.Uint32(x)
+	}
+}
+
+func (h *Header) Read(r *Reader) error {
+	b := r.BytesAt(0, len(Magic))
+	h.Magic = string(b)
+	if h.Magic != Magic {
+		return errors.New("wrong magic, not a Go object file")
+	}
+	off := uint32(len(h.Magic))
+	copy(h.Fingerprint[:], r.BytesAt(off, len(h.Fingerprint)))
+	off += 8
+	h.Flags = r.uint32At(off)
+	off += 4
+	for i := range h.Offsets {
+		h.Offsets[i] = r.uint32At(off)
+		off += 4
+	}
+	return nil
+}
+
+func (h *Header) Size() int {
+	return len(h.Magic) + 4 + 4*len(h.Offsets)
+}
+
+// Autolib
+type ImportedPkg struct {
+	Pkg         string
+	Fingerprint FingerprintType
+}
+
+const importedPkgSize = stringRefSize + 8
+
+func (p *ImportedPkg) Write(w *Writer) {
+	w.StringRef(p.Pkg)
+	w.Bytes(p.Fingerprint[:])
+}
+
+// Symbol definition.
+//
+// Serialized format:
+// Sym struct {
+//    Name  string
+//    ABI   uint16
+//    Type  uint8
+//    Flag  uint8
+//    Flag2 uint8
+//    Siz   uint32
+//    Align uint32
+// }
+type Sym [SymSize]byte
+
+const SymSize = stringRefSize + 2 + 1 + 1 + 1 + 4 + 4
+
+const SymABIstatic = ^uint16(0)
+
+const (
+	ObjFlagShared            = 1 << iota // this object is built with -shared
+	ObjFlagNeedNameExpansion             // the linker needs to expand `"".` to package path in symbol names
+	ObjFlagFromAssembly                  // object is from asm src, not go
+)
+
+// Sym.Flag
+const (
+	SymFlagDupok = 1 << iota
+	SymFlagLocal
+	SymFlagTypelink
+	SymFlagLeaf
+	SymFlagNoSplit
+	SymFlagReflectMethod
+	SymFlagGoType
+	SymFlagTopFrame
+)
+
+// Sym.Flag2
+const (
+	SymFlagUsedInIface = 1 << iota
+	SymFlagItab
+)
+
+// Returns the length of the name of the symbol.
+func (s *Sym) NameLen(r *Reader) int {
+	return int(binary.LittleEndian.Uint32(s[:]))
+}
+
+func (s *Sym) Name(r *Reader) string {
+	len := binary.LittleEndian.Uint32(s[:])
+	off := binary.LittleEndian.Uint32(s[4:])
+	return r.StringAt(off, len)
+}
+
+func (s *Sym) ABI() uint16   { return binary.LittleEndian.Uint16(s[8:]) }
+func (s *Sym) Type() uint8   { return s[10] }
+func (s *Sym) Flag() uint8   { return s[11] }
+func (s *Sym) Flag2() uint8  { return s[12] }
+func (s *Sym) Siz() uint32   { return binary.LittleEndian.Uint32(s[13:]) }
+func (s *Sym) Align() uint32 { return binary.LittleEndian.Uint32(s[17:]) }
+
+func (s *Sym) Dupok() bool         { return s.Flag()&SymFlagDupok != 0 }
+func (s *Sym) Local() bool         { return s.Flag()&SymFlagLocal != 0 }
+func (s *Sym) Typelink() bool      { return s.Flag()&SymFlagTypelink != 0 }
+func (s *Sym) Leaf() bool          { return s.Flag()&SymFlagLeaf != 0 }
+func (s *Sym) NoSplit() bool       { return s.Flag()&SymFlagNoSplit != 0 }
+func (s *Sym) ReflectMethod() bool { return s.Flag()&SymFlagReflectMethod != 0 }
+func (s *Sym) IsGoType() bool      { return s.Flag()&SymFlagGoType != 0 }
+func (s *Sym) TopFrame() bool      { return s.Flag()&SymFlagTopFrame != 0 }
+func (s *Sym) UsedInIface() bool   { return s.Flag2()&SymFlagUsedInIface != 0 }
+func (s *Sym) IsItab() bool        { return s.Flag2()&SymFlagItab != 0 }
+
+func (s *Sym) SetName(x string, w *Writer) {
+	binary.LittleEndian.PutUint32(s[:], uint32(len(x)))
+	binary.LittleEndian.PutUint32(s[4:], w.stringOff(x))
+}
+
+func (s *Sym) SetABI(x uint16)   { binary.LittleEndian.PutUint16(s[8:], x) }
+func (s *Sym) SetType(x uint8)   { s[10] = x }
+func (s *Sym) SetFlag(x uint8)   { s[11] = x }
+func (s *Sym) SetFlag2(x uint8)  { s[12] = x }
+func (s *Sym) SetSiz(x uint32)   { binary.LittleEndian.PutUint32(s[13:], x) }
+func (s *Sym) SetAlign(x uint32) { binary.LittleEndian.PutUint32(s[17:], x) }
+
+func (s *Sym) Write(w *Writer) { w.Bytes(s[:]) }
+
+// for testing
+func (s *Sym) fromBytes(b []byte) { copy(s[:], b) }
+
+// Symbol reference.
+type SymRef struct {
+	PkgIdx uint32
+	SymIdx uint32
+}
+
+// Hash64
+type Hash64Type [Hash64Size]byte
+
+const Hash64Size = 8
+
+// Hash
+type HashType [HashSize]byte
+
+const HashSize = sha1.Size
+
+// Relocation.
+//
+// Serialized format:
+// Reloc struct {
+//    Off  int32
+//    Siz  uint8
+//    Type uint8
+//    Add  int64
+//    Sym  SymRef
+// }
+type Reloc [RelocSize]byte
+
+const RelocSize = 4 + 1 + 1 + 8 + 8
+
+func (r *Reloc) Off() int32  { return int32(binary.LittleEndian.Uint32(r[:])) }
+func (r *Reloc) Siz() uint8  { return r[4] }
+func (r *Reloc) Type() uint8 { return r[5] }
+func (r *Reloc) Add() int64  { return int64(binary.LittleEndian.Uint64(r[6:])) }
+func (r *Reloc) Sym() SymRef {
+	return SymRef{binary.LittleEndian.Uint32(r[14:]), binary.LittleEndian.Uint32(r[18:])}
+}
+
+func (r *Reloc) SetOff(x int32)  { binary.LittleEndian.PutUint32(r[:], uint32(x)) }
+func (r *Reloc) SetSiz(x uint8)  { r[4] = x }
+func (r *Reloc) SetType(x uint8) { r[5] = x }
+func (r *Reloc) SetAdd(x int64)  { binary.LittleEndian.PutUint64(r[6:], uint64(x)) }
+func (r *Reloc) SetSym(x SymRef) {
+	binary.LittleEndian.PutUint32(r[14:], x.PkgIdx)
+	binary.LittleEndian.PutUint32(r[18:], x.SymIdx)
+}
+
+func (r *Reloc) Set(off int32, size uint8, typ uint8, add int64, sym SymRef) {
+	r.SetOff(off)
+	r.SetSiz(size)
+	r.SetType(typ)
+	r.SetAdd(add)
+	r.SetSym(sym)
+}
+
+func (r *Reloc) Write(w *Writer) { w.Bytes(r[:]) }
+
+// for testing
+func (r *Reloc) fromBytes(b []byte) { copy(r[:], b) }
+
+// Aux symbol info.
+//
+// Serialized format:
+// Aux struct {
+//    Type uint8
+//    Sym  SymRef
+// }
+type Aux [AuxSize]byte
+
+const AuxSize = 1 + 8
+
+// Aux Type
+const (
+	AuxGotype = iota
+	AuxFuncInfo
+	AuxFuncdata
+	AuxDwarfInfo
+	AuxDwarfLoc
+	AuxDwarfRanges
+	AuxDwarfLines
+
+	// TODO: more. Pcdata?
+)
+
+func (a *Aux) Type() uint8 { return a[0] }
+func (a *Aux) Sym() SymRef {
+	return SymRef{binary.LittleEndian.Uint32(a[1:]), binary.LittleEndian.Uint32(a[5:])}
+}
+
+func (a *Aux) SetType(x uint8) { a[0] = x }
+func (a *Aux) SetSym(x SymRef) {
+	binary.LittleEndian.PutUint32(a[1:], x.PkgIdx)
+	binary.LittleEndian.PutUint32(a[5:], x.SymIdx)
+}
+
+func (a *Aux) Write(w *Writer) { w.Bytes(a[:]) }
+
+// for testing
+func (a *Aux) fromBytes(b []byte) { copy(a[:], b) }
+
+// Referenced symbol flags.
+//
+// Serialized format:
+// RefFlags struct {
+//    Sym   symRef
+//    Flag  uint8
+//    Flag2 uint8
+// }
+type RefFlags [RefFlagsSize]byte
+
+const RefFlagsSize = 8 + 1 + 1
+
+func (r *RefFlags) Sym() SymRef {
+	return SymRef{binary.LittleEndian.Uint32(r[:]), binary.LittleEndian.Uint32(r[4:])}
+}
+func (r *RefFlags) Flag() uint8  { return r[8] }
+func (r *RefFlags) Flag2() uint8 { return r[9] }
+
+func (r *RefFlags) SetSym(x SymRef) {
+	binary.LittleEndian.PutUint32(r[:], x.PkgIdx)
+	binary.LittleEndian.PutUint32(r[4:], x.SymIdx)
+}
+func (r *RefFlags) SetFlag(x uint8)  { r[8] = x }
+func (r *RefFlags) SetFlag2(x uint8) { r[9] = x }
+
+func (r *RefFlags) Write(w *Writer) { w.Bytes(r[:]) }
+
+// Referenced symbol name.
+//
+// Serialized format:
+// RefName struct {
+//    Sym  symRef
+//    Name string
+// }
+type RefName [RefNameSize]byte
+
+const RefNameSize = 8 + stringRefSize
+
+func (n *RefName) Sym() SymRef {
+	return SymRef{binary.LittleEndian.Uint32(n[:]), binary.LittleEndian.Uint32(n[4:])}
+}
+func (n *RefName) Name(r *Reader) string {
+	len := binary.LittleEndian.Uint32(n[8:])
+	off := binary.LittleEndian.Uint32(n[12:])
+	return r.StringAt(off, len)
+}
+
+func (n *RefName) SetSym(x SymRef) {
+	binary.LittleEndian.PutUint32(n[:], x.PkgIdx)
+	binary.LittleEndian.PutUint32(n[4:], x.SymIdx)
+}
+func (n *RefName) SetName(x string, w *Writer) {
+	binary.LittleEndian.PutUint32(n[8:], uint32(len(x)))
+	binary.LittleEndian.PutUint32(n[12:], w.stringOff(x))
+}
+
+func (n *RefName) Write(w *Writer) { w.Bytes(n[:]) }
+
+type Writer struct {
+	wr        *bio.Writer
+	stringMap map[string]uint32
+	off       uint32 // running offset
+}
+
+func NewWriter(wr *bio.Writer) *Writer {
+	return &Writer{wr: wr, stringMap: make(map[string]uint32)}
+}
+
+func (w *Writer) AddString(s string) {
+	if _, ok := w.stringMap[s]; ok {
+		return
+	}
+	w.stringMap[s] = w.off
+	w.RawString(s)
+}
+
+func (w *Writer) stringOff(s string) uint32 {
+	off, ok := w.stringMap[s]
+	if !ok {
+		panic(fmt.Sprintf("writeStringRef: string not added: %q", s))
+	}
+	return off
+}
+
+func (w *Writer) StringRef(s string) {
+	w.Uint32(uint32(len(s)))
+	w.Uint32(w.stringOff(s))
+}
+
+func (w *Writer) RawString(s string) {
+	w.wr.WriteString(s)
+	w.off += uint32(len(s))
+}
+
+func (w *Writer) Bytes(s []byte) {
+	w.wr.Write(s)
+	w.off += uint32(len(s))
+}
+
+func (w *Writer) Uint64(x uint64) {
+	var b [8]byte
+	binary.LittleEndian.PutUint64(b[:], x)
+	w.wr.Write(b[:])
+	w.off += 8
+}
+
+func (w *Writer) Uint32(x uint32) {
+	var b [4]byte
+	binary.LittleEndian.PutUint32(b[:], x)
+	w.wr.Write(b[:])
+	w.off += 4
+}
+
+func (w *Writer) Uint16(x uint16) {
+	var b [2]byte
+	binary.LittleEndian.PutUint16(b[:], x)
+	w.wr.Write(b[:])
+	w.off += 2
+}
+
+func (w *Writer) Uint8(x uint8) {
+	w.wr.WriteByte(x)
+	w.off++
+}
+
+func (w *Writer) Offset() uint32 {
+	return w.off
+}
+
+type Reader struct {
+	b        []byte // mmapped bytes, if not nil
+	readonly bool   // whether b is backed with read-only memory
+
+	rd    io.ReaderAt
+	start uint32
+	h     Header // keep block offsets
+}
+
+func NewReaderFromBytes(b []byte, readonly bool) *Reader {
+	r := &Reader{b: b, readonly: readonly, rd: bytes.NewReader(b), start: 0}
+	err := r.h.Read(r)
+	if err != nil {
+		return nil
+	}
+	return r
+}
+
+func (r *Reader) BytesAt(off uint32, len int) []byte {
+	if len == 0 {
+		return nil
+	}
+	end := int(off) + len
+	return r.b[int(off):end:end]
+}
+
+func (r *Reader) uint64At(off uint32) uint64 {
+	b := r.BytesAt(off, 8)
+	return binary.LittleEndian.Uint64(b)
+}
+
+func (r *Reader) int64At(off uint32) int64 {
+	return int64(r.uint64At(off))
+}
+
+func (r *Reader) uint32At(off uint32) uint32 {
+	b := r.BytesAt(off, 4)
+	return binary.LittleEndian.Uint32(b)
+}
+
+func (r *Reader) int32At(off uint32) int32 {
+	return int32(r.uint32At(off))
+}
+
+func (r *Reader) uint16At(off uint32) uint16 {
+	b := r.BytesAt(off, 2)
+	return binary.LittleEndian.Uint16(b)
+}
+
+func (r *Reader) uint8At(off uint32) uint8 {
+	b := r.BytesAt(off, 1)
+	return b[0]
+}
+
+func (r *Reader) StringAt(off uint32, len uint32) string {
+	b := r.b[off : off+len]
+	if r.readonly {
+		return toString(b) // backed by RO memory, ok to make unsafe string
+	}
+	return string(b)
+}
+
+func toString(b []byte) string {
+	if len(b) == 0 {
+		return ""
+	}
+
+	var s string
+	hdr := (*unsafeheader.String)(unsafe.Pointer(&s))
+	hdr.Data = unsafe.Pointer(&b[0])
+	hdr.Len = len(b)
+
+	return s
+}
+
+func (r *Reader) StringRef(off uint32) string {
+	l := r.uint32At(off)
+	return r.StringAt(r.uint32At(off+4), l)
+}
+
+func (r *Reader) Fingerprint() FingerprintType {
+	return r.h.Fingerprint
+}
+
+func (r *Reader) Autolib() []ImportedPkg {
+	n := (r.h.Offsets[BlkAutolib+1] - r.h.Offsets[BlkAutolib]) / importedPkgSize
+	s := make([]ImportedPkg, n)
+	off := r.h.Offsets[BlkAutolib]
+	for i := range s {
+		s[i].Pkg = r.StringRef(off)
+		copy(s[i].Fingerprint[:], r.BytesAt(off+stringRefSize, len(s[i].Fingerprint)))
+		off += importedPkgSize
+	}
+	return s
+}
+
+func (r *Reader) Pkglist() []string {
+	n := (r.h.Offsets[BlkPkgIdx+1] - r.h.Offsets[BlkPkgIdx]) / stringRefSize
+	s := make([]string, n)
+	off := r.h.Offsets[BlkPkgIdx]
+	for i := range s {
+		s[i] = r.StringRef(off)
+		off += stringRefSize
+	}
+	return s
+}
+
+func (r *Reader) NPkg() int {
+	return int(r.h.Offsets[BlkPkgIdx+1]-r.h.Offsets[BlkPkgIdx]) / stringRefSize
+}
+
+func (r *Reader) Pkg(i int) string {
+	off := r.h.Offsets[BlkPkgIdx] + uint32(i)*stringRefSize
+	return r.StringRef(off)
+}
+
+func (r *Reader) NFile() int {
+	return int(r.h.Offsets[BlkFile+1]-r.h.Offsets[BlkFile]) / stringRefSize
+}
+
+func (r *Reader) File(i int) string {
+	off := r.h.Offsets[BlkFile] + uint32(i)*stringRefSize
+	return r.StringRef(off)
+}
+
+func (r *Reader) NSym() int {
+	return int(r.h.Offsets[BlkSymdef+1]-r.h.Offsets[BlkSymdef]) / SymSize
+}
+
+func (r *Reader) NHashed64def() int {
+	return int(r.h.Offsets[BlkHashed64def+1]-r.h.Offsets[BlkHashed64def]) / SymSize
+}
+
+func (r *Reader) NHasheddef() int {
+	return int(r.h.Offsets[BlkHasheddef+1]-r.h.Offsets[BlkHasheddef]) / SymSize
+}
+
+func (r *Reader) NNonpkgdef() int {
+	return int(r.h.Offsets[BlkNonpkgdef+1]-r.h.Offsets[BlkNonpkgdef]) / SymSize
+}
+
+func (r *Reader) NNonpkgref() int {
+	return int(r.h.Offsets[BlkNonpkgref+1]-r.h.Offsets[BlkNonpkgref]) / SymSize
+}
+
+// SymOff returns the offset of the i-th symbol.
+func (r *Reader) SymOff(i uint32) uint32 {
+	return r.h.Offsets[BlkSymdef] + uint32(i*SymSize)
+}
+
+// Sym returns a pointer to the i-th symbol.
+func (r *Reader) Sym(i uint32) *Sym {
+	off := r.SymOff(i)
+	return (*Sym)(unsafe.Pointer(&r.b[off]))
+}
+
+// NRefFlags returns the number of referenced symbol flags.
+func (r *Reader) NRefFlags() int {
+	return int(r.h.Offsets[BlkRefFlags+1]-r.h.Offsets[BlkRefFlags]) / RefFlagsSize
+}
+
+// RefFlags returns a pointer to the i-th referenced symbol flags.
+// Note: here i is not a local symbol index, just a counter.
+func (r *Reader) RefFlags(i int) *RefFlags {
+	off := r.h.Offsets[BlkRefFlags] + uint32(i*RefFlagsSize)
+	return (*RefFlags)(unsafe.Pointer(&r.b[off]))
+}
+
+// Hash64 returns the i-th short hashed symbol's hash.
+// Note: here i is the index of short hashed symbols, not all symbols
+// (unlike other accessors).
+func (r *Reader) Hash64(i uint32) uint64 {
+	off := r.h.Offsets[BlkHash64] + uint32(i*Hash64Size)
+	return r.uint64At(off)
+}
+
+// Hash returns a pointer to the i-th hashed symbol's hash.
+// Note: here i is the index of hashed symbols, not all symbols
+// (unlike other accessors).
+func (r *Reader) Hash(i uint32) *HashType {
+	off := r.h.Offsets[BlkHash] + uint32(i*HashSize)
+	return (*HashType)(unsafe.Pointer(&r.b[off]))
+}
+
+// NReloc returns the number of relocations of the i-th symbol.
+func (r *Reader) NReloc(i uint32) int {
+	relocIdxOff := r.h.Offsets[BlkRelocIdx] + uint32(i*4)
+	return int(r.uint32At(relocIdxOff+4) - r.uint32At(relocIdxOff))
+}
+
+// RelocOff returns the offset of the j-th relocation of the i-th symbol.
+func (r *Reader) RelocOff(i uint32, j int) uint32 {
+	relocIdxOff := r.h.Offsets[BlkRelocIdx] + uint32(i*4)
+	relocIdx := r.uint32At(relocIdxOff)
+	return r.h.Offsets[BlkReloc] + (relocIdx+uint32(j))*uint32(RelocSize)
+}
+
+// Reloc returns a pointer to the j-th relocation of the i-th symbol.
+func (r *Reader) Reloc(i uint32, j int) *Reloc {
+	off := r.RelocOff(i, j)
+	return (*Reloc)(unsafe.Pointer(&r.b[off]))
+}
+
+// Relocs returns a pointer to the relocations of the i-th symbol.
+func (r *Reader) Relocs(i uint32) []Reloc {
+	off := r.RelocOff(i, 0)
+	n := r.NReloc(i)
+	return (*[1 << 20]Reloc)(unsafe.Pointer(&r.b[off]))[:n:n]
+}
+
+// NAux returns the number of aux symbols of the i-th symbol.
+func (r *Reader) NAux(i uint32) int {
+	auxIdxOff := r.h.Offsets[BlkAuxIdx] + i*4
+	return int(r.uint32At(auxIdxOff+4) - r.uint32At(auxIdxOff))
+}
+
+// AuxOff returns the offset of the j-th aux symbol of the i-th symbol.
+func (r *Reader) AuxOff(i uint32, j int) uint32 {
+	auxIdxOff := r.h.Offsets[BlkAuxIdx] + i*4
+	auxIdx := r.uint32At(auxIdxOff)
+	return r.h.Offsets[BlkAux] + (auxIdx+uint32(j))*uint32(AuxSize)
+}
+
+// Aux returns a pointer to the j-th aux symbol of the i-th symbol.
+func (r *Reader) Aux(i uint32, j int) *Aux {
+	off := r.AuxOff(i, j)
+	return (*Aux)(unsafe.Pointer(&r.b[off]))
+}
+
+// Auxs returns the aux symbols of the i-th symbol.
+func (r *Reader) Auxs(i uint32) []Aux {
+	off := r.AuxOff(i, 0)
+	n := r.NAux(i)
+	return (*[1 << 20]Aux)(unsafe.Pointer(&r.b[off]))[:n:n]
+}
+
+// DataOff returns the offset of the i-th symbol's data.
+func (r *Reader) DataOff(i uint32) uint32 {
+	dataIdxOff := r.h.Offsets[BlkDataIdx] + i*4
+	return r.h.Offsets[BlkData] + r.uint32At(dataIdxOff)
+}
+
+// DataSize returns the size of the i-th symbol's data.
+func (r *Reader) DataSize(i uint32) int {
+	dataIdxOff := r.h.Offsets[BlkDataIdx] + i*4
+	return int(r.uint32At(dataIdxOff+4) - r.uint32At(dataIdxOff))
+}
+
+// Data returns the i-th symbol's data.
+func (r *Reader) Data(i uint32) []byte {
+	dataIdxOff := r.h.Offsets[BlkDataIdx] + i*4
+	base := r.h.Offsets[BlkData]
+	off := r.uint32At(dataIdxOff)
+	end := r.uint32At(dataIdxOff + 4)
+	return r.BytesAt(base+off, int(end-off))
+}
+
+// AuxDataBase returns the base offset of the aux data block.
+func (r *Reader) PcdataBase() uint32 {
+	return r.h.Offsets[BlkPcdata]
+}
+
+// NRefName returns the number of referenced symbol names.
+func (r *Reader) NRefName() int {
+	return int(r.h.Offsets[BlkRefName+1]-r.h.Offsets[BlkRefName]) / RefNameSize
+}
+
+// RefName returns a pointer to the i-th referenced symbol name.
+// Note: here i is not a local symbol index, just a counter.
+func (r *Reader) RefName(i int) *RefName {
+	off := r.h.Offsets[BlkRefName] + uint32(i*RefNameSize)
+	return (*RefName)(unsafe.Pointer(&r.b[off]))
+}
+
+// ReadOnly returns whether r.BytesAt returns read-only bytes.
+func (r *Reader) ReadOnly() bool {
+	return r.readonly
+}
+
+// Flags returns the flag bits read from the object file header.
+func (r *Reader) Flags() uint32 {
+	return r.h.Flags
+}
+
+func (r *Reader) Shared() bool            { return r.Flags()&ObjFlagShared != 0 }
+func (r *Reader) NeedNameExpansion() bool { return r.Flags()&ObjFlagNeedNameExpansion != 0 }
+func (r *Reader) FromAssembly() bool      { return r.Flags()&ObjFlagFromAssembly != 0 }
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/abi_string.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/abi_string.go
new file mode 100644
index 000000000..a439da36a
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/abi_string.go
@@ -0,0 +1,16 @@
+// Code generated by "stringer -type ABI"; DO NOT EDIT.
+
+package obj
+
+import "strconv"
+
+const _ABI_name = "ABI0ABIInternalABICount"
+
+var _ABI_index = [...]uint8{0, 4, 15, 23}
+
+func (i ABI) String() string {
+	if i >= ABI(len(_ABI_index)-1) {
+		return "ABI(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+	return _ABI_name[_ABI_index[i]:_ABI_index[i+1]]
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/addrtype_string.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/addrtype_string.go
new file mode 100644
index 000000000..71f0dd97a
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/addrtype_string.go
@@ -0,0 +1,16 @@
+// Code generated by "stringer -type AddrType"; DO NOT EDIT.
+
+package obj
+
+import "strconv"
+
+const _AddrType_name = "TYPE_NONETYPE_BRANCHTYPE_TEXTSIZETYPE_MEMTYPE_CONSTTYPE_FCONSTTYPE_SCONSTTYPE_REGTYPE_ADDRTYPE_SHIFTTYPE_REGREGTYPE_REGREG2TYPE_INDIRTYPE_REGLIST"
+
+var _AddrType_index = [...]uint8{0, 9, 20, 33, 41, 51, 62, 73, 81, 90, 100, 111, 123, 133, 145}
+
+func (i AddrType) String() string {
+	if i >= AddrType(len(_AddrType_index)-1) {
+		return "AddrType(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+	return _AddrType_name[_AddrType_index[i]:_AddrType_index[i+1]]
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/a.out.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/a.out.go
new file mode 100644
index 000000000..8f8b8dbc4
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/a.out.go
@@ -0,0 +1,410 @@
+// Inferno utils/5c/5.out.h
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/5c/5.out.h
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package arm
+
+import "github.com/twitchyliquid64/golang-asm/obj"
+
+//go:generate go run ../stringer.go -i $GOFILE -o anames.go -p arm
+
+const (
+	NSNAME = 8
+	NSYM   = 50
+	NREG   = 16
+)
+
+/* -1 disables use of REGARG */
+const (
+	REGARG = -1
+)
+
+const (
+	REG_R0 = obj.RBaseARM + iota // must be 16-aligned
+	REG_R1
+	REG_R2
+	REG_R3
+	REG_R4
+	REG_R5
+	REG_R6
+	REG_R7
+	REG_R8
+	REG_R9
+	REG_R10
+	REG_R11
+	REG_R12
+	REG_R13
+	REG_R14
+	REG_R15
+
+	REG_F0 // must be 16-aligned
+	REG_F1
+	REG_F2
+	REG_F3
+	REG_F4
+	REG_F5
+	REG_F6
+	REG_F7
+	REG_F8
+	REG_F9
+	REG_F10
+	REG_F11
+	REG_F12
+	REG_F13
+	REG_F14
+	REG_F15
+
+	REG_FPSR // must be 2-aligned
+	REG_FPCR
+
+	REG_CPSR // must be 2-aligned
+	REG_SPSR
+
+	REGRET = REG_R0
+	/* compiler allocates R1 up as temps */
+	/* compiler allocates register variables R3 up */
+	/* compiler allocates external registers R10 down */
+	REGEXT = REG_R10
+	/* these two registers are declared in runtime.h */
+	REGG = REGEXT - 0
+	REGM = REGEXT - 1
+
+	REGCTXT = REG_R7
+	REGTMP  = REG_R11
+	REGSP   = REG_R13
+	REGLINK = REG_R14
+	REGPC   = REG_R15
+
+	NFREG = 16
+	/* compiler allocates register variables F0 up */
+	/* compiler allocates external registers F7 down */
+	FREGRET = REG_F0
+	FREGEXT = REG_F7
+	FREGTMP = REG_F15
+)
+
+// http://infocenter.arm.com/help/topic/com.arm.doc.ihi0040b/IHI0040B_aadwarf.pdf
+var ARMDWARFRegisters = map[int16]int16{}
+
+func init() {
+	// f assigns dwarfregisters[from:to] = (base):(step*(to-from)+base)
+	f := func(from, to, base, step int16) {
+		for r := int16(from); r <= to; r++ {
+			ARMDWARFRegisters[r] = step*(r-from) + base
+		}
+	}
+	f(REG_R0, REG_R15, 0, 1)
+	f(REG_F0, REG_F15, 64, 2) // Use d0 through D15, aka S0, S2, ..., S30
+}
+
+// Special registers, after subtracting obj.RBaseARM, bit 9 indicates
+// a special register and the low bits select the register.
+const (
+	REG_SPECIAL = obj.RBaseARM + 1<<9 + iota
+	REG_MB_SY
+	REG_MB_ST
+	REG_MB_ISH
+	REG_MB_ISHST
+	REG_MB_NSH
+	REG_MB_NSHST
+	REG_MB_OSH
+	REG_MB_OSHST
+
+	MAXREG
+)
+
+const (
+	C_NONE = iota
+	C_REG
+	C_REGREG
+	C_REGREG2
+	C_REGLIST
+	C_SHIFT     /* register shift R>>x */
+	C_SHIFTADDR /* memory address with shifted offset R>>x(R) */
+	C_FREG
+	C_PSR
+	C_FCR
+	C_SPR /* REG_MB_SY */
+
+	C_RCON   /* 0xff rotated */
+	C_NCON   /* ~RCON */
+	C_RCON2A /* OR of two disjoint C_RCON constants */
+	C_RCON2S /* subtraction of two disjoint C_RCON constants */
+	C_SCON   /* 0xffff */
+	C_LCON
+	C_LCONADDR
+	C_ZFCON
+	C_SFCON
+	C_LFCON
+
+	C_RACON
+	C_LACON
+
+	C_SBRA
+	C_LBRA
+
+	C_HAUTO  /* halfword insn offset (-0xff to 0xff) */
+	C_FAUTO  /* float insn offset (0 to 0x3fc, word aligned) */
+	C_HFAUTO /* both H and F */
+	C_SAUTO  /* -0xfff to 0xfff */
+	C_LAUTO
+
+	C_HOREG
+	C_FOREG
+	C_HFOREG
+	C_SOREG
+	C_ROREG
+	C_SROREG /* both nil and R */
+	C_LOREG
+
+	C_PC
+	C_SP
+	C_HREG
+
+	C_ADDR /* reference to relocatable address */
+
+	// TLS "var" in local exec mode: will become a constant offset from
+	// thread local base that is ultimately chosen by the program linker.
+	C_TLS_LE
+
+	// TLS "var" in initial exec mode: will become a memory address (chosen
+	// by the program linker) that the dynamic linker will fill with the
+	// offset from the thread local base.
+	C_TLS_IE
+
+	C_TEXTSIZE
+
+	C_GOK
+
+	C_NCLASS /* must be the last */
+)
+
+const (
+	AAND = obj.ABaseARM + obj.A_ARCHSPECIFIC + iota
+	AEOR
+	ASUB
+	ARSB
+	AADD
+	AADC
+	ASBC
+	ARSC
+	ATST
+	ATEQ
+	ACMP
+	ACMN
+	AORR
+	ABIC
+
+	AMVN
+
+	/*
+	 * Do not reorder or fragment the conditional branch
+	 * opcodes, or the predication code will break
+	 */
+	ABEQ
+	ABNE
+	ABCS
+	ABHS
+	ABCC
+	ABLO
+	ABMI
+	ABPL
+	ABVS
+	ABVC
+	ABHI
+	ABLS
+	ABGE
+	ABLT
+	ABGT
+	ABLE
+
+	AMOVWD
+	AMOVWF
+	AMOVDW
+	AMOVFW
+	AMOVFD
+	AMOVDF
+	AMOVF
+	AMOVD
+
+	ACMPF
+	ACMPD
+	AADDF
+	AADDD
+	ASUBF
+	ASUBD
+	AMULF
+	AMULD
+	ANMULF
+	ANMULD
+	AMULAF
+	AMULAD
+	ANMULAF
+	ANMULAD
+	AMULSF
+	AMULSD
+	ANMULSF
+	ANMULSD
+	AFMULAF
+	AFMULAD
+	AFNMULAF
+	AFNMULAD
+	AFMULSF
+	AFMULSD
+	AFNMULSF
+	AFNMULSD
+	ADIVF
+	ADIVD
+	ASQRTF
+	ASQRTD
+	AABSF
+	AABSD
+	ANEGF
+	ANEGD
+
+	ASRL
+	ASRA
+	ASLL
+	AMULU
+	ADIVU
+	AMUL
+	AMMUL
+	ADIV
+	AMOD
+	AMODU
+	ADIVHW
+	ADIVUHW
+
+	AMOVB
+	AMOVBS
+	AMOVBU
+	AMOVH
+	AMOVHS
+	AMOVHU
+	AMOVW
+	AMOVM
+	ASWPBU
+	ASWPW
+
+	ARFE
+	ASWI
+	AMULA
+	AMULS
+	AMMULA
+	AMMULS
+
+	AWORD
+
+	AMULL
+	AMULAL
+	AMULLU
+	AMULALU
+
+	ABX
+	ABXRET
+	ADWORD
+
+	ALDREX
+	ASTREX
+	ALDREXD
+	ASTREXD
+
+	ADMB
+
+	APLD
+
+	ACLZ
+	AREV
+	AREV16
+	AREVSH
+	ARBIT
+
+	AXTAB
+	AXTAH
+	AXTABU
+	AXTAHU
+
+	ABFX
+	ABFXU
+	ABFC
+	ABFI
+
+	AMULWT
+	AMULWB
+	AMULBB
+	AMULAWT
+	AMULAWB
+	AMULABB
+
+	AMRC // MRC/MCR
+
+	ALAST
+
+	// aliases
+	AB  = obj.AJMP
+	ABL = obj.ACALL
+)
+
+/* scond byte */
+const (
+	C_SCOND = (1 << 4) - 1
+	C_SBIT  = 1 << 4
+	C_PBIT  = 1 << 5
+	C_WBIT  = 1 << 6
+	C_FBIT  = 1 << 7 /* psr flags-only */
+	C_UBIT  = 1 << 7 /* up bit, unsigned bit */
+
+	// These constants are the ARM condition codes encodings,
+	// XORed with 14 so that C_SCOND_NONE has value 0,
+	// so that a zeroed Prog.scond means "always execute".
+	C_SCOND_XOR = 14
+
+	C_SCOND_EQ   = 0 ^ C_SCOND_XOR
+	C_SCOND_NE   = 1 ^ C_SCOND_XOR
+	C_SCOND_HS   = 2 ^ C_SCOND_XOR
+	C_SCOND_LO   = 3 ^ C_SCOND_XOR
+	C_SCOND_MI   = 4 ^ C_SCOND_XOR
+	C_SCOND_PL   = 5 ^ C_SCOND_XOR
+	C_SCOND_VS   = 6 ^ C_SCOND_XOR
+	C_SCOND_VC   = 7 ^ C_SCOND_XOR
+	C_SCOND_HI   = 8 ^ C_SCOND_XOR
+	C_SCOND_LS   = 9 ^ C_SCOND_XOR
+	C_SCOND_GE   = 10 ^ C_SCOND_XOR
+	C_SCOND_LT   = 11 ^ C_SCOND_XOR
+	C_SCOND_GT   = 12 ^ C_SCOND_XOR
+	C_SCOND_LE   = 13 ^ C_SCOND_XOR
+	C_SCOND_NONE = 14 ^ C_SCOND_XOR
+	C_SCOND_NV   = 15 ^ C_SCOND_XOR
+
+	/* D_SHIFT type */
+	SHIFT_LL = 0 << 5
+	SHIFT_LR = 1 << 5
+	SHIFT_AR = 2 << 5
+	SHIFT_RR = 3 << 5
+)
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/anames.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/anames.go
new file mode 100644
index 000000000..8a05133e9
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/anames.go
@@ -0,0 +1,144 @@
+// Code generated by stringer -i a.out.go -o anames.go -p arm; DO NOT EDIT.
+
+package arm
+
+import "github.com/twitchyliquid64/golang-asm/obj"
+
+var Anames = []string{
+	obj.A_ARCHSPECIFIC: "AND",
+	"EOR",
+	"SUB",
+	"RSB",
+	"ADD",
+	"ADC",
+	"SBC",
+	"RSC",
+	"TST",
+	"TEQ",
+	"CMP",
+	"CMN",
+	"ORR",
+	"BIC",
+	"MVN",
+	"BEQ",
+	"BNE",
+	"BCS",
+	"BHS",
+	"BCC",
+	"BLO",
+	"BMI",
+	"BPL",
+	"BVS",
+	"BVC",
+	"BHI",
+	"BLS",
+	"BGE",
+	"BLT",
+	"BGT",
+	"BLE",
+	"MOVWD",
+	"MOVWF",
+	"MOVDW",
+	"MOVFW",
+	"MOVFD",
+	"MOVDF",
+	"MOVF",
+	"MOVD",
+	"CMPF",
+	"CMPD",
+	"ADDF",
+	"ADDD",
+	"SUBF",
+	"SUBD",
+	"MULF",
+	"MULD",
+	"NMULF",
+	"NMULD",
+	"MULAF",
+	"MULAD",
+	"NMULAF",
+	"NMULAD",
+	"MULSF",
+	"MULSD",
+	"NMULSF",
+	"NMULSD",
+	"FMULAF",
+	"FMULAD",
+	"FNMULAF",
+	"FNMULAD",
+	"FMULSF",
+	"FMULSD",
+	"FNMULSF",
+	"FNMULSD",
+	"DIVF",
+	"DIVD",
+	"SQRTF",
+	"SQRTD",
+	"ABSF",
+	"ABSD",
+	"NEGF",
+	"NEGD",
+	"SRL",
+	"SRA",
+	"SLL",
+	"MULU",
+	"DIVU",
+	"MUL",
+	"MMUL",
+	"DIV",
+	"MOD",
+	"MODU",
+	"DIVHW",
+	"DIVUHW",
+	"MOVB",
+	"MOVBS",
+	"MOVBU",
+	"MOVH",
+	"MOVHS",
+	"MOVHU",
+	"MOVW",
+	"MOVM",
+	"SWPBU",
+	"SWPW",
+	"RFE",
+	"SWI",
+	"MULA",
+	"MULS",
+	"MMULA",
+	"MMULS",
+	"WORD",
+	"MULL",
+	"MULAL",
+	"MULLU",
+	"MULALU",
+	"BX",
+	"BXRET",
+	"DWORD",
+	"LDREX",
+	"STREX",
+	"LDREXD",
+	"STREXD",
+	"DMB",
+	"PLD",
+	"CLZ",
+	"REV",
+	"REV16",
+	"REVSH",
+	"RBIT",
+	"XTAB",
+	"XTAH",
+	"XTABU",
+	"XTAHU",
+	"BFX",
+	"BFXU",
+	"BFC",
+	"BFI",
+	"MULWT",
+	"MULWB",
+	"MULBB",
+	"MULAWT",
+	"MULAWB",
+	"MULABB",
+	"MRC",
+	"LAST",
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/anames5.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/anames5.go
new file mode 100644
index 000000000..78fcd55f7
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/anames5.go
@@ -0,0 +1,77 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package arm
+
+var cnames5 = []string{
+	"NONE",
+	"REG",
+	"REGREG",
+	"REGREG2",
+	"REGLIST",
+	"SHIFT",
+	"SHIFTADDR",
+	"FREG",
+	"PSR",
+	"FCR",
+	"SPR",
+	"RCON",
+	"NCON",
+	"RCON2A",
+	"RCON2S",
+	"SCON",
+	"LCON",
+	"LCONADDR",
+	"ZFCON",
+	"SFCON",
+	"LFCON",
+	"RACON",
+	"LACON",
+	"SBRA",
+	"LBRA",
+	"HAUTO",
+	"FAUTO",
+	"HFAUTO",
+	"SAUTO",
+	"LAUTO",
+	"HOREG",
+	"FOREG",
+	"HFOREG",
+	"SOREG",
+	"ROREG",
+	"SROREG",
+	"LOREG",
+	"PC",
+	"SP",
+	"HREG",
+	"ADDR",
+	"C_TLS_LE",
+	"C_TLS_IE",
+	"TEXTSIZE",
+	"GOK",
+	"NCLASS",
+	"SCOND = (1<<4)-1",
+	"SBIT = 1<<4",
+	"PBIT = 1<<5",
+	"WBIT = 1<<6",
+	"FBIT = 1<<7",
+	"UBIT = 1<<7",
+	"SCOND_XOR = 14",
+	"SCOND_EQ = 0 ^ C_SCOND_XOR",
+	"SCOND_NE = 1 ^ C_SCOND_XOR",
+	"SCOND_HS = 2 ^ C_SCOND_XOR",
+	"SCOND_LO = 3 ^ C_SCOND_XOR",
+	"SCOND_MI = 4 ^ C_SCOND_XOR",
+	"SCOND_PL = 5 ^ C_SCOND_XOR",
+	"SCOND_VS = 6 ^ C_SCOND_XOR",
+	"SCOND_VC = 7 ^ C_SCOND_XOR",
+	"SCOND_HI = 8 ^ C_SCOND_XOR",
+	"SCOND_LS = 9 ^ C_SCOND_XOR",
+	"SCOND_GE = 10 ^ C_SCOND_XOR",
+	"SCOND_LT = 11 ^ C_SCOND_XOR",
+	"SCOND_GT = 12 ^ C_SCOND_XOR",
+	"SCOND_LE = 13 ^ C_SCOND_XOR",
+	"SCOND_NONE = 14 ^ C_SCOND_XOR",
+	"SCOND_NV = 15 ^ C_SCOND_XOR",
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/asm5.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/asm5.go
new file mode 100644
index 000000000..924657fb3
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/asm5.go
@@ -0,0 +1,3096 @@
+// Inferno utils/5l/span.c
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/5l/span.c
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package arm
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"fmt"
+	"log"
+	"math"
+	"sort"
+)
+
+// ctxt5 holds state while assembling a single function.
+// Each function gets a fresh ctxt5.
+// This allows for multiple functions to be safely concurrently assembled.
+type ctxt5 struct {
+	ctxt       *obj.Link
+	newprog    obj.ProgAlloc
+	cursym     *obj.LSym
+	printp     *obj.Prog
+	blitrl     *obj.Prog
+	elitrl     *obj.Prog
+	autosize   int64
+	instoffset int64
+	pc         int64
+	pool       struct {
+		start uint32
+		size  uint32
+		extra uint32
+	}
+}
+
+type Optab struct {
+	as       obj.As
+	a1       uint8
+	a2       int8
+	a3       uint8
+	type_    uint8
+	size     int8
+	param    int16
+	flag     int8
+	pcrelsiz uint8
+	scond    uint8 // optional flags accepted by the instruction
+}
+
+type Opcross [32][2][32]uint8
+
+const (
+	LFROM  = 1 << 0
+	LTO    = 1 << 1
+	LPOOL  = 1 << 2
+	LPCREL = 1 << 3
+)
+
+var optab = []Optab{
+	/* struct Optab:
+	OPCODE, from, prog->reg, to, type, size, param, flag, extra data size, optional suffix */
+	{obj.ATEXT, C_ADDR, C_NONE, C_TEXTSIZE, 0, 0, 0, 0, 0, 0},
+	{AADD, C_REG, C_REG, C_REG, 1, 4, 0, 0, 0, C_SBIT},
+	{AADD, C_REG, C_NONE, C_REG, 1, 4, 0, 0, 0, C_SBIT},
+	{AAND, C_REG, C_REG, C_REG, 1, 4, 0, 0, 0, C_SBIT},
+	{AAND, C_REG, C_NONE, C_REG, 1, 4, 0, 0, 0, C_SBIT},
+	{AORR, C_REG, C_REG, C_REG, 1, 4, 0, 0, 0, C_SBIT},
+	{AORR, C_REG, C_NONE, C_REG, 1, 4, 0, 0, 0, C_SBIT},
+	{AMOVW, C_REG, C_NONE, C_REG, 1, 4, 0, 0, 0, C_SBIT},
+	{AMVN, C_REG, C_NONE, C_REG, 1, 4, 0, 0, 0, C_SBIT},
+	{ACMP, C_REG, C_REG, C_NONE, 1, 4, 0, 0, 0, 0},
+	{AADD, C_RCON, C_REG, C_REG, 2, 4, 0, 0, 0, C_SBIT},
+	{AADD, C_RCON, C_NONE, C_REG, 2, 4, 0, 0, 0, C_SBIT},
+	{AAND, C_RCON, C_REG, C_REG, 2, 4, 0, 0, 0, C_SBIT},
+	{AAND, C_RCON, C_NONE, C_REG, 2, 4, 0, 0, 0, C_SBIT},
+	{AORR, C_RCON, C_REG, C_REG, 2, 4, 0, 0, 0, C_SBIT},
+	{AORR, C_RCON, C_NONE, C_REG, 2, 4, 0, 0, 0, C_SBIT},
+	{AMOVW, C_RCON, C_NONE, C_REG, 2, 4, 0, 0, 0, 0},
+	{AMVN, C_RCON, C_NONE, C_REG, 2, 4, 0, 0, 0, 0},
+	{ACMP, C_RCON, C_REG, C_NONE, 2, 4, 0, 0, 0, 0},
+	{AADD, C_SHIFT, C_REG, C_REG, 3, 4, 0, 0, 0, C_SBIT},
+	{AADD, C_SHIFT, C_NONE, C_REG, 3, 4, 0, 0, 0, C_SBIT},
+	{AAND, C_SHIFT, C_REG, C_REG, 3, 4, 0, 0, 0, C_SBIT},
+	{AAND, C_SHIFT, C_NONE, C_REG, 3, 4, 0, 0, 0, C_SBIT},
+	{AORR, C_SHIFT, C_REG, C_REG, 3, 4, 0, 0, 0, C_SBIT},
+	{AORR, C_SHIFT, C_NONE, C_REG, 3, 4, 0, 0, 0, C_SBIT},
+	{AMVN, C_SHIFT, C_NONE, C_REG, 3, 4, 0, 0, 0, C_SBIT},
+	{ACMP, C_SHIFT, C_REG, C_NONE, 3, 4, 0, 0, 0, 0},
+	{AMOVW, C_RACON, C_NONE, C_REG, 4, 4, REGSP, 0, 0, C_SBIT},
+	{AB, C_NONE, C_NONE, C_SBRA, 5, 4, 0, LPOOL, 0, 0},
+	{ABL, C_NONE, C_NONE, C_SBRA, 5, 4, 0, 0, 0, 0},
+	{ABX, C_NONE, C_NONE, C_SBRA, 74, 20, 0, 0, 0, 0},
+	{ABEQ, C_NONE, C_NONE, C_SBRA, 5, 4, 0, 0, 0, 0},
+	{ABEQ, C_RCON, C_NONE, C_SBRA, 5, 4, 0, 0, 0, 0}, // prediction hinted form, hint ignored
+	{AB, C_NONE, C_NONE, C_ROREG, 6, 4, 0, LPOOL, 0, 0},
+	{ABL, C_NONE, C_NONE, C_ROREG, 7, 4, 0, 0, 0, 0},
+	{ABL, C_REG, C_NONE, C_ROREG, 7, 4, 0, 0, 0, 0},
+	{ABX, C_NONE, C_NONE, C_ROREG, 75, 12, 0, 0, 0, 0},
+	{ABXRET, C_NONE, C_NONE, C_ROREG, 76, 4, 0, 0, 0, 0},
+	{ASLL, C_RCON, C_REG, C_REG, 8, 4, 0, 0, 0, C_SBIT},
+	{ASLL, C_RCON, C_NONE, C_REG, 8, 4, 0, 0, 0, C_SBIT},
+	{ASLL, C_REG, C_NONE, C_REG, 9, 4, 0, 0, 0, C_SBIT},
+	{ASLL, C_REG, C_REG, C_REG, 9, 4, 0, 0, 0, C_SBIT},
+	{ASWI, C_NONE, C_NONE, C_NONE, 10, 4, 0, 0, 0, 0},
+	{ASWI, C_NONE, C_NONE, C_LCON, 10, 4, 0, 0, 0, 0},
+	{AWORD, C_NONE, C_NONE, C_LCON, 11, 4, 0, 0, 0, 0},
+	{AWORD, C_NONE, C_NONE, C_LCONADDR, 11, 4, 0, 0, 0, 0},
+	{AWORD, C_NONE, C_NONE, C_ADDR, 11, 4, 0, 0, 0, 0},
+	{AWORD, C_NONE, C_NONE, C_TLS_LE, 103, 4, 0, 0, 0, 0},
+	{AWORD, C_NONE, C_NONE, C_TLS_IE, 104, 4, 0, 0, 0, 0},
+	{AMOVW, C_NCON, C_NONE, C_REG, 12, 4, 0, 0, 0, 0},
+	{AMOVW, C_SCON, C_NONE, C_REG, 12, 4, 0, 0, 0, 0},
+	{AMOVW, C_LCON, C_NONE, C_REG, 12, 4, 0, LFROM, 0, 0},
+	{AMOVW, C_LCONADDR, C_NONE, C_REG, 12, 4, 0, LFROM | LPCREL, 4, 0},
+	{AMVN, C_NCON, C_NONE, C_REG, 12, 4, 0, 0, 0, 0},
+	{AADD, C_NCON, C_REG, C_REG, 13, 8, 0, 0, 0, C_SBIT},
+	{AADD, C_NCON, C_NONE, C_REG, 13, 8, 0, 0, 0, C_SBIT},
+	{AAND, C_NCON, C_REG, C_REG, 13, 8, 0, 0, 0, C_SBIT},
+	{AAND, C_NCON, C_NONE, C_REG, 13, 8, 0, 0, 0, C_SBIT},
+	{AORR, C_NCON, C_REG, C_REG, 13, 8, 0, 0, 0, C_SBIT},
+	{AORR, C_NCON, C_NONE, C_REG, 13, 8, 0, 0, 0, C_SBIT},
+	{ACMP, C_NCON, C_REG, C_NONE, 13, 8, 0, 0, 0, 0},
+	{AADD, C_SCON, C_REG, C_REG, 13, 8, 0, 0, 0, C_SBIT},
+	{AADD, C_SCON, C_NONE, C_REG, 13, 8, 0, 0, 0, C_SBIT},
+	{AAND, C_SCON, C_REG, C_REG, 13, 8, 0, 0, 0, C_SBIT},
+	{AAND, C_SCON, C_NONE, C_REG, 13, 8, 0, 0, 0, C_SBIT},
+	{AORR, C_SCON, C_REG, C_REG, 13, 8, 0, 0, 0, C_SBIT},
+	{AORR, C_SCON, C_NONE, C_REG, 13, 8, 0, 0, 0, C_SBIT},
+	{AMVN, C_SCON, C_NONE, C_REG, 13, 8, 0, 0, 0, 0},
+	{ACMP, C_SCON, C_REG, C_NONE, 13, 8, 0, 0, 0, 0},
+	{AADD, C_RCON2A, C_REG, C_REG, 106, 8, 0, 0, 0, 0},
+	{AADD, C_RCON2A, C_NONE, C_REG, 106, 8, 0, 0, 0, 0},
+	{AORR, C_RCON2A, C_REG, C_REG, 106, 8, 0, 0, 0, 0},
+	{AORR, C_RCON2A, C_NONE, C_REG, 106, 8, 0, 0, 0, 0},
+	{AADD, C_RCON2S, C_REG, C_REG, 107, 8, 0, 0, 0, 0},
+	{AADD, C_RCON2S, C_NONE, C_REG, 107, 8, 0, 0, 0, 0},
+	{AADD, C_LCON, C_REG, C_REG, 13, 8, 0, LFROM, 0, C_SBIT},
+	{AADD, C_LCON, C_NONE, C_REG, 13, 8, 0, LFROM, 0, C_SBIT},
+	{AAND, C_LCON, C_REG, C_REG, 13, 8, 0, LFROM, 0, C_SBIT},
+	{AAND, C_LCON, C_NONE, C_REG, 13, 8, 0, LFROM, 0, C_SBIT},
+	{AORR, C_LCON, C_REG, C_REG, 13, 8, 0, LFROM, 0, C_SBIT},
+	{AORR, C_LCON, C_NONE, C_REG, 13, 8, 0, LFROM, 0, C_SBIT},
+	{AMVN, C_LCON, C_NONE, C_REG, 13, 8, 0, LFROM, 0, 0},
+	{ACMP, C_LCON, C_REG, C_NONE, 13, 8, 0, LFROM, 0, 0},
+	{AMOVB, C_REG, C_NONE, C_REG, 1, 4, 0, 0, 0, 0},
+	{AMOVBS, C_REG, C_NONE, C_REG, 14, 8, 0, 0, 0, 0},
+	{AMOVBU, C_REG, C_NONE, C_REG, 58, 4, 0, 0, 0, 0},
+	{AMOVH, C_REG, C_NONE, C_REG, 1, 4, 0, 0, 0, 0},
+	{AMOVHS, C_REG, C_NONE, C_REG, 14, 8, 0, 0, 0, 0},
+	{AMOVHU, C_REG, C_NONE, C_REG, 14, 8, 0, 0, 0, 0},
+	{AMUL, C_REG, C_REG, C_REG, 15, 4, 0, 0, 0, C_SBIT},
+	{AMUL, C_REG, C_NONE, C_REG, 15, 4, 0, 0, 0, C_SBIT},
+	{ADIV, C_REG, C_REG, C_REG, 16, 4, 0, 0, 0, 0},
+	{ADIV, C_REG, C_NONE, C_REG, 16, 4, 0, 0, 0, 0},
+	{ADIVHW, C_REG, C_REG, C_REG, 105, 4, 0, 0, 0, 0},
+	{ADIVHW, C_REG, C_NONE, C_REG, 105, 4, 0, 0, 0, 0},
+	{AMULL, C_REG, C_REG, C_REGREG, 17, 4, 0, 0, 0, C_SBIT},
+	{ABFX, C_LCON, C_REG, C_REG, 18, 4, 0, 0, 0, 0},  // width in From, LSB in From3
+	{ABFX, C_LCON, C_NONE, C_REG, 18, 4, 0, 0, 0, 0}, // width in From, LSB in From3
+	{AMOVW, C_REG, C_NONE, C_SAUTO, 20, 4, REGSP, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVW, C_REG, C_NONE, C_SOREG, 20, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVB, C_REG, C_NONE, C_SAUTO, 20, 4, REGSP, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVB, C_REG, C_NONE, C_SOREG, 20, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBS, C_REG, C_NONE, C_SAUTO, 20, 4, REGSP, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBS, C_REG, C_NONE, C_SOREG, 20, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBU, C_REG, C_NONE, C_SAUTO, 20, 4, REGSP, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBU, C_REG, C_NONE, C_SOREG, 20, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVW, C_SAUTO, C_NONE, C_REG, 21, 4, REGSP, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVW, C_SOREG, C_NONE, C_REG, 21, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBU, C_SAUTO, C_NONE, C_REG, 21, 4, REGSP, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBU, C_SOREG, C_NONE, C_REG, 21, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AXTAB, C_SHIFT, C_REG, C_REG, 22, 4, 0, 0, 0, 0},
+	{AXTAB, C_SHIFT, C_NONE, C_REG, 22, 4, 0, 0, 0, 0},
+	{AMOVW, C_SHIFT, C_NONE, C_REG, 23, 4, 0, 0, 0, C_SBIT},
+	{AMOVB, C_SHIFT, C_NONE, C_REG, 23, 4, 0, 0, 0, 0},
+	{AMOVBS, C_SHIFT, C_NONE, C_REG, 23, 4, 0, 0, 0, 0},
+	{AMOVBU, C_SHIFT, C_NONE, C_REG, 23, 4, 0, 0, 0, 0},
+	{AMOVH, C_SHIFT, C_NONE, C_REG, 23, 4, 0, 0, 0, 0},
+	{AMOVHS, C_SHIFT, C_NONE, C_REG, 23, 4, 0, 0, 0, 0},
+	{AMOVHU, C_SHIFT, C_NONE, C_REG, 23, 4, 0, 0, 0, 0},
+	{AMOVW, C_REG, C_NONE, C_LAUTO, 30, 8, REGSP, LTO, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVW, C_REG, C_NONE, C_LOREG, 30, 8, 0, LTO, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVW, C_REG, C_NONE, C_ADDR, 64, 8, 0, LTO | LPCREL, 4, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVB, C_REG, C_NONE, C_LAUTO, 30, 8, REGSP, LTO, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVB, C_REG, C_NONE, C_LOREG, 30, 8, 0, LTO, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVB, C_REG, C_NONE, C_ADDR, 64, 8, 0, LTO | LPCREL, 4, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBS, C_REG, C_NONE, C_LAUTO, 30, 8, REGSP, LTO, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBS, C_REG, C_NONE, C_LOREG, 30, 8, 0, LTO, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBS, C_REG, C_NONE, C_ADDR, 64, 8, 0, LTO | LPCREL, 4, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBU, C_REG, C_NONE, C_LAUTO, 30, 8, REGSP, LTO, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBU, C_REG, C_NONE, C_LOREG, 30, 8, 0, LTO, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBU, C_REG, C_NONE, C_ADDR, 64, 8, 0, LTO | LPCREL, 4, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVW, C_TLS_LE, C_NONE, C_REG, 101, 4, 0, LFROM, 0, 0},
+	{AMOVW, C_TLS_IE, C_NONE, C_REG, 102, 8, 0, LFROM, 0, 0},
+	{AMOVW, C_LAUTO, C_NONE, C_REG, 31, 8, REGSP, LFROM, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVW, C_LOREG, C_NONE, C_REG, 31, 8, 0, LFROM, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVW, C_ADDR, C_NONE, C_REG, 65, 8, 0, LFROM | LPCREL, 4, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBU, C_LAUTO, C_NONE, C_REG, 31, 8, REGSP, LFROM, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBU, C_LOREG, C_NONE, C_REG, 31, 8, 0, LFROM, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBU, C_ADDR, C_NONE, C_REG, 65, 8, 0, LFROM | LPCREL, 4, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVW, C_LACON, C_NONE, C_REG, 34, 8, REGSP, LFROM, 0, C_SBIT},
+	{AMOVW, C_PSR, C_NONE, C_REG, 35, 4, 0, 0, 0, 0},
+	{AMOVW, C_REG, C_NONE, C_PSR, 36, 4, 0, 0, 0, 0},
+	{AMOVW, C_RCON, C_NONE, C_PSR, 37, 4, 0, 0, 0, 0},
+	{AMOVM, C_REGLIST, C_NONE, C_SOREG, 38, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVM, C_SOREG, C_NONE, C_REGLIST, 39, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{ASWPW, C_SOREG, C_REG, C_REG, 40, 4, 0, 0, 0, 0},
+	{ARFE, C_NONE, C_NONE, C_NONE, 41, 4, 0, 0, 0, 0},
+	{AMOVF, C_FREG, C_NONE, C_FAUTO, 50, 4, REGSP, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVF, C_FREG, C_NONE, C_FOREG, 50, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVF, C_FAUTO, C_NONE, C_FREG, 51, 4, REGSP, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVF, C_FOREG, C_NONE, C_FREG, 51, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVF, C_FREG, C_NONE, C_LAUTO, 52, 12, REGSP, LTO, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVF, C_FREG, C_NONE, C_LOREG, 52, 12, 0, LTO, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVF, C_LAUTO, C_NONE, C_FREG, 53, 12, REGSP, LFROM, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVF, C_LOREG, C_NONE, C_FREG, 53, 12, 0, LFROM, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVF, C_FREG, C_NONE, C_ADDR, 68, 8, 0, LTO | LPCREL, 4, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVF, C_ADDR, C_NONE, C_FREG, 69, 8, 0, LFROM | LPCREL, 4, C_PBIT | C_WBIT | C_UBIT},
+	{AADDF, C_FREG, C_NONE, C_FREG, 54, 4, 0, 0, 0, 0},
+	{AADDF, C_FREG, C_FREG, C_FREG, 54, 4, 0, 0, 0, 0},
+	{AMOVF, C_FREG, C_NONE, C_FREG, 55, 4, 0, 0, 0, 0},
+	{ANEGF, C_FREG, C_NONE, C_FREG, 55, 4, 0, 0, 0, 0},
+	{AMOVW, C_REG, C_NONE, C_FCR, 56, 4, 0, 0, 0, 0},
+	{AMOVW, C_FCR, C_NONE, C_REG, 57, 4, 0, 0, 0, 0},
+	{AMOVW, C_SHIFTADDR, C_NONE, C_REG, 59, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBU, C_SHIFTADDR, C_NONE, C_REG, 59, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVB, C_SHIFTADDR, C_NONE, C_REG, 60, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBS, C_SHIFTADDR, C_NONE, C_REG, 60, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVH, C_SHIFTADDR, C_NONE, C_REG, 60, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHS, C_SHIFTADDR, C_NONE, C_REG, 60, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHU, C_SHIFTADDR, C_NONE, C_REG, 60, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVW, C_REG, C_NONE, C_SHIFTADDR, 61, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVB, C_REG, C_NONE, C_SHIFTADDR, 61, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBS, C_REG, C_NONE, C_SHIFTADDR, 61, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBU, C_REG, C_NONE, C_SHIFTADDR, 61, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVH, C_REG, C_NONE, C_SHIFTADDR, 62, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHS, C_REG, C_NONE, C_SHIFTADDR, 62, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHU, C_REG, C_NONE, C_SHIFTADDR, 62, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVH, C_REG, C_NONE, C_HAUTO, 70, 4, REGSP, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVH, C_REG, C_NONE, C_HOREG, 70, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHS, C_REG, C_NONE, C_HAUTO, 70, 4, REGSP, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHS, C_REG, C_NONE, C_HOREG, 70, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHU, C_REG, C_NONE, C_HAUTO, 70, 4, REGSP, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHU, C_REG, C_NONE, C_HOREG, 70, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVB, C_HAUTO, C_NONE, C_REG, 71, 4, REGSP, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVB, C_HOREG, C_NONE, C_REG, 71, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBS, C_HAUTO, C_NONE, C_REG, 71, 4, REGSP, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBS, C_HOREG, C_NONE, C_REG, 71, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVH, C_HAUTO, C_NONE, C_REG, 71, 4, REGSP, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVH, C_HOREG, C_NONE, C_REG, 71, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHS, C_HAUTO, C_NONE, C_REG, 71, 4, REGSP, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHS, C_HOREG, C_NONE, C_REG, 71, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHU, C_HAUTO, C_NONE, C_REG, 71, 4, REGSP, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHU, C_HOREG, C_NONE, C_REG, 71, 4, 0, 0, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVH, C_REG, C_NONE, C_LAUTO, 72, 8, REGSP, LTO, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVH, C_REG, C_NONE, C_LOREG, 72, 8, 0, LTO, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVH, C_REG, C_NONE, C_ADDR, 94, 8, 0, LTO | LPCREL, 4, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHS, C_REG, C_NONE, C_LAUTO, 72, 8, REGSP, LTO, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHS, C_REG, C_NONE, C_LOREG, 72, 8, 0, LTO, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHS, C_REG, C_NONE, C_ADDR, 94, 8, 0, LTO | LPCREL, 4, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHU, C_REG, C_NONE, C_LAUTO, 72, 8, REGSP, LTO, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHU, C_REG, C_NONE, C_LOREG, 72, 8, 0, LTO, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHU, C_REG, C_NONE, C_ADDR, 94, 8, 0, LTO | LPCREL, 4, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVB, C_LAUTO, C_NONE, C_REG, 73, 8, REGSP, LFROM, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVB, C_LOREG, C_NONE, C_REG, 73, 8, 0, LFROM, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVB, C_ADDR, C_NONE, C_REG, 93, 8, 0, LFROM | LPCREL, 4, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBS, C_LAUTO, C_NONE, C_REG, 73, 8, REGSP, LFROM, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBS, C_LOREG, C_NONE, C_REG, 73, 8, 0, LFROM, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVBS, C_ADDR, C_NONE, C_REG, 93, 8, 0, LFROM | LPCREL, 4, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVH, C_LAUTO, C_NONE, C_REG, 73, 8, REGSP, LFROM, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVH, C_LOREG, C_NONE, C_REG, 73, 8, 0, LFROM, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVH, C_ADDR, C_NONE, C_REG, 93, 8, 0, LFROM | LPCREL, 4, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHS, C_LAUTO, C_NONE, C_REG, 73, 8, REGSP, LFROM, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHS, C_LOREG, C_NONE, C_REG, 73, 8, 0, LFROM, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHS, C_ADDR, C_NONE, C_REG, 93, 8, 0, LFROM | LPCREL, 4, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHU, C_LAUTO, C_NONE, C_REG, 73, 8, REGSP, LFROM, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHU, C_LOREG, C_NONE, C_REG, 73, 8, 0, LFROM, 0, C_PBIT | C_WBIT | C_UBIT},
+	{AMOVHU, C_ADDR, C_NONE, C_REG, 93, 8, 0, LFROM | LPCREL, 4, C_PBIT | C_WBIT | C_UBIT},
+	{ALDREX, C_SOREG, C_NONE, C_REG, 77, 4, 0, 0, 0, 0},
+	{ASTREX, C_SOREG, C_REG, C_REG, 78, 4, 0, 0, 0, 0},
+	{ADMB, C_NONE, C_NONE, C_NONE, 110, 4, 0, 0, 0, 0},
+	{ADMB, C_LCON, C_NONE, C_NONE, 110, 4, 0, 0, 0, 0},
+	{ADMB, C_SPR, C_NONE, C_NONE, 110, 4, 0, 0, 0, 0},
+	{AMOVF, C_ZFCON, C_NONE, C_FREG, 80, 8, 0, 0, 0, 0},
+	{AMOVF, C_SFCON, C_NONE, C_FREG, 81, 4, 0, 0, 0, 0},
+	{ACMPF, C_FREG, C_FREG, C_NONE, 82, 8, 0, 0, 0, 0},
+	{ACMPF, C_FREG, C_NONE, C_NONE, 83, 8, 0, 0, 0, 0},
+	{AMOVFW, C_FREG, C_NONE, C_FREG, 84, 4, 0, 0, 0, C_UBIT},
+	{AMOVWF, C_FREG, C_NONE, C_FREG, 85, 4, 0, 0, 0, C_UBIT},
+	{AMOVFW, C_FREG, C_NONE, C_REG, 86, 8, 0, 0, 0, C_UBIT},
+	{AMOVWF, C_REG, C_NONE, C_FREG, 87, 8, 0, 0, 0, C_UBIT},
+	{AMOVW, C_REG, C_NONE, C_FREG, 88, 4, 0, 0, 0, 0},
+	{AMOVW, C_FREG, C_NONE, C_REG, 89, 4, 0, 0, 0, 0},
+	{ALDREXD, C_SOREG, C_NONE, C_REG, 91, 4, 0, 0, 0, 0},
+	{ASTREXD, C_SOREG, C_REG, C_REG, 92, 4, 0, 0, 0, 0},
+	{APLD, C_SOREG, C_NONE, C_NONE, 95, 4, 0, 0, 0, 0},
+	{obj.AUNDEF, C_NONE, C_NONE, C_NONE, 96, 4, 0, 0, 0, 0},
+	{ACLZ, C_REG, C_NONE, C_REG, 97, 4, 0, 0, 0, 0},
+	{AMULWT, C_REG, C_REG, C_REG, 98, 4, 0, 0, 0, 0},
+	{AMULA, C_REG, C_REG, C_REGREG2, 99, 4, 0, 0, 0, C_SBIT},
+	{AMULAWT, C_REG, C_REG, C_REGREG2, 99, 4, 0, 0, 0, 0},
+	{obj.APCDATA, C_LCON, C_NONE, C_LCON, 0, 0, 0, 0, 0, 0},
+	{obj.AFUNCDATA, C_LCON, C_NONE, C_ADDR, 0, 0, 0, 0, 0, 0},
+	{obj.ANOP, C_NONE, C_NONE, C_NONE, 0, 0, 0, 0, 0, 0},
+	{obj.ANOP, C_LCON, C_NONE, C_NONE, 0, 0, 0, 0, 0, 0}, // nop variants, see #40689
+	{obj.ANOP, C_REG, C_NONE, C_NONE, 0, 0, 0, 0, 0, 0},
+	{obj.ANOP, C_FREG, C_NONE, C_NONE, 0, 0, 0, 0, 0, 0},
+	{obj.ADUFFZERO, C_NONE, C_NONE, C_SBRA, 5, 4, 0, 0, 0, 0}, // same as ABL
+	{obj.ADUFFCOPY, C_NONE, C_NONE, C_SBRA, 5, 4, 0, 0, 0, 0}, // same as ABL
+	{obj.AXXX, C_NONE, C_NONE, C_NONE, 0, 4, 0, 0, 0, 0},
+}
+
+var mbOp = []struct {
+	reg int16
+	enc uint32
+}{
+	{REG_MB_SY, 15},
+	{REG_MB_ST, 14},
+	{REG_MB_ISH, 11},
+	{REG_MB_ISHST, 10},
+	{REG_MB_NSH, 7},
+	{REG_MB_NSHST, 6},
+	{REG_MB_OSH, 3},
+	{REG_MB_OSHST, 2},
+}
+
+var oprange [ALAST & obj.AMask][]Optab
+
+var xcmp [C_GOK + 1][C_GOK + 1]bool
+
+var (
+	deferreturn *obj.LSym
+	symdiv      *obj.LSym
+	symdivu     *obj.LSym
+	symmod      *obj.LSym
+	symmodu     *obj.LSym
+)
+
+// Note about encoding: Prog.scond holds the condition encoding,
+// but XOR'ed with C_SCOND_XOR, so that C_SCOND_NONE == 0.
+// The code that shifts the value << 28 has the responsibility
+// for XORing with C_SCOND_XOR too.
+
+func checkSuffix(c *ctxt5, p *obj.Prog, o *Optab) {
+	if p.Scond&C_SBIT != 0 && o.scond&C_SBIT == 0 {
+		c.ctxt.Diag("invalid .S suffix: %v", p)
+	}
+	if p.Scond&C_PBIT != 0 && o.scond&C_PBIT == 0 {
+		c.ctxt.Diag("invalid .P suffix: %v", p)
+	}
+	if p.Scond&C_WBIT != 0 && o.scond&C_WBIT == 0 {
+		c.ctxt.Diag("invalid .W suffix: %v", p)
+	}
+	if p.Scond&C_UBIT != 0 && o.scond&C_UBIT == 0 {
+		c.ctxt.Diag("invalid .U suffix: %v", p)
+	}
+}
+
+func span5(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
+	if ctxt.Retpoline {
+		ctxt.Diag("-spectre=ret not supported on arm")
+		ctxt.Retpoline = false // don't keep printing
+	}
+
+	var p *obj.Prog
+	var op *obj.Prog
+
+	p = cursym.Func.Text
+	if p == nil || p.Link == nil { // handle external functions and ELF section symbols
+		return
+	}
+
+	if oprange[AAND&obj.AMask] == nil {
+		ctxt.Diag("arm ops not initialized, call arm.buildop first")
+	}
+
+	c := ctxt5{ctxt: ctxt, newprog: newprog, cursym: cursym, autosize: p.To.Offset + 4}
+	pc := int32(0)
+
+	op = p
+	p = p.Link
+	var m int
+	var o *Optab
+	for ; p != nil || c.blitrl != nil; op, p = p, p.Link {
+		if p == nil {
+			if c.checkpool(op, pc) {
+				p = op
+				continue
+			}
+
+			// can't happen: blitrl is not nil, but checkpool didn't flushpool
+			ctxt.Diag("internal inconsistency")
+
+			break
+		}
+
+		p.Pc = int64(pc)
+		o = c.oplook(p)
+		m = int(o.size)
+
+		if m%4 != 0 || p.Pc%4 != 0 {
+			ctxt.Diag("!pc invalid: %v size=%d", p, m)
+		}
+
+		// must check literal pool here in case p generates many instructions
+		if c.blitrl != nil {
+			// Emit the constant pool just before p if p
+			// would push us over the immediate size limit.
+			if c.checkpool(op, pc+int32(m)) {
+				// Back up to the instruction just
+				// before the pool and continue with
+				// the first instruction of the pool.
+				p = op
+				continue
+			}
+		}
+
+		if m == 0 && (p.As != obj.AFUNCDATA && p.As != obj.APCDATA && p.As != obj.ANOP) {
+			ctxt.Diag("zero-width instruction\n%v", p)
+			continue
+		}
+
+		switch o.flag & (LFROM | LTO | LPOOL) {
+		case LFROM:
+			c.addpool(p, &p.From)
+
+		case LTO:
+			c.addpool(p, &p.To)
+
+		case LPOOL:
+			if p.Scond&C_SCOND == C_SCOND_NONE {
+				c.flushpool(p, 0, 0)
+			}
+		}
+
+		if p.As == AMOVW && p.To.Type == obj.TYPE_REG && p.To.Reg == REGPC && p.Scond&C_SCOND == C_SCOND_NONE {
+			c.flushpool(p, 0, 0)
+		}
+
+		pc += int32(m)
+	}
+
+	c.cursym.Size = int64(pc)
+
+	/*
+	 * if any procedure is large enough to
+	 * generate a large SBRA branch, then
+	 * generate extra passes putting branches
+	 * around jmps to fix. this is rare.
+	 */
+	times := 0
+
+	var bflag int
+	var opc int32
+	var out [6 + 3]uint32
+	for {
+		bflag = 0
+		pc = 0
+		times++
+		c.cursym.Func.Text.Pc = 0 // force re-layout the code.
+		for p = c.cursym.Func.Text; p != nil; p = p.Link {
+			o = c.oplook(p)
+			if int64(pc) > p.Pc {
+				p.Pc = int64(pc)
+			}
+
+			/* very large branches
+			if(o->type == 6 && p->pcond) {
+				otxt = p->pcond->pc - c;
+				if(otxt < 0)
+					otxt = -otxt;
+				if(otxt >= (1L<<17) - 10) {
+					q = emallocz(sizeof(Prog));
+					q->link = p->link;
+					p->link = q;
+					q->as = AB;
+					q->to.type = TYPE_BRANCH;
+					q->pcond = p->pcond;
+					p->pcond = q;
+					q = emallocz(sizeof(Prog));
+					q->link = p->link;
+					p->link = q;
+					q->as = AB;
+					q->to.type = TYPE_BRANCH;
+					q->pcond = q->link->link;
+					bflag = 1;
+				}
+			}
+			*/
+			opc = int32(p.Pc)
+			m = int(o.size)
+			if p.Pc != int64(opc) {
+				bflag = 1
+			}
+
+			//print("%v pc changed %d to %d in iter. %d\n", p, opc, (int32)p->pc, times);
+			pc = int32(p.Pc + int64(m))
+
+			if m%4 != 0 || p.Pc%4 != 0 {
+				ctxt.Diag("pc invalid: %v size=%d", p, m)
+			}
+
+			if m/4 > len(out) {
+				ctxt.Diag("instruction size too large: %d > %d", m/4, len(out))
+			}
+			if m == 0 && (p.As != obj.AFUNCDATA && p.As != obj.APCDATA && p.As != obj.ANOP) {
+				if p.As == obj.ATEXT {
+					c.autosize = p.To.Offset + 4
+					continue
+				}
+
+				ctxt.Diag("zero-width instruction\n%v", p)
+				continue
+			}
+		}
+
+		c.cursym.Size = int64(pc)
+		if bflag == 0 {
+			break
+		}
+	}
+
+	if pc%4 != 0 {
+		ctxt.Diag("sym->size=%d, invalid", pc)
+	}
+
+	/*
+	 * lay out the code.  all the pc-relative code references,
+	 * even cross-function, are resolved now;
+	 * only data references need to be relocated.
+	 * with more work we could leave cross-function
+	 * code references to be relocated too, and then
+	 * perhaps we'd be able to parallelize the span loop above.
+	 */
+
+	p = c.cursym.Func.Text
+	c.autosize = p.To.Offset + 4
+	c.cursym.Grow(c.cursym.Size)
+
+	bp := c.cursym.P
+	pc = int32(p.Pc) // even p->link might need extra padding
+	var v int
+	for p = p.Link; p != nil; p = p.Link {
+		c.pc = p.Pc
+		o = c.oplook(p)
+		opc = int32(p.Pc)
+		c.asmout(p, o, out[:])
+		m = int(o.size)
+
+		if m%4 != 0 || p.Pc%4 != 0 {
+			ctxt.Diag("final stage: pc invalid: %v size=%d", p, m)
+		}
+
+		if int64(pc) > p.Pc {
+			ctxt.Diag("PC padding invalid: want %#d, has %#d: %v", p.Pc, pc, p)
+		}
+		for int64(pc) != p.Pc {
+			// emit 0xe1a00000 (MOVW R0, R0)
+			bp[0] = 0x00
+			bp = bp[1:]
+
+			bp[0] = 0x00
+			bp = bp[1:]
+			bp[0] = 0xa0
+			bp = bp[1:]
+			bp[0] = 0xe1
+			bp = bp[1:]
+			pc += 4
+		}
+
+		for i := 0; i < m/4; i++ {
+			v = int(out[i])
+			bp[0] = byte(v)
+			bp = bp[1:]
+			bp[0] = byte(v >> 8)
+			bp = bp[1:]
+			bp[0] = byte(v >> 16)
+			bp = bp[1:]
+			bp[0] = byte(v >> 24)
+			bp = bp[1:]
+		}
+
+		pc += int32(m)
+	}
+}
+
+// checkpool flushes the literal pool when the first reference to
+// it threatens to go out of range of a 12-bit PC-relative offset.
+//
+// nextpc is the tentative next PC at which the pool could be emitted.
+// checkpool should be called *before* emitting the instruction that
+// would cause the PC to reach nextpc.
+// If nextpc is too far from the first pool reference, checkpool will
+// flush the pool immediately after p.
+// The caller should resume processing a p.Link.
+func (c *ctxt5) checkpool(p *obj.Prog, nextpc int32) bool {
+	poolLast := nextpc
+	poolLast += 4                      // the AB instruction to jump around the pool
+	poolLast += int32(c.pool.size) - 4 // the offset of the last pool entry
+
+	refPC := int32(c.pool.start) // PC of the first pool reference
+
+	v := poolLast - refPC - 8 // 12-bit PC-relative offset (see omvl)
+
+	if c.pool.size >= 0xff0 || immaddr(v) == 0 {
+		return c.flushpool(p, 1, 0)
+	} else if p.Link == nil {
+		return c.flushpool(p, 2, 0)
+	}
+	return false
+}
+
+func (c *ctxt5) flushpool(p *obj.Prog, skip int, force int) bool {
+	if c.blitrl != nil {
+		if skip != 0 {
+			if false && skip == 1 {
+				fmt.Printf("note: flush literal pool at %x: len=%d ref=%x\n", uint64(p.Pc+4), c.pool.size, c.pool.start)
+			}
+			q := c.newprog()
+			q.As = AB
+			q.To.Type = obj.TYPE_BRANCH
+			q.To.SetTarget(p.Link)
+			q.Link = c.blitrl
+			q.Pos = p.Pos
+			c.blitrl = q
+		} else if force == 0 && (p.Pc+int64(c.pool.size)-int64(c.pool.start) < 2048) {
+			return false
+		}
+
+		// The line number for constant pool entries doesn't really matter.
+		// We set it to the line number of the preceding instruction so that
+		// there are no deltas to encode in the pc-line tables.
+		for q := c.blitrl; q != nil; q = q.Link {
+			q.Pos = p.Pos
+		}
+
+		c.elitrl.Link = p.Link
+		p.Link = c.blitrl
+
+		c.blitrl = nil /* BUG: should refer back to values until out-of-range */
+		c.elitrl = nil
+		c.pool.size = 0
+		c.pool.start = 0
+		c.pool.extra = 0
+		return true
+	}
+
+	return false
+}
+
+func (c *ctxt5) addpool(p *obj.Prog, a *obj.Addr) {
+	t := c.newprog()
+	t.As = AWORD
+
+	switch c.aclass(a) {
+	default:
+		t.To.Offset = a.Offset
+		t.To.Sym = a.Sym
+		t.To.Type = a.Type
+		t.To.Name = a.Name
+
+		if c.ctxt.Flag_shared && t.To.Sym != nil {
+			t.Rel = p
+		}
+
+	case C_SROREG,
+		C_LOREG,
+		C_ROREG,
+		C_FOREG,
+		C_SOREG,
+		C_HOREG,
+		C_FAUTO,
+		C_SAUTO,
+		C_LAUTO,
+		C_LACON:
+		t.To.Type = obj.TYPE_CONST
+		t.To.Offset = c.instoffset
+	}
+
+	if t.Rel == nil {
+		for q := c.blitrl; q != nil; q = q.Link { /* could hash on t.t0.offset */
+			if q.Rel == nil && q.To == t.To {
+				p.Pool = q
+				return
+			}
+		}
+	}
+
+	q := c.newprog()
+	*q = *t
+	q.Pc = int64(c.pool.size)
+
+	if c.blitrl == nil {
+		c.blitrl = q
+		c.pool.start = uint32(p.Pc)
+	} else {
+		c.elitrl.Link = q
+	}
+	c.elitrl = q
+	c.pool.size += 4
+
+	// Store the link to the pool entry in Pool.
+	p.Pool = q
+}
+
+func (c *ctxt5) regoff(a *obj.Addr) int32 {
+	c.instoffset = 0
+	c.aclass(a)
+	return int32(c.instoffset)
+}
+
+func immrot(v uint32) int32 {
+	for i := 0; i < 16; i++ {
+		if v&^0xff == 0 {
+			return int32(uint32(int32(i)<<8) | v | 1<<25)
+		}
+		v = v<<2 | v>>30
+	}
+
+	return 0
+}
+
+// immrot2a returns bits encoding the immediate constant fields of two instructions,
+// such that the encoded constants x, y satisfy x|y==v, x&y==0.
+// Returns 0,0 if no such decomposition of v exists.
+func immrot2a(v uint32) (uint32, uint32) {
+	for i := uint(1); i < 32; i++ {
+		m := uint32(1<<i - 1)
+		if x, y := immrot(v&m), immrot(v&^m); x != 0 && y != 0 {
+			return uint32(x), uint32(y)
+		}
+	}
+	// TODO: handle some more cases, like where
+	// the wraparound from the rotate could help.
+	return 0, 0
+}
+
+// immrot2s returns bits encoding the immediate constant fields of two instructions,
+// such that the encoded constants y, x satisfy y-x==v, y&x==0.
+// Returns 0,0 if no such decomposition of v exists.
+func immrot2s(v uint32) (uint32, uint32) {
+	if immrot(v) != 0 {
+		return v, 0
+	}
+	// suppose v in the form of {leading 00, upper effective bits, lower 8 effective bits, trailing 00}
+	// omit trailing 00
+	var i uint32
+	for i = 2; i < 32; i += 2 {
+		if v&(1<<i-1) != 0 {
+			break
+		}
+	}
+	// i must be <= 24, then adjust i just above lower 8 effective bits of v
+	i += 6
+	// let x = {the complement of lower 8 effective bits, trailing 00}, y = x + v
+	x := 1<<i - v&(1<<i-1)
+	y := v + x
+	if y, x = uint32(immrot(y)), uint32(immrot(x)); y != 0 && x != 0 {
+		return y, x
+	}
+	return 0, 0
+}
+
+func immaddr(v int32) int32 {
+	if v >= 0 && v <= 0xfff {
+		return v&0xfff | 1<<24 | 1<<23 /* pre indexing */ /* pre indexing, up */
+	}
+	if v >= -0xfff && v < 0 {
+		return -v&0xfff | 1<<24 /* pre indexing */
+	}
+	return 0
+}
+
+func immfloat(v int32) bool {
+	return v&0xC03 == 0 /* offset will fit in floating-point load/store */
+}
+
+func immhalf(v int32) bool {
+	if v >= 0 && v <= 0xff {
+		return v|1<<24|1<<23 != 0 /* pre indexing */ /* pre indexing, up */
+	}
+	if v >= -0xff && v < 0 {
+		return -v&0xff|1<<24 != 0 /* pre indexing */
+	}
+	return false
+}
+
+func (c *ctxt5) aclass(a *obj.Addr) int {
+	switch a.Type {
+	case obj.TYPE_NONE:
+		return C_NONE
+
+	case obj.TYPE_REG:
+		c.instoffset = 0
+		if REG_R0 <= a.Reg && a.Reg <= REG_R15 {
+			return C_REG
+		}
+		if REG_F0 <= a.Reg && a.Reg <= REG_F15 {
+			return C_FREG
+		}
+		if a.Reg == REG_FPSR || a.Reg == REG_FPCR {
+			return C_FCR
+		}
+		if a.Reg == REG_CPSR || a.Reg == REG_SPSR {
+			return C_PSR
+		}
+		if a.Reg >= REG_SPECIAL {
+			return C_SPR
+		}
+		return C_GOK
+
+	case obj.TYPE_REGREG:
+		return C_REGREG
+
+	case obj.TYPE_REGREG2:
+		return C_REGREG2
+
+	case obj.TYPE_REGLIST:
+		return C_REGLIST
+
+	case obj.TYPE_SHIFT:
+		if a.Reg == 0 {
+			// register shift R>>i
+			return C_SHIFT
+		} else {
+			// memory address with shifted offset R>>i(R)
+			return C_SHIFTADDR
+		}
+
+	case obj.TYPE_MEM:
+		switch a.Name {
+		case obj.NAME_EXTERN,
+			obj.NAME_GOTREF,
+			obj.NAME_STATIC:
+			if a.Sym == nil || a.Sym.Name == "" {
+				fmt.Printf("null sym external\n")
+				return C_GOK
+			}
+
+			c.instoffset = 0 // s.b. unused but just in case
+			if a.Sym.Type == objabi.STLSBSS {
+				if c.ctxt.Flag_shared {
+					return C_TLS_IE
+				} else {
+					return C_TLS_LE
+				}
+			}
+
+			return C_ADDR
+
+		case obj.NAME_AUTO:
+			if a.Reg == REGSP {
+				// unset base register for better printing, since
+				// a.Offset is still relative to pseudo-SP.
+				a.Reg = obj.REG_NONE
+			}
+			c.instoffset = c.autosize + a.Offset
+			if t := immaddr(int32(c.instoffset)); t != 0 {
+				if immhalf(int32(c.instoffset)) {
+					if immfloat(t) {
+						return C_HFAUTO
+					}
+					return C_HAUTO
+				}
+
+				if immfloat(t) {
+					return C_FAUTO
+				}
+				return C_SAUTO
+			}
+
+			return C_LAUTO
+
+		case obj.NAME_PARAM:
+			if a.Reg == REGSP {
+				// unset base register for better printing, since
+				// a.Offset is still relative to pseudo-FP.
+				a.Reg = obj.REG_NONE
+			}
+			c.instoffset = c.autosize + a.Offset + 4
+			if t := immaddr(int32(c.instoffset)); t != 0 {
+				if immhalf(int32(c.instoffset)) {
+					if immfloat(t) {
+						return C_HFAUTO
+					}
+					return C_HAUTO
+				}
+
+				if immfloat(t) {
+					return C_FAUTO
+				}
+				return C_SAUTO
+			}
+
+			return C_LAUTO
+
+		case obj.NAME_NONE:
+			c.instoffset = a.Offset
+			if t := immaddr(int32(c.instoffset)); t != 0 {
+				if immhalf(int32(c.instoffset)) { /* n.b. that it will also satisfy immrot */
+					if immfloat(t) {
+						return C_HFOREG
+					}
+					return C_HOREG
+				}
+
+				if immfloat(t) {
+					return C_FOREG /* n.b. that it will also satisfy immrot */
+				}
+				if immrot(uint32(c.instoffset)) != 0 {
+					return C_SROREG
+				}
+				if immhalf(int32(c.instoffset)) {
+					return C_HOREG
+				}
+				return C_SOREG
+			}
+
+			if immrot(uint32(c.instoffset)) != 0 {
+				return C_ROREG
+			}
+			return C_LOREG
+		}
+
+		return C_GOK
+
+	case obj.TYPE_FCONST:
+		if c.chipzero5(a.Val.(float64)) >= 0 {
+			return C_ZFCON
+		}
+		if c.chipfloat5(a.Val.(float64)) >= 0 {
+			return C_SFCON
+		}
+		return C_LFCON
+
+	case obj.TYPE_TEXTSIZE:
+		return C_TEXTSIZE
+
+	case obj.TYPE_CONST,
+		obj.TYPE_ADDR:
+		switch a.Name {
+		case obj.NAME_NONE:
+			c.instoffset = a.Offset
+			if a.Reg != 0 {
+				return c.aconsize()
+			}
+
+			if immrot(uint32(c.instoffset)) != 0 {
+				return C_RCON
+			}
+			if immrot(^uint32(c.instoffset)) != 0 {
+				return C_NCON
+			}
+			if uint32(c.instoffset) <= 0xffff && objabi.GOARM == 7 {
+				return C_SCON
+			}
+			if x, y := immrot2a(uint32(c.instoffset)); x != 0 && y != 0 {
+				return C_RCON2A
+			}
+			if y, x := immrot2s(uint32(c.instoffset)); x != 0 && y != 0 {
+				return C_RCON2S
+			}
+			return C_LCON
+
+		case obj.NAME_EXTERN,
+			obj.NAME_GOTREF,
+			obj.NAME_STATIC:
+			s := a.Sym
+			if s == nil {
+				break
+			}
+			c.instoffset = 0 // s.b. unused but just in case
+			return C_LCONADDR
+
+		case obj.NAME_AUTO:
+			if a.Reg == REGSP {
+				// unset base register for better printing, since
+				// a.Offset is still relative to pseudo-SP.
+				a.Reg = obj.REG_NONE
+			}
+			c.instoffset = c.autosize + a.Offset
+			return c.aconsize()
+
+		case obj.NAME_PARAM:
+			if a.Reg == REGSP {
+				// unset base register for better printing, since
+				// a.Offset is still relative to pseudo-FP.
+				a.Reg = obj.REG_NONE
+			}
+			c.instoffset = c.autosize + a.Offset + 4
+			return c.aconsize()
+		}
+
+		return C_GOK
+
+	case obj.TYPE_BRANCH:
+		return C_SBRA
+	}
+
+	return C_GOK
+}
+
+func (c *ctxt5) aconsize() int {
+	if immrot(uint32(c.instoffset)) != 0 {
+		return C_RACON
+	}
+	if immrot(uint32(-c.instoffset)) != 0 {
+		return C_RACON
+	}
+	return C_LACON
+}
+
+func (c *ctxt5) oplook(p *obj.Prog) *Optab {
+	a1 := int(p.Optab)
+	if a1 != 0 {
+		return &optab[a1-1]
+	}
+	a1 = int(p.From.Class)
+	if a1 == 0 {
+		a1 = c.aclass(&p.From) + 1
+		p.From.Class = int8(a1)
+	}
+
+	a1--
+	a3 := int(p.To.Class)
+	if a3 == 0 {
+		a3 = c.aclass(&p.To) + 1
+		p.To.Class = int8(a3)
+	}
+
+	a3--
+	a2 := C_NONE
+	if p.Reg != 0 {
+		switch {
+		case REG_F0 <= p.Reg && p.Reg <= REG_F15:
+			a2 = C_FREG
+		case REG_R0 <= p.Reg && p.Reg <= REG_R15:
+			a2 = C_REG
+		default:
+			c.ctxt.Diag("invalid register in %v", p)
+		}
+	}
+
+	// check illegal base register
+	switch a1 {
+	case C_SOREG, C_LOREG, C_HOREG, C_FOREG, C_ROREG, C_HFOREG, C_SROREG, C_SHIFTADDR:
+		if p.From.Reg < REG_R0 || REG_R15 < p.From.Reg {
+			c.ctxt.Diag("illegal base register: %v", p)
+		}
+	default:
+	}
+	switch a3 {
+	case C_SOREG, C_LOREG, C_HOREG, C_FOREG, C_ROREG, C_HFOREG, C_SROREG, C_SHIFTADDR:
+		if p.To.Reg < REG_R0 || REG_R15 < p.To.Reg {
+			c.ctxt.Diag("illegal base register: %v", p)
+		}
+	default:
+	}
+
+	// If current instruction has a .S suffix (flags update),
+	// we must use the constant pool instead of splitting it.
+	if (a1 == C_RCON2A || a1 == C_RCON2S) && p.Scond&C_SBIT != 0 {
+		a1 = C_LCON
+	}
+	if (a3 == C_RCON2A || a3 == C_RCON2S) && p.Scond&C_SBIT != 0 {
+		a3 = C_LCON
+	}
+
+	if false { /*debug['O']*/
+		fmt.Printf("oplook %v %v %v %v\n", p.As, DRconv(a1), DRconv(a2), DRconv(a3))
+		fmt.Printf("\t\t%d %d\n", p.From.Type, p.To.Type)
+	}
+
+	ops := oprange[p.As&obj.AMask]
+	c1 := &xcmp[a1]
+	c3 := &xcmp[a3]
+	for i := range ops {
+		op := &ops[i]
+		if int(op.a2) == a2 && c1[op.a1] && c3[op.a3] {
+			p.Optab = uint16(cap(optab) - cap(ops) + i + 1)
+			checkSuffix(c, p, op)
+			return op
+		}
+	}
+
+	c.ctxt.Diag("illegal combination %v; %v %v %v; from %d %d; to %d %d", p, DRconv(a1), DRconv(a2), DRconv(a3), p.From.Type, p.From.Name, p.To.Type, p.To.Name)
+	if ops == nil {
+		ops = optab
+	}
+	return &ops[0]
+}
+
+func cmp(a int, b int) bool {
+	if a == b {
+		return true
+	}
+	switch a {
+	case C_LCON:
+		if b == C_RCON || b == C_NCON || b == C_SCON || b == C_RCON2A || b == C_RCON2S {
+			return true
+		}
+
+	case C_LACON:
+		if b == C_RACON {
+			return true
+		}
+
+	case C_LFCON:
+		if b == C_ZFCON || b == C_SFCON {
+			return true
+		}
+
+	case C_HFAUTO:
+		return b == C_HAUTO || b == C_FAUTO
+
+	case C_FAUTO, C_HAUTO:
+		return b == C_HFAUTO
+
+	case C_SAUTO:
+		return cmp(C_HFAUTO, b)
+
+	case C_LAUTO:
+		return cmp(C_SAUTO, b)
+
+	case C_HFOREG:
+		return b == C_HOREG || b == C_FOREG
+
+	case C_FOREG, C_HOREG:
+		return b == C_HFOREG
+
+	case C_SROREG:
+		return cmp(C_SOREG, b) || cmp(C_ROREG, b)
+
+	case C_SOREG, C_ROREG:
+		return b == C_SROREG || cmp(C_HFOREG, b)
+
+	case C_LOREG:
+		return cmp(C_SROREG, b)
+
+	case C_LBRA:
+		if b == C_SBRA {
+			return true
+		}
+
+	case C_HREG:
+		return cmp(C_SP, b) || cmp(C_PC, b)
+	}
+
+	return false
+}
+
+type ocmp []Optab
+
+func (x ocmp) Len() int {
+	return len(x)
+}
+
+func (x ocmp) Swap(i, j int) {
+	x[i], x[j] = x[j], x[i]
+}
+
+func (x ocmp) Less(i, j int) bool {
+	p1 := &x[i]
+	p2 := &x[j]
+	n := int(p1.as) - int(p2.as)
+	if n != 0 {
+		return n < 0
+	}
+	n = int(p1.a1) - int(p2.a1)
+	if n != 0 {
+		return n < 0
+	}
+	n = int(p1.a2) - int(p2.a2)
+	if n != 0 {
+		return n < 0
+	}
+	n = int(p1.a3) - int(p2.a3)
+	if n != 0 {
+		return n < 0
+	}
+	return false
+}
+
+func opset(a, b0 obj.As) {
+	oprange[a&obj.AMask] = oprange[b0]
+}
+
+func buildop(ctxt *obj.Link) {
+	if oprange[AAND&obj.AMask] != nil {
+		// Already initialized; stop now.
+		// This happens in the cmd/asm tests,
+		// each of which re-initializes the arch.
+		return
+	}
+
+	deferreturn = ctxt.LookupABI("runtime.deferreturn", obj.ABIInternal)
+
+	symdiv = ctxt.Lookup("runtime._div")
+	symdivu = ctxt.Lookup("runtime._divu")
+	symmod = ctxt.Lookup("runtime._mod")
+	symmodu = ctxt.Lookup("runtime._modu")
+
+	var n int
+
+	for i := 0; i < C_GOK; i++ {
+		for n = 0; n < C_GOK; n++ {
+			if cmp(n, i) {
+				xcmp[i][n] = true
+			}
+		}
+	}
+	for n = 0; optab[n].as != obj.AXXX; n++ {
+		if optab[n].flag&LPCREL != 0 {
+			if ctxt.Flag_shared {
+				optab[n].size += int8(optab[n].pcrelsiz)
+			} else {
+				optab[n].flag &^= LPCREL
+			}
+		}
+	}
+
+	sort.Sort(ocmp(optab[:n]))
+	for i := 0; i < n; i++ {
+		r := optab[i].as
+		r0 := r & obj.AMask
+		start := i
+		for optab[i].as == r {
+			i++
+		}
+		oprange[r0] = optab[start:i]
+		i--
+
+		switch r {
+		default:
+			ctxt.Diag("unknown op in build: %v", r)
+			ctxt.DiagFlush()
+			log.Fatalf("bad code")
+
+		case AADD:
+			opset(ASUB, r0)
+			opset(ARSB, r0)
+			opset(AADC, r0)
+			opset(ASBC, r0)
+			opset(ARSC, r0)
+
+		case AORR:
+			opset(AEOR, r0)
+			opset(ABIC, r0)
+
+		case ACMP:
+			opset(ATEQ, r0)
+			opset(ACMN, r0)
+			opset(ATST, r0)
+
+		case AMVN:
+			break
+
+		case ABEQ:
+			opset(ABNE, r0)
+			opset(ABCS, r0)
+			opset(ABHS, r0)
+			opset(ABCC, r0)
+			opset(ABLO, r0)
+			opset(ABMI, r0)
+			opset(ABPL, r0)
+			opset(ABVS, r0)
+			opset(ABVC, r0)
+			opset(ABHI, r0)
+			opset(ABLS, r0)
+			opset(ABGE, r0)
+			opset(ABLT, r0)
+			opset(ABGT, r0)
+			opset(ABLE, r0)
+
+		case ASLL:
+			opset(ASRL, r0)
+			opset(ASRA, r0)
+
+		case AMUL:
+			opset(AMULU, r0)
+
+		case ADIV:
+			opset(AMOD, r0)
+			opset(AMODU, r0)
+			opset(ADIVU, r0)
+
+		case ADIVHW:
+			opset(ADIVUHW, r0)
+
+		case AMOVW,
+			AMOVB,
+			AMOVBS,
+			AMOVBU,
+			AMOVH,
+			AMOVHS,
+			AMOVHU:
+			break
+
+		case ASWPW:
+			opset(ASWPBU, r0)
+
+		case AB,
+			ABL,
+			ABX,
+			ABXRET,
+			obj.ADUFFZERO,
+			obj.ADUFFCOPY,
+			ASWI,
+			AWORD,
+			AMOVM,
+			ARFE,
+			obj.ATEXT:
+			break
+
+		case AADDF:
+			opset(AADDD, r0)
+			opset(ASUBF, r0)
+			opset(ASUBD, r0)
+			opset(AMULF, r0)
+			opset(AMULD, r0)
+			opset(ANMULF, r0)
+			opset(ANMULD, r0)
+			opset(AMULAF, r0)
+			opset(AMULAD, r0)
+			opset(AMULSF, r0)
+			opset(AMULSD, r0)
+			opset(ANMULAF, r0)
+			opset(ANMULAD, r0)
+			opset(ANMULSF, r0)
+			opset(ANMULSD, r0)
+			opset(AFMULAF, r0)
+			opset(AFMULAD, r0)
+			opset(AFMULSF, r0)
+			opset(AFMULSD, r0)
+			opset(AFNMULAF, r0)
+			opset(AFNMULAD, r0)
+			opset(AFNMULSF, r0)
+			opset(AFNMULSD, r0)
+			opset(ADIVF, r0)
+			opset(ADIVD, r0)
+
+		case ANEGF:
+			opset(ANEGD, r0)
+			opset(ASQRTF, r0)
+			opset(ASQRTD, r0)
+			opset(AMOVFD, r0)
+			opset(AMOVDF, r0)
+			opset(AABSF, r0)
+			opset(AABSD, r0)
+
+		case ACMPF:
+			opset(ACMPD, r0)
+
+		case AMOVF:
+			opset(AMOVD, r0)
+
+		case AMOVFW:
+			opset(AMOVDW, r0)
+
+		case AMOVWF:
+			opset(AMOVWD, r0)
+
+		case AMULL:
+			opset(AMULAL, r0)
+			opset(AMULLU, r0)
+			opset(AMULALU, r0)
+
+		case AMULWT:
+			opset(AMULWB, r0)
+			opset(AMULBB, r0)
+			opset(AMMUL, r0)
+
+		case AMULAWT:
+			opset(AMULAWB, r0)
+			opset(AMULABB, r0)
+			opset(AMULS, r0)
+			opset(AMMULA, r0)
+			opset(AMMULS, r0)
+
+		case ABFX:
+			opset(ABFXU, r0)
+			opset(ABFC, r0)
+			opset(ABFI, r0)
+
+		case ACLZ:
+			opset(AREV, r0)
+			opset(AREV16, r0)
+			opset(AREVSH, r0)
+			opset(ARBIT, r0)
+
+		case AXTAB:
+			opset(AXTAH, r0)
+			opset(AXTABU, r0)
+			opset(AXTAHU, r0)
+
+		case ALDREX,
+			ASTREX,
+			ALDREXD,
+			ASTREXD,
+			ADMB,
+			APLD,
+			AAND,
+			AMULA,
+			obj.AUNDEF,
+			obj.AFUNCDATA,
+			obj.APCDATA,
+			obj.ANOP:
+			break
+		}
+	}
+}
+
+func (c *ctxt5) asmout(p *obj.Prog, o *Optab, out []uint32) {
+	c.printp = p
+	o1 := uint32(0)
+	o2 := uint32(0)
+	o3 := uint32(0)
+	o4 := uint32(0)
+	o5 := uint32(0)
+	o6 := uint32(0)
+	if false { /*debug['P']*/
+		fmt.Printf("%x: %v\ttype %d\n", uint32(p.Pc), p, o.type_)
+	}
+	switch o.type_ {
+	default:
+		c.ctxt.Diag("%v: unknown asm %d", p, o.type_)
+
+	case 0: /* pseudo ops */
+		if false { /*debug['G']*/
+			fmt.Printf("%x: %s: arm\n", uint32(p.Pc), p.From.Sym.Name)
+		}
+
+	case 1: /* op R,[R],R */
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		r := int(p.Reg)
+		if p.To.Type == obj.TYPE_NONE {
+			rt = 0
+		}
+		if p.As == AMOVB || p.As == AMOVH || p.As == AMOVW || p.As == AMVN {
+			r = 0
+		} else if r == 0 {
+			r = rt
+		}
+		o1 |= (uint32(rf)&15)<<0 | (uint32(r)&15)<<16 | (uint32(rt)&15)<<12
+
+	case 2: /* movbu $I,[R],R */
+		c.aclass(&p.From)
+
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+		o1 |= uint32(immrot(uint32(c.instoffset)))
+		rt := int(p.To.Reg)
+		r := int(p.Reg)
+		if p.To.Type == obj.TYPE_NONE {
+			rt = 0
+		}
+		if p.As == AMOVW || p.As == AMVN {
+			r = 0
+		} else if r == 0 {
+			r = rt
+		}
+		o1 |= (uint32(r)&15)<<16 | (uint32(rt)&15)<<12
+
+	case 106: /* op $I,R,R where I can be decomposed into 2 immediates */
+		c.aclass(&p.From)
+		r := int(p.Reg)
+		rt := int(p.To.Reg)
+		if r == 0 {
+			r = rt
+		}
+		x, y := immrot2a(uint32(c.instoffset))
+		var as2 obj.As
+		switch p.As {
+		case AADD, ASUB, AORR, AEOR, ABIC:
+			as2 = p.As // ADD, SUB, ORR, EOR, BIC
+		case ARSB:
+			as2 = AADD // RSB -> RSB/ADD pair
+		case AADC:
+			as2 = AADD // ADC -> ADC/ADD pair
+		case ASBC:
+			as2 = ASUB // SBC -> SBC/SUB pair
+		case ARSC:
+			as2 = AADD // RSC -> RSC/ADD pair
+		default:
+			c.ctxt.Diag("unknown second op for %v", p)
+		}
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+		o2 = c.oprrr(p, as2, int(p.Scond))
+		o1 |= (uint32(r)&15)<<16 | (uint32(rt)&15)<<12
+		o2 |= (uint32(rt)&15)<<16 | (uint32(rt)&15)<<12
+		o1 |= x
+		o2 |= y
+
+	case 107: /* op $I,R,R where I can be decomposed into 2 immediates */
+		c.aclass(&p.From)
+		r := int(p.Reg)
+		rt := int(p.To.Reg)
+		if r == 0 {
+			r = rt
+		}
+		y, x := immrot2s(uint32(c.instoffset))
+		var as2 obj.As
+		switch p.As {
+		case AADD:
+			as2 = ASUB // ADD -> ADD/SUB pair
+		case ASUB:
+			as2 = AADD // SUB -> SUB/ADD pair
+		case ARSB:
+			as2 = ASUB // RSB -> RSB/SUB pair
+		case AADC:
+			as2 = ASUB // ADC -> ADC/SUB pair
+		case ASBC:
+			as2 = AADD // SBC -> SBC/ADD pair
+		case ARSC:
+			as2 = ASUB // RSC -> RSC/SUB pair
+		default:
+			c.ctxt.Diag("unknown second op for %v", p)
+		}
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+		o2 = c.oprrr(p, as2, int(p.Scond))
+		o1 |= (uint32(r)&15)<<16 | (uint32(rt)&15)<<12
+		o2 |= (uint32(rt)&15)<<16 | (uint32(rt)&15)<<12
+		o1 |= y
+		o2 |= x
+
+	case 3: /* add R<<[IR],[R],R */
+		o1 = c.mov(p)
+
+	case 4: /* MOVW $off(R), R -> add $off,[R],R */
+		c.aclass(&p.From)
+		if c.instoffset < 0 {
+			o1 = c.oprrr(p, ASUB, int(p.Scond))
+			o1 |= uint32(immrot(uint32(-c.instoffset)))
+		} else {
+			o1 = c.oprrr(p, AADD, int(p.Scond))
+			o1 |= uint32(immrot(uint32(c.instoffset)))
+		}
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o1 |= (uint32(r) & 15) << 16
+		o1 |= (uint32(p.To.Reg) & 15) << 12
+
+	case 5: /* bra s */
+		o1 = c.opbra(p, p.As, int(p.Scond))
+
+		v := int32(-8)
+		if p.To.Sym != nil {
+			rel := obj.Addrel(c.cursym)
+			rel.Off = int32(c.pc)
+			rel.Siz = 4
+			rel.Sym = p.To.Sym
+			v += int32(p.To.Offset)
+			rel.Add = int64(o1) | (int64(v)>>2)&0xffffff
+			rel.Type = objabi.R_CALLARM
+			break
+		}
+
+		if p.To.Target() != nil {
+			v = int32((p.To.Target().Pc - c.pc) - 8)
+		}
+		o1 |= (uint32(v) >> 2) & 0xffffff
+
+	case 6: /* b ,O(R) -> add $O,R,PC */
+		c.aclass(&p.To)
+
+		o1 = c.oprrr(p, AADD, int(p.Scond))
+		o1 |= uint32(immrot(uint32(c.instoffset)))
+		o1 |= (uint32(p.To.Reg) & 15) << 16
+		o1 |= (REGPC & 15) << 12
+
+	case 7: /* bl (R) -> blx R */
+		c.aclass(&p.To)
+
+		if c.instoffset != 0 {
+			c.ctxt.Diag("%v: doesn't support BL offset(REG) with non-zero offset %d", p, c.instoffset)
+		}
+		o1 = c.oprrr(p, ABL, int(p.Scond))
+		o1 |= (uint32(p.To.Reg) & 15) << 0
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 0
+		rel.Type = objabi.R_CALLIND
+
+	case 8: /* sll $c,[R],R -> mov (R<<$c),R */
+		c.aclass(&p.From)
+
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		o1 |= (uint32(r) & 15) << 0
+		o1 |= uint32((c.instoffset & 31) << 7)
+		o1 |= (uint32(p.To.Reg) & 15) << 12
+
+	case 9: /* sll R,[R],R -> mov (R<<R),R */
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		o1 |= (uint32(r) & 15) << 0
+		o1 |= (uint32(p.From.Reg)&15)<<8 | 1<<4
+		o1 |= (uint32(p.To.Reg) & 15) << 12
+
+	case 10: /* swi [$con] */
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+
+		if p.To.Type != obj.TYPE_NONE {
+			c.aclass(&p.To)
+			o1 |= uint32(c.instoffset & 0xffffff)
+		}
+
+	case 11: /* word */
+		c.aclass(&p.To)
+
+		o1 = uint32(c.instoffset)
+		if p.To.Sym != nil {
+			// This case happens with words generated
+			// in the PC stream as part of the literal pool (c.pool).
+			rel := obj.Addrel(c.cursym)
+
+			rel.Off = int32(c.pc)
+			rel.Siz = 4
+			rel.Sym = p.To.Sym
+			rel.Add = p.To.Offset
+
+			if c.ctxt.Flag_shared {
+				if p.To.Name == obj.NAME_GOTREF {
+					rel.Type = objabi.R_GOTPCREL
+				} else {
+					rel.Type = objabi.R_PCREL
+				}
+				rel.Add += c.pc - p.Rel.Pc - 8
+			} else {
+				rel.Type = objabi.R_ADDR
+			}
+			o1 = 0
+		}
+
+	case 12: /* movw $lcon, reg */
+		if o.a1 == C_SCON {
+			o1 = c.omvs(p, &p.From, int(p.To.Reg))
+		} else if p.As == AMVN {
+			o1 = c.omvr(p, &p.From, int(p.To.Reg))
+		} else {
+			o1 = c.omvl(p, &p.From, int(p.To.Reg))
+		}
+
+		if o.flag&LPCREL != 0 {
+			o2 = c.oprrr(p, AADD, int(p.Scond)) | (uint32(p.To.Reg)&15)<<0 | (REGPC&15)<<16 | (uint32(p.To.Reg)&15)<<12
+		}
+
+	case 13: /* op $lcon, [R], R */
+		if o.a1 == C_SCON {
+			o1 = c.omvs(p, &p.From, REGTMP)
+		} else {
+			o1 = c.omvl(p, &p.From, REGTMP)
+		}
+
+		if o1 == 0 {
+			break
+		}
+		o2 = c.oprrr(p, p.As, int(p.Scond))
+		o2 |= REGTMP & 15
+		r := int(p.Reg)
+		if p.As == AMVN {
+			r = 0
+		} else if r == 0 {
+			r = int(p.To.Reg)
+		}
+		o2 |= (uint32(r) & 15) << 16
+		if p.To.Type != obj.TYPE_NONE {
+			o2 |= (uint32(p.To.Reg) & 15) << 12
+		}
+
+	case 14: /* movb/movbu/movh/movhu R,R */
+		o1 = c.oprrr(p, ASLL, int(p.Scond))
+
+		if p.As == AMOVBU || p.As == AMOVHU {
+			o2 = c.oprrr(p, ASRL, int(p.Scond))
+		} else {
+			o2 = c.oprrr(p, ASRA, int(p.Scond))
+		}
+
+		r := int(p.To.Reg)
+		o1 |= (uint32(p.From.Reg)&15)<<0 | (uint32(r)&15)<<12
+		o2 |= uint32(r)&15 | (uint32(r)&15)<<12
+		if p.As == AMOVB || p.As == AMOVBS || p.As == AMOVBU {
+			o1 |= 24 << 7
+			o2 |= 24 << 7
+		} else {
+			o1 |= 16 << 7
+			o2 |= 16 << 7
+		}
+
+	case 15: /* mul r,[r,]r */
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		r := int(p.Reg)
+		if r == 0 {
+			r = rt
+		}
+
+		o1 |= (uint32(rf)&15)<<8 | (uint32(r)&15)<<0 | (uint32(rt)&15)<<16
+
+	case 16: /* div r,[r,]r */
+		o1 = 0xf << 28
+
+		o2 = 0
+
+	case 17:
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		rt2 := int(p.To.Offset)
+		r := int(p.Reg)
+		o1 |= (uint32(rf)&15)<<8 | (uint32(r)&15)<<0 | (uint32(rt)&15)<<16 | (uint32(rt2)&15)<<12
+
+	case 18: /* BFX/BFXU/BFC/BFI */
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+		rt := int(p.To.Reg)
+		r := int(p.Reg)
+		if r == 0 {
+			r = rt
+		} else if p.As == ABFC { // only "BFC $width, $lsb, Reg" is accepted, p.Reg must be 0
+			c.ctxt.Diag("illegal combination: %v", p)
+		}
+		if p.GetFrom3() == nil || p.GetFrom3().Type != obj.TYPE_CONST {
+			c.ctxt.Diag("%v: missing or wrong LSB", p)
+			break
+		}
+		lsb := p.GetFrom3().Offset
+		width := p.From.Offset
+		if lsb < 0 || lsb > 31 || width <= 0 || (lsb+width) > 32 {
+			c.ctxt.Diag("%v: wrong width or LSB", p)
+		}
+		switch p.As {
+		case ABFX, ABFXU: // (width-1) is encoded
+			o1 |= (uint32(r)&15)<<0 | (uint32(rt)&15)<<12 | uint32(lsb)<<7 | uint32(width-1)<<16
+		case ABFC, ABFI: // MSB is encoded
+			o1 |= (uint32(r)&15)<<0 | (uint32(rt)&15)<<12 | uint32(lsb)<<7 | uint32(lsb+width-1)<<16
+		default:
+			c.ctxt.Diag("illegal combination: %v", p)
+		}
+
+	case 20: /* mov/movb/movbu R,O(R) */
+		c.aclass(&p.To)
+
+		r := int(p.To.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o1 = c.osr(p.As, int(p.From.Reg), int32(c.instoffset), r, int(p.Scond))
+
+	case 21: /* mov/movbu O(R),R -> lr */
+		c.aclass(&p.From)
+
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o1 = c.olr(int32(c.instoffset), r, int(p.To.Reg), int(p.Scond))
+		if p.As != AMOVW {
+			o1 |= 1 << 22
+		}
+
+	case 22: /* XTAB R@>i, [R], R */
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+		switch p.From.Offset &^ 0xf {
+		// only 0/8/16/24 bits rotation is accepted
+		case SHIFT_RR, SHIFT_RR | 8<<7, SHIFT_RR | 16<<7, SHIFT_RR | 24<<7:
+			o1 |= uint32(p.From.Offset) & 0xc0f
+		default:
+			c.ctxt.Diag("illegal shift: %v", p)
+		}
+		rt := p.To.Reg
+		r := p.Reg
+		if r == 0 {
+			r = rt
+		}
+		o1 |= (uint32(rt)&15)<<12 | (uint32(r)&15)<<16
+
+	case 23: /* MOVW/MOVB/MOVH R@>i, R */
+		switch p.As {
+		case AMOVW:
+			o1 = c.mov(p)
+		case AMOVBU, AMOVBS, AMOVB, AMOVHU, AMOVHS, AMOVH:
+			o1 = c.movxt(p)
+		default:
+			c.ctxt.Diag("illegal combination: %v", p)
+		}
+
+	case 30: /* mov/movb/movbu R,L(R) */
+		o1 = c.omvl(p, &p.To, REGTMP)
+
+		if o1 == 0 {
+			break
+		}
+		r := int(p.To.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o2 = c.osrr(int(p.From.Reg), REGTMP&15, r, int(p.Scond))
+		if p.As != AMOVW {
+			o2 |= 1 << 22
+		}
+
+	case 31: /* mov/movbu L(R),R -> lr[b] */
+		o1 = c.omvl(p, &p.From, REGTMP)
+
+		if o1 == 0 {
+			break
+		}
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o2 = c.olrr(REGTMP&15, r, int(p.To.Reg), int(p.Scond))
+		if p.As == AMOVBU || p.As == AMOVBS || p.As == AMOVB {
+			o2 |= 1 << 22
+		}
+
+	case 34: /* mov $lacon,R */
+		o1 = c.omvl(p, &p.From, REGTMP)
+
+		if o1 == 0 {
+			break
+		}
+
+		o2 = c.oprrr(p, AADD, int(p.Scond))
+		o2 |= REGTMP & 15
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o2 |= (uint32(r) & 15) << 16
+		if p.To.Type != obj.TYPE_NONE {
+			o2 |= (uint32(p.To.Reg) & 15) << 12
+		}
+
+	case 35: /* mov PSR,R */
+		o1 = 2<<23 | 0xf<<16 | 0<<0
+
+		o1 |= ((uint32(p.Scond) & C_SCOND) ^ C_SCOND_XOR) << 28
+		o1 |= (uint32(p.From.Reg) & 1) << 22
+		o1 |= (uint32(p.To.Reg) & 15) << 12
+
+	case 36: /* mov R,PSR */
+		o1 = 2<<23 | 0x2cf<<12 | 0<<4
+
+		if p.Scond&C_FBIT != 0 {
+			o1 ^= 0x010 << 12
+		}
+		o1 |= ((uint32(p.Scond) & C_SCOND) ^ C_SCOND_XOR) << 28
+		o1 |= (uint32(p.To.Reg) & 1) << 22
+		o1 |= (uint32(p.From.Reg) & 15) << 0
+
+	case 37: /* mov $con,PSR */
+		c.aclass(&p.From)
+
+		o1 = 2<<23 | 0x2cf<<12 | 0<<4
+		if p.Scond&C_FBIT != 0 {
+			o1 ^= 0x010 << 12
+		}
+		o1 |= ((uint32(p.Scond) & C_SCOND) ^ C_SCOND_XOR) << 28
+		o1 |= uint32(immrot(uint32(c.instoffset)))
+		o1 |= (uint32(p.To.Reg) & 1) << 22
+		o1 |= (uint32(p.From.Reg) & 15) << 0
+
+	case 38, 39:
+		switch o.type_ {
+		case 38: /* movm $con,oreg -> stm */
+			o1 = 0x4 << 25
+
+			o1 |= uint32(p.From.Offset & 0xffff)
+			o1 |= (uint32(p.To.Reg) & 15) << 16
+			c.aclass(&p.To)
+
+		case 39: /* movm oreg,$con -> ldm */
+			o1 = 0x4<<25 | 1<<20
+
+			o1 |= uint32(p.To.Offset & 0xffff)
+			o1 |= (uint32(p.From.Reg) & 15) << 16
+			c.aclass(&p.From)
+		}
+
+		if c.instoffset != 0 {
+			c.ctxt.Diag("offset must be zero in MOVM; %v", p)
+		}
+		o1 |= ((uint32(p.Scond) & C_SCOND) ^ C_SCOND_XOR) << 28
+		if p.Scond&C_PBIT != 0 {
+			o1 |= 1 << 24
+		}
+		if p.Scond&C_UBIT != 0 {
+			o1 |= 1 << 23
+		}
+		if p.Scond&C_WBIT != 0 {
+			o1 |= 1 << 21
+		}
+
+	case 40: /* swp oreg,reg,reg */
+		c.aclass(&p.From)
+
+		if c.instoffset != 0 {
+			c.ctxt.Diag("offset must be zero in SWP")
+		}
+		o1 = 0x2<<23 | 0x9<<4
+		if p.As != ASWPW {
+			o1 |= 1 << 22
+		}
+		o1 |= (uint32(p.From.Reg) & 15) << 16
+		o1 |= (uint32(p.Reg) & 15) << 0
+		o1 |= (uint32(p.To.Reg) & 15) << 12
+		o1 |= ((uint32(p.Scond) & C_SCOND) ^ C_SCOND_XOR) << 28
+
+	case 41: /* rfe -> movm.s.w.u 0(r13),[r15] */
+		o1 = 0xe8fd8000
+
+	case 50: /* floating point store */
+		v := c.regoff(&p.To)
+
+		r := int(p.To.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o1 = c.ofsr(p.As, int(p.From.Reg), v, r, int(p.Scond), p)
+
+	case 51: /* floating point load */
+		v := c.regoff(&p.From)
+
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o1 = c.ofsr(p.As, int(p.To.Reg), v, r, int(p.Scond), p) | 1<<20
+
+	case 52: /* floating point store, int32 offset UGLY */
+		o1 = c.omvl(p, &p.To, REGTMP)
+
+		if o1 == 0 {
+			break
+		}
+		r := int(p.To.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o2 = c.oprrr(p, AADD, int(p.Scond)) | (REGTMP&15)<<12 | (REGTMP&15)<<16 | (uint32(r)&15)<<0
+		o3 = c.ofsr(p.As, int(p.From.Reg), 0, REGTMP, int(p.Scond), p)
+
+	case 53: /* floating point load, int32 offset UGLY */
+		o1 = c.omvl(p, &p.From, REGTMP)
+
+		if o1 == 0 {
+			break
+		}
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o2 = c.oprrr(p, AADD, int(p.Scond)) | (REGTMP&15)<<12 | (REGTMP&15)<<16 | (uint32(r)&15)<<0
+		o3 = c.ofsr(p.As, int(p.To.Reg), 0, (REGTMP&15), int(p.Scond), p) | 1<<20
+
+	case 54: /* floating point arith */
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		r := int(p.Reg)
+		if r == 0 {
+			switch p.As {
+			case AMULAD, AMULAF, AMULSF, AMULSD, ANMULAF, ANMULAD, ANMULSF, ANMULSD,
+				AFMULAD, AFMULAF, AFMULSF, AFMULSD, AFNMULAF, AFNMULAD, AFNMULSF, AFNMULSD:
+				c.ctxt.Diag("illegal combination: %v", p)
+			default:
+				r = rt
+			}
+		}
+
+		o1 |= (uint32(rf)&15)<<0 | (uint32(r)&15)<<16 | (uint32(rt)&15)<<12
+
+	case 55: /* negf freg, freg */
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+
+		o1 |= (uint32(rf)&15)<<0 | (uint32(rt)&15)<<12
+
+	case 56: /* move to FP[CS]R */
+		o1 = ((uint32(p.Scond)&C_SCOND)^C_SCOND_XOR)<<28 | 0xee1<<16 | 0xa1<<4
+
+		o1 |= (uint32(p.From.Reg) & 15) << 12
+
+	case 57: /* move from FP[CS]R */
+		o1 = ((uint32(p.Scond)&C_SCOND)^C_SCOND_XOR)<<28 | 0xef1<<16 | 0xa1<<4
+
+		o1 |= (uint32(p.To.Reg) & 15) << 12
+
+	case 58: /* movbu R,R */
+		o1 = c.oprrr(p, AAND, int(p.Scond))
+
+		o1 |= uint32(immrot(0xff))
+		rt := int(p.To.Reg)
+		r := int(p.From.Reg)
+		if p.To.Type == obj.TYPE_NONE {
+			rt = 0
+		}
+		if r == 0 {
+			r = rt
+		}
+		o1 |= (uint32(r)&15)<<16 | (uint32(rt)&15)<<12
+
+	case 59: /* movw/bu R<<I(R),R -> ldr indexed */
+		if p.From.Reg == 0 {
+			c.ctxt.Diag("source operand is not a memory address: %v", p)
+			break
+		}
+		if p.From.Offset&(1<<4) != 0 {
+			c.ctxt.Diag("bad shift in LDR")
+			break
+		}
+		o1 = c.olrr(int(p.From.Offset), int(p.From.Reg), int(p.To.Reg), int(p.Scond))
+		if p.As == AMOVBU {
+			o1 |= 1 << 22
+		}
+
+	case 60: /* movb R(R),R -> ldrsb indexed */
+		if p.From.Reg == 0 {
+			c.ctxt.Diag("source operand is not a memory address: %v", p)
+			break
+		}
+		if p.From.Offset&(^0xf) != 0 {
+			c.ctxt.Diag("bad shift: %v", p)
+			break
+		}
+		o1 = c.olhrr(int(p.From.Offset), int(p.From.Reg), int(p.To.Reg), int(p.Scond))
+		switch p.As {
+		case AMOVB, AMOVBS:
+			o1 ^= 1<<5 | 1<<6
+		case AMOVH, AMOVHS:
+			o1 ^= 1 << 6
+		default:
+		}
+		if p.Scond&C_UBIT != 0 {
+			o1 &^= 1 << 23
+		}
+
+	case 61: /* movw/b/bu R,R<<[IR](R) -> str indexed */
+		if p.To.Reg == 0 {
+			c.ctxt.Diag("MOV to shifter operand")
+		}
+		o1 = c.osrr(int(p.From.Reg), int(p.To.Offset), int(p.To.Reg), int(p.Scond))
+		if p.As == AMOVB || p.As == AMOVBS || p.As == AMOVBU {
+			o1 |= 1 << 22
+		}
+
+	case 62: /* MOVH/MOVHS/MOVHU Reg, Reg<<0(Reg) -> strh */
+		if p.To.Reg == 0 {
+			c.ctxt.Diag("MOV to shifter operand")
+		}
+		if p.To.Offset&(^0xf) != 0 {
+			c.ctxt.Diag("bad shift: %v", p)
+		}
+		o1 = c.olhrr(int(p.To.Offset), int(p.To.Reg), int(p.From.Reg), int(p.Scond))
+		o1 ^= 1 << 20
+		if p.Scond&C_UBIT != 0 {
+			o1 &^= 1 << 23
+		}
+
+		/* reloc ops */
+	case 64: /* mov/movb/movbu R,addr */
+		o1 = c.omvl(p, &p.To, REGTMP)
+
+		if o1 == 0 {
+			break
+		}
+		o2 = c.osr(p.As, int(p.From.Reg), 0, REGTMP, int(p.Scond))
+		if o.flag&LPCREL != 0 {
+			o3 = o2
+			o2 = c.oprrr(p, AADD, int(p.Scond)) | REGTMP&15 | (REGPC&15)<<16 | (REGTMP&15)<<12
+		}
+
+	case 65: /* mov/movbu addr,R */
+		o1 = c.omvl(p, &p.From, REGTMP)
+
+		if o1 == 0 {
+			break
+		}
+		o2 = c.olr(0, REGTMP, int(p.To.Reg), int(p.Scond))
+		if p.As == AMOVBU || p.As == AMOVBS || p.As == AMOVB {
+			o2 |= 1 << 22
+		}
+		if o.flag&LPCREL != 0 {
+			o3 = o2
+			o2 = c.oprrr(p, AADD, int(p.Scond)) | REGTMP&15 | (REGPC&15)<<16 | (REGTMP&15)<<12
+		}
+
+	case 101: /* movw tlsvar,R, local exec*/
+		o1 = c.omvl(p, &p.From, int(p.To.Reg))
+
+	case 102: /* movw tlsvar,R, initial exec*/
+		o1 = c.omvl(p, &p.From, int(p.To.Reg))
+		o2 = c.olrr(int(p.To.Reg)&15, (REGPC & 15), int(p.To.Reg), int(p.Scond))
+
+	case 103: /* word tlsvar, local exec */
+		if p.To.Sym == nil {
+			c.ctxt.Diag("nil sym in tls %v", p)
+		}
+		if p.To.Offset != 0 {
+			c.ctxt.Diag("offset against tls var in %v", p)
+		}
+		// This case happens with words generated in the PC stream as part of
+		// the literal c.pool.
+		rel := obj.Addrel(c.cursym)
+
+		rel.Off = int32(c.pc)
+		rel.Siz = 4
+		rel.Sym = p.To.Sym
+		rel.Type = objabi.R_TLS_LE
+		o1 = 0
+
+	case 104: /* word tlsvar, initial exec */
+		if p.To.Sym == nil {
+			c.ctxt.Diag("nil sym in tls %v", p)
+		}
+		if p.To.Offset != 0 {
+			c.ctxt.Diag("offset against tls var in %v", p)
+		}
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 4
+		rel.Sym = p.To.Sym
+		rel.Type = objabi.R_TLS_IE
+		rel.Add = c.pc - p.Rel.Pc - 8 - int64(rel.Siz)
+
+	case 68: /* floating point store -> ADDR */
+		o1 = c.omvl(p, &p.To, REGTMP)
+
+		if o1 == 0 {
+			break
+		}
+		o2 = c.ofsr(p.As, int(p.From.Reg), 0, REGTMP, int(p.Scond), p)
+		if o.flag&LPCREL != 0 {
+			o3 = o2
+			o2 = c.oprrr(p, AADD, int(p.Scond)) | REGTMP&15 | (REGPC&15)<<16 | (REGTMP&15)<<12
+		}
+
+	case 69: /* floating point load <- ADDR */
+		o1 = c.omvl(p, &p.From, REGTMP)
+
+		if o1 == 0 {
+			break
+		}
+		o2 = c.ofsr(p.As, int(p.To.Reg), 0, (REGTMP&15), int(p.Scond), p) | 1<<20
+		if o.flag&LPCREL != 0 {
+			o3 = o2
+			o2 = c.oprrr(p, AADD, int(p.Scond)) | REGTMP&15 | (REGPC&15)<<16 | (REGTMP&15)<<12
+		}
+
+		/* ArmV4 ops: */
+	case 70: /* movh/movhu R,O(R) -> strh */
+		c.aclass(&p.To)
+
+		r := int(p.To.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o1 = c.oshr(int(p.From.Reg), int32(c.instoffset), r, int(p.Scond))
+
+	case 71: /* movb/movh/movhu O(R),R -> ldrsb/ldrsh/ldrh */
+		c.aclass(&p.From)
+
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o1 = c.olhr(int32(c.instoffset), r, int(p.To.Reg), int(p.Scond))
+		if p.As == AMOVB || p.As == AMOVBS {
+			o1 ^= 1<<5 | 1<<6
+		} else if p.As == AMOVH || p.As == AMOVHS {
+			o1 ^= (1 << 6)
+		}
+
+	case 72: /* movh/movhu R,L(R) -> strh */
+		o1 = c.omvl(p, &p.To, REGTMP)
+
+		if o1 == 0 {
+			break
+		}
+		r := int(p.To.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o2 = c.oshrr(int(p.From.Reg), REGTMP&15, r, int(p.Scond))
+
+	case 73: /* movb/movh/movhu L(R),R -> ldrsb/ldrsh/ldrh */
+		o1 = c.omvl(p, &p.From, REGTMP)
+
+		if o1 == 0 {
+			break
+		}
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o2 = c.olhrr(REGTMP&15, r, int(p.To.Reg), int(p.Scond))
+		if p.As == AMOVB || p.As == AMOVBS {
+			o2 ^= 1<<5 | 1<<6
+		} else if p.As == AMOVH || p.As == AMOVHS {
+			o2 ^= (1 << 6)
+		}
+
+	case 74: /* bx $I */
+		c.ctxt.Diag("ABX $I")
+
+	case 75: /* bx O(R) */
+		c.aclass(&p.To)
+
+		if c.instoffset != 0 {
+			c.ctxt.Diag("non-zero offset in ABX")
+		}
+
+		/*
+			o1 = 	c.oprrr(p, AADD, p->scond) | immrot(0) | ((REGPC&15)<<16) | ((REGLINK&15)<<12);	// mov PC, LR
+			o2 = (((p->scond&C_SCOND) ^ C_SCOND_XOR)<<28) | (0x12fff<<8) | (1<<4) | ((p->to.reg&15) << 0);		// BX R
+		*/
+		// p->to.reg may be REGLINK
+		o1 = c.oprrr(p, AADD, int(p.Scond))
+
+		o1 |= uint32(immrot(uint32(c.instoffset)))
+		o1 |= (uint32(p.To.Reg) & 15) << 16
+		o1 |= (REGTMP & 15) << 12
+		o2 = c.oprrr(p, AADD, int(p.Scond)) | uint32(immrot(0)) | (REGPC&15)<<16 | (REGLINK&15)<<12 // mov PC, LR
+		o3 = ((uint32(p.Scond)&C_SCOND)^C_SCOND_XOR)<<28 | 0x12fff<<8 | 1<<4 | REGTMP&15            // BX Rtmp
+
+	case 76: /* bx O(R) when returning from fn*/
+		c.ctxt.Diag("ABXRET")
+
+	case 77: /* ldrex oreg,reg */
+		c.aclass(&p.From)
+
+		if c.instoffset != 0 {
+			c.ctxt.Diag("offset must be zero in LDREX")
+		}
+		o1 = 0x19<<20 | 0xf9f
+		o1 |= (uint32(p.From.Reg) & 15) << 16
+		o1 |= (uint32(p.To.Reg) & 15) << 12
+		o1 |= ((uint32(p.Scond) & C_SCOND) ^ C_SCOND_XOR) << 28
+
+	case 78: /* strex reg,oreg,reg */
+		c.aclass(&p.From)
+
+		if c.instoffset != 0 {
+			c.ctxt.Diag("offset must be zero in STREX")
+		}
+		if p.To.Reg == p.From.Reg || p.To.Reg == p.Reg {
+			c.ctxt.Diag("cannot use same register as both source and destination: %v", p)
+		}
+		o1 = 0x18<<20 | 0xf90
+		o1 |= (uint32(p.From.Reg) & 15) << 16
+		o1 |= (uint32(p.Reg) & 15) << 0
+		o1 |= (uint32(p.To.Reg) & 15) << 12
+		o1 |= ((uint32(p.Scond) & C_SCOND) ^ C_SCOND_XOR) << 28
+
+	case 80: /* fmov zfcon,freg */
+		if p.As == AMOVD {
+			o1 = 0xeeb00b00 // VMOV imm 64
+			o2 = c.oprrr(p, ASUBD, int(p.Scond))
+		} else {
+			o1 = 0x0eb00a00 // VMOV imm 32
+			o2 = c.oprrr(p, ASUBF, int(p.Scond))
+		}
+
+		v := int32(0x70) // 1.0
+		r := (int(p.To.Reg) & 15) << 0
+
+		// movf $1.0, r
+		o1 |= ((uint32(p.Scond) & C_SCOND) ^ C_SCOND_XOR) << 28
+
+		o1 |= (uint32(r) & 15) << 12
+		o1 |= (uint32(v) & 0xf) << 0
+		o1 |= (uint32(v) & 0xf0) << 12
+
+		// subf r,r,r
+		o2 |= (uint32(r)&15)<<0 | (uint32(r)&15)<<16 | (uint32(r)&15)<<12
+
+	case 81: /* fmov sfcon,freg */
+		o1 = 0x0eb00a00 // VMOV imm 32
+		if p.As == AMOVD {
+			o1 = 0xeeb00b00 // VMOV imm 64
+		}
+		o1 |= ((uint32(p.Scond) & C_SCOND) ^ C_SCOND_XOR) << 28
+		o1 |= (uint32(p.To.Reg) & 15) << 12
+		v := int32(c.chipfloat5(p.From.Val.(float64)))
+		o1 |= (uint32(v) & 0xf) << 0
+		o1 |= (uint32(v) & 0xf0) << 12
+
+	case 82: /* fcmp freg,freg, */
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+
+		o1 |= (uint32(p.Reg)&15)<<12 | (uint32(p.From.Reg)&15)<<0
+		o2 = 0x0ef1fa10 // VMRS R15
+		o2 |= ((uint32(p.Scond) & C_SCOND) ^ C_SCOND_XOR) << 28
+
+	case 83: /* fcmp freg,, */
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+
+		o1 |= (uint32(p.From.Reg)&15)<<12 | 1<<16
+		o2 = 0x0ef1fa10 // VMRS R15
+		o2 |= ((uint32(p.Scond) & C_SCOND) ^ C_SCOND_XOR) << 28
+
+	case 84: /* movfw freg,freg - truncate float-to-fix */
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+
+		o1 |= (uint32(p.From.Reg) & 15) << 0
+		o1 |= (uint32(p.To.Reg) & 15) << 12
+
+	case 85: /* movwf freg,freg - fix-to-float */
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+
+		o1 |= (uint32(p.From.Reg) & 15) << 0
+		o1 |= (uint32(p.To.Reg) & 15) << 12
+
+		// macro for movfw freg,FTMP; movw FTMP,reg
+	case 86: /* movfw freg,reg - truncate float-to-fix */
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+
+		o1 |= (uint32(p.From.Reg) & 15) << 0
+		o1 |= (FREGTMP & 15) << 12
+		o2 = c.oprrr(p, -AMOVFW, int(p.Scond))
+		o2 |= (FREGTMP & 15) << 16
+		o2 |= (uint32(p.To.Reg) & 15) << 12
+
+		// macro for movw reg,FTMP; movwf FTMP,freg
+	case 87: /* movwf reg,freg - fix-to-float */
+		o1 = c.oprrr(p, -AMOVWF, int(p.Scond))
+
+		o1 |= (uint32(p.From.Reg) & 15) << 12
+		o1 |= (FREGTMP & 15) << 16
+		o2 = c.oprrr(p, p.As, int(p.Scond))
+		o2 |= (FREGTMP & 15) << 0
+		o2 |= (uint32(p.To.Reg) & 15) << 12
+
+	case 88: /* movw reg,freg  */
+		o1 = c.oprrr(p, -AMOVWF, int(p.Scond))
+
+		o1 |= (uint32(p.From.Reg) & 15) << 12
+		o1 |= (uint32(p.To.Reg) & 15) << 16
+
+	case 89: /* movw freg,reg  */
+		o1 = c.oprrr(p, -AMOVFW, int(p.Scond))
+
+		o1 |= (uint32(p.From.Reg) & 15) << 16
+		o1 |= (uint32(p.To.Reg) & 15) << 12
+
+	case 91: /* ldrexd oreg,reg */
+		c.aclass(&p.From)
+
+		if c.instoffset != 0 {
+			c.ctxt.Diag("offset must be zero in LDREX")
+		}
+		o1 = 0x1b<<20 | 0xf9f
+		o1 |= (uint32(p.From.Reg) & 15) << 16
+		o1 |= (uint32(p.To.Reg) & 15) << 12
+		o1 |= ((uint32(p.Scond) & C_SCOND) ^ C_SCOND_XOR) << 28
+
+	case 92: /* strexd reg,oreg,reg */
+		c.aclass(&p.From)
+
+		if c.instoffset != 0 {
+			c.ctxt.Diag("offset must be zero in STREX")
+		}
+		if p.Reg&1 != 0 {
+			c.ctxt.Diag("source register must be even in STREXD: %v", p)
+		}
+		if p.To.Reg == p.From.Reg || p.To.Reg == p.Reg || p.To.Reg == p.Reg+1 {
+			c.ctxt.Diag("cannot use same register as both source and destination: %v", p)
+		}
+		o1 = 0x1a<<20 | 0xf90
+		o1 |= (uint32(p.From.Reg) & 15) << 16
+		o1 |= (uint32(p.Reg) & 15) << 0
+		o1 |= (uint32(p.To.Reg) & 15) << 12
+		o1 |= ((uint32(p.Scond) & C_SCOND) ^ C_SCOND_XOR) << 28
+
+	case 93: /* movb/movh/movhu addr,R -> ldrsb/ldrsh/ldrh */
+		o1 = c.omvl(p, &p.From, REGTMP)
+
+		if o1 == 0 {
+			break
+		}
+		o2 = c.olhr(0, REGTMP, int(p.To.Reg), int(p.Scond))
+		if p.As == AMOVB || p.As == AMOVBS {
+			o2 ^= 1<<5 | 1<<6
+		} else if p.As == AMOVH || p.As == AMOVHS {
+			o2 ^= (1 << 6)
+		}
+		if o.flag&LPCREL != 0 {
+			o3 = o2
+			o2 = c.oprrr(p, AADD, int(p.Scond)) | REGTMP&15 | (REGPC&15)<<16 | (REGTMP&15)<<12
+		}
+
+	case 94: /* movh/movhu R,addr -> strh */
+		o1 = c.omvl(p, &p.To, REGTMP)
+
+		if o1 == 0 {
+			break
+		}
+		o2 = c.oshr(int(p.From.Reg), 0, REGTMP, int(p.Scond))
+		if o.flag&LPCREL != 0 {
+			o3 = o2
+			o2 = c.oprrr(p, AADD, int(p.Scond)) | REGTMP&15 | (REGPC&15)<<16 | (REGTMP&15)<<12
+		}
+
+	case 95: /* PLD off(reg) */
+		o1 = 0xf5d0f000
+
+		o1 |= (uint32(p.From.Reg) & 15) << 16
+		if p.From.Offset < 0 {
+			o1 &^= (1 << 23)
+			o1 |= uint32((-p.From.Offset) & 0xfff)
+		} else {
+			o1 |= uint32(p.From.Offset & 0xfff)
+		}
+
+	// This is supposed to be something that stops execution.
+	// It's not supposed to be reached, ever, but if it is, we'd
+	// like to be able to tell how we got there. Assemble as
+	// 0xf7fabcfd which is guaranteed to raise undefined instruction
+	// exception.
+	case 96: /* UNDEF */
+		o1 = 0xf7fabcfd
+
+	case 97: /* CLZ Rm, Rd */
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+
+		o1 |= (uint32(p.To.Reg) & 15) << 12
+		o1 |= (uint32(p.From.Reg) & 15) << 0
+
+	case 98: /* MULW{T,B} Rs, Rm, Rd */
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+
+		o1 |= (uint32(p.To.Reg) & 15) << 16
+		o1 |= (uint32(p.From.Reg) & 15) << 8
+		o1 |= (uint32(p.Reg) & 15) << 0
+
+	case 99: /* MULAW{T,B} Rs, Rm, Rn, Rd */
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+
+		o1 |= (uint32(p.To.Reg) & 15) << 16
+		o1 |= (uint32(p.From.Reg) & 15) << 8
+		o1 |= (uint32(p.Reg) & 15) << 0
+		o1 |= uint32((p.To.Offset & 15) << 12)
+
+	case 105: /* divhw r,[r,]r */
+		o1 = c.oprrr(p, p.As, int(p.Scond))
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		r := int(p.Reg)
+		if r == 0 {
+			r = rt
+		}
+		o1 |= (uint32(rf)&15)<<8 | (uint32(r)&15)<<0 | (uint32(rt)&15)<<16
+
+	case 110: /* dmb [mbop | $con] */
+		o1 = 0xf57ff050
+		mbop := uint32(0)
+
+		switch c.aclass(&p.From) {
+		case C_SPR:
+			for _, f := range mbOp {
+				if f.reg == p.From.Reg {
+					mbop = f.enc
+					break
+				}
+			}
+		case C_RCON:
+			for _, f := range mbOp {
+				enc := uint32(c.instoffset)
+				if f.enc == enc {
+					mbop = enc
+					break
+				}
+			}
+		case C_NONE:
+			mbop = 0xf
+		}
+
+		if mbop == 0 {
+			c.ctxt.Diag("illegal mb option:\n%v", p)
+		}
+		o1 |= mbop
+	}
+
+	out[0] = o1
+	out[1] = o2
+	out[2] = o3
+	out[3] = o4
+	out[4] = o5
+	out[5] = o6
+}
+
+func (c *ctxt5) movxt(p *obj.Prog) uint32 {
+	o1 := ((uint32(p.Scond) & C_SCOND) ^ C_SCOND_XOR) << 28
+	switch p.As {
+	case AMOVB, AMOVBS:
+		o1 |= 0x6af<<16 | 0x7<<4
+	case AMOVH, AMOVHS:
+		o1 |= 0x6bf<<16 | 0x7<<4
+	case AMOVBU:
+		o1 |= 0x6ef<<16 | 0x7<<4
+	case AMOVHU:
+		o1 |= 0x6ff<<16 | 0x7<<4
+	default:
+		c.ctxt.Diag("illegal combination: %v", p)
+	}
+	switch p.From.Offset &^ 0xf {
+	// only 0/8/16/24 bits rotation is accepted
+	case SHIFT_RR, SHIFT_RR | 8<<7, SHIFT_RR | 16<<7, SHIFT_RR | 24<<7:
+		o1 |= uint32(p.From.Offset) & 0xc0f
+	default:
+		c.ctxt.Diag("illegal shift: %v", p)
+	}
+	o1 |= (uint32(p.To.Reg) & 15) << 12
+	return o1
+}
+
+func (c *ctxt5) mov(p *obj.Prog) uint32 {
+	c.aclass(&p.From)
+	o1 := c.oprrr(p, p.As, int(p.Scond))
+	o1 |= uint32(p.From.Offset)
+	rt := int(p.To.Reg)
+	if p.To.Type == obj.TYPE_NONE {
+		rt = 0
+	}
+	r := int(p.Reg)
+	if p.As == AMOVW || p.As == AMVN {
+		r = 0
+	} else if r == 0 {
+		r = rt
+	}
+	o1 |= (uint32(r)&15)<<16 | (uint32(rt)&15)<<12
+	return o1
+}
+
+func (c *ctxt5) oprrr(p *obj.Prog, a obj.As, sc int) uint32 {
+	o := ((uint32(sc) & C_SCOND) ^ C_SCOND_XOR) << 28
+	if sc&C_SBIT != 0 {
+		o |= 1 << 20
+	}
+	switch a {
+	case ADIVHW:
+		return o | 0x71<<20 | 0xf<<12 | 0x1<<4
+	case ADIVUHW:
+		return o | 0x73<<20 | 0xf<<12 | 0x1<<4
+	case AMMUL:
+		return o | 0x75<<20 | 0xf<<12 | 0x1<<4
+	case AMULS:
+		return o | 0x6<<20 | 0x9<<4
+	case AMMULA:
+		return o | 0x75<<20 | 0x1<<4
+	case AMMULS:
+		return o | 0x75<<20 | 0xd<<4
+	case AMULU, AMUL:
+		return o | 0x0<<21 | 0x9<<4
+	case AMULA:
+		return o | 0x1<<21 | 0x9<<4
+	case AMULLU:
+		return o | 0x4<<21 | 0x9<<4
+	case AMULL:
+		return o | 0x6<<21 | 0x9<<4
+	case AMULALU:
+		return o | 0x5<<21 | 0x9<<4
+	case AMULAL:
+		return o | 0x7<<21 | 0x9<<4
+	case AAND:
+		return o | 0x0<<21
+	case AEOR:
+		return o | 0x1<<21
+	case ASUB:
+		return o | 0x2<<21
+	case ARSB:
+		return o | 0x3<<21
+	case AADD:
+		return o | 0x4<<21
+	case AADC:
+		return o | 0x5<<21
+	case ASBC:
+		return o | 0x6<<21
+	case ARSC:
+		return o | 0x7<<21
+	case ATST:
+		return o | 0x8<<21 | 1<<20
+	case ATEQ:
+		return o | 0x9<<21 | 1<<20
+	case ACMP:
+		return o | 0xa<<21 | 1<<20
+	case ACMN:
+		return o | 0xb<<21 | 1<<20
+	case AORR:
+		return o | 0xc<<21
+
+	case AMOVB, AMOVH, AMOVW:
+		if sc&(C_PBIT|C_WBIT) != 0 {
+			c.ctxt.Diag("invalid .P/.W suffix: %v", p)
+		}
+		return o | 0xd<<21
+	case ABIC:
+		return o | 0xe<<21
+	case AMVN:
+		return o | 0xf<<21
+	case ASLL:
+		return o | 0xd<<21 | 0<<5
+	case ASRL:
+		return o | 0xd<<21 | 1<<5
+	case ASRA:
+		return o | 0xd<<21 | 2<<5
+	case ASWI:
+		return o | 0xf<<24
+
+	case AADDD:
+		return o | 0xe<<24 | 0x3<<20 | 0xb<<8 | 0<<4
+	case AADDF:
+		return o | 0xe<<24 | 0x3<<20 | 0xa<<8 | 0<<4
+	case ASUBD:
+		return o | 0xe<<24 | 0x3<<20 | 0xb<<8 | 4<<4
+	case ASUBF:
+		return o | 0xe<<24 | 0x3<<20 | 0xa<<8 | 4<<4
+	case AMULD:
+		return o | 0xe<<24 | 0x2<<20 | 0xb<<8 | 0<<4
+	case AMULF:
+		return o | 0xe<<24 | 0x2<<20 | 0xa<<8 | 0<<4
+	case ANMULD:
+		return o | 0xe<<24 | 0x2<<20 | 0xb<<8 | 0x4<<4
+	case ANMULF:
+		return o | 0xe<<24 | 0x2<<20 | 0xa<<8 | 0x4<<4
+	case AMULAD:
+		return o | 0xe<<24 | 0xb<<8
+	case AMULAF:
+		return o | 0xe<<24 | 0xa<<8
+	case AMULSD:
+		return o | 0xe<<24 | 0xb<<8 | 0x4<<4
+	case AMULSF:
+		return o | 0xe<<24 | 0xa<<8 | 0x4<<4
+	case ANMULAD:
+		return o | 0xe<<24 | 0x1<<20 | 0xb<<8 | 0x4<<4
+	case ANMULAF:
+		return o | 0xe<<24 | 0x1<<20 | 0xa<<8 | 0x4<<4
+	case ANMULSD:
+		return o | 0xe<<24 | 0x1<<20 | 0xb<<8
+	case ANMULSF:
+		return o | 0xe<<24 | 0x1<<20 | 0xa<<8
+	case AFMULAD:
+		return o | 0xe<<24 | 0xa<<20 | 0xb<<8
+	case AFMULAF:
+		return o | 0xe<<24 | 0xa<<20 | 0xa<<8
+	case AFMULSD:
+		return o | 0xe<<24 | 0xa<<20 | 0xb<<8 | 0x4<<4
+	case AFMULSF:
+		return o | 0xe<<24 | 0xa<<20 | 0xa<<8 | 0x4<<4
+	case AFNMULAD:
+		return o | 0xe<<24 | 0x9<<20 | 0xb<<8 | 0x4<<4
+	case AFNMULAF:
+		return o | 0xe<<24 | 0x9<<20 | 0xa<<8 | 0x4<<4
+	case AFNMULSD:
+		return o | 0xe<<24 | 0x9<<20 | 0xb<<8
+	case AFNMULSF:
+		return o | 0xe<<24 | 0x9<<20 | 0xa<<8
+	case ADIVD:
+		return o | 0xe<<24 | 0x8<<20 | 0xb<<8 | 0<<4
+	case ADIVF:
+		return o | 0xe<<24 | 0x8<<20 | 0xa<<8 | 0<<4
+	case ASQRTD:
+		return o | 0xe<<24 | 0xb<<20 | 1<<16 | 0xb<<8 | 0xc<<4
+	case ASQRTF:
+		return o | 0xe<<24 | 0xb<<20 | 1<<16 | 0xa<<8 | 0xc<<4
+	case AABSD:
+		return o | 0xe<<24 | 0xb<<20 | 0<<16 | 0xb<<8 | 0xc<<4
+	case AABSF:
+		return o | 0xe<<24 | 0xb<<20 | 0<<16 | 0xa<<8 | 0xc<<4
+	case ANEGD:
+		return o | 0xe<<24 | 0xb<<20 | 1<<16 | 0xb<<8 | 0x4<<4
+	case ANEGF:
+		return o | 0xe<<24 | 0xb<<20 | 1<<16 | 0xa<<8 | 0x4<<4
+	case ACMPD:
+		return o | 0xe<<24 | 0xb<<20 | 4<<16 | 0xb<<8 | 0xc<<4
+	case ACMPF:
+		return o | 0xe<<24 | 0xb<<20 | 4<<16 | 0xa<<8 | 0xc<<4
+
+	case AMOVF:
+		return o | 0xe<<24 | 0xb<<20 | 0<<16 | 0xa<<8 | 4<<4
+	case AMOVD:
+		return o | 0xe<<24 | 0xb<<20 | 0<<16 | 0xb<<8 | 4<<4
+
+	case AMOVDF:
+		return o | 0xe<<24 | 0xb<<20 | 7<<16 | 0xa<<8 | 0xc<<4 | 1<<8 // dtof
+	case AMOVFD:
+		return o | 0xe<<24 | 0xb<<20 | 7<<16 | 0xa<<8 | 0xc<<4 | 0<<8 // dtof
+
+	case AMOVWF:
+		if sc&C_UBIT == 0 {
+			o |= 1 << 7 /* signed */
+		}
+		return o | 0xe<<24 | 0xb<<20 | 8<<16 | 0xa<<8 | 4<<4 | 0<<18 | 0<<8 // toint, double
+
+	case AMOVWD:
+		if sc&C_UBIT == 0 {
+			o |= 1 << 7 /* signed */
+		}
+		return o | 0xe<<24 | 0xb<<20 | 8<<16 | 0xa<<8 | 4<<4 | 0<<18 | 1<<8 // toint, double
+
+	case AMOVFW:
+		if sc&C_UBIT == 0 {
+			o |= 1 << 16 /* signed */
+		}
+		return o | 0xe<<24 | 0xb<<20 | 8<<16 | 0xa<<8 | 4<<4 | 1<<18 | 0<<8 | 1<<7 // toint, double, trunc
+
+	case AMOVDW:
+		if sc&C_UBIT == 0 {
+			o |= 1 << 16 /* signed */
+		}
+		return o | 0xe<<24 | 0xb<<20 | 8<<16 | 0xa<<8 | 4<<4 | 1<<18 | 1<<8 | 1<<7 // toint, double, trunc
+
+	case -AMOVWF: // copy WtoF
+		return o | 0xe<<24 | 0x0<<20 | 0xb<<8 | 1<<4
+
+	case -AMOVFW: // copy FtoW
+		return o | 0xe<<24 | 0x1<<20 | 0xb<<8 | 1<<4
+
+	case -ACMP: // cmp imm
+		return o | 0x3<<24 | 0x5<<20
+
+	case ABFX:
+		return o | 0x3d<<21 | 0x5<<4
+
+	case ABFXU:
+		return o | 0x3f<<21 | 0x5<<4
+
+	case ABFC:
+		return o | 0x3e<<21 | 0x1f
+
+	case ABFI:
+		return o | 0x3e<<21 | 0x1<<4
+
+	case AXTAB:
+		return o | 0x6a<<20 | 0x7<<4
+
+	case AXTAH:
+		return o | 0x6b<<20 | 0x7<<4
+
+	case AXTABU:
+		return o | 0x6e<<20 | 0x7<<4
+
+	case AXTAHU:
+		return o | 0x6f<<20 | 0x7<<4
+
+		// CLZ doesn't support .nil
+	case ACLZ:
+		return o&(0xf<<28) | 0x16f<<16 | 0xf1<<4
+
+	case AREV:
+		return o&(0xf<<28) | 0x6bf<<16 | 0xf3<<4
+
+	case AREV16:
+		return o&(0xf<<28) | 0x6bf<<16 | 0xfb<<4
+
+	case AREVSH:
+		return o&(0xf<<28) | 0x6ff<<16 | 0xfb<<4
+
+	case ARBIT:
+		return o&(0xf<<28) | 0x6ff<<16 | 0xf3<<4
+
+	case AMULWT:
+		return o&(0xf<<28) | 0x12<<20 | 0xe<<4
+
+	case AMULWB:
+		return o&(0xf<<28) | 0x12<<20 | 0xa<<4
+
+	case AMULBB:
+		return o&(0xf<<28) | 0x16<<20 | 0x8<<4
+
+	case AMULAWT:
+		return o&(0xf<<28) | 0x12<<20 | 0xc<<4
+
+	case AMULAWB:
+		return o&(0xf<<28) | 0x12<<20 | 0x8<<4
+
+	case AMULABB:
+		return o&(0xf<<28) | 0x10<<20 | 0x8<<4
+
+	case ABL: // BLX REG
+		return o&(0xf<<28) | 0x12fff3<<4
+	}
+
+	c.ctxt.Diag("%v: bad rrr %d", p, a)
+	return 0
+}
+
+func (c *ctxt5) opbra(p *obj.Prog, a obj.As, sc int) uint32 {
+	sc &= C_SCOND
+	sc ^= C_SCOND_XOR
+	if a == ABL || a == obj.ADUFFZERO || a == obj.ADUFFCOPY {
+		return uint32(sc)<<28 | 0x5<<25 | 0x1<<24
+	}
+	if sc != 0xe {
+		c.ctxt.Diag("%v: .COND on bcond instruction", p)
+	}
+	switch a {
+	case ABEQ:
+		return 0x0<<28 | 0x5<<25
+	case ABNE:
+		return 0x1<<28 | 0x5<<25
+	case ABCS:
+		return 0x2<<28 | 0x5<<25
+	case ABHS:
+		return 0x2<<28 | 0x5<<25
+	case ABCC:
+		return 0x3<<28 | 0x5<<25
+	case ABLO:
+		return 0x3<<28 | 0x5<<25
+	case ABMI:
+		return 0x4<<28 | 0x5<<25
+	case ABPL:
+		return 0x5<<28 | 0x5<<25
+	case ABVS:
+		return 0x6<<28 | 0x5<<25
+	case ABVC:
+		return 0x7<<28 | 0x5<<25
+	case ABHI:
+		return 0x8<<28 | 0x5<<25
+	case ABLS:
+		return 0x9<<28 | 0x5<<25
+	case ABGE:
+		return 0xa<<28 | 0x5<<25
+	case ABLT:
+		return 0xb<<28 | 0x5<<25
+	case ABGT:
+		return 0xc<<28 | 0x5<<25
+	case ABLE:
+		return 0xd<<28 | 0x5<<25
+	case AB:
+		return 0xe<<28 | 0x5<<25
+	}
+
+	c.ctxt.Diag("%v: bad bra %v", p, a)
+	return 0
+}
+
+func (c *ctxt5) olr(v int32, b int, r int, sc int) uint32 {
+	o := ((uint32(sc) & C_SCOND) ^ C_SCOND_XOR) << 28
+	if sc&C_PBIT == 0 {
+		o |= 1 << 24
+	}
+	if sc&C_UBIT == 0 {
+		o |= 1 << 23
+	}
+	if sc&C_WBIT != 0 {
+		o |= 1 << 21
+	}
+	o |= 1<<26 | 1<<20
+	if v < 0 {
+		if sc&C_UBIT != 0 {
+			c.ctxt.Diag(".U on neg offset")
+		}
+		v = -v
+		o ^= 1 << 23
+	}
+
+	if v >= 1<<12 || v < 0 {
+		c.ctxt.Diag("literal span too large: %d (R%d)\n%v", v, b, c.printp)
+	}
+	o |= uint32(v)
+	o |= (uint32(b) & 15) << 16
+	o |= (uint32(r) & 15) << 12
+	return o
+}
+
+func (c *ctxt5) olhr(v int32, b int, r int, sc int) uint32 {
+	o := ((uint32(sc) & C_SCOND) ^ C_SCOND_XOR) << 28
+	if sc&C_PBIT == 0 {
+		o |= 1 << 24
+	}
+	if sc&C_WBIT != 0 {
+		o |= 1 << 21
+	}
+	o |= 1<<23 | 1<<20 | 0xb<<4
+	if v < 0 {
+		v = -v
+		o ^= 1 << 23
+	}
+
+	if v >= 1<<8 || v < 0 {
+		c.ctxt.Diag("literal span too large: %d (R%d)\n%v", v, b, c.printp)
+	}
+	o |= uint32(v)&0xf | (uint32(v)>>4)<<8 | 1<<22
+	o |= (uint32(b) & 15) << 16
+	o |= (uint32(r) & 15) << 12
+	return o
+}
+
+func (c *ctxt5) osr(a obj.As, r int, v int32, b int, sc int) uint32 {
+	o := c.olr(v, b, r, sc) ^ (1 << 20)
+	if a != AMOVW {
+		o |= 1 << 22
+	}
+	return o
+}
+
+func (c *ctxt5) oshr(r int, v int32, b int, sc int) uint32 {
+	o := c.olhr(v, b, r, sc) ^ (1 << 20)
+	return o
+}
+
+func (c *ctxt5) osrr(r int, i int, b int, sc int) uint32 {
+	return c.olr(int32(i), b, r, sc) ^ (1<<25 | 1<<20)
+}
+
+func (c *ctxt5) oshrr(r int, i int, b int, sc int) uint32 {
+	return c.olhr(int32(i), b, r, sc) ^ (1<<22 | 1<<20)
+}
+
+func (c *ctxt5) olrr(i int, b int, r int, sc int) uint32 {
+	return c.olr(int32(i), b, r, sc) ^ (1 << 25)
+}
+
+func (c *ctxt5) olhrr(i int, b int, r int, sc int) uint32 {
+	return c.olhr(int32(i), b, r, sc) ^ (1 << 22)
+}
+
+func (c *ctxt5) ofsr(a obj.As, r int, v int32, b int, sc int, p *obj.Prog) uint32 {
+	o := ((uint32(sc) & C_SCOND) ^ C_SCOND_XOR) << 28
+	if sc&C_PBIT == 0 {
+		o |= 1 << 24
+	}
+	if sc&C_WBIT != 0 {
+		o |= 1 << 21
+	}
+	o |= 6<<25 | 1<<24 | 1<<23 | 10<<8
+	if v < 0 {
+		v = -v
+		o ^= 1 << 23
+	}
+
+	if v&3 != 0 {
+		c.ctxt.Diag("odd offset for floating point op: %d\n%v", v, p)
+	} else if v >= 1<<10 || v < 0 {
+		c.ctxt.Diag("literal span too large: %d\n%v", v, p)
+	}
+	o |= (uint32(v) >> 2) & 0xFF
+	o |= (uint32(b) & 15) << 16
+	o |= (uint32(r) & 15) << 12
+
+	switch a {
+	default:
+		c.ctxt.Diag("bad fst %v", a)
+		fallthrough
+
+	case AMOVD:
+		o |= 1 << 8
+		fallthrough
+
+	case AMOVF:
+		break
+	}
+
+	return o
+}
+
+// MOVW $"lower 16-bit", Reg
+func (c *ctxt5) omvs(p *obj.Prog, a *obj.Addr, dr int) uint32 {
+	o1 := ((uint32(p.Scond) & C_SCOND) ^ C_SCOND_XOR) << 28
+	o1 |= 0x30 << 20
+	o1 |= (uint32(dr) & 15) << 12
+	o1 |= uint32(a.Offset) & 0x0fff
+	o1 |= (uint32(a.Offset) & 0xf000) << 4
+	return o1
+}
+
+// MVN $C_NCON, Reg -> MOVW $C_RCON, Reg
+func (c *ctxt5) omvr(p *obj.Prog, a *obj.Addr, dr int) uint32 {
+	o1 := c.oprrr(p, AMOVW, int(p.Scond))
+	o1 |= (uint32(dr) & 15) << 12
+	v := immrot(^uint32(a.Offset))
+	if v == 0 {
+		c.ctxt.Diag("%v: missing literal", p)
+		return 0
+	}
+	o1 |= uint32(v)
+	return o1
+}
+
+func (c *ctxt5) omvl(p *obj.Prog, a *obj.Addr, dr int) uint32 {
+	var o1 uint32
+	if p.Pool == nil {
+		c.aclass(a)
+		v := immrot(^uint32(c.instoffset))
+		if v == 0 {
+			c.ctxt.Diag("%v: missing literal", p)
+			return 0
+		}
+
+		o1 = c.oprrr(p, AMVN, int(p.Scond)&C_SCOND)
+		o1 |= uint32(v)
+		o1 |= (uint32(dr) & 15) << 12
+	} else {
+		v := int32(p.Pool.Pc - p.Pc - 8)
+		o1 = c.olr(v, REGPC, dr, int(p.Scond)&C_SCOND)
+	}
+
+	return o1
+}
+
+func (c *ctxt5) chipzero5(e float64) int {
+	// We use GOARM=7 to gate the use of VFPv3 vmov (imm) instructions.
+	if objabi.GOARM < 7 || math.Float64bits(e) != 0 {
+		return -1
+	}
+	return 0
+}
+
+func (c *ctxt5) chipfloat5(e float64) int {
+	// We use GOARM=7 to gate the use of VFPv3 vmov (imm) instructions.
+	if objabi.GOARM < 7 {
+		return -1
+	}
+
+	ei := math.Float64bits(e)
+	l := uint32(ei)
+	h := uint32(ei >> 32)
+
+	if l != 0 || h&0xffff != 0 {
+		return -1
+	}
+	h1 := h & 0x7fc00000
+	if h1 != 0x40000000 && h1 != 0x3fc00000 {
+		return -1
+	}
+	n := 0
+
+	// sign bit (a)
+	if h&0x80000000 != 0 {
+		n |= 1 << 7
+	}
+
+	// exp sign bit (b)
+	if h1 == 0x3fc00000 {
+		n |= 1 << 6
+	}
+
+	// rest of exp and mantissa (cd-efgh)
+	n |= int((h >> 16) & 0x3f)
+
+	//print("match %.8lux %.8lux %d\n", l, h, n);
+	return n
+}
+
+func nocache(p *obj.Prog) {
+	p.Optab = 0
+	p.From.Class = 0
+	if p.GetFrom3() != nil {
+		p.GetFrom3().Class = 0
+	}
+	p.To.Class = 0
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/list5.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/list5.go
new file mode 100644
index 000000000..30e03001a
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/list5.go
@@ -0,0 +1,124 @@
+// Inferno utils/5c/list.c
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/5c/list.c
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package arm
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"fmt"
+)
+
+func init() {
+	obj.RegisterRegister(obj.RBaseARM, MAXREG, rconv)
+	obj.RegisterOpcode(obj.ABaseARM, Anames)
+	obj.RegisterRegisterList(obj.RegListARMLo, obj.RegListARMHi, rlconv)
+	obj.RegisterOpSuffix("arm", obj.CConvARM)
+}
+
+func rconv(r int) string {
+	if r == 0 {
+		return "NONE"
+	}
+	if r == REGG {
+		// Special case.
+		return "g"
+	}
+	if REG_R0 <= r && r <= REG_R15 {
+		return fmt.Sprintf("R%d", r-REG_R0)
+	}
+	if REG_F0 <= r && r <= REG_F15 {
+		return fmt.Sprintf("F%d", r-REG_F0)
+	}
+
+	switch r {
+	case REG_FPSR:
+		return "FPSR"
+
+	case REG_FPCR:
+		return "FPCR"
+
+	case REG_CPSR:
+		return "CPSR"
+
+	case REG_SPSR:
+		return "SPSR"
+
+	case REG_MB_SY:
+		return "MB_SY"
+	case REG_MB_ST:
+		return "MB_ST"
+	case REG_MB_ISH:
+		return "MB_ISH"
+	case REG_MB_ISHST:
+		return "MB_ISHST"
+	case REG_MB_NSH:
+		return "MB_NSH"
+	case REG_MB_NSHST:
+		return "MB_NSHST"
+	case REG_MB_OSH:
+		return "MB_OSH"
+	case REG_MB_OSHST:
+		return "MB_OSHST"
+	}
+
+	return fmt.Sprintf("Rgok(%d)", r-obj.RBaseARM)
+}
+
+func DRconv(a int) string {
+	s := "C_??"
+	if a >= C_NONE && a <= C_NCLASS {
+		s = cnames5[a]
+	}
+	var fp string
+	fp += s
+	return fp
+}
+
+func rlconv(list int64) string {
+	str := ""
+	for i := 0; i < 16; i++ {
+		if list&(1<<uint(i)) != 0 {
+			if str == "" {
+				str += "["
+			} else {
+				str += ","
+			}
+			// This is ARM-specific; R10 is g.
+			if i == REGG-REG_R0 {
+				str += "g"
+			} else {
+				str += fmt.Sprintf("R%d", i)
+			}
+		}
+	}
+
+	str += "]"
+	return str
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/obj5.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/obj5.go
new file mode 100644
index 000000000..50e0698a3
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm/obj5.go
@@ -0,0 +1,784 @@
+// Derived from Inferno utils/5c/swt.c
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/5c/swt.c
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package arm
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"github.com/twitchyliquid64/golang-asm/sys"
+)
+
+var progedit_tlsfallback *obj.LSym
+
+func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
+	p.From.Class = 0
+	p.To.Class = 0
+
+	c := ctxt5{ctxt: ctxt, newprog: newprog}
+
+	// Rewrite B/BL to symbol as TYPE_BRANCH.
+	switch p.As {
+	case AB, ABL, obj.ADUFFZERO, obj.ADUFFCOPY:
+		if p.To.Type == obj.TYPE_MEM && (p.To.Name == obj.NAME_EXTERN || p.To.Name == obj.NAME_STATIC) && p.To.Sym != nil {
+			p.To.Type = obj.TYPE_BRANCH
+		}
+	}
+
+	// Replace TLS register fetches on older ARM processors.
+	switch p.As {
+	// Treat MRC 15, 0, <reg>, C13, C0, 3 specially.
+	case AMRC:
+		if p.To.Offset&0xffff0fff == 0xee1d0f70 {
+			// Because the instruction might be rewritten to a BL which returns in R0
+			// the register must be zero.
+			if p.To.Offset&0xf000 != 0 {
+				ctxt.Diag("%v: TLS MRC instruction must write to R0 as it might get translated into a BL instruction", p.Line())
+			}
+
+			if objabi.GOARM < 7 {
+				// Replace it with BL runtime.read_tls_fallback(SB) for ARM CPUs that lack the tls extension.
+				if progedit_tlsfallback == nil {
+					progedit_tlsfallback = ctxt.Lookup("runtime.read_tls_fallback")
+				}
+
+				// MOVW	LR, R11
+				p.As = AMOVW
+
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REGLINK
+				p.To.Type = obj.TYPE_REG
+				p.To.Reg = REGTMP
+
+				// BL	runtime.read_tls_fallback(SB)
+				p = obj.Appendp(p, newprog)
+
+				p.As = ABL
+				p.To.Type = obj.TYPE_BRANCH
+				p.To.Sym = progedit_tlsfallback
+				p.To.Offset = 0
+
+				// MOVW	R11, LR
+				p = obj.Appendp(p, newprog)
+
+				p.As = AMOVW
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REGTMP
+				p.To.Type = obj.TYPE_REG
+				p.To.Reg = REGLINK
+				break
+			}
+		}
+
+		// Otherwise, MRC/MCR instructions need no further treatment.
+		p.As = AWORD
+	}
+
+	// Rewrite float constants to values stored in memory.
+	switch p.As {
+	case AMOVF:
+		if p.From.Type == obj.TYPE_FCONST && c.chipfloat5(p.From.Val.(float64)) < 0 && (c.chipzero5(p.From.Val.(float64)) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
+			f32 := float32(p.From.Val.(float64))
+			p.From.Type = obj.TYPE_MEM
+			p.From.Sym = ctxt.Float32Sym(f32)
+			p.From.Name = obj.NAME_EXTERN
+			p.From.Offset = 0
+		}
+
+	case AMOVD:
+		if p.From.Type == obj.TYPE_FCONST && c.chipfloat5(p.From.Val.(float64)) < 0 && (c.chipzero5(p.From.Val.(float64)) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
+			p.From.Type = obj.TYPE_MEM
+			p.From.Sym = ctxt.Float64Sym(p.From.Val.(float64))
+			p.From.Name = obj.NAME_EXTERN
+			p.From.Offset = 0
+		}
+	}
+
+	if ctxt.Flag_dynlink {
+		c.rewriteToUseGot(p)
+	}
+}
+
+// Rewrite p, if necessary, to access global data via the global offset table.
+func (c *ctxt5) rewriteToUseGot(p *obj.Prog) {
+	if p.As == obj.ADUFFCOPY || p.As == obj.ADUFFZERO {
+		//     ADUFFxxx $offset
+		// becomes
+		//     MOVW runtime.duffxxx@GOT, R9
+		//     ADD $offset, R9
+		//     CALL (R9)
+		var sym *obj.LSym
+		if p.As == obj.ADUFFZERO {
+			sym = c.ctxt.Lookup("runtime.duffzero")
+		} else {
+			sym = c.ctxt.Lookup("runtime.duffcopy")
+		}
+		offset := p.To.Offset
+		p.As = AMOVW
+		p.From.Type = obj.TYPE_MEM
+		p.From.Name = obj.NAME_GOTREF
+		p.From.Sym = sym
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R9
+		p.To.Name = obj.NAME_NONE
+		p.To.Offset = 0
+		p.To.Sym = nil
+		p1 := obj.Appendp(p, c.newprog)
+		p1.As = AADD
+		p1.From.Type = obj.TYPE_CONST
+		p1.From.Offset = offset
+		p1.To.Type = obj.TYPE_REG
+		p1.To.Reg = REG_R9
+		p2 := obj.Appendp(p1, c.newprog)
+		p2.As = obj.ACALL
+		p2.To.Type = obj.TYPE_MEM
+		p2.To.Reg = REG_R9
+		return
+	}
+
+	// We only care about global data: NAME_EXTERN means a global
+	// symbol in the Go sense, and p.Sym.Local is true for a few
+	// internally defined symbols.
+	if p.From.Type == obj.TYPE_ADDR && p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
+		// MOVW $sym, Rx becomes MOVW sym@GOT, Rx
+		// MOVW $sym+<off>, Rx becomes MOVW sym@GOT, Rx; ADD <off>, Rx
+		if p.As != AMOVW {
+			c.ctxt.Diag("do not know how to handle TYPE_ADDR in %v with -dynlink", p)
+		}
+		if p.To.Type != obj.TYPE_REG {
+			c.ctxt.Diag("do not know how to handle LEAQ-type insn to non-register in %v with -dynlink", p)
+		}
+		p.From.Type = obj.TYPE_MEM
+		p.From.Name = obj.NAME_GOTREF
+		if p.From.Offset != 0 {
+			q := obj.Appendp(p, c.newprog)
+			q.As = AADD
+			q.From.Type = obj.TYPE_CONST
+			q.From.Offset = p.From.Offset
+			q.To = p.To
+			p.From.Offset = 0
+		}
+	}
+	if p.GetFrom3() != nil && p.GetFrom3().Name == obj.NAME_EXTERN {
+		c.ctxt.Diag("don't know how to handle %v with -dynlink", p)
+	}
+	var source *obj.Addr
+	// MOVx sym, Ry becomes MOVW sym@GOT, R9; MOVx (R9), Ry
+	// MOVx Ry, sym becomes MOVW sym@GOT, R9; MOVx Ry, (R9)
+	// An addition may be inserted between the two MOVs if there is an offset.
+	if p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
+		if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
+			c.ctxt.Diag("cannot handle NAME_EXTERN on both sides in %v with -dynlink", p)
+		}
+		source = &p.From
+	} else if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
+		source = &p.To
+	} else {
+		return
+	}
+	if p.As == obj.ATEXT || p.As == obj.AFUNCDATA || p.As == obj.ACALL || p.As == obj.ARET || p.As == obj.AJMP {
+		return
+	}
+	if source.Sym.Type == objabi.STLSBSS {
+		return
+	}
+	if source.Type != obj.TYPE_MEM {
+		c.ctxt.Diag("don't know how to handle %v with -dynlink", p)
+	}
+	p1 := obj.Appendp(p, c.newprog)
+	p2 := obj.Appendp(p1, c.newprog)
+
+	p1.As = AMOVW
+	p1.From.Type = obj.TYPE_MEM
+	p1.From.Sym = source.Sym
+	p1.From.Name = obj.NAME_GOTREF
+	p1.To.Type = obj.TYPE_REG
+	p1.To.Reg = REG_R9
+
+	p2.As = p.As
+	p2.From = p.From
+	p2.To = p.To
+	if p.From.Name == obj.NAME_EXTERN {
+		p2.From.Reg = REG_R9
+		p2.From.Name = obj.NAME_NONE
+		p2.From.Sym = nil
+	} else if p.To.Name == obj.NAME_EXTERN {
+		p2.To.Reg = REG_R9
+		p2.To.Name = obj.NAME_NONE
+		p2.To.Sym = nil
+	} else {
+		return
+	}
+	obj.Nopout(p)
+}
+
+// Prog.mark
+const (
+	FOLL  = 1 << 0
+	LABEL = 1 << 1
+	LEAF  = 1 << 2
+)
+
+func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
+	autosize := int32(0)
+
+	if cursym.Func.Text == nil || cursym.Func.Text.Link == nil {
+		return
+	}
+
+	c := ctxt5{ctxt: ctxt, cursym: cursym, newprog: newprog}
+
+	p := c.cursym.Func.Text
+	autoffset := int32(p.To.Offset)
+	if autoffset == -4 {
+		// Historical way to mark NOFRAME.
+		p.From.Sym.Set(obj.AttrNoFrame, true)
+		autoffset = 0
+	}
+	if autoffset < 0 || autoffset%4 != 0 {
+		c.ctxt.Diag("frame size %d not 0 or a positive multiple of 4", autoffset)
+	}
+	if p.From.Sym.NoFrame() {
+		if autoffset != 0 {
+			c.ctxt.Diag("NOFRAME functions must have a frame size of 0, not %d", autoffset)
+		}
+	}
+
+	cursym.Func.Locals = autoffset
+	cursym.Func.Args = p.To.Val.(int32)
+
+	/*
+	 * find leaf subroutines
+	 */
+	for p := cursym.Func.Text; p != nil; p = p.Link {
+		switch p.As {
+		case obj.ATEXT:
+			p.Mark |= LEAF
+
+		case ADIV, ADIVU, AMOD, AMODU:
+			cursym.Func.Text.Mark &^= LEAF
+
+		case ABL,
+			ABX,
+			obj.ADUFFZERO,
+			obj.ADUFFCOPY:
+			cursym.Func.Text.Mark &^= LEAF
+		}
+	}
+
+	var q2 *obj.Prog
+	for p := cursym.Func.Text; p != nil; p = p.Link {
+		o := p.As
+		switch o {
+		case obj.ATEXT:
+			autosize = autoffset
+
+			if p.Mark&LEAF != 0 && autosize == 0 {
+				// A leaf function with no locals has no frame.
+				p.From.Sym.Set(obj.AttrNoFrame, true)
+			}
+
+			if !p.From.Sym.NoFrame() {
+				// If there is a stack frame at all, it includes
+				// space to save the LR.
+				autosize += 4
+			}
+
+			if autosize == 0 && cursym.Func.Text.Mark&LEAF == 0 {
+				// A very few functions that do not return to their caller
+				// are not identified as leaves but still have no frame.
+				if ctxt.Debugvlog {
+					ctxt.Logf("save suppressed in: %s\n", cursym.Name)
+				}
+
+				cursym.Func.Text.Mark |= LEAF
+			}
+
+			// FP offsets need an updated p.To.Offset.
+			p.To.Offset = int64(autosize) - 4
+
+			if cursym.Func.Text.Mark&LEAF != 0 {
+				cursym.Set(obj.AttrLeaf, true)
+				if p.From.Sym.NoFrame() {
+					break
+				}
+			}
+
+			if !p.From.Sym.NoSplit() {
+				p = c.stacksplit(p, autosize) // emit split check
+			}
+
+			// MOVW.W		R14,$-autosize(SP)
+			p = obj.Appendp(p, c.newprog)
+
+			p.As = AMOVW
+			p.Scond |= C_WBIT
+			p.From.Type = obj.TYPE_REG
+			p.From.Reg = REGLINK
+			p.To.Type = obj.TYPE_MEM
+			p.To.Offset = int64(-autosize)
+			p.To.Reg = REGSP
+			p.Spadj = autosize
+
+			if cursym.Func.Text.From.Sym.Wrapper() {
+				// if(g->panic != nil && g->panic->argp == FP) g->panic->argp = bottom-of-frame
+				//
+				//	MOVW g_panic(g), R1
+				//	CMP  $0, R1
+				//	B.NE checkargp
+				// end:
+				//	NOP
+				// ... function ...
+				// checkargp:
+				//	MOVW panic_argp(R1), R2
+				//	ADD  $(autosize+4), R13, R3
+				//	CMP  R2, R3
+				//	B.NE end
+				//	ADD  $4, R13, R4
+				//	MOVW R4, panic_argp(R1)
+				//	B    end
+				//
+				// The NOP is needed to give the jumps somewhere to land.
+				// It is a liblink NOP, not an ARM NOP: it encodes to 0 instruction bytes.
+
+				p = obj.Appendp(p, newprog)
+				p.As = AMOVW
+				p.From.Type = obj.TYPE_MEM
+				p.From.Reg = REGG
+				p.From.Offset = 4 * int64(ctxt.Arch.PtrSize) // G.panic
+				p.To.Type = obj.TYPE_REG
+				p.To.Reg = REG_R1
+
+				p = obj.Appendp(p, newprog)
+				p.As = ACMP
+				p.From.Type = obj.TYPE_CONST
+				p.From.Offset = 0
+				p.Reg = REG_R1
+
+				// B.NE checkargp
+				bne := obj.Appendp(p, newprog)
+				bne.As = ABNE
+				bne.To.Type = obj.TYPE_BRANCH
+
+				// end: NOP
+				end := obj.Appendp(bne, newprog)
+				end.As = obj.ANOP
+
+				// find end of function
+				var last *obj.Prog
+				for last = end; last.Link != nil; last = last.Link {
+				}
+
+				// MOVW panic_argp(R1), R2
+				mov := obj.Appendp(last, newprog)
+				mov.As = AMOVW
+				mov.From.Type = obj.TYPE_MEM
+				mov.From.Reg = REG_R1
+				mov.From.Offset = 0 // Panic.argp
+				mov.To.Type = obj.TYPE_REG
+				mov.To.Reg = REG_R2
+
+				// B.NE branch target is MOVW above
+				bne.To.SetTarget(mov)
+
+				// ADD $(autosize+4), R13, R3
+				p = obj.Appendp(mov, newprog)
+				p.As = AADD
+				p.From.Type = obj.TYPE_CONST
+				p.From.Offset = int64(autosize) + 4
+				p.Reg = REG_R13
+				p.To.Type = obj.TYPE_REG
+				p.To.Reg = REG_R3
+
+				// CMP R2, R3
+				p = obj.Appendp(p, newprog)
+				p.As = ACMP
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REG_R2
+				p.Reg = REG_R3
+
+				// B.NE end
+				p = obj.Appendp(p, newprog)
+				p.As = ABNE
+				p.To.Type = obj.TYPE_BRANCH
+				p.To.SetTarget(end)
+
+				// ADD $4, R13, R4
+				p = obj.Appendp(p, newprog)
+				p.As = AADD
+				p.From.Type = obj.TYPE_CONST
+				p.From.Offset = 4
+				p.Reg = REG_R13
+				p.To.Type = obj.TYPE_REG
+				p.To.Reg = REG_R4
+
+				// MOVW R4, panic_argp(R1)
+				p = obj.Appendp(p, newprog)
+				p.As = AMOVW
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REG_R4
+				p.To.Type = obj.TYPE_MEM
+				p.To.Reg = REG_R1
+				p.To.Offset = 0 // Panic.argp
+
+				// B end
+				p = obj.Appendp(p, newprog)
+				p.As = AB
+				p.To.Type = obj.TYPE_BRANCH
+				p.To.SetTarget(end)
+
+				// reset for subsequent passes
+				p = end
+			}
+
+		case obj.ARET:
+			nocache(p)
+			if cursym.Func.Text.Mark&LEAF != 0 {
+				if autosize == 0 {
+					p.As = AB
+					p.From = obj.Addr{}
+					if p.To.Sym != nil { // retjmp
+						p.To.Type = obj.TYPE_BRANCH
+					} else {
+						p.To.Type = obj.TYPE_MEM
+						p.To.Offset = 0
+						p.To.Reg = REGLINK
+					}
+
+					break
+				}
+			}
+
+			p.As = AMOVW
+			p.Scond |= C_PBIT
+			p.From.Type = obj.TYPE_MEM
+			p.From.Offset = int64(autosize)
+			p.From.Reg = REGSP
+			p.To.Type = obj.TYPE_REG
+			p.To.Reg = REGPC
+
+			// If there are instructions following
+			// this ARET, they come from a branch
+			// with the same stackframe, so no spadj.
+			if p.To.Sym != nil { // retjmp
+				p.To.Reg = REGLINK
+				q2 = obj.Appendp(p, newprog)
+				q2.As = AB
+				q2.To.Type = obj.TYPE_BRANCH
+				q2.To.Sym = p.To.Sym
+				p.To.Sym = nil
+				p = q2
+			}
+
+		case AADD:
+			if p.From.Type == obj.TYPE_CONST && p.From.Reg == 0 && p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP {
+				p.Spadj = int32(-p.From.Offset)
+			}
+
+		case ASUB:
+			if p.From.Type == obj.TYPE_CONST && p.From.Reg == 0 && p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP {
+				p.Spadj = int32(p.From.Offset)
+			}
+
+		case ADIV, ADIVU, AMOD, AMODU:
+			if cursym.Func.Text.From.Sym.NoSplit() {
+				ctxt.Diag("cannot divide in NOSPLIT function")
+			}
+			const debugdivmod = false
+			if debugdivmod {
+				break
+			}
+			if p.From.Type != obj.TYPE_REG {
+				break
+			}
+			if p.To.Type != obj.TYPE_REG {
+				break
+			}
+
+			// Make copy because we overwrite p below.
+			q1 := *p
+			if q1.Reg == REGTMP || q1.Reg == 0 && q1.To.Reg == REGTMP {
+				ctxt.Diag("div already using REGTMP: %v", p)
+			}
+
+			/* MOV m(g),REGTMP */
+			p.As = AMOVW
+			p.Pos = q1.Pos
+			p.From.Type = obj.TYPE_MEM
+			p.From.Reg = REGG
+			p.From.Offset = 6 * 4 // offset of g.m
+			p.Reg = 0
+			p.To.Type = obj.TYPE_REG
+			p.To.Reg = REGTMP
+
+			/* MOV a,m_divmod(REGTMP) */
+			p = obj.Appendp(p, newprog)
+			p.As = AMOVW
+			p.Pos = q1.Pos
+			p.From.Type = obj.TYPE_REG
+			p.From.Reg = q1.From.Reg
+			p.To.Type = obj.TYPE_MEM
+			p.To.Reg = REGTMP
+			p.To.Offset = 8 * 4 // offset of m.divmod
+
+			/* MOV b, R8 */
+			p = obj.Appendp(p, newprog)
+			p.As = AMOVW
+			p.Pos = q1.Pos
+			p.From.Type = obj.TYPE_REG
+			p.From.Reg = q1.Reg
+			if q1.Reg == 0 {
+				p.From.Reg = q1.To.Reg
+			}
+			p.To.Type = obj.TYPE_REG
+			p.To.Reg = REG_R8
+			p.To.Offset = 0
+
+			/* CALL appropriate */
+			p = obj.Appendp(p, newprog)
+			p.As = ABL
+			p.Pos = q1.Pos
+			p.To.Type = obj.TYPE_BRANCH
+			switch o {
+			case ADIV:
+				p.To.Sym = symdiv
+			case ADIVU:
+				p.To.Sym = symdivu
+			case AMOD:
+				p.To.Sym = symmod
+			case AMODU:
+				p.To.Sym = symmodu
+			}
+
+			/* MOV REGTMP, b */
+			p = obj.Appendp(p, newprog)
+			p.As = AMOVW
+			p.Pos = q1.Pos
+			p.From.Type = obj.TYPE_REG
+			p.From.Reg = REGTMP
+			p.From.Offset = 0
+			p.To.Type = obj.TYPE_REG
+			p.To.Reg = q1.To.Reg
+
+		case AMOVW:
+			if (p.Scond&C_WBIT != 0) && p.To.Type == obj.TYPE_MEM && p.To.Reg == REGSP {
+				p.Spadj = int32(-p.To.Offset)
+			}
+			if (p.Scond&C_PBIT != 0) && p.From.Type == obj.TYPE_MEM && p.From.Reg == REGSP && p.To.Reg != REGPC {
+				p.Spadj = int32(-p.From.Offset)
+			}
+			if p.From.Type == obj.TYPE_ADDR && p.From.Reg == REGSP && p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP {
+				p.Spadj = int32(-p.From.Offset)
+			}
+
+		case obj.AGETCALLERPC:
+			if cursym.Leaf() {
+				/* MOVW LR, Rd */
+				p.As = AMOVW
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REGLINK
+			} else {
+				/* MOVW (RSP), Rd */
+				p.As = AMOVW
+				p.From.Type = obj.TYPE_MEM
+				p.From.Reg = REGSP
+			}
+		}
+	}
+}
+
+func (c *ctxt5) stacksplit(p *obj.Prog, framesize int32) *obj.Prog {
+	// MOVW g_stackguard(g), R1
+	p = obj.Appendp(p, c.newprog)
+
+	p.As = AMOVW
+	p.From.Type = obj.TYPE_MEM
+	p.From.Reg = REGG
+	p.From.Offset = 2 * int64(c.ctxt.Arch.PtrSize) // G.stackguard0
+	if c.cursym.CFunc() {
+		p.From.Offset = 3 * int64(c.ctxt.Arch.PtrSize) // G.stackguard1
+	}
+	p.To.Type = obj.TYPE_REG
+	p.To.Reg = REG_R1
+
+	// Mark the stack bound check and morestack call async nonpreemptible.
+	// If we get preempted here, when resumed the preemption request is
+	// cleared, but we'll still call morestack, which will double the stack
+	// unnecessarily. See issue #35470.
+	p = c.ctxt.StartUnsafePoint(p, c.newprog)
+
+	if framesize <= objabi.StackSmall {
+		// small stack: SP < stackguard
+		//	CMP	stackguard, SP
+		p = obj.Appendp(p, c.newprog)
+
+		p.As = ACMP
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R1
+		p.Reg = REGSP
+	} else if framesize <= objabi.StackBig {
+		// large stack: SP-framesize < stackguard-StackSmall
+		//	MOVW $-(framesize-StackSmall)(SP), R2
+		//	CMP stackguard, R2
+		p = obj.Appendp(p, c.newprog)
+
+		p.As = AMOVW
+		p.From.Type = obj.TYPE_ADDR
+		p.From.Reg = REGSP
+		p.From.Offset = -(int64(framesize) - objabi.StackSmall)
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R2
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = ACMP
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R1
+		p.Reg = REG_R2
+	} else {
+		// Such a large stack we need to protect against wraparound
+		// if SP is close to zero.
+		//	SP-stackguard+StackGuard < framesize + (StackGuard-StackSmall)
+		// The +StackGuard on both sides is required to keep the left side positive:
+		// SP is allowed to be slightly below stackguard. See stack.h.
+		//	CMP     $StackPreempt, R1
+		//	MOVW.NE $StackGuard(SP), R2
+		//	SUB.NE  R1, R2
+		//	MOVW.NE $(framesize+(StackGuard-StackSmall)), R3
+		//	CMP.NE  R3, R2
+		p = obj.Appendp(p, c.newprog)
+
+		p.As = ACMP
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = int64(uint32(objabi.StackPreempt & (1<<32 - 1)))
+		p.Reg = REG_R1
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = AMOVW
+		p.From.Type = obj.TYPE_ADDR
+		p.From.Reg = REGSP
+		p.From.Offset = int64(objabi.StackGuard)
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R2
+		p.Scond = C_SCOND_NE
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = ASUB
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R1
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R2
+		p.Scond = C_SCOND_NE
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = AMOVW
+		p.From.Type = obj.TYPE_ADDR
+		p.From.Offset = int64(framesize) + (int64(objabi.StackGuard) - objabi.StackSmall)
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R3
+		p.Scond = C_SCOND_NE
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = ACMP
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R3
+		p.Reg = REG_R2
+		p.Scond = C_SCOND_NE
+	}
+
+	// BLS call-to-morestack
+	bls := obj.Appendp(p, c.newprog)
+	bls.As = ABLS
+	bls.To.Type = obj.TYPE_BRANCH
+
+	end := c.ctxt.EndUnsafePoint(bls, c.newprog, -1)
+
+	var last *obj.Prog
+	for last = c.cursym.Func.Text; last.Link != nil; last = last.Link {
+	}
+
+	// Now we are at the end of the function, but logically
+	// we are still in function prologue. We need to fix the
+	// SP data and PCDATA.
+	spfix := obj.Appendp(last, c.newprog)
+	spfix.As = obj.ANOP
+	spfix.Spadj = -framesize
+
+	pcdata := c.ctxt.EmitEntryStackMap(c.cursym, spfix, c.newprog)
+	pcdata = c.ctxt.StartUnsafePoint(pcdata, c.newprog)
+
+	// MOVW	LR, R3
+	movw := obj.Appendp(pcdata, c.newprog)
+	movw.As = AMOVW
+	movw.From.Type = obj.TYPE_REG
+	movw.From.Reg = REGLINK
+	movw.To.Type = obj.TYPE_REG
+	movw.To.Reg = REG_R3
+
+	bls.To.SetTarget(movw)
+
+	// BL runtime.morestack
+	call := obj.Appendp(movw, c.newprog)
+	call.As = obj.ACALL
+	call.To.Type = obj.TYPE_BRANCH
+	morestack := "runtime.morestack"
+	switch {
+	case c.cursym.CFunc():
+		morestack = "runtime.morestackc"
+	case !c.cursym.Func.Text.From.Sym.NeedCtxt():
+		morestack = "runtime.morestack_noctxt"
+	}
+	call.To.Sym = c.ctxt.Lookup(morestack)
+
+	pcdata = c.ctxt.EndUnsafePoint(call, c.newprog, -1)
+
+	// B start
+	b := obj.Appendp(pcdata, c.newprog)
+	b.As = obj.AJMP
+	b.To.Type = obj.TYPE_BRANCH
+	b.To.SetTarget(c.cursym.Func.Text.Link)
+	b.Spadj = +framesize
+
+	return end
+}
+
+var unaryDst = map[obj.As]bool{
+	ASWI:  true,
+	AWORD: true,
+}
+
+var Linkarm = obj.LinkArch{
+	Arch:           sys.ArchARM,
+	Init:           buildop,
+	Preprocess:     preprocess,
+	Assemble:       span5,
+	Progedit:       progedit,
+	UnaryDst:       unaryDst,
+	DWARFRegisters: ARMDWARFRegisters,
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/a.out.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/a.out.go
new file mode 100644
index 000000000..04c084ea2
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/a.out.go
@@ -0,0 +1,1033 @@
+// cmd/7c/7.out.h  from Vita Nuova.
+// https://code.google.com/p/ken-cc/source/browse/src/cmd/7c/7.out.h
+//
+// 	Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
+// 	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+// 	Portions Copyright © 1997-1999 Vita Nuova Limited
+// 	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+// 	Portions Copyright © 2004,2006 Bruce Ellis
+// 	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+// 	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+// 	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package arm64
+
+import "github.com/twitchyliquid64/golang-asm/obj"
+
+const (
+	NSNAME = 8
+	NSYM   = 50
+	NREG   = 32 /* number of general registers */
+	NFREG  = 32 /* number of floating point registers */
+)
+
+// General purpose registers, kept in the low bits of Prog.Reg.
+const (
+	// integer
+	REG_R0 = obj.RBaseARM64 + iota
+	REG_R1
+	REG_R2
+	REG_R3
+	REG_R4
+	REG_R5
+	REG_R6
+	REG_R7
+	REG_R8
+	REG_R9
+	REG_R10
+	REG_R11
+	REG_R12
+	REG_R13
+	REG_R14
+	REG_R15
+	REG_R16
+	REG_R17
+	REG_R18
+	REG_R19
+	REG_R20
+	REG_R21
+	REG_R22
+	REG_R23
+	REG_R24
+	REG_R25
+	REG_R26
+	REG_R27
+	REG_R28
+	REG_R29
+	REG_R30
+	REG_R31
+
+	// scalar floating point
+	REG_F0
+	REG_F1
+	REG_F2
+	REG_F3
+	REG_F4
+	REG_F5
+	REG_F6
+	REG_F7
+	REG_F8
+	REG_F9
+	REG_F10
+	REG_F11
+	REG_F12
+	REG_F13
+	REG_F14
+	REG_F15
+	REG_F16
+	REG_F17
+	REG_F18
+	REG_F19
+	REG_F20
+	REG_F21
+	REG_F22
+	REG_F23
+	REG_F24
+	REG_F25
+	REG_F26
+	REG_F27
+	REG_F28
+	REG_F29
+	REG_F30
+	REG_F31
+
+	// SIMD
+	REG_V0
+	REG_V1
+	REG_V2
+	REG_V3
+	REG_V4
+	REG_V5
+	REG_V6
+	REG_V7
+	REG_V8
+	REG_V9
+	REG_V10
+	REG_V11
+	REG_V12
+	REG_V13
+	REG_V14
+	REG_V15
+	REG_V16
+	REG_V17
+	REG_V18
+	REG_V19
+	REG_V20
+	REG_V21
+	REG_V22
+	REG_V23
+	REG_V24
+	REG_V25
+	REG_V26
+	REG_V27
+	REG_V28
+	REG_V29
+	REG_V30
+	REG_V31
+
+	// The EQ in
+	// 	CSET	EQ, R0
+	// is encoded as TYPE_REG, even though it's not really a register.
+	COND_EQ
+	COND_NE
+	COND_HS
+	COND_LO
+	COND_MI
+	COND_PL
+	COND_VS
+	COND_VC
+	COND_HI
+	COND_LS
+	COND_GE
+	COND_LT
+	COND_GT
+	COND_LE
+	COND_AL
+	COND_NV
+
+	REG_RSP = REG_V31 + 32 // to differentiate ZR/SP, REG_RSP&0x1f = 31
+)
+
+// bits 0-4 indicates register: Vn
+// bits 5-8 indicates arrangement: <T>
+const (
+	REG_ARNG = obj.RBaseARM64 + 1<<10 + iota<<9 // Vn.<T>
+	REG_ELEM                                    // Vn.<T>[index]
+	REG_ELEM_END
+)
+
+// Not registers, but flags that can be combined with regular register
+// constants to indicate extended register conversion. When checking,
+// you should subtract obj.RBaseARM64 first. From this difference, bit 11
+// indicates extended register, bits 8-10 select the conversion mode.
+// REG_LSL is the index shift specifier, bit 9 indicates shifted offset register.
+const REG_LSL = obj.RBaseARM64 + 1<<9
+const REG_EXT = obj.RBaseARM64 + 1<<11
+
+const (
+	REG_UXTB = REG_EXT + iota<<8
+	REG_UXTH
+	REG_UXTW
+	REG_UXTX
+	REG_SXTB
+	REG_SXTH
+	REG_SXTW
+	REG_SXTX
+)
+
+// Special registers, after subtracting obj.RBaseARM64, bit 12 indicates
+// a special register and the low bits select the register.
+// SYSREG_END is the last item in the automatically generated system register
+// declaration, and it is defined in the sysRegEnc.go file.
+const (
+	REG_SPECIAL = obj.RBaseARM64 + 1<<12
+	REG_DAIFSet = SYSREG_END + iota
+	REG_DAIFClr
+	REG_PLDL1KEEP
+	REG_PLDL1STRM
+	REG_PLDL2KEEP
+	REG_PLDL2STRM
+	REG_PLDL3KEEP
+	REG_PLDL3STRM
+	REG_PLIL1KEEP
+	REG_PLIL1STRM
+	REG_PLIL2KEEP
+	REG_PLIL2STRM
+	REG_PLIL3KEEP
+	REG_PLIL3STRM
+	REG_PSTL1KEEP
+	REG_PSTL1STRM
+	REG_PSTL2KEEP
+	REG_PSTL2STRM
+	REG_PSTL3KEEP
+	REG_PSTL3STRM
+)
+
+// Register assignments:
+//
+// compiler allocates R0 up as temps
+// compiler allocates register variables R7-R25
+// compiler allocates external registers R26 down
+//
+// compiler allocates register variables F7-F26
+// compiler allocates external registers F26 down
+const (
+	REGMIN = REG_R7  // register variables allocated from here to REGMAX
+	REGRT1 = REG_R16 // ARM64 IP0, external linker may use as a scrach register in trampoline
+	REGRT2 = REG_R17 // ARM64 IP1, external linker may use as a scrach register in trampoline
+	REGPR  = REG_R18 // ARM64 platform register, unused in the Go toolchain
+	REGMAX = REG_R25
+
+	REGCTXT = REG_R26 // environment for closures
+	REGTMP  = REG_R27 // reserved for liblink
+	REGG    = REG_R28 // G
+	REGFP   = REG_R29 // frame pointer, unused in the Go toolchain
+	REGLINK = REG_R30
+
+	// ARM64 uses R31 as both stack pointer and zero register,
+	// depending on the instruction. To differentiate RSP from ZR,
+	// we use a different numeric value for REGZERO and REGSP.
+	REGZERO = REG_R31
+	REGSP   = REG_RSP
+
+	FREGRET = REG_F0
+	FREGMIN = REG_F7  // first register variable
+	FREGMAX = REG_F26 // last register variable for 7g only
+	FREGEXT = REG_F26 // first external register
+)
+
+// http://infocenter.arm.com/help/topic/com.arm.doc.ecm0665627/abi_sve_aadwarf_100985_0000_00_en.pdf
+var ARM64DWARFRegisters = map[int16]int16{
+	REG_R0:  0,
+	REG_R1:  1,
+	REG_R2:  2,
+	REG_R3:  3,
+	REG_R4:  4,
+	REG_R5:  5,
+	REG_R6:  6,
+	REG_R7:  7,
+	REG_R8:  8,
+	REG_R9:  9,
+	REG_R10: 10,
+	REG_R11: 11,
+	REG_R12: 12,
+	REG_R13: 13,
+	REG_R14: 14,
+	REG_R15: 15,
+	REG_R16: 16,
+	REG_R17: 17,
+	REG_R18: 18,
+	REG_R19: 19,
+	REG_R20: 20,
+	REG_R21: 21,
+	REG_R22: 22,
+	REG_R23: 23,
+	REG_R24: 24,
+	REG_R25: 25,
+	REG_R26: 26,
+	REG_R27: 27,
+	REG_R28: 28,
+	REG_R29: 29,
+	REG_R30: 30,
+
+	// floating point
+	REG_F0:  64,
+	REG_F1:  65,
+	REG_F2:  66,
+	REG_F3:  67,
+	REG_F4:  68,
+	REG_F5:  69,
+	REG_F6:  70,
+	REG_F7:  71,
+	REG_F8:  72,
+	REG_F9:  73,
+	REG_F10: 74,
+	REG_F11: 75,
+	REG_F12: 76,
+	REG_F13: 77,
+	REG_F14: 78,
+	REG_F15: 79,
+	REG_F16: 80,
+	REG_F17: 81,
+	REG_F18: 82,
+	REG_F19: 83,
+	REG_F20: 84,
+	REG_F21: 85,
+	REG_F22: 86,
+	REG_F23: 87,
+	REG_F24: 88,
+	REG_F25: 89,
+	REG_F26: 90,
+	REG_F27: 91,
+	REG_F28: 92,
+	REG_F29: 93,
+	REG_F30: 94,
+	REG_F31: 95,
+
+	// SIMD
+	REG_V0:  64,
+	REG_V1:  65,
+	REG_V2:  66,
+	REG_V3:  67,
+	REG_V4:  68,
+	REG_V5:  69,
+	REG_V6:  70,
+	REG_V7:  71,
+	REG_V8:  72,
+	REG_V9:  73,
+	REG_V10: 74,
+	REG_V11: 75,
+	REG_V12: 76,
+	REG_V13: 77,
+	REG_V14: 78,
+	REG_V15: 79,
+	REG_V16: 80,
+	REG_V17: 81,
+	REG_V18: 82,
+	REG_V19: 83,
+	REG_V20: 84,
+	REG_V21: 85,
+	REG_V22: 86,
+	REG_V23: 87,
+	REG_V24: 88,
+	REG_V25: 89,
+	REG_V26: 90,
+	REG_V27: 91,
+	REG_V28: 92,
+	REG_V29: 93,
+	REG_V30: 94,
+	REG_V31: 95,
+}
+
+const (
+	BIG = 2048 - 8
+)
+
+const (
+	/* mark flags */
+	LABEL = 1 << iota
+	LEAF
+	FLOAT
+	BRANCH
+	LOAD
+	FCMP
+	SYNC
+	LIST
+	FOLL
+	NOSCHED
+)
+
+const (
+	// optab is sorted based on the order of these constants
+	// and the first match is chosen.
+	// The more specific class needs to come earlier.
+	C_NONE   = iota
+	C_REG    // R0..R30
+	C_RSP    // R0..R30, RSP
+	C_FREG   // F0..F31
+	C_VREG   // V0..V31
+	C_PAIR   // (Rn, Rm)
+	C_SHIFT  // Rn<<2
+	C_EXTREG // Rn.UXTB[<<3]
+	C_SPR    // REG_NZCV
+	C_COND   // EQ, NE, etc
+	C_ARNG   // Vn.<T>
+	C_ELEM   // Vn.<T>[index]
+	C_LIST   // [V1, V2, V3]
+
+	C_ZCON     // $0 or ZR
+	C_ABCON0   // could be C_ADDCON0 or C_BITCON
+	C_ADDCON0  // 12-bit unsigned, unshifted
+	C_ABCON    // could be C_ADDCON or C_BITCON
+	C_AMCON    // could be C_ADDCON or C_MOVCON
+	C_ADDCON   // 12-bit unsigned, shifted left by 0 or 12
+	C_MBCON    // could be C_MOVCON or C_BITCON
+	C_MOVCON   // generated by a 16-bit constant, optionally inverted and/or shifted by multiple of 16
+	C_BITCON   // bitfield and logical immediate masks
+	C_ADDCON2  // 24-bit constant
+	C_LCON     // 32-bit constant
+	C_MOVCON2  // a constant that can be loaded with one MOVZ/MOVN and one MOVK
+	C_MOVCON3  // a constant that can be loaded with one MOVZ/MOVN and two MOVKs
+	C_VCON     // 64-bit constant
+	C_FCON     // floating-point constant
+	C_VCONADDR // 64-bit memory address
+
+	C_AACON  // ADDCON offset in auto constant $a(FP)
+	C_AACON2 // 24-bit offset in auto constant $a(FP)
+	C_LACON  // 32-bit offset in auto constant $a(FP)
+	C_AECON  // ADDCON offset in extern constant $e(SB)
+
+	// TODO(aram): only one branch class should be enough
+	C_SBRA // for TYPE_BRANCH
+	C_LBRA
+
+	C_ZAUTO      // 0(RSP)
+	C_NSAUTO_8   // -256 <= x < 0, 0 mod 8
+	C_NSAUTO_4   // -256 <= x < 0, 0 mod 4
+	C_NSAUTO     // -256 <= x < 0
+	C_NPAUTO     // -512 <= x < 0, 0 mod 8
+	C_NAUTO4K    // -4095 <= x < 0
+	C_PSAUTO_8   // 0 to 255, 0 mod 8
+	C_PSAUTO_4   // 0 to 255, 0 mod 4
+	C_PSAUTO     // 0 to 255
+	C_PPAUTO     // 0 to 504, 0 mod 8
+	C_UAUTO4K_8  // 0 to 4095, 0 mod 8
+	C_UAUTO4K_4  // 0 to 4095, 0 mod 4
+	C_UAUTO4K_2  // 0 to 4095, 0 mod 2
+	C_UAUTO4K    // 0 to 4095
+	C_UAUTO8K_8  // 0 to 8190, 0 mod 8
+	C_UAUTO8K_4  // 0 to 8190, 0 mod 4
+	C_UAUTO8K    // 0 to 8190, 0 mod 2
+	C_UAUTO16K_8 // 0 to 16380, 0 mod 8
+	C_UAUTO16K   // 0 to 16380, 0 mod 4
+	C_UAUTO32K   // 0 to 32760, 0 mod 8
+	C_LAUTO      // any other 32-bit constant
+
+	C_SEXT1  // 0 to 4095, direct
+	C_SEXT2  // 0 to 8190
+	C_SEXT4  // 0 to 16380
+	C_SEXT8  // 0 to 32760
+	C_SEXT16 // 0 to 65520
+	C_LEXT
+
+	C_ZOREG    // 0(R)
+	C_NSOREG_8 // must mirror C_NSAUTO_8, etc
+	C_NSOREG_4
+	C_NSOREG
+	C_NPOREG
+	C_NOREG4K
+	C_PSOREG_8
+	C_PSOREG_4
+	C_PSOREG
+	C_PPOREG
+	C_UOREG4K_8
+	C_UOREG4K_4
+	C_UOREG4K_2
+	C_UOREG4K
+	C_UOREG8K_8
+	C_UOREG8K_4
+	C_UOREG8K
+	C_UOREG16K_8
+	C_UOREG16K
+	C_UOREG32K
+	C_LOREG
+
+	C_ADDR // TODO(aram): explain difference from C_VCONADDR
+
+	// The GOT slot for a symbol in -dynlink mode.
+	C_GOTADDR
+
+	// TLS "var" in local exec mode: will become a constant offset from
+	// thread local base that is ultimately chosen by the program linker.
+	C_TLS_LE
+
+	// TLS "var" in initial exec mode: will become a memory address (chosen
+	// by the program linker) that the dynamic linker will fill with the
+	// offset from the thread local base.
+	C_TLS_IE
+
+	C_ROFF // register offset (including register extended)
+
+	C_GOK
+	C_TEXTSIZE
+	C_NCLASS // must be last
+)
+
+const (
+	C_XPRE  = 1 << 6 // match arm.C_WBIT, so Prog.String know how to print it
+	C_XPOST = 1 << 5 // match arm.C_PBIT, so Prog.String know how to print it
+)
+
+//go:generate go run ../stringer.go -i $GOFILE -o anames.go -p arm64
+
+const (
+	AADC = obj.ABaseARM64 + obj.A_ARCHSPECIFIC + iota
+	AADCS
+	AADCSW
+	AADCW
+	AADD
+	AADDS
+	AADDSW
+	AADDW
+	AADR
+	AADRP
+	AAND
+	AANDS
+	AANDSW
+	AANDW
+	AASR
+	AASRW
+	AAT
+	ABFI
+	ABFIW
+	ABFM
+	ABFMW
+	ABFXIL
+	ABFXILW
+	ABIC
+	ABICS
+	ABICSW
+	ABICW
+	ABRK
+	ACBNZ
+	ACBNZW
+	ACBZ
+	ACBZW
+	ACCMN
+	ACCMNW
+	ACCMP
+	ACCMPW
+	ACINC
+	ACINCW
+	ACINV
+	ACINVW
+	ACLREX
+	ACLS
+	ACLSW
+	ACLZ
+	ACLZW
+	ACMN
+	ACMNW
+	ACMP
+	ACMPW
+	ACNEG
+	ACNEGW
+	ACRC32B
+	ACRC32CB
+	ACRC32CH
+	ACRC32CW
+	ACRC32CX
+	ACRC32H
+	ACRC32W
+	ACRC32X
+	ACSEL
+	ACSELW
+	ACSET
+	ACSETM
+	ACSETMW
+	ACSETW
+	ACSINC
+	ACSINCW
+	ACSINV
+	ACSINVW
+	ACSNEG
+	ACSNEGW
+	ADC
+	ADCPS1
+	ADCPS2
+	ADCPS3
+	ADMB
+	ADRPS
+	ADSB
+	AEON
+	AEONW
+	AEOR
+	AEORW
+	AERET
+	AEXTR
+	AEXTRW
+	AHINT
+	AHLT
+	AHVC
+	AIC
+	AISB
+	ALDADDAB
+	ALDADDAD
+	ALDADDAH
+	ALDADDAW
+	ALDADDALB
+	ALDADDALD
+	ALDADDALH
+	ALDADDALW
+	ALDADDB
+	ALDADDD
+	ALDADDH
+	ALDADDW
+	ALDADDLB
+	ALDADDLD
+	ALDADDLH
+	ALDADDLW
+	ALDANDAB
+	ALDANDAD
+	ALDANDAH
+	ALDANDAW
+	ALDANDALB
+	ALDANDALD
+	ALDANDALH
+	ALDANDALW
+	ALDANDB
+	ALDANDD
+	ALDANDH
+	ALDANDW
+	ALDANDLB
+	ALDANDLD
+	ALDANDLH
+	ALDANDLW
+	ALDAR
+	ALDARB
+	ALDARH
+	ALDARW
+	ALDAXP
+	ALDAXPW
+	ALDAXR
+	ALDAXRB
+	ALDAXRH
+	ALDAXRW
+	ALDEORAB
+	ALDEORAD
+	ALDEORAH
+	ALDEORAW
+	ALDEORALB
+	ALDEORALD
+	ALDEORALH
+	ALDEORALW
+	ALDEORB
+	ALDEORD
+	ALDEORH
+	ALDEORW
+	ALDEORLB
+	ALDEORLD
+	ALDEORLH
+	ALDEORLW
+	ALDORAB
+	ALDORAD
+	ALDORAH
+	ALDORAW
+	ALDORALB
+	ALDORALD
+	ALDORALH
+	ALDORALW
+	ALDORB
+	ALDORD
+	ALDORH
+	ALDORW
+	ALDORLB
+	ALDORLD
+	ALDORLH
+	ALDORLW
+	ALDP
+	ALDPW
+	ALDPSW
+	ALDXR
+	ALDXRB
+	ALDXRH
+	ALDXRW
+	ALDXP
+	ALDXPW
+	ALSL
+	ALSLW
+	ALSR
+	ALSRW
+	AMADD
+	AMADDW
+	AMNEG
+	AMNEGW
+	AMOVK
+	AMOVKW
+	AMOVN
+	AMOVNW
+	AMOVZ
+	AMOVZW
+	AMRS
+	AMSR
+	AMSUB
+	AMSUBW
+	AMUL
+	AMULW
+	AMVN
+	AMVNW
+	ANEG
+	ANEGS
+	ANEGSW
+	ANEGW
+	ANGC
+	ANGCS
+	ANGCSW
+	ANGCW
+	ANOOP
+	AORN
+	AORNW
+	AORR
+	AORRW
+	APRFM
+	APRFUM
+	ARBIT
+	ARBITW
+	AREM
+	AREMW
+	AREV
+	AREV16
+	AREV16W
+	AREV32
+	AREVW
+	AROR
+	ARORW
+	ASBC
+	ASBCS
+	ASBCSW
+	ASBCW
+	ASBFIZ
+	ASBFIZW
+	ASBFM
+	ASBFMW
+	ASBFX
+	ASBFXW
+	ASDIV
+	ASDIVW
+	ASEV
+	ASEVL
+	ASMADDL
+	ASMC
+	ASMNEGL
+	ASMSUBL
+	ASMULH
+	ASMULL
+	ASTXR
+	ASTXRB
+	ASTXRH
+	ASTXP
+	ASTXPW
+	ASTXRW
+	ASTLP
+	ASTLPW
+	ASTLR
+	ASTLRB
+	ASTLRH
+	ASTLRW
+	ASTLXP
+	ASTLXPW
+	ASTLXR
+	ASTLXRB
+	ASTLXRH
+	ASTLXRW
+	ASTP
+	ASTPW
+	ASUB
+	ASUBS
+	ASUBSW
+	ASUBW
+	ASVC
+	ASXTB
+	ASXTBW
+	ASXTH
+	ASXTHW
+	ASXTW
+	ASYS
+	ASYSL
+	ATBNZ
+	ATBZ
+	ATLBI
+	ATST
+	ATSTW
+	AUBFIZ
+	AUBFIZW
+	AUBFM
+	AUBFMW
+	AUBFX
+	AUBFXW
+	AUDIV
+	AUDIVW
+	AUMADDL
+	AUMNEGL
+	AUMSUBL
+	AUMULH
+	AUMULL
+	AUREM
+	AUREMW
+	AUXTB
+	AUXTH
+	AUXTW
+	AUXTBW
+	AUXTHW
+	AWFE
+	AWFI
+	AYIELD
+	AMOVB
+	AMOVBU
+	AMOVH
+	AMOVHU
+	AMOVW
+	AMOVWU
+	AMOVD
+	AMOVNP
+	AMOVNPW
+	AMOVP
+	AMOVPD
+	AMOVPQ
+	AMOVPS
+	AMOVPSW
+	AMOVPW
+	ASWPAD
+	ASWPAW
+	ASWPAH
+	ASWPAB
+	ASWPALD
+	ASWPALW
+	ASWPALH
+	ASWPALB
+	ASWPD
+	ASWPW
+	ASWPH
+	ASWPB
+	ASWPLD
+	ASWPLW
+	ASWPLH
+	ASWPLB
+	ABEQ
+	ABNE
+	ABCS
+	ABHS
+	ABCC
+	ABLO
+	ABMI
+	ABPL
+	ABVS
+	ABVC
+	ABHI
+	ABLS
+	ABGE
+	ABLT
+	ABGT
+	ABLE
+	AFABSD
+	AFABSS
+	AFADDD
+	AFADDS
+	AFCCMPD
+	AFCCMPED
+	AFCCMPS
+	AFCCMPES
+	AFCMPD
+	AFCMPED
+	AFCMPES
+	AFCMPS
+	AFCVTSD
+	AFCVTDS
+	AFCVTZSD
+	AFCVTZSDW
+	AFCVTZSS
+	AFCVTZSSW
+	AFCVTZUD
+	AFCVTZUDW
+	AFCVTZUS
+	AFCVTZUSW
+	AFDIVD
+	AFDIVS
+	AFLDPD
+	AFLDPS
+	AFMOVD
+	AFMOVS
+	AFMOVQ
+	AFMULD
+	AFMULS
+	AFNEGD
+	AFNEGS
+	AFSQRTD
+	AFSQRTS
+	AFSTPD
+	AFSTPS
+	AFSUBD
+	AFSUBS
+	ASCVTFD
+	ASCVTFS
+	ASCVTFWD
+	ASCVTFWS
+	AUCVTFD
+	AUCVTFS
+	AUCVTFWD
+	AUCVTFWS
+	AWORD
+	ADWORD
+	AFCSELS
+	AFCSELD
+	AFMAXS
+	AFMINS
+	AFMAXD
+	AFMIND
+	AFMAXNMS
+	AFMAXNMD
+	AFNMULS
+	AFNMULD
+	AFRINTNS
+	AFRINTND
+	AFRINTPS
+	AFRINTPD
+	AFRINTMS
+	AFRINTMD
+	AFRINTZS
+	AFRINTZD
+	AFRINTAS
+	AFRINTAD
+	AFRINTXS
+	AFRINTXD
+	AFRINTIS
+	AFRINTID
+	AFMADDS
+	AFMADDD
+	AFMSUBS
+	AFMSUBD
+	AFNMADDS
+	AFNMADDD
+	AFNMSUBS
+	AFNMSUBD
+	AFMINNMS
+	AFMINNMD
+	AFCVTDH
+	AFCVTHS
+	AFCVTHD
+	AFCVTSH
+	AAESD
+	AAESE
+	AAESIMC
+	AAESMC
+	ASHA1C
+	ASHA1H
+	ASHA1M
+	ASHA1P
+	ASHA1SU0
+	ASHA1SU1
+	ASHA256H
+	ASHA256H2
+	ASHA256SU0
+	ASHA256SU1
+	ASHA512H
+	ASHA512H2
+	ASHA512SU0
+	ASHA512SU1
+	AVADD
+	AVADDP
+	AVAND
+	AVBIF
+	AVCMEQ
+	AVCNT
+	AVEOR
+	AVMOV
+	AVLD1
+	AVLD2
+	AVLD3
+	AVLD4
+	AVLD1R
+	AVLD2R
+	AVLD3R
+	AVLD4R
+	AVORR
+	AVREV16
+	AVREV32
+	AVREV64
+	AVST1
+	AVST2
+	AVST3
+	AVST4
+	AVDUP
+	AVADDV
+	AVMOVI
+	AVUADDLV
+	AVSUB
+	AVFMLA
+	AVFMLS
+	AVPMULL
+	AVPMULL2
+	AVEXT
+	AVRBIT
+	AVUSHR
+	AVUSHLL
+	AVUSHLL2
+	AVUXTL
+	AVUXTL2
+	AVUZP1
+	AVUZP2
+	AVSHL
+	AVSRI
+	AVBSL
+	AVBIT
+	AVTBL
+	AVZIP1
+	AVZIP2
+	AVCMTST
+	ALAST
+	AB  = obj.AJMP
+	ABL = obj.ACALL
+)
+
+const (
+	// shift types
+	SHIFT_LL = 0 << 22
+	SHIFT_LR = 1 << 22
+	SHIFT_AR = 2 << 22
+)
+
+// Arrangement for ARM64 SIMD instructions
+const (
+	// arrangement types
+	ARNG_8B = iota
+	ARNG_16B
+	ARNG_1D
+	ARNG_4H
+	ARNG_8H
+	ARNG_2S
+	ARNG_4S
+	ARNG_2D
+	ARNG_1Q
+	ARNG_B
+	ARNG_H
+	ARNG_S
+	ARNG_D
+)
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/anames.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/anames.go
new file mode 100644
index 000000000..0ce620a9e
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/anames.go
@@ -0,0 +1,512 @@
+// Code generated by stringer -i a.out.go -o anames.go -p arm64; DO NOT EDIT.
+
+package arm64
+
+import "github.com/twitchyliquid64/golang-asm/obj"
+
+var Anames = []string{
+	obj.A_ARCHSPECIFIC: "ADC",
+	"ADCS",
+	"ADCSW",
+	"ADCW",
+	"ADD",
+	"ADDS",
+	"ADDSW",
+	"ADDW",
+	"ADR",
+	"ADRP",
+	"AND",
+	"ANDS",
+	"ANDSW",
+	"ANDW",
+	"ASR",
+	"ASRW",
+	"AT",
+	"BFI",
+	"BFIW",
+	"BFM",
+	"BFMW",
+	"BFXIL",
+	"BFXILW",
+	"BIC",
+	"BICS",
+	"BICSW",
+	"BICW",
+	"BRK",
+	"CBNZ",
+	"CBNZW",
+	"CBZ",
+	"CBZW",
+	"CCMN",
+	"CCMNW",
+	"CCMP",
+	"CCMPW",
+	"CINC",
+	"CINCW",
+	"CINV",
+	"CINVW",
+	"CLREX",
+	"CLS",
+	"CLSW",
+	"CLZ",
+	"CLZW",
+	"CMN",
+	"CMNW",
+	"CMP",
+	"CMPW",
+	"CNEG",
+	"CNEGW",
+	"CRC32B",
+	"CRC32CB",
+	"CRC32CH",
+	"CRC32CW",
+	"CRC32CX",
+	"CRC32H",
+	"CRC32W",
+	"CRC32X",
+	"CSEL",
+	"CSELW",
+	"CSET",
+	"CSETM",
+	"CSETMW",
+	"CSETW",
+	"CSINC",
+	"CSINCW",
+	"CSINV",
+	"CSINVW",
+	"CSNEG",
+	"CSNEGW",
+	"DC",
+	"DCPS1",
+	"DCPS2",
+	"DCPS3",
+	"DMB",
+	"DRPS",
+	"DSB",
+	"EON",
+	"EONW",
+	"EOR",
+	"EORW",
+	"ERET",
+	"EXTR",
+	"EXTRW",
+	"HINT",
+	"HLT",
+	"HVC",
+	"IC",
+	"ISB",
+	"LDADDAB",
+	"LDADDAD",
+	"LDADDAH",
+	"LDADDAW",
+	"LDADDALB",
+	"LDADDALD",
+	"LDADDALH",
+	"LDADDALW",
+	"LDADDB",
+	"LDADDD",
+	"LDADDH",
+	"LDADDW",
+	"LDADDLB",
+	"LDADDLD",
+	"LDADDLH",
+	"LDADDLW",
+	"LDANDAB",
+	"LDANDAD",
+	"LDANDAH",
+	"LDANDAW",
+	"LDANDALB",
+	"LDANDALD",
+	"LDANDALH",
+	"LDANDALW",
+	"LDANDB",
+	"LDANDD",
+	"LDANDH",
+	"LDANDW",
+	"LDANDLB",
+	"LDANDLD",
+	"LDANDLH",
+	"LDANDLW",
+	"LDAR",
+	"LDARB",
+	"LDARH",
+	"LDARW",
+	"LDAXP",
+	"LDAXPW",
+	"LDAXR",
+	"LDAXRB",
+	"LDAXRH",
+	"LDAXRW",
+	"LDEORAB",
+	"LDEORAD",
+	"LDEORAH",
+	"LDEORAW",
+	"LDEORALB",
+	"LDEORALD",
+	"LDEORALH",
+	"LDEORALW",
+	"LDEORB",
+	"LDEORD",
+	"LDEORH",
+	"LDEORW",
+	"LDEORLB",
+	"LDEORLD",
+	"LDEORLH",
+	"LDEORLW",
+	"LDORAB",
+	"LDORAD",
+	"LDORAH",
+	"LDORAW",
+	"LDORALB",
+	"LDORALD",
+	"LDORALH",
+	"LDORALW",
+	"LDORB",
+	"LDORD",
+	"LDORH",
+	"LDORW",
+	"LDORLB",
+	"LDORLD",
+	"LDORLH",
+	"LDORLW",
+	"LDP",
+	"LDPW",
+	"LDPSW",
+	"LDXR",
+	"LDXRB",
+	"LDXRH",
+	"LDXRW",
+	"LDXP",
+	"LDXPW",
+	"LSL",
+	"LSLW",
+	"LSR",
+	"LSRW",
+	"MADD",
+	"MADDW",
+	"MNEG",
+	"MNEGW",
+	"MOVK",
+	"MOVKW",
+	"MOVN",
+	"MOVNW",
+	"MOVZ",
+	"MOVZW",
+	"MRS",
+	"MSR",
+	"MSUB",
+	"MSUBW",
+	"MUL",
+	"MULW",
+	"MVN",
+	"MVNW",
+	"NEG",
+	"NEGS",
+	"NEGSW",
+	"NEGW",
+	"NGC",
+	"NGCS",
+	"NGCSW",
+	"NGCW",
+	"NOOP",
+	"ORN",
+	"ORNW",
+	"ORR",
+	"ORRW",
+	"PRFM",
+	"PRFUM",
+	"RBIT",
+	"RBITW",
+	"REM",
+	"REMW",
+	"REV",
+	"REV16",
+	"REV16W",
+	"REV32",
+	"REVW",
+	"ROR",
+	"RORW",
+	"SBC",
+	"SBCS",
+	"SBCSW",
+	"SBCW",
+	"SBFIZ",
+	"SBFIZW",
+	"SBFM",
+	"SBFMW",
+	"SBFX",
+	"SBFXW",
+	"SDIV",
+	"SDIVW",
+	"SEV",
+	"SEVL",
+	"SMADDL",
+	"SMC",
+	"SMNEGL",
+	"SMSUBL",
+	"SMULH",
+	"SMULL",
+	"STXR",
+	"STXRB",
+	"STXRH",
+	"STXP",
+	"STXPW",
+	"STXRW",
+	"STLP",
+	"STLPW",
+	"STLR",
+	"STLRB",
+	"STLRH",
+	"STLRW",
+	"STLXP",
+	"STLXPW",
+	"STLXR",
+	"STLXRB",
+	"STLXRH",
+	"STLXRW",
+	"STP",
+	"STPW",
+	"SUB",
+	"SUBS",
+	"SUBSW",
+	"SUBW",
+	"SVC",
+	"SXTB",
+	"SXTBW",
+	"SXTH",
+	"SXTHW",
+	"SXTW",
+	"SYS",
+	"SYSL",
+	"TBNZ",
+	"TBZ",
+	"TLBI",
+	"TST",
+	"TSTW",
+	"UBFIZ",
+	"UBFIZW",
+	"UBFM",
+	"UBFMW",
+	"UBFX",
+	"UBFXW",
+	"UDIV",
+	"UDIVW",
+	"UMADDL",
+	"UMNEGL",
+	"UMSUBL",
+	"UMULH",
+	"UMULL",
+	"UREM",
+	"UREMW",
+	"UXTB",
+	"UXTH",
+	"UXTW",
+	"UXTBW",
+	"UXTHW",
+	"WFE",
+	"WFI",
+	"YIELD",
+	"MOVB",
+	"MOVBU",
+	"MOVH",
+	"MOVHU",
+	"MOVW",
+	"MOVWU",
+	"MOVD",
+	"MOVNP",
+	"MOVNPW",
+	"MOVP",
+	"MOVPD",
+	"MOVPQ",
+	"MOVPS",
+	"MOVPSW",
+	"MOVPW",
+	"SWPAD",
+	"SWPAW",
+	"SWPAH",
+	"SWPAB",
+	"SWPALD",
+	"SWPALW",
+	"SWPALH",
+	"SWPALB",
+	"SWPD",
+	"SWPW",
+	"SWPH",
+	"SWPB",
+	"SWPLD",
+	"SWPLW",
+	"SWPLH",
+	"SWPLB",
+	"BEQ",
+	"BNE",
+	"BCS",
+	"BHS",
+	"BCC",
+	"BLO",
+	"BMI",
+	"BPL",
+	"BVS",
+	"BVC",
+	"BHI",
+	"BLS",
+	"BGE",
+	"BLT",
+	"BGT",
+	"BLE",
+	"FABSD",
+	"FABSS",
+	"FADDD",
+	"FADDS",
+	"FCCMPD",
+	"FCCMPED",
+	"FCCMPS",
+	"FCCMPES",
+	"FCMPD",
+	"FCMPED",
+	"FCMPES",
+	"FCMPS",
+	"FCVTSD",
+	"FCVTDS",
+	"FCVTZSD",
+	"FCVTZSDW",
+	"FCVTZSS",
+	"FCVTZSSW",
+	"FCVTZUD",
+	"FCVTZUDW",
+	"FCVTZUS",
+	"FCVTZUSW",
+	"FDIVD",
+	"FDIVS",
+	"FLDPD",
+	"FLDPS",
+	"FMOVD",
+	"FMOVS",
+	"FMOVQ",
+	"FMULD",
+	"FMULS",
+	"FNEGD",
+	"FNEGS",
+	"FSQRTD",
+	"FSQRTS",
+	"FSTPD",
+	"FSTPS",
+	"FSUBD",
+	"FSUBS",
+	"SCVTFD",
+	"SCVTFS",
+	"SCVTFWD",
+	"SCVTFWS",
+	"UCVTFD",
+	"UCVTFS",
+	"UCVTFWD",
+	"UCVTFWS",
+	"WORD",
+	"DWORD",
+	"FCSELS",
+	"FCSELD",
+	"FMAXS",
+	"FMINS",
+	"FMAXD",
+	"FMIND",
+	"FMAXNMS",
+	"FMAXNMD",
+	"FNMULS",
+	"FNMULD",
+	"FRINTNS",
+	"FRINTND",
+	"FRINTPS",
+	"FRINTPD",
+	"FRINTMS",
+	"FRINTMD",
+	"FRINTZS",
+	"FRINTZD",
+	"FRINTAS",
+	"FRINTAD",
+	"FRINTXS",
+	"FRINTXD",
+	"FRINTIS",
+	"FRINTID",
+	"FMADDS",
+	"FMADDD",
+	"FMSUBS",
+	"FMSUBD",
+	"FNMADDS",
+	"FNMADDD",
+	"FNMSUBS",
+	"FNMSUBD",
+	"FMINNMS",
+	"FMINNMD",
+	"FCVTDH",
+	"FCVTHS",
+	"FCVTHD",
+	"FCVTSH",
+	"AESD",
+	"AESE",
+	"AESIMC",
+	"AESMC",
+	"SHA1C",
+	"SHA1H",
+	"SHA1M",
+	"SHA1P",
+	"SHA1SU0",
+	"SHA1SU1",
+	"SHA256H",
+	"SHA256H2",
+	"SHA256SU0",
+	"SHA256SU1",
+	"SHA512H",
+	"SHA512H2",
+	"SHA512SU0",
+	"SHA512SU1",
+	"VADD",
+	"VADDP",
+	"VAND",
+	"VBIF",
+	"VCMEQ",
+	"VCNT",
+	"VEOR",
+	"VMOV",
+	"VLD1",
+	"VLD2",
+	"VLD3",
+	"VLD4",
+	"VLD1R",
+	"VLD2R",
+	"VLD3R",
+	"VLD4R",
+	"VORR",
+	"VREV16",
+	"VREV32",
+	"VREV64",
+	"VST1",
+	"VST2",
+	"VST3",
+	"VST4",
+	"VDUP",
+	"VADDV",
+	"VMOVI",
+	"VUADDLV",
+	"VSUB",
+	"VFMLA",
+	"VFMLS",
+	"VPMULL",
+	"VPMULL2",
+	"VEXT",
+	"VRBIT",
+	"VUSHR",
+	"VUSHLL",
+	"VUSHLL2",
+	"VUXTL",
+	"VUXTL2",
+	"VUZP1",
+	"VUZP2",
+	"VSHL",
+	"VSRI",
+	"VBSL",
+	"VBIT",
+	"VTBL",
+	"VZIP1",
+	"VZIP2",
+	"VCMTST",
+	"LAST",
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/anames7.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/anames7.go
new file mode 100644
index 000000000..96c9f788d
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/anames7.go
@@ -0,0 +1,100 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package arm64
+
+// This order should be strictly consistent to that in a.out.go
+var cnames7 = []string{
+	"NONE",
+	"REG",
+	"RSP",
+	"FREG",
+	"VREG",
+	"PAIR",
+	"SHIFT",
+	"EXTREG",
+	"SPR",
+	"COND",
+	"ARNG",
+	"ELEM",
+	"LIST",
+	"ZCON",
+	"ABCON0",
+	"ADDCON0",
+	"ABCON",
+	"AMCON",
+	"ADDCON",
+	"MBCON",
+	"MOVCON",
+	"BITCON",
+	"ADDCON2",
+	"LCON",
+	"MOVCON2",
+	"MOVCON3",
+	"VCON",
+	"FCON",
+	"VCONADDR",
+	"AACON",
+	"AACON2",
+	"LACON",
+	"AECON",
+	"SBRA",
+	"LBRA",
+	"ZAUTO",
+	"NSAUTO_8",
+	"NSAUTO_4",
+	"NSAUTO",
+	"NPAUTO",
+	"NAUTO4K",
+	"PSAUTO_8",
+	"PSAUTO_4",
+	"PSAUTO",
+	"PPAUTO",
+	"UAUTO4K_8",
+	"UAUTO4K_4",
+	"UAUTO4K_2",
+	"UAUTO4K",
+	"UAUTO8K_8",
+	"UAUTO8K_4",
+	"UAUTO8K",
+	"UAUTO16K_8",
+	"UAUTO16K",
+	"UAUTO32K",
+	"LAUTO",
+	"SEXT1",
+	"SEXT2",
+	"SEXT4",
+	"SEXT8",
+	"SEXT16",
+	"LEXT",
+	"ZOREG",
+	"NSOREG_8",
+	"NSOREG_4",
+	"NSOREG",
+	"NPOREG",
+	"NOREG4K",
+	"PSOREG_8",
+	"PSOREG_4",
+	"PSOREG",
+	"PPOREG",
+	"UOREG4K_8",
+	"UOREG4K_4",
+	"UOREG4K_2",
+	"UOREG4K",
+	"UOREG8K_8",
+	"UOREG8K_4",
+	"UOREG8K",
+	"UOREG16K_8",
+	"UOREG16K",
+	"UOREG32K",
+	"LOREG",
+	"ADDR",
+	"GOTADDR",
+	"TLS_LE",
+	"TLS_IE",
+	"ROFF",
+	"GOK",
+	"TEXTSIZE",
+	"NCLASS",
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/asm7.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/asm7.go
new file mode 100644
index 000000000..2bbb64b9d
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/asm7.go
@@ -0,0 +1,7140 @@
+// cmd/7l/asm.c, cmd/7l/asmout.c, cmd/7l/optab.c, cmd/7l/span.c, cmd/ld/sub.c, cmd/ld/mod.c, from Vita Nuova.
+// https://code.google.com/p/ken-cc/source/browse/
+//
+// 	Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
+// 	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+// 	Portions Copyright © 1997-1999 Vita Nuova Limited
+// 	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+// 	Portions Copyright © 2004,2006 Bruce Ellis
+// 	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+// 	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+// 	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package arm64
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"fmt"
+	"log"
+	"math"
+	"sort"
+)
+
+// ctxt7 holds state while assembling a single function.
+// Each function gets a fresh ctxt7.
+// This allows for multiple functions to be safely concurrently assembled.
+type ctxt7 struct {
+	ctxt       *obj.Link
+	newprog    obj.ProgAlloc
+	cursym     *obj.LSym
+	blitrl     *obj.Prog
+	elitrl     *obj.Prog
+	autosize   int32
+	extrasize  int32
+	instoffset int64
+	pc         int64
+	pool       struct {
+		start uint32
+		size  uint32
+	}
+}
+
+const (
+	funcAlign = 16
+)
+
+const (
+	REGFROM = 1
+)
+
+type Optab struct {
+	as    obj.As
+	a1    uint8
+	a2    uint8
+	a3    uint8
+	a4    uint8
+	type_ int8
+	size  int8
+	param int16
+	flag  int8
+	scond uint16
+}
+
+func IsAtomicInstruction(as obj.As) bool {
+	_, ok := atomicInstructions[as]
+	return ok
+}
+
+// known field values of an instruction.
+var atomicInstructions = map[obj.As]uint32{
+	ALDADDAD:  3<<30 | 0x1c5<<21 | 0x00<<10,
+	ALDADDAW:  2<<30 | 0x1c5<<21 | 0x00<<10,
+	ALDADDAH:  1<<30 | 0x1c5<<21 | 0x00<<10,
+	ALDADDAB:  0<<30 | 0x1c5<<21 | 0x00<<10,
+	ALDADDALD: 3<<30 | 0x1c7<<21 | 0x00<<10,
+	ALDADDALW: 2<<30 | 0x1c7<<21 | 0x00<<10,
+	ALDADDALH: 1<<30 | 0x1c7<<21 | 0x00<<10,
+	ALDADDALB: 0<<30 | 0x1c7<<21 | 0x00<<10,
+	ALDADDD:   3<<30 | 0x1c1<<21 | 0x00<<10,
+	ALDADDW:   2<<30 | 0x1c1<<21 | 0x00<<10,
+	ALDADDH:   1<<30 | 0x1c1<<21 | 0x00<<10,
+	ALDADDB:   0<<30 | 0x1c1<<21 | 0x00<<10,
+	ALDADDLD:  3<<30 | 0x1c3<<21 | 0x00<<10,
+	ALDADDLW:  2<<30 | 0x1c3<<21 | 0x00<<10,
+	ALDADDLH:  1<<30 | 0x1c3<<21 | 0x00<<10,
+	ALDADDLB:  0<<30 | 0x1c3<<21 | 0x00<<10,
+	ALDANDAD:  3<<30 | 0x1c5<<21 | 0x04<<10,
+	ALDANDAW:  2<<30 | 0x1c5<<21 | 0x04<<10,
+	ALDANDAH:  1<<30 | 0x1c5<<21 | 0x04<<10,
+	ALDANDAB:  0<<30 | 0x1c5<<21 | 0x04<<10,
+	ALDANDALD: 3<<30 | 0x1c7<<21 | 0x04<<10,
+	ALDANDALW: 2<<30 | 0x1c7<<21 | 0x04<<10,
+	ALDANDALH: 1<<30 | 0x1c7<<21 | 0x04<<10,
+	ALDANDALB: 0<<30 | 0x1c7<<21 | 0x04<<10,
+	ALDANDD:   3<<30 | 0x1c1<<21 | 0x04<<10,
+	ALDANDW:   2<<30 | 0x1c1<<21 | 0x04<<10,
+	ALDANDH:   1<<30 | 0x1c1<<21 | 0x04<<10,
+	ALDANDB:   0<<30 | 0x1c1<<21 | 0x04<<10,
+	ALDANDLD:  3<<30 | 0x1c3<<21 | 0x04<<10,
+	ALDANDLW:  2<<30 | 0x1c3<<21 | 0x04<<10,
+	ALDANDLH:  1<<30 | 0x1c3<<21 | 0x04<<10,
+	ALDANDLB:  0<<30 | 0x1c3<<21 | 0x04<<10,
+	ALDEORAD:  3<<30 | 0x1c5<<21 | 0x08<<10,
+	ALDEORAW:  2<<30 | 0x1c5<<21 | 0x08<<10,
+	ALDEORAH:  1<<30 | 0x1c5<<21 | 0x08<<10,
+	ALDEORAB:  0<<30 | 0x1c5<<21 | 0x08<<10,
+	ALDEORALD: 3<<30 | 0x1c7<<21 | 0x08<<10,
+	ALDEORALW: 2<<30 | 0x1c7<<21 | 0x08<<10,
+	ALDEORALH: 1<<30 | 0x1c7<<21 | 0x08<<10,
+	ALDEORALB: 0<<30 | 0x1c7<<21 | 0x08<<10,
+	ALDEORD:   3<<30 | 0x1c1<<21 | 0x08<<10,
+	ALDEORW:   2<<30 | 0x1c1<<21 | 0x08<<10,
+	ALDEORH:   1<<30 | 0x1c1<<21 | 0x08<<10,
+	ALDEORB:   0<<30 | 0x1c1<<21 | 0x08<<10,
+	ALDEORLD:  3<<30 | 0x1c3<<21 | 0x08<<10,
+	ALDEORLW:  2<<30 | 0x1c3<<21 | 0x08<<10,
+	ALDEORLH:  1<<30 | 0x1c3<<21 | 0x08<<10,
+	ALDEORLB:  0<<30 | 0x1c3<<21 | 0x08<<10,
+	ALDORAD:   3<<30 | 0x1c5<<21 | 0x0c<<10,
+	ALDORAW:   2<<30 | 0x1c5<<21 | 0x0c<<10,
+	ALDORAH:   1<<30 | 0x1c5<<21 | 0x0c<<10,
+	ALDORAB:   0<<30 | 0x1c5<<21 | 0x0c<<10,
+	ALDORALD:  3<<30 | 0x1c7<<21 | 0x0c<<10,
+	ALDORALW:  2<<30 | 0x1c7<<21 | 0x0c<<10,
+	ALDORALH:  1<<30 | 0x1c7<<21 | 0x0c<<10,
+	ALDORALB:  0<<30 | 0x1c7<<21 | 0x0c<<10,
+	ALDORD:    3<<30 | 0x1c1<<21 | 0x0c<<10,
+	ALDORW:    2<<30 | 0x1c1<<21 | 0x0c<<10,
+	ALDORH:    1<<30 | 0x1c1<<21 | 0x0c<<10,
+	ALDORB:    0<<30 | 0x1c1<<21 | 0x0c<<10,
+	ALDORLD:   3<<30 | 0x1c3<<21 | 0x0c<<10,
+	ALDORLW:   2<<30 | 0x1c3<<21 | 0x0c<<10,
+	ALDORLH:   1<<30 | 0x1c3<<21 | 0x0c<<10,
+	ALDORLB:   0<<30 | 0x1c3<<21 | 0x0c<<10,
+	ASWPAD:    3<<30 | 0x1c5<<21 | 0x20<<10,
+	ASWPAW:    2<<30 | 0x1c5<<21 | 0x20<<10,
+	ASWPAH:    1<<30 | 0x1c5<<21 | 0x20<<10,
+	ASWPAB:    0<<30 | 0x1c5<<21 | 0x20<<10,
+	ASWPALD:   3<<30 | 0x1c7<<21 | 0x20<<10,
+	ASWPALW:   2<<30 | 0x1c7<<21 | 0x20<<10,
+	ASWPALH:   1<<30 | 0x1c7<<21 | 0x20<<10,
+	ASWPALB:   0<<30 | 0x1c7<<21 | 0x20<<10,
+	ASWPD:     3<<30 | 0x1c1<<21 | 0x20<<10,
+	ASWPW:     2<<30 | 0x1c1<<21 | 0x20<<10,
+	ASWPH:     1<<30 | 0x1c1<<21 | 0x20<<10,
+	ASWPB:     0<<30 | 0x1c1<<21 | 0x20<<10,
+	ASWPLD:    3<<30 | 0x1c3<<21 | 0x20<<10,
+	ASWPLW:    2<<30 | 0x1c3<<21 | 0x20<<10,
+	ASWPLH:    1<<30 | 0x1c3<<21 | 0x20<<10,
+	ASWPLB:    0<<30 | 0x1c3<<21 | 0x20<<10,
+}
+
+var oprange [ALAST & obj.AMask][]Optab
+
+var xcmp [C_NCLASS][C_NCLASS]bool
+
+const (
+	S32     = 0 << 31
+	S64     = 1 << 31
+	Sbit    = 1 << 29
+	LSL0_32 = 2 << 13
+	LSL0_64 = 3 << 13
+)
+
+func OPDP2(x uint32) uint32 {
+	return 0<<30 | 0<<29 | 0xd6<<21 | x<<10
+}
+
+func OPDP3(sf uint32, op54 uint32, op31 uint32, o0 uint32) uint32 {
+	return sf<<31 | op54<<29 | 0x1B<<24 | op31<<21 | o0<<15
+}
+
+func OPBcc(x uint32) uint32 {
+	return 0x2A<<25 | 0<<24 | 0<<4 | x&15
+}
+
+func OPBLR(x uint32) uint32 {
+	/* x=0, JMP; 1, CALL; 2, RET */
+	return 0x6B<<25 | 0<<23 | x<<21 | 0x1F<<16 | 0<<10
+}
+
+func SYSOP(l uint32, op0 uint32, op1 uint32, crn uint32, crm uint32, op2 uint32, rt uint32) uint32 {
+	return 0x354<<22 | l<<21 | op0<<19 | op1<<16 | crn&15<<12 | crm&15<<8 | op2<<5 | rt
+}
+
+func SYSHINT(x uint32) uint32 {
+	return SYSOP(0, 0, 3, 2, 0, x, 0x1F)
+}
+
+func LDSTR12U(sz uint32, v uint32, opc uint32) uint32 {
+	return sz<<30 | 7<<27 | v<<26 | 1<<24 | opc<<22
+}
+
+func LDSTR9S(sz uint32, v uint32, opc uint32) uint32 {
+	return sz<<30 | 7<<27 | v<<26 | 0<<24 | opc<<22
+}
+
+func LD2STR(o uint32) uint32 {
+	return o &^ (3 << 22)
+}
+
+func LDSTX(sz uint32, o2 uint32, l uint32, o1 uint32, o0 uint32) uint32 {
+	return sz<<30 | 0x8<<24 | o2<<23 | l<<22 | o1<<21 | o0<<15
+}
+
+func FPCMP(m uint32, s uint32, type_ uint32, op uint32, op2 uint32) uint32 {
+	return m<<31 | s<<29 | 0x1E<<24 | type_<<22 | 1<<21 | op<<14 | 8<<10 | op2
+}
+
+func FPCCMP(m uint32, s uint32, type_ uint32, op uint32) uint32 {
+	return m<<31 | s<<29 | 0x1E<<24 | type_<<22 | 1<<21 | 1<<10 | op<<4
+}
+
+func FPOP1S(m uint32, s uint32, type_ uint32, op uint32) uint32 {
+	return m<<31 | s<<29 | 0x1E<<24 | type_<<22 | 1<<21 | op<<15 | 0x10<<10
+}
+
+func FPOP2S(m uint32, s uint32, type_ uint32, op uint32) uint32 {
+	return m<<31 | s<<29 | 0x1E<<24 | type_<<22 | 1<<21 | op<<12 | 2<<10
+}
+
+func FPOP3S(m uint32, s uint32, type_ uint32, op uint32, op2 uint32) uint32 {
+	return m<<31 | s<<29 | 0x1F<<24 | type_<<22 | op<<21 | op2<<15
+}
+
+func FPCVTI(sf uint32, s uint32, type_ uint32, rmode uint32, op uint32) uint32 {
+	return sf<<31 | s<<29 | 0x1E<<24 | type_<<22 | 1<<21 | rmode<<19 | op<<16 | 0<<10
+}
+
+func ADR(p uint32, o uint32, rt uint32) uint32 {
+	return p<<31 | (o&3)<<29 | 0x10<<24 | ((o>>2)&0x7FFFF)<<5 | rt&31
+}
+
+func OPBIT(x uint32) uint32 {
+	return 1<<30 | 0<<29 | 0xD6<<21 | 0<<16 | x<<10
+}
+
+func MOVCONST(d int64, s int, rt int) uint32 {
+	return uint32(((d>>uint(s*16))&0xFFFF)<<5) | uint32(s)&3<<21 | uint32(rt&31)
+}
+
+const (
+	// Optab.flag
+	LFROM     = 1 << 0 // p.From uses constant pool
+	LTO       = 1 << 1 // p.To uses constant pool
+	NOTUSETMP = 1 << 2 // p expands to multiple instructions, but does NOT use REGTMP
+)
+
+var optab = []Optab{
+	/* struct Optab:
+	OPCODE, from, prog->reg, from3, to, type,size,param,flag,scond */
+	{obj.ATEXT, C_ADDR, C_NONE, C_NONE, C_TEXTSIZE, 0, 0, 0, 0, 0},
+
+	/* arithmetic operations */
+	{AADD, C_REG, C_REG, C_NONE, C_REG, 1, 4, 0, 0, 0},
+	{AADD, C_REG, C_NONE, C_NONE, C_REG, 1, 4, 0, 0, 0},
+	{AADC, C_REG, C_REG, C_NONE, C_REG, 1, 4, 0, 0, 0},
+	{AADC, C_REG, C_NONE, C_NONE, C_REG, 1, 4, 0, 0, 0},
+	{ANEG, C_REG, C_NONE, C_NONE, C_REG, 25, 4, 0, 0, 0},
+	{ANEG, C_NONE, C_NONE, C_NONE, C_REG, 25, 4, 0, 0, 0},
+	{ANGC, C_REG, C_NONE, C_NONE, C_REG, 17, 4, 0, 0, 0},
+	{ACMP, C_REG, C_REG, C_NONE, C_NONE, 1, 4, 0, 0, 0},
+	{AADD, C_ADDCON, C_RSP, C_NONE, C_RSP, 2, 4, 0, 0, 0},
+	{AADD, C_ADDCON, C_NONE, C_NONE, C_RSP, 2, 4, 0, 0, 0},
+	{ACMP, C_ADDCON, C_RSP, C_NONE, C_NONE, 2, 4, 0, 0, 0},
+	{AADD, C_MOVCON, C_RSP, C_NONE, C_RSP, 62, 8, 0, 0, 0},
+	{AADD, C_MOVCON, C_NONE, C_NONE, C_RSP, 62, 8, 0, 0, 0},
+	{ACMP, C_MOVCON, C_RSP, C_NONE, C_NONE, 62, 8, 0, 0, 0},
+	{AADD, C_BITCON, C_RSP, C_NONE, C_RSP, 62, 8, 0, 0, 0},
+	{AADD, C_BITCON, C_NONE, C_NONE, C_RSP, 62, 8, 0, 0, 0},
+	{ACMP, C_BITCON, C_RSP, C_NONE, C_NONE, 62, 8, 0, 0, 0},
+	{AADD, C_ADDCON2, C_RSP, C_NONE, C_RSP, 48, 8, 0, NOTUSETMP, 0},
+	{AADD, C_ADDCON2, C_NONE, C_NONE, C_RSP, 48, 8, 0, NOTUSETMP, 0},
+	{AADD, C_MOVCON2, C_RSP, C_NONE, C_RSP, 13, 12, 0, 0, 0},
+	{AADD, C_MOVCON2, C_NONE, C_NONE, C_RSP, 13, 12, 0, 0, 0},
+	{AADD, C_MOVCON3, C_RSP, C_NONE, C_RSP, 13, 16, 0, 0, 0},
+	{AADD, C_MOVCON3, C_NONE, C_NONE, C_RSP, 13, 16, 0, 0, 0},
+	{AADD, C_VCON, C_RSP, C_NONE, C_RSP, 13, 20, 0, 0, 0},
+	{AADD, C_VCON, C_NONE, C_NONE, C_RSP, 13, 20, 0, 0, 0},
+	{ACMP, C_MOVCON2, C_REG, C_NONE, C_NONE, 13, 12, 0, 0, 0},
+	{ACMP, C_MOVCON3, C_REG, C_NONE, C_NONE, 13, 16, 0, 0, 0},
+	{ACMP, C_VCON, C_REG, C_NONE, C_NONE, 13, 20, 0, 0, 0},
+	{AADD, C_SHIFT, C_REG, C_NONE, C_REG, 3, 4, 0, 0, 0},
+	{AADD, C_SHIFT, C_NONE, C_NONE, C_REG, 3, 4, 0, 0, 0},
+	{AMVN, C_SHIFT, C_NONE, C_NONE, C_REG, 3, 4, 0, 0, 0},
+	{ACMP, C_SHIFT, C_REG, C_NONE, C_NONE, 3, 4, 0, 0, 0},
+	{ANEG, C_SHIFT, C_NONE, C_NONE, C_REG, 26, 4, 0, 0, 0},
+	{AADD, C_REG, C_RSP, C_NONE, C_RSP, 27, 4, 0, 0, 0},
+	{AADD, C_REG, C_NONE, C_NONE, C_RSP, 27, 4, 0, 0, 0},
+	{ACMP, C_REG, C_RSP, C_NONE, C_NONE, 27, 4, 0, 0, 0},
+	{AADD, C_EXTREG, C_RSP, C_NONE, C_RSP, 27, 4, 0, 0, 0},
+	{AADD, C_EXTREG, C_NONE, C_NONE, C_RSP, 27, 4, 0, 0, 0},
+	{AMVN, C_EXTREG, C_NONE, C_NONE, C_RSP, 27, 4, 0, 0, 0},
+	{ACMP, C_EXTREG, C_RSP, C_NONE, C_NONE, 27, 4, 0, 0, 0},
+	{AADD, C_REG, C_REG, C_NONE, C_REG, 1, 4, 0, 0, 0},
+	{AADD, C_REG, C_NONE, C_NONE, C_REG, 1, 4, 0, 0, 0},
+	{AMUL, C_REG, C_REG, C_NONE, C_REG, 15, 4, 0, 0, 0},
+	{AMUL, C_REG, C_NONE, C_NONE, C_REG, 15, 4, 0, 0, 0},
+	{AMADD, C_REG, C_REG, C_REG, C_REG, 15, 4, 0, 0, 0},
+	{AREM, C_REG, C_REG, C_NONE, C_REG, 16, 8, 0, 0, 0},
+	{AREM, C_REG, C_NONE, C_NONE, C_REG, 16, 8, 0, 0, 0},
+	{ASDIV, C_REG, C_NONE, C_NONE, C_REG, 1, 4, 0, 0, 0},
+	{ASDIV, C_REG, C_REG, C_NONE, C_REG, 1, 4, 0, 0, 0},
+
+	{AFADDS, C_FREG, C_NONE, C_NONE, C_FREG, 54, 4, 0, 0, 0},
+	{AFADDS, C_FREG, C_FREG, C_NONE, C_FREG, 54, 4, 0, 0, 0},
+	{AFMSUBD, C_FREG, C_FREG, C_FREG, C_FREG, 15, 4, 0, 0, 0},
+	{AFCMPS, C_FREG, C_FREG, C_NONE, C_NONE, 56, 4, 0, 0, 0},
+	{AFCMPS, C_FCON, C_FREG, C_NONE, C_NONE, 56, 4, 0, 0, 0},
+	{AVADDP, C_ARNG, C_ARNG, C_NONE, C_ARNG, 72, 4, 0, 0, 0},
+	{AVADD, C_ARNG, C_ARNG, C_NONE, C_ARNG, 72, 4, 0, 0, 0},
+	{AVADD, C_VREG, C_VREG, C_NONE, C_VREG, 89, 4, 0, 0, 0},
+	{AVADD, C_VREG, C_NONE, C_NONE, C_VREG, 89, 4, 0, 0, 0},
+	{AVADDV, C_ARNG, C_NONE, C_NONE, C_VREG, 85, 4, 0, 0, 0},
+
+	/* logical operations */
+	{AAND, C_REG, C_REG, C_NONE, C_REG, 1, 4, 0, 0, 0},
+	{AAND, C_REG, C_NONE, C_NONE, C_REG, 1, 4, 0, 0, 0},
+	{AANDS, C_REG, C_REG, C_NONE, C_REG, 1, 4, 0, 0, 0},
+	{AANDS, C_REG, C_NONE, C_NONE, C_REG, 1, 4, 0, 0, 0},
+	{ATST, C_REG, C_REG, C_NONE, C_NONE, 1, 4, 0, 0, 0},
+	{AAND, C_MBCON, C_REG, C_NONE, C_RSP, 53, 4, 0, 0, 0},
+	{AAND, C_MBCON, C_NONE, C_NONE, C_REG, 53, 4, 0, 0, 0},
+	{AANDS, C_MBCON, C_REG, C_NONE, C_REG, 53, 4, 0, 0, 0},
+	{AANDS, C_MBCON, C_NONE, C_NONE, C_REG, 53, 4, 0, 0, 0},
+	{ATST, C_MBCON, C_REG, C_NONE, C_NONE, 53, 4, 0, 0, 0},
+	{AAND, C_BITCON, C_REG, C_NONE, C_RSP, 53, 4, 0, 0, 0},
+	{AAND, C_BITCON, C_NONE, C_NONE, C_REG, 53, 4, 0, 0, 0},
+	{AANDS, C_BITCON, C_REG, C_NONE, C_REG, 53, 4, 0, 0, 0},
+	{AANDS, C_BITCON, C_NONE, C_NONE, C_REG, 53, 4, 0, 0, 0},
+	{ATST, C_BITCON, C_REG, C_NONE, C_NONE, 53, 4, 0, 0, 0},
+	{AAND, C_MOVCON, C_REG, C_NONE, C_REG, 62, 8, 0, 0, 0},
+	{AAND, C_MOVCON, C_NONE, C_NONE, C_REG, 62, 8, 0, 0, 0},
+	{AANDS, C_MOVCON, C_REG, C_NONE, C_REG, 62, 8, 0, 0, 0},
+	{AANDS, C_MOVCON, C_NONE, C_NONE, C_REG, 62, 8, 0, 0, 0},
+	{ATST, C_MOVCON, C_REG, C_NONE, C_NONE, 62, 8, 0, 0, 0},
+	{AAND, C_MOVCON2, C_REG, C_NONE, C_REG, 28, 12, 0, 0, 0},
+	{AAND, C_MOVCON2, C_NONE, C_NONE, C_REG, 28, 12, 0, 0, 0},
+	{AAND, C_MOVCON3, C_REG, C_NONE, C_REG, 28, 16, 0, 0, 0},
+	{AAND, C_MOVCON3, C_NONE, C_NONE, C_REG, 28, 16, 0, 0, 0},
+	{AAND, C_VCON, C_REG, C_NONE, C_REG, 28, 20, 0, 0, 0},
+	{AAND, C_VCON, C_NONE, C_NONE, C_REG, 28, 20, 0, 0, 0},
+	{AANDS, C_MOVCON2, C_REG, C_NONE, C_REG, 28, 12, 0, 0, 0},
+	{AANDS, C_MOVCON2, C_NONE, C_NONE, C_REG, 28, 12, 0, 0, 0},
+	{AANDS, C_MOVCON3, C_REG, C_NONE, C_REG, 28, 16, 0, 0, 0},
+	{AANDS, C_MOVCON3, C_NONE, C_NONE, C_REG, 28, 16, 0, 0, 0},
+	{AANDS, C_VCON, C_REG, C_NONE, C_REG, 28, 20, 0, 0, 0},
+	{AANDS, C_VCON, C_NONE, C_NONE, C_REG, 28, 20, 0, 0, 0},
+	{ATST, C_MOVCON2, C_REG, C_NONE, C_NONE, 28, 12, 0, 0, 0},
+	{ATST, C_MOVCON3, C_REG, C_NONE, C_NONE, 28, 16, 0, 0, 0},
+	{ATST, C_VCON, C_REG, C_NONE, C_NONE, 28, 20, 0, 0, 0},
+	{AAND, C_SHIFT, C_REG, C_NONE, C_REG, 3, 4, 0, 0, 0},
+	{AAND, C_SHIFT, C_NONE, C_NONE, C_REG, 3, 4, 0, 0, 0},
+	{AANDS, C_SHIFT, C_REG, C_NONE, C_REG, 3, 4, 0, 0, 0},
+	{AANDS, C_SHIFT, C_NONE, C_NONE, C_REG, 3, 4, 0, 0, 0},
+	{ATST, C_SHIFT, C_REG, C_NONE, C_NONE, 3, 4, 0, 0, 0},
+	{AMOVD, C_RSP, C_NONE, C_NONE, C_RSP, 24, 4, 0, 0, 0},
+	{AMVN, C_REG, C_NONE, C_NONE, C_REG, 24, 4, 0, 0, 0},
+	{AMOVB, C_REG, C_NONE, C_NONE, C_REG, 45, 4, 0, 0, 0},
+	{AMOVBU, C_REG, C_NONE, C_NONE, C_REG, 45, 4, 0, 0, 0},
+	{AMOVH, C_REG, C_NONE, C_NONE, C_REG, 45, 4, 0, 0, 0}, /* also MOVHU */
+	{AMOVW, C_REG, C_NONE, C_NONE, C_REG, 45, 4, 0, 0, 0}, /* also MOVWU */
+	/* TODO: MVN C_SHIFT */
+
+	/* MOVs that become MOVK/MOVN/MOVZ/ADD/SUB/OR */
+	{AMOVW, C_MOVCON, C_NONE, C_NONE, C_REG, 32, 4, 0, 0, 0},
+	{AMOVD, C_MOVCON, C_NONE, C_NONE, C_REG, 32, 4, 0, 0, 0},
+	{AMOVW, C_BITCON, C_NONE, C_NONE, C_REG, 32, 4, 0, 0, 0},
+	{AMOVD, C_BITCON, C_NONE, C_NONE, C_REG, 32, 4, 0, 0, 0},
+	{AMOVW, C_MOVCON2, C_NONE, C_NONE, C_REG, 12, 8, 0, NOTUSETMP, 0},
+	{AMOVD, C_MOVCON2, C_NONE, C_NONE, C_REG, 12, 8, 0, NOTUSETMP, 0},
+	{AMOVD, C_MOVCON3, C_NONE, C_NONE, C_REG, 12, 12, 0, NOTUSETMP, 0},
+	{AMOVD, C_VCON, C_NONE, C_NONE, C_REG, 12, 16, 0, NOTUSETMP, 0},
+
+	{AMOVK, C_VCON, C_NONE, C_NONE, C_REG, 33, 4, 0, 0, 0},
+	{AMOVD, C_AACON, C_NONE, C_NONE, C_RSP, 4, 4, REGFROM, 0, 0},
+	{AMOVD, C_AACON2, C_NONE, C_NONE, C_RSP, 4, 8, REGFROM, 0, 0},
+
+	/* load long effective stack address (load int32 offset and add) */
+	{AMOVD, C_LACON, C_NONE, C_NONE, C_RSP, 34, 8, REGSP, LFROM, 0},
+
+	// Move a large constant to a Vn.
+	{AFMOVQ, C_VCON, C_NONE, C_NONE, C_VREG, 101, 4, 0, LFROM, 0},
+	{AFMOVD, C_VCON, C_NONE, C_NONE, C_VREG, 101, 4, 0, LFROM, 0},
+	{AFMOVS, C_LCON, C_NONE, C_NONE, C_VREG, 101, 4, 0, LFROM, 0},
+
+	/* jump operations */
+	{AB, C_NONE, C_NONE, C_NONE, C_SBRA, 5, 4, 0, 0, 0},
+	{ABL, C_NONE, C_NONE, C_NONE, C_SBRA, 5, 4, 0, 0, 0},
+	{AB, C_NONE, C_NONE, C_NONE, C_ZOREG, 6, 4, 0, 0, 0},
+	{ABL, C_NONE, C_NONE, C_NONE, C_REG, 6, 4, 0, 0, 0},
+	{ABL, C_REG, C_NONE, C_NONE, C_REG, 6, 4, 0, 0, 0},
+	{ABL, C_NONE, C_NONE, C_NONE, C_ZOREG, 6, 4, 0, 0, 0},
+	{obj.ARET, C_NONE, C_NONE, C_NONE, C_REG, 6, 4, 0, 0, 0},
+	{obj.ARET, C_NONE, C_NONE, C_NONE, C_ZOREG, 6, 4, 0, 0, 0},
+	{ABEQ, C_NONE, C_NONE, C_NONE, C_SBRA, 7, 4, 0, 0, 0},
+	{ACBZ, C_REG, C_NONE, C_NONE, C_SBRA, 39, 4, 0, 0, 0},
+	{ATBZ, C_VCON, C_REG, C_NONE, C_SBRA, 40, 4, 0, 0, 0},
+	{AERET, C_NONE, C_NONE, C_NONE, C_NONE, 41, 4, 0, 0, 0},
+
+	// get a PC-relative address
+	{AADRP, C_SBRA, C_NONE, C_NONE, C_REG, 60, 4, 0, 0, 0},
+	{AADR, C_SBRA, C_NONE, C_NONE, C_REG, 61, 4, 0, 0, 0},
+
+	{ACLREX, C_NONE, C_NONE, C_NONE, C_VCON, 38, 4, 0, 0, 0},
+	{ACLREX, C_NONE, C_NONE, C_NONE, C_NONE, 38, 4, 0, 0, 0},
+	{ABFM, C_VCON, C_REG, C_VCON, C_REG, 42, 4, 0, 0, 0},
+	{ABFI, C_VCON, C_REG, C_VCON, C_REG, 43, 4, 0, 0, 0},
+	{AEXTR, C_VCON, C_REG, C_REG, C_REG, 44, 4, 0, 0, 0},
+	{ASXTB, C_REG, C_NONE, C_NONE, C_REG, 45, 4, 0, 0, 0},
+	{ACLS, C_REG, C_NONE, C_NONE, C_REG, 46, 4, 0, 0, 0},
+	{ALSL, C_VCON, C_REG, C_NONE, C_REG, 8, 4, 0, 0, 0},
+	{ALSL, C_VCON, C_NONE, C_NONE, C_REG, 8, 4, 0, 0, 0},
+	{ALSL, C_REG, C_NONE, C_NONE, C_REG, 9, 4, 0, 0, 0},
+	{ALSL, C_REG, C_REG, C_NONE, C_REG, 9, 4, 0, 0, 0},
+	{ASVC, C_VCON, C_NONE, C_NONE, C_NONE, 10, 4, 0, 0, 0},
+	{ASVC, C_NONE, C_NONE, C_NONE, C_NONE, 10, 4, 0, 0, 0},
+	{ADWORD, C_NONE, C_NONE, C_NONE, C_VCON, 11, 8, 0, NOTUSETMP, 0},
+	{ADWORD, C_NONE, C_NONE, C_NONE, C_LEXT, 11, 8, 0, NOTUSETMP, 0},
+	{ADWORD, C_NONE, C_NONE, C_NONE, C_ADDR, 11, 8, 0, NOTUSETMP, 0},
+	{ADWORD, C_NONE, C_NONE, C_NONE, C_LACON, 11, 8, 0, NOTUSETMP, 0},
+	{AWORD, C_NONE, C_NONE, C_NONE, C_LCON, 14, 4, 0, 0, 0},
+	{AWORD, C_NONE, C_NONE, C_NONE, C_LEXT, 14, 4, 0, 0, 0},
+	{AWORD, C_NONE, C_NONE, C_NONE, C_ADDR, 14, 4, 0, 0, 0},
+	{AMOVW, C_VCONADDR, C_NONE, C_NONE, C_REG, 68, 8, 0, NOTUSETMP, 0},
+	{AMOVD, C_VCONADDR, C_NONE, C_NONE, C_REG, 68, 8, 0, NOTUSETMP, 0},
+	{AMOVB, C_REG, C_NONE, C_NONE, C_ADDR, 64, 12, 0, 0, 0},
+	{AMOVBU, C_REG, C_NONE, C_NONE, C_ADDR, 64, 12, 0, 0, 0},
+	{AMOVH, C_REG, C_NONE, C_NONE, C_ADDR, 64, 12, 0, 0, 0},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_ADDR, 64, 12, 0, 0, 0},
+	{AMOVD, C_REG, C_NONE, C_NONE, C_ADDR, 64, 12, 0, 0, 0},
+	{AMOVB, C_ADDR, C_NONE, C_NONE, C_REG, 65, 12, 0, 0, 0},
+	{AMOVBU, C_ADDR, C_NONE, C_NONE, C_REG, 65, 12, 0, 0, 0},
+	{AMOVH, C_ADDR, C_NONE, C_NONE, C_REG, 65, 12, 0, 0, 0},
+	{AMOVW, C_ADDR, C_NONE, C_NONE, C_REG, 65, 12, 0, 0, 0},
+	{AMOVD, C_ADDR, C_NONE, C_NONE, C_REG, 65, 12, 0, 0, 0},
+	{AMOVD, C_GOTADDR, C_NONE, C_NONE, C_REG, 71, 8, 0, 0, 0},
+	{AMOVD, C_TLS_LE, C_NONE, C_NONE, C_REG, 69, 4, 0, 0, 0},
+	{AMOVD, C_TLS_IE, C_NONE, C_NONE, C_REG, 70, 8, 0, 0, 0},
+
+	{AFMOVS, C_FREG, C_NONE, C_NONE, C_ADDR, 64, 12, 0, 0, 0},
+	{AFMOVS, C_ADDR, C_NONE, C_NONE, C_FREG, 65, 12, 0, 0, 0},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_ADDR, 64, 12, 0, 0, 0},
+	{AFMOVD, C_ADDR, C_NONE, C_NONE, C_FREG, 65, 12, 0, 0, 0},
+	{AFMOVS, C_FCON, C_NONE, C_NONE, C_FREG, 55, 4, 0, 0, 0},
+	{AFMOVS, C_FREG, C_NONE, C_NONE, C_FREG, 54, 4, 0, 0, 0},
+	{AFMOVD, C_FCON, C_NONE, C_NONE, C_FREG, 55, 4, 0, 0, 0},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_FREG, 54, 4, 0, 0, 0},
+	{AFMOVS, C_REG, C_NONE, C_NONE, C_FREG, 29, 4, 0, 0, 0},
+	{AFMOVS, C_FREG, C_NONE, C_NONE, C_REG, 29, 4, 0, 0, 0},
+	{AFMOVD, C_REG, C_NONE, C_NONE, C_FREG, 29, 4, 0, 0, 0},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_REG, 29, 4, 0, 0, 0},
+	{AFCVTZSD, C_FREG, C_NONE, C_NONE, C_REG, 29, 4, 0, 0, 0},
+	{ASCVTFD, C_REG, C_NONE, C_NONE, C_FREG, 29, 4, 0, 0, 0},
+	{AFCVTSD, C_FREG, C_NONE, C_NONE, C_FREG, 29, 4, 0, 0, 0},
+	{AVMOV, C_ELEM, C_NONE, C_NONE, C_REG, 73, 4, 0, 0, 0},
+	{AVMOV, C_ELEM, C_NONE, C_NONE, C_ELEM, 92, 4, 0, 0, 0},
+	{AVMOV, C_ELEM, C_NONE, C_NONE, C_VREG, 80, 4, 0, 0, 0},
+	{AVMOV, C_REG, C_NONE, C_NONE, C_ARNG, 82, 4, 0, 0, 0},
+	{AVMOV, C_REG, C_NONE, C_NONE, C_ELEM, 78, 4, 0, 0, 0},
+	{AVMOV, C_ARNG, C_NONE, C_NONE, C_ARNG, 83, 4, 0, 0, 0},
+	{AVDUP, C_ELEM, C_NONE, C_NONE, C_ARNG, 79, 4, 0, 0, 0},
+	{AVMOVI, C_ADDCON, C_NONE, C_NONE, C_ARNG, 86, 4, 0, 0, 0},
+	{AVFMLA, C_ARNG, C_ARNG, C_NONE, C_ARNG, 72, 4, 0, 0, 0},
+	{AVEXT, C_VCON, C_ARNG, C_ARNG, C_ARNG, 94, 4, 0, 0, 0},
+	{AVTBL, C_ARNG, C_NONE, C_LIST, C_ARNG, 100, 4, 0, 0, 0},
+	{AVUSHR, C_VCON, C_ARNG, C_NONE, C_ARNG, 95, 4, 0, 0, 0},
+	{AVZIP1, C_ARNG, C_ARNG, C_NONE, C_ARNG, 72, 4, 0, 0, 0},
+	{AVUSHLL, C_VCON, C_ARNG, C_NONE, C_ARNG, 102, 4, 0, 0, 0},
+	{AVUXTL, C_ARNG, C_NONE, C_NONE, C_ARNG, 102, 4, 0, 0, 0},
+
+	/* conditional operations */
+	{ACSEL, C_COND, C_REG, C_REG, C_REG, 18, 4, 0, 0, 0},
+	{ACINC, C_COND, C_REG, C_NONE, C_REG, 18, 4, 0, 0, 0},
+	{ACSET, C_COND, C_NONE, C_NONE, C_REG, 18, 4, 0, 0, 0},
+	{AFCSELD, C_COND, C_FREG, C_FREG, C_FREG, 18, 4, 0, 0, 0},
+	{ACCMN, C_COND, C_REG, C_REG, C_VCON, 19, 4, 0, 0, 0},
+	{ACCMN, C_COND, C_REG, C_VCON, C_VCON, 19, 4, 0, 0, 0},
+	{AFCCMPS, C_COND, C_FREG, C_FREG, C_VCON, 57, 4, 0, 0, 0},
+
+	/* scaled 12-bit unsigned displacement store */
+	{AMOVB, C_REG, C_NONE, C_NONE, C_UAUTO4K, 20, 4, REGSP, 0, 0},
+	{AMOVB, C_REG, C_NONE, C_NONE, C_UOREG4K, 20, 4, 0, 0, 0},
+	{AMOVBU, C_REG, C_NONE, C_NONE, C_UAUTO4K, 20, 4, REGSP, 0, 0},
+	{AMOVBU, C_REG, C_NONE, C_NONE, C_UOREG4K, 20, 4, 0, 0, 0},
+	{AMOVH, C_REG, C_NONE, C_NONE, C_UAUTO8K, 20, 4, REGSP, 0, 0},
+	{AMOVH, C_REG, C_NONE, C_NONE, C_UOREG8K, 20, 4, 0, 0, 0},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_UAUTO16K, 20, 4, REGSP, 0, 0},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_UOREG16K, 20, 4, 0, 0, 0},
+	{AMOVD, C_REG, C_NONE, C_NONE, C_UAUTO32K, 20, 4, REGSP, 0, 0},
+	{AMOVD, C_REG, C_NONE, C_NONE, C_UOREG32K, 20, 4, 0, 0, 0},
+
+	{AFMOVS, C_FREG, C_NONE, C_NONE, C_UAUTO16K, 20, 4, REGSP, 0, 0},
+	{AFMOVS, C_FREG, C_NONE, C_NONE, C_UOREG16K, 20, 4, 0, 0, 0},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_UAUTO32K, 20, 4, REGSP, 0, 0},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_UOREG32K, 20, 4, 0, 0, 0},
+
+	/* unscaled 9-bit signed displacement store */
+	{AMOVB, C_REG, C_NONE, C_NONE, C_NSAUTO, 20, 4, REGSP, 0, 0},
+	{AMOVB, C_REG, C_NONE, C_NONE, C_NSOREG, 20, 4, 0, 0, 0},
+	{AMOVBU, C_REG, C_NONE, C_NONE, C_NSAUTO, 20, 4, REGSP, 0, 0},
+	{AMOVBU, C_REG, C_NONE, C_NONE, C_NSOREG, 20, 4, 0, 0, 0},
+	{AMOVH, C_REG, C_NONE, C_NONE, C_NSAUTO, 20, 4, REGSP, 0, 0},
+	{AMOVH, C_REG, C_NONE, C_NONE, C_NSOREG, 20, 4, 0, 0, 0},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_NSAUTO, 20, 4, REGSP, 0, 0},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_NSOREG, 20, 4, 0, 0, 0},
+	{AMOVD, C_REG, C_NONE, C_NONE, C_NSAUTO, 20, 4, REGSP, 0, 0},
+	{AMOVD, C_REG, C_NONE, C_NONE, C_NSOREG, 20, 4, 0, 0, 0},
+
+	{AFMOVS, C_FREG, C_NONE, C_NONE, C_NSAUTO, 20, 4, REGSP, 0, 0},
+	{AFMOVS, C_FREG, C_NONE, C_NONE, C_NSOREG, 20, 4, 0, 0, 0},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_NSAUTO, 20, 4, REGSP, 0, 0},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_NSOREG, 20, 4, 0, 0, 0},
+
+	/* scaled 12-bit unsigned displacement load */
+	{AMOVB, C_UAUTO4K, C_NONE, C_NONE, C_REG, 21, 4, REGSP, 0, 0},
+	{AMOVB, C_UOREG4K, C_NONE, C_NONE, C_REG, 21, 4, 0, 0, 0},
+	{AMOVBU, C_UAUTO4K, C_NONE, C_NONE, C_REG, 21, 4, REGSP, 0, 0},
+	{AMOVBU, C_UOREG4K, C_NONE, C_NONE, C_REG, 21, 4, 0, 0, 0},
+	{AMOVH, C_UAUTO8K, C_NONE, C_NONE, C_REG, 21, 4, REGSP, 0, 0},
+	{AMOVH, C_UOREG8K, C_NONE, C_NONE, C_REG, 21, 4, 0, 0, 0},
+	{AMOVW, C_UAUTO16K, C_NONE, C_NONE, C_REG, 21, 4, REGSP, 0, 0},
+	{AMOVW, C_UOREG16K, C_NONE, C_NONE, C_REG, 21, 4, 0, 0, 0},
+	{AMOVD, C_UAUTO32K, C_NONE, C_NONE, C_REG, 21, 4, REGSP, 0, 0},
+	{AMOVD, C_UOREG32K, C_NONE, C_NONE, C_REG, 21, 4, 0, 0, 0},
+
+	{AFMOVS, C_UAUTO16K, C_NONE, C_NONE, C_FREG, 21, 4, REGSP, 0, 0},
+	{AFMOVS, C_UOREG16K, C_NONE, C_NONE, C_FREG, 21, 4, 0, 0, 0},
+	{AFMOVD, C_UAUTO32K, C_NONE, C_NONE, C_FREG, 21, 4, REGSP, 0, 0},
+	{AFMOVD, C_UOREG32K, C_NONE, C_NONE, C_FREG, 21, 4, 0, 0, 0},
+
+	/* unscaled 9-bit signed displacement load */
+	{AMOVB, C_NSAUTO, C_NONE, C_NONE, C_REG, 21, 4, REGSP, 0, 0},
+	{AMOVB, C_NSOREG, C_NONE, C_NONE, C_REG, 21, 4, 0, 0, 0},
+	{AMOVBU, C_NSAUTO, C_NONE, C_NONE, C_REG, 21, 4, REGSP, 0, 0},
+	{AMOVBU, C_NSOREG, C_NONE, C_NONE, C_REG, 21, 4, 0, 0, 0},
+	{AMOVH, C_NSAUTO, C_NONE, C_NONE, C_REG, 21, 4, REGSP, 0, 0},
+	{AMOVH, C_NSOREG, C_NONE, C_NONE, C_REG, 21, 4, 0, 0, 0},
+	{AMOVW, C_NSAUTO, C_NONE, C_NONE, C_REG, 21, 4, REGSP, 0, 0},
+	{AMOVW, C_NSOREG, C_NONE, C_NONE, C_REG, 21, 4, 0, 0, 0},
+	{AMOVD, C_NSAUTO, C_NONE, C_NONE, C_REG, 21, 4, REGSP, 0, 0},
+	{AMOVD, C_NSOREG, C_NONE, C_NONE, C_REG, 21, 4, 0, 0, 0},
+
+	{AFMOVS, C_NSAUTO, C_NONE, C_NONE, C_FREG, 21, 4, REGSP, 0, 0},
+	{AFMOVS, C_NSOREG, C_NONE, C_NONE, C_FREG, 21, 4, 0, 0, 0},
+	{AFMOVD, C_NSAUTO, C_NONE, C_NONE, C_FREG, 21, 4, REGSP, 0, 0},
+	{AFMOVD, C_NSOREG, C_NONE, C_NONE, C_FREG, 21, 4, 0, 0, 0},
+
+	/* long displacement store */
+	{AMOVB, C_REG, C_NONE, C_NONE, C_LAUTO, 30, 8, REGSP, LTO, 0},
+	{AMOVB, C_REG, C_NONE, C_NONE, C_LOREG, 30, 8, 0, LTO, 0},
+	{AMOVBU, C_REG, C_NONE, C_NONE, C_LAUTO, 30, 8, REGSP, LTO, 0},
+	{AMOVBU, C_REG, C_NONE, C_NONE, C_LOREG, 30, 8, 0, LTO, 0},
+	{AMOVH, C_REG, C_NONE, C_NONE, C_LAUTO, 30, 8, REGSP, LTO, 0},
+	{AMOVH, C_REG, C_NONE, C_NONE, C_LOREG, 30, 8, 0, LTO, 0},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_LAUTO, 30, 8, REGSP, LTO, 0},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_LOREG, 30, 8, 0, LTO, 0},
+	{AMOVD, C_REG, C_NONE, C_NONE, C_LAUTO, 30, 8, REGSP, LTO, 0},
+	{AMOVD, C_REG, C_NONE, C_NONE, C_LOREG, 30, 8, 0, LTO, 0},
+
+	{AFMOVS, C_FREG, C_NONE, C_NONE, C_LAUTO, 30, 8, REGSP, LTO, 0},
+	{AFMOVS, C_FREG, C_NONE, C_NONE, C_LOREG, 30, 8, 0, LTO, 0},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_LAUTO, 30, 8, REGSP, LTO, 0},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_LOREG, 30, 8, 0, LTO, 0},
+
+	/* long displacement load */
+	{AMOVB, C_LAUTO, C_NONE, C_NONE, C_REG, 31, 8, REGSP, LFROM, 0},
+	{AMOVB, C_LOREG, C_NONE, C_NONE, C_REG, 31, 8, 0, LFROM, 0},
+	{AMOVBU, C_LAUTO, C_NONE, C_NONE, C_REG, 31, 8, REGSP, LFROM, 0},
+	{AMOVBU, C_LOREG, C_NONE, C_NONE, C_REG, 31, 8, 0, LFROM, 0},
+	{AMOVH, C_LAUTO, C_NONE, C_NONE, C_REG, 31, 8, REGSP, LFROM, 0},
+	{AMOVH, C_LOREG, C_NONE, C_NONE, C_REG, 31, 8, 0, LFROM, 0},
+	{AMOVW, C_LAUTO, C_NONE, C_NONE, C_REG, 31, 8, REGSP, LFROM, 0},
+	{AMOVW, C_LOREG, C_NONE, C_NONE, C_REG, 31, 8, 0, LFROM, 0},
+	{AMOVD, C_LAUTO, C_NONE, C_NONE, C_REG, 31, 8, REGSP, LFROM, 0},
+	{AMOVD, C_LOREG, C_NONE, C_NONE, C_REG, 31, 8, 0, LFROM, 0},
+
+	{AFMOVS, C_LAUTO, C_NONE, C_NONE, C_FREG, 31, 8, REGSP, LFROM, 0},
+	{AFMOVS, C_LOREG, C_NONE, C_NONE, C_FREG, 31, 8, 0, LFROM, 0},
+	{AFMOVD, C_LAUTO, C_NONE, C_NONE, C_FREG, 31, 8, REGSP, LFROM, 0},
+	{AFMOVD, C_LOREG, C_NONE, C_NONE, C_FREG, 31, 8, 0, LFROM, 0},
+
+	/* pre/post-indexed load (unscaled, signed 9-bit offset) */
+	{AMOVD, C_LOREG, C_NONE, C_NONE, C_REG, 22, 4, 0, 0, C_XPOST},
+	{AMOVW, C_LOREG, C_NONE, C_NONE, C_REG, 22, 4, 0, 0, C_XPOST},
+	{AMOVH, C_LOREG, C_NONE, C_NONE, C_REG, 22, 4, 0, 0, C_XPOST},
+	{AMOVB, C_LOREG, C_NONE, C_NONE, C_REG, 22, 4, 0, 0, C_XPOST},
+	{AMOVBU, C_LOREG, C_NONE, C_NONE, C_REG, 22, 4, 0, 0, C_XPOST},
+	{AFMOVS, C_LOREG, C_NONE, C_NONE, C_FREG, 22, 4, 0, 0, C_XPOST},
+	{AFMOVD, C_LOREG, C_NONE, C_NONE, C_FREG, 22, 4, 0, 0, C_XPOST},
+
+	{AMOVD, C_LOREG, C_NONE, C_NONE, C_REG, 22, 4, 0, 0, C_XPRE},
+	{AMOVW, C_LOREG, C_NONE, C_NONE, C_REG, 22, 4, 0, 0, C_XPRE},
+	{AMOVH, C_LOREG, C_NONE, C_NONE, C_REG, 22, 4, 0, 0, C_XPRE},
+	{AMOVB, C_LOREG, C_NONE, C_NONE, C_REG, 22, 4, 0, 0, C_XPRE},
+	{AMOVBU, C_LOREG, C_NONE, C_NONE, C_REG, 22, 4, 0, 0, C_XPRE},
+	{AFMOVS, C_LOREG, C_NONE, C_NONE, C_FREG, 22, 4, 0, 0, C_XPRE},
+	{AFMOVD, C_LOREG, C_NONE, C_NONE, C_FREG, 22, 4, 0, 0, C_XPRE},
+
+	/* pre/post-indexed store (unscaled, signed 9-bit offset) */
+	{AMOVD, C_REG, C_NONE, C_NONE, C_LOREG, 23, 4, 0, 0, C_XPOST},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_LOREG, 23, 4, 0, 0, C_XPOST},
+	{AMOVH, C_REG, C_NONE, C_NONE, C_LOREG, 23, 4, 0, 0, C_XPOST},
+	{AMOVB, C_REG, C_NONE, C_NONE, C_LOREG, 23, 4, 0, 0, C_XPOST},
+	{AMOVBU, C_REG, C_NONE, C_NONE, C_LOREG, 23, 4, 0, 0, C_XPOST},
+	{AFMOVS, C_FREG, C_NONE, C_NONE, C_LOREG, 23, 4, 0, 0, C_XPOST},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_LOREG, 23, 4, 0, 0, C_XPOST},
+
+	{AMOVD, C_REG, C_NONE, C_NONE, C_LOREG, 23, 4, 0, 0, C_XPRE},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_LOREG, 23, 4, 0, 0, C_XPRE},
+	{AMOVH, C_REG, C_NONE, C_NONE, C_LOREG, 23, 4, 0, 0, C_XPRE},
+	{AMOVB, C_REG, C_NONE, C_NONE, C_LOREG, 23, 4, 0, 0, C_XPRE},
+	{AMOVBU, C_REG, C_NONE, C_NONE, C_LOREG, 23, 4, 0, 0, C_XPRE},
+	{AFMOVS, C_FREG, C_NONE, C_NONE, C_LOREG, 23, 4, 0, 0, C_XPRE},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_LOREG, 23, 4, 0, 0, C_XPRE},
+
+	/* load with shifted or extended register offset */
+	{AMOVD, C_ROFF, C_NONE, C_NONE, C_REG, 98, 4, 0, 0, 0},
+	{AMOVW, C_ROFF, C_NONE, C_NONE, C_REG, 98, 4, 0, 0, 0},
+	{AMOVH, C_ROFF, C_NONE, C_NONE, C_REG, 98, 4, 0, 0, 0},
+	{AMOVB, C_ROFF, C_NONE, C_NONE, C_REG, 98, 4, 0, 0, 0},
+	{AMOVBU, C_ROFF, C_NONE, C_NONE, C_REG, 98, 4, 0, 0, 0},
+	{AFMOVS, C_ROFF, C_NONE, C_NONE, C_FREG, 98, 4, 0, 0, 0},
+	{AFMOVD, C_ROFF, C_NONE, C_NONE, C_FREG, 98, 4, 0, 0, 0},
+
+	/* store with extended register offset */
+	{AMOVD, C_REG, C_NONE, C_NONE, C_ROFF, 99, 4, 0, 0, 0},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_ROFF, 99, 4, 0, 0, 0},
+	{AMOVH, C_REG, C_NONE, C_NONE, C_ROFF, 99, 4, 0, 0, 0},
+	{AMOVB, C_REG, C_NONE, C_NONE, C_ROFF, 99, 4, 0, 0, 0},
+	{AFMOVS, C_FREG, C_NONE, C_NONE, C_ROFF, 99, 4, 0, 0, 0},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_ROFF, 99, 4, 0, 0, 0},
+
+	/* pre/post-indexed/signed-offset load/store register pair
+	   (unscaled, signed 10-bit quad-aligned and long offset) */
+	{ALDP, C_NPAUTO, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, 0},
+	{ALDP, C_NPAUTO, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPRE},
+	{ALDP, C_NPAUTO, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPOST},
+	{ALDP, C_PPAUTO, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, 0},
+	{ALDP, C_PPAUTO, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPRE},
+	{ALDP, C_PPAUTO, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPOST},
+	{ALDP, C_UAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, 0},
+	{ALDP, C_UAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, C_XPRE},
+	{ALDP, C_UAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, C_XPOST},
+	{ALDP, C_NAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, 0},
+	{ALDP, C_NAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, C_XPRE},
+	{ALDP, C_NAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, C_XPOST},
+	{ALDP, C_LAUTO, C_NONE, C_NONE, C_PAIR, 75, 12, REGSP, LFROM, 0},
+	{ALDP, C_LAUTO, C_NONE, C_NONE, C_PAIR, 75, 12, REGSP, LFROM, C_XPRE},
+	{ALDP, C_LAUTO, C_NONE, C_NONE, C_PAIR, 75, 12, REGSP, LFROM, C_XPOST},
+	{ALDP, C_NPOREG, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, 0},
+	{ALDP, C_NPOREG, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPRE},
+	{ALDP, C_NPOREG, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPOST},
+	{ALDP, C_PPOREG, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, 0},
+	{ALDP, C_PPOREG, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPRE},
+	{ALDP, C_PPOREG, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPOST},
+	{ALDP, C_UOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, 0},
+	{ALDP, C_UOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, C_XPRE},
+	{ALDP, C_UOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, C_XPOST},
+	{ALDP, C_NOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, 0},
+	{ALDP, C_NOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, C_XPRE},
+	{ALDP, C_NOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, C_XPOST},
+	{ALDP, C_LOREG, C_NONE, C_NONE, C_PAIR, 75, 12, 0, LFROM, 0},
+	{ALDP, C_LOREG, C_NONE, C_NONE, C_PAIR, 75, 12, 0, LFROM, C_XPRE},
+	{ALDP, C_LOREG, C_NONE, C_NONE, C_PAIR, 75, 12, 0, LFROM, C_XPOST},
+	{ALDP, C_ADDR, C_NONE, C_NONE, C_PAIR, 88, 12, 0, 0, 0},
+
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_NPAUTO, 67, 4, REGSP, 0, 0},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_NPAUTO, 67, 4, REGSP, 0, C_XPRE},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_NPAUTO, 67, 4, REGSP, 0, C_XPOST},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_PPAUTO, 67, 4, REGSP, 0, 0},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_PPAUTO, 67, 4, REGSP, 0, C_XPRE},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_PPAUTO, 67, 4, REGSP, 0, C_XPOST},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_UAUTO4K, 76, 8, REGSP, 0, 0},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_UAUTO4K, 76, 8, REGSP, 0, C_XPRE},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_UAUTO4K, 76, 8, REGSP, 0, C_XPOST},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 12, REGSP, 0, 0},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 12, REGSP, 0, C_XPRE},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 12, REGSP, 0, C_XPOST},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_LAUTO, 77, 12, REGSP, LTO, 0},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_LAUTO, 77, 12, REGSP, LTO, C_XPRE},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_LAUTO, 77, 12, REGSP, LTO, C_XPOST},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_NPOREG, 67, 4, 0, 0, 0},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_NPOREG, 67, 4, 0, 0, C_XPRE},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_NPOREG, 67, 4, 0, 0, C_XPOST},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_PPOREG, 67, 4, 0, 0, 0},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_PPOREG, 67, 4, 0, 0, C_XPRE},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_PPOREG, 67, 4, 0, 0, C_XPOST},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_UOREG4K, 76, 8, 0, 0, 0},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_UOREG4K, 76, 8, 0, 0, C_XPRE},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_UOREG4K, 76, 8, 0, 0, C_XPOST},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_NOREG4K, 76, 8, 0, 0, 0},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_NOREG4K, 76, 8, 0, 0, C_XPRE},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_NOREG4K, 76, 8, 0, 0, C_XPOST},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_LOREG, 77, 12, 0, LTO, 0},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_LOREG, 77, 12, 0, LTO, C_XPRE},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_LOREG, 77, 12, 0, LTO, C_XPOST},
+	{ASTP, C_PAIR, C_NONE, C_NONE, C_ADDR, 87, 12, 0, 0, 0},
+
+	// differ from LDP/STP for C_NSAUTO_4/C_PSAUTO_4/C_NSOREG_4/C_PSOREG_4
+	{ALDPW, C_NSAUTO_4, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, 0},
+	{ALDPW, C_NSAUTO_4, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPRE},
+	{ALDPW, C_NSAUTO_4, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPOST},
+	{ALDPW, C_PSAUTO_4, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, 0},
+	{ALDPW, C_PSAUTO_4, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPRE},
+	{ALDPW, C_PSAUTO_4, C_NONE, C_NONE, C_PAIR, 66, 4, REGSP, 0, C_XPOST},
+	{ALDPW, C_UAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, 0},
+	{ALDPW, C_UAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, C_XPRE},
+	{ALDPW, C_UAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, C_XPOST},
+	{ALDPW, C_NAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, 0},
+	{ALDPW, C_NAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, C_XPRE},
+	{ALDPW, C_NAUTO4K, C_NONE, C_NONE, C_PAIR, 74, 8, REGSP, 0, C_XPOST},
+	{ALDPW, C_LAUTO, C_NONE, C_NONE, C_PAIR, 75, 12, REGSP, LFROM, 0},
+	{ALDPW, C_LAUTO, C_NONE, C_NONE, C_PAIR, 75, 12, REGSP, LFROM, C_XPRE},
+	{ALDPW, C_LAUTO, C_NONE, C_NONE, C_PAIR, 75, 12, REGSP, LFROM, C_XPOST},
+	{ALDPW, C_NSOREG_4, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, 0},
+	{ALDPW, C_NSOREG_4, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPRE},
+	{ALDPW, C_NSOREG_4, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPOST},
+	{ALDPW, C_PSOREG_4, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, 0},
+	{ALDPW, C_PSOREG_4, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPRE},
+	{ALDPW, C_PSOREG_4, C_NONE, C_NONE, C_PAIR, 66, 4, 0, 0, C_XPOST},
+	{ALDPW, C_UOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, 0},
+	{ALDPW, C_UOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, C_XPRE},
+	{ALDPW, C_UOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, C_XPOST},
+	{ALDPW, C_NOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, 0},
+	{ALDPW, C_NOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, C_XPRE},
+	{ALDPW, C_NOREG4K, C_NONE, C_NONE, C_PAIR, 74, 8, 0, 0, C_XPOST},
+	{ALDPW, C_LOREG, C_NONE, C_NONE, C_PAIR, 75, 12, 0, LFROM, 0},
+	{ALDPW, C_LOREG, C_NONE, C_NONE, C_PAIR, 75, 12, 0, LFROM, C_XPRE},
+	{ALDPW, C_LOREG, C_NONE, C_NONE, C_PAIR, 75, 12, 0, LFROM, C_XPOST},
+	{ALDPW, C_ADDR, C_NONE, C_NONE, C_PAIR, 88, 12, 0, 0, 0},
+
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NSAUTO_4, 67, 4, REGSP, 0, 0},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NSAUTO_4, 67, 4, REGSP, 0, C_XPRE},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NSAUTO_4, 67, 4, REGSP, 0, C_XPOST},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_PSAUTO_4, 67, 4, REGSP, 0, 0},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_PSAUTO_4, 67, 4, REGSP, 0, C_XPRE},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_PSAUTO_4, 67, 4, REGSP, 0, C_XPOST},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_UAUTO4K, 76, 8, REGSP, 0, 0},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_UAUTO4K, 76, 8, REGSP, 0, C_XPRE},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_UAUTO4K, 76, 8, REGSP, 0, C_XPOST},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 12, REGSP, 0, 0},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 12, REGSP, 0, C_XPRE},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NAUTO4K, 76, 12, REGSP, 0, C_XPOST},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_LAUTO, 77, 12, REGSP, LTO, 0},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_LAUTO, 77, 12, REGSP, LTO, C_XPRE},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_LAUTO, 77, 12, REGSP, LTO, C_XPOST},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NSOREG_4, 67, 4, 0, 0, 0},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NSOREG_4, 67, 4, 0, 0, C_XPRE},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NSOREG_4, 67, 4, 0, 0, C_XPOST},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_PSOREG_4, 67, 4, 0, 0, 0},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_PSOREG_4, 67, 4, 0, 0, C_XPRE},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_PSOREG_4, 67, 4, 0, 0, C_XPOST},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_UOREG4K, 76, 8, 0, 0, 0},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_UOREG4K, 76, 8, 0, 0, C_XPRE},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_UOREG4K, 76, 8, 0, 0, C_XPOST},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NOREG4K, 76, 8, 0, 0, 0},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NOREG4K, 76, 8, 0, 0, C_XPRE},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_NOREG4K, 76, 8, 0, 0, C_XPOST},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_LOREG, 77, 12, 0, LTO, 0},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_LOREG, 77, 12, 0, LTO, C_XPRE},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_LOREG, 77, 12, 0, LTO, C_XPOST},
+	{ASTPW, C_PAIR, C_NONE, C_NONE, C_ADDR, 87, 12, 0, 0, 0},
+
+	{ASWPD, C_REG, C_NONE, C_NONE, C_ZOREG, 47, 4, 0, 0, 0},     // RegTo2=C_REG
+	{ASWPD, C_REG, C_NONE, C_NONE, C_ZAUTO, 47, 4, REGSP, 0, 0}, // RegTo2=C_REG
+	{ALDAR, C_ZOREG, C_NONE, C_NONE, C_REG, 58, 4, 0, 0, 0},
+	{ALDXR, C_ZOREG, C_NONE, C_NONE, C_REG, 58, 4, 0, 0, 0},
+	{ALDAXR, C_ZOREG, C_NONE, C_NONE, C_REG, 58, 4, 0, 0, 0},
+	{ALDXP, C_ZOREG, C_NONE, C_NONE, C_PAIR, 58, 4, 0, 0, 0},
+	{ASTLR, C_REG, C_NONE, C_NONE, C_ZOREG, 59, 4, 0, 0, 0},  // RegTo2=C_NONE
+	{ASTXR, C_REG, C_NONE, C_NONE, C_ZOREG, 59, 4, 0, 0, 0},  // RegTo2=C_REG
+	{ASTLXR, C_REG, C_NONE, C_NONE, C_ZOREG, 59, 4, 0, 0, 0}, // RegTo2=C_REG
+	{ASTXP, C_PAIR, C_NONE, C_NONE, C_ZOREG, 59, 4, 0, 0, 0},
+
+	/* VLD[1-4]/VST[1-4] */
+	{AVLD1, C_ZOREG, C_NONE, C_NONE, C_LIST, 81, 4, 0, 0, 0},
+	{AVLD1, C_LOREG, C_NONE, C_NONE, C_LIST, 81, 4, 0, 0, C_XPOST},
+	{AVLD1, C_ROFF, C_NONE, C_NONE, C_LIST, 81, 4, 0, 0, C_XPOST},
+	{AVLD1R, C_ZOREG, C_NONE, C_NONE, C_LIST, 81, 4, 0, 0, 0},
+	{AVLD1R, C_LOREG, C_NONE, C_NONE, C_LIST, 81, 4, 0, 0, C_XPOST},
+	{AVLD1R, C_ROFF, C_NONE, C_NONE, C_LIST, 81, 4, 0, 0, C_XPOST},
+	{AVLD1, C_LOREG, C_NONE, C_NONE, C_ELEM, 97, 4, 0, 0, C_XPOST},
+	{AVLD1, C_ROFF, C_NONE, C_NONE, C_ELEM, 97, 4, 0, 0, C_XPOST},
+	{AVLD1, C_LOREG, C_NONE, C_NONE, C_ELEM, 97, 4, 0, 0, 0},
+	{AVST1, C_LIST, C_NONE, C_NONE, C_ZOREG, 84, 4, 0, 0, 0},
+	{AVST1, C_LIST, C_NONE, C_NONE, C_LOREG, 84, 4, 0, 0, C_XPOST},
+	{AVST1, C_LIST, C_NONE, C_NONE, C_ROFF, 84, 4, 0, 0, C_XPOST},
+	{AVST2, C_LIST, C_NONE, C_NONE, C_ZOREG, 84, 4, 0, 0, 0},
+	{AVST2, C_LIST, C_NONE, C_NONE, C_LOREG, 84, 4, 0, 0, C_XPOST},
+	{AVST2, C_LIST, C_NONE, C_NONE, C_ROFF, 84, 4, 0, 0, C_XPOST},
+	{AVST3, C_LIST, C_NONE, C_NONE, C_ZOREG, 84, 4, 0, 0, 0},
+	{AVST3, C_LIST, C_NONE, C_NONE, C_LOREG, 84, 4, 0, 0, C_XPOST},
+	{AVST3, C_LIST, C_NONE, C_NONE, C_ROFF, 84, 4, 0, 0, C_XPOST},
+	{AVST4, C_LIST, C_NONE, C_NONE, C_ZOREG, 84, 4, 0, 0, 0},
+	{AVST4, C_LIST, C_NONE, C_NONE, C_LOREG, 84, 4, 0, 0, C_XPOST},
+	{AVST4, C_LIST, C_NONE, C_NONE, C_ROFF, 84, 4, 0, 0, C_XPOST},
+	{AVST1, C_ELEM, C_NONE, C_NONE, C_LOREG, 96, 4, 0, 0, C_XPOST},
+	{AVST1, C_ELEM, C_NONE, C_NONE, C_ROFF, 96, 4, 0, 0, C_XPOST},
+	{AVST1, C_ELEM, C_NONE, C_NONE, C_LOREG, 96, 4, 0, 0, 0},
+
+	/* special */
+	{AMOVD, C_SPR, C_NONE, C_NONE, C_REG, 35, 4, 0, 0, 0},
+	{AMRS, C_SPR, C_NONE, C_NONE, C_REG, 35, 4, 0, 0, 0},
+	{AMOVD, C_REG, C_NONE, C_NONE, C_SPR, 36, 4, 0, 0, 0},
+	{AMSR, C_REG, C_NONE, C_NONE, C_SPR, 36, 4, 0, 0, 0},
+	{AMOVD, C_VCON, C_NONE, C_NONE, C_SPR, 37, 4, 0, 0, 0},
+	{AMSR, C_VCON, C_NONE, C_NONE, C_SPR, 37, 4, 0, 0, 0},
+	{APRFM, C_UOREG32K, C_NONE, C_NONE, C_SPR, 91, 4, 0, 0, 0},
+	{APRFM, C_UOREG32K, C_NONE, C_NONE, C_LCON, 91, 4, 0, 0, 0},
+	{ADMB, C_VCON, C_NONE, C_NONE, C_NONE, 51, 4, 0, 0, 0},
+	{AHINT, C_VCON, C_NONE, C_NONE, C_NONE, 52, 4, 0, 0, 0},
+	{ASYS, C_VCON, C_NONE, C_NONE, C_NONE, 50, 4, 0, 0, 0},
+	{ASYS, C_VCON, C_REG, C_NONE, C_NONE, 50, 4, 0, 0, 0},
+	{ASYSL, C_VCON, C_NONE, C_NONE, C_REG, 50, 4, 0, 0, 0},
+
+	/* encryption instructions */
+	{AAESD, C_VREG, C_NONE, C_NONE, C_VREG, 29, 4, 0, 0, 0}, // for compatibility with old code
+	{AAESD, C_ARNG, C_NONE, C_NONE, C_ARNG, 29, 4, 0, 0, 0}, // recommend using the new one for better readability
+	{ASHA1C, C_VREG, C_REG, C_NONE, C_VREG, 1, 4, 0, 0, 0},
+	{ASHA1C, C_ARNG, C_VREG, C_NONE, C_VREG, 1, 4, 0, 0, 0},
+	{ASHA1H, C_VREG, C_NONE, C_NONE, C_VREG, 29, 4, 0, 0, 0},
+	{ASHA1SU0, C_ARNG, C_ARNG, C_NONE, C_ARNG, 1, 4, 0, 0, 0},
+	{ASHA256H, C_ARNG, C_VREG, C_NONE, C_VREG, 1, 4, 0, 0, 0},
+	{AVREV32, C_ARNG, C_NONE, C_NONE, C_ARNG, 83, 4, 0, 0, 0},
+	{AVPMULL, C_ARNG, C_ARNG, C_NONE, C_ARNG, 93, 4, 0, 0, 0},
+
+	{obj.AUNDEF, C_NONE, C_NONE, C_NONE, C_NONE, 90, 4, 0, 0, 0},
+	{obj.APCDATA, C_VCON, C_NONE, C_NONE, C_VCON, 0, 0, 0, 0, 0},
+	{obj.AFUNCDATA, C_VCON, C_NONE, C_NONE, C_ADDR, 0, 0, 0, 0, 0},
+	{obj.ANOP, C_NONE, C_NONE, C_NONE, C_NONE, 0, 0, 0, 0, 0},
+	{obj.ANOP, C_LCON, C_NONE, C_NONE, C_NONE, 0, 0, 0, 0, 0}, // nop variants, see #40689
+	{obj.ANOP, C_REG, C_NONE, C_NONE, C_NONE, 0, 0, 0, 0, 0},
+	{obj.ANOP, C_VREG, C_NONE, C_NONE, C_NONE, 0, 0, 0, 0, 0},
+	{obj.ADUFFZERO, C_NONE, C_NONE, C_NONE, C_SBRA, 5, 4, 0, 0, 0}, // same as AB/ABL
+	{obj.ADUFFCOPY, C_NONE, C_NONE, C_NONE, C_SBRA, 5, 4, 0, 0, 0}, // same as AB/ABL
+	{obj.APCALIGN, C_LCON, C_NONE, C_NONE, C_NONE, 0, 0, 0, 0, 0},  // align code
+
+	{obj.AXXX, C_NONE, C_NONE, C_NONE, C_NONE, 0, 4, 0, 0, 0},
+}
+
+/*
+ * valid pstate field values, and value to use in instruction
+ */
+var pstatefield = []struct {
+	reg int16
+	enc uint32
+}{
+	{REG_SPSel, 0<<16 | 4<<12 | 5<<5},
+	{REG_DAIFSet, 3<<16 | 4<<12 | 6<<5},
+	{REG_DAIFClr, 3<<16 | 4<<12 | 7<<5},
+}
+
+var prfopfield = []struct {
+	reg int16
+	enc uint32
+}{
+	{REG_PLDL1KEEP, 0},
+	{REG_PLDL1STRM, 1},
+	{REG_PLDL2KEEP, 2},
+	{REG_PLDL2STRM, 3},
+	{REG_PLDL3KEEP, 4},
+	{REG_PLDL3STRM, 5},
+	{REG_PLIL1KEEP, 8},
+	{REG_PLIL1STRM, 9},
+	{REG_PLIL2KEEP, 10},
+	{REG_PLIL2STRM, 11},
+	{REG_PLIL3KEEP, 12},
+	{REG_PLIL3STRM, 13},
+	{REG_PSTL1KEEP, 16},
+	{REG_PSTL1STRM, 17},
+	{REG_PSTL2KEEP, 18},
+	{REG_PSTL2STRM, 19},
+	{REG_PSTL3KEEP, 20},
+	{REG_PSTL3STRM, 21},
+}
+
+// Used for padinng NOOP instruction
+const OP_NOOP = 0xd503201f
+
+// align code to a certain length by padding bytes.
+func pcAlignPadLength(pc int64, alignedValue int64, ctxt *obj.Link) int {
+	if !((alignedValue&(alignedValue-1) == 0) && 8 <= alignedValue && alignedValue <= 2048) {
+		ctxt.Diag("alignment value of an instruction must be a power of two and in the range [8, 2048], got %d\n", alignedValue)
+	}
+	return int(-pc & (alignedValue - 1))
+}
+
+func span7(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
+	if ctxt.Retpoline {
+		ctxt.Diag("-spectre=ret not supported on arm64")
+		ctxt.Retpoline = false // don't keep printing
+	}
+
+	p := cursym.Func.Text
+	if p == nil || p.Link == nil { // handle external functions and ELF section symbols
+		return
+	}
+
+	if oprange[AAND&obj.AMask] == nil {
+		ctxt.Diag("arm64 ops not initialized, call arm64.buildop first")
+	}
+
+	c := ctxt7{ctxt: ctxt, newprog: newprog, cursym: cursym, autosize: int32(p.To.Offset & 0xffffffff), extrasize: int32(p.To.Offset >> 32)}
+	p.To.Offset &= 0xffffffff // extrasize is no longer needed
+
+	bflag := 1
+	pc := int64(0)
+	p.Pc = pc
+	var m int
+	var o *Optab
+	for p = p.Link; p != nil; p = p.Link {
+		if p.As == ADWORD && (pc&7) != 0 {
+			pc += 4
+		}
+		p.Pc = pc
+		o = c.oplook(p)
+		m = int(o.size)
+		if m == 0 {
+			switch p.As {
+			case obj.APCALIGN:
+				alignedValue := p.From.Offset
+				m = pcAlignPadLength(pc, alignedValue, ctxt)
+				// Update the current text symbol alignment value.
+				if int32(alignedValue) > cursym.Func.Align {
+					cursym.Func.Align = int32(alignedValue)
+				}
+				break
+			case obj.ANOP, obj.AFUNCDATA, obj.APCDATA:
+				continue
+			default:
+				c.ctxt.Diag("zero-width instruction\n%v", p)
+			}
+		}
+		switch o.flag & (LFROM | LTO) {
+		case LFROM:
+			c.addpool(p, &p.From)
+
+		case LTO:
+			c.addpool(p, &p.To)
+			break
+		}
+
+		if p.As == AB || p.As == obj.ARET || p.As == AERET { /* TODO: other unconditional operations */
+			c.checkpool(p, 0)
+		}
+		pc += int64(m)
+		if c.blitrl != nil {
+			c.checkpool(p, 1)
+		}
+	}
+
+	c.cursym.Size = pc
+
+	/*
+	 * if any procedure is large enough to
+	 * generate a large SBRA branch, then
+	 * generate extra passes putting branches
+	 * around jmps to fix. this is rare.
+	 */
+	for bflag != 0 {
+		bflag = 0
+		pc = 0
+		for p = c.cursym.Func.Text.Link; p != nil; p = p.Link {
+			if p.As == ADWORD && (pc&7) != 0 {
+				pc += 4
+			}
+			p.Pc = pc
+			o = c.oplook(p)
+
+			/* very large branches */
+			if (o.type_ == 7 || o.type_ == 39 || o.type_ == 40) && p.To.Target() != nil { // 7: BEQ and like, 39: CBZ and like, 40: TBZ and like
+				otxt := p.To.Target().Pc - pc
+				var toofar bool
+				switch o.type_ {
+				case 7, 39: // branch instruction encodes 19 bits
+					toofar = otxt <= -(1<<20)+10 || otxt >= (1<<20)-10
+				case 40: // branch instruction encodes 14 bits
+					toofar = otxt <= -(1<<15)+10 || otxt >= (1<<15)-10
+				}
+				if toofar {
+					q := c.newprog()
+					q.Link = p.Link
+					p.Link = q
+					q.As = AB
+					q.To.Type = obj.TYPE_BRANCH
+					q.To.SetTarget(p.To.Target())
+					p.To.SetTarget(q)
+					q = c.newprog()
+					q.Link = p.Link
+					p.Link = q
+					q.As = AB
+					q.To.Type = obj.TYPE_BRANCH
+					q.To.SetTarget(q.Link.Link)
+					bflag = 1
+				}
+			}
+			m = int(o.size)
+
+			if m == 0 {
+				switch p.As {
+				case obj.APCALIGN:
+					alignedValue := p.From.Offset
+					m = pcAlignPadLength(pc, alignedValue, ctxt)
+					break
+				case obj.ANOP, obj.AFUNCDATA, obj.APCDATA:
+					continue
+				default:
+					c.ctxt.Diag("zero-width instruction\n%v", p)
+				}
+			}
+
+			pc += int64(m)
+		}
+	}
+
+	pc += -pc & (funcAlign - 1)
+	c.cursym.Size = pc
+
+	/*
+	 * lay out the code, emitting code and data relocations.
+	 */
+	c.cursym.Grow(c.cursym.Size)
+	bp := c.cursym.P
+	psz := int32(0)
+	var i int
+	var out [6]uint32
+	for p := c.cursym.Func.Text.Link; p != nil; p = p.Link {
+		c.pc = p.Pc
+		o = c.oplook(p)
+
+		// need to align DWORDs on 8-byte boundary. The ISA doesn't
+		// require it, but the various 64-bit loads we generate assume it.
+		if o.as == ADWORD && psz%8 != 0 {
+			bp[3] = 0
+			bp[2] = bp[3]
+			bp[1] = bp[2]
+			bp[0] = bp[1]
+			bp = bp[4:]
+			psz += 4
+		}
+
+		if int(o.size) > 4*len(out) {
+			log.Fatalf("out array in span7 is too small, need at least %d for %v", o.size/4, p)
+		}
+		if p.As == obj.APCALIGN {
+			alignedValue := p.From.Offset
+			v := pcAlignPadLength(p.Pc, alignedValue, c.ctxt)
+			for i = 0; i < int(v/4); i++ {
+				// emit ANOOP instruction by the padding size
+				c.ctxt.Arch.ByteOrder.PutUint32(bp, OP_NOOP)
+				bp = bp[4:]
+				psz += 4
+			}
+		} else {
+			c.asmout(p, o, out[:])
+			for i = 0; i < int(o.size/4); i++ {
+				c.ctxt.Arch.ByteOrder.PutUint32(bp, out[i])
+				bp = bp[4:]
+				psz += 4
+			}
+		}
+	}
+
+	// Mark nonpreemptible instruction sequences.
+	// We use REGTMP as a scratch register during call injection,
+	// so instruction sequences that use REGTMP are unsafe to
+	// preempt asynchronously.
+	obj.MarkUnsafePoints(c.ctxt, c.cursym.Func.Text, c.newprog, c.isUnsafePoint, c.isRestartable)
+}
+
+// isUnsafePoint returns whether p is an unsafe point.
+func (c *ctxt7) isUnsafePoint(p *obj.Prog) bool {
+	// If p explicitly uses REGTMP, it's unsafe to preempt, because the
+	// preemption sequence clobbers REGTMP.
+	return p.From.Reg == REGTMP || p.To.Reg == REGTMP || p.Reg == REGTMP
+}
+
+// isRestartable returns whether p is a multi-instruction sequence that,
+// if preempted, can be restarted.
+func (c *ctxt7) isRestartable(p *obj.Prog) bool {
+	if c.isUnsafePoint(p) {
+		return false
+	}
+	// If p is a multi-instruction sequence with uses REGTMP inserted by
+	// the assembler in order to materialize a large constant/offset, we
+	// can restart p (at the start of the instruction sequence), recompute
+	// the content of REGTMP, upon async preemption. Currently, all cases
+	// of assembler-inserted REGTMP fall into this category.
+	// If p doesn't use REGTMP, it can be simply preempted, so we don't
+	// mark it.
+	o := c.oplook(p)
+	return o.size > 4 && o.flag&NOTUSETMP == 0
+}
+
+/*
+ * when the first reference to the literal pool threatens
+ * to go out of range of a 1Mb PC-relative offset
+ * drop the pool now, and branch round it.
+ */
+func (c *ctxt7) checkpool(p *obj.Prog, skip int) {
+	if c.pool.size >= 0xffff0 || !ispcdisp(int32(p.Pc+4+int64(c.pool.size)-int64(c.pool.start)+8)) {
+		c.flushpool(p, skip)
+	} else if p.Link == nil {
+		c.flushpool(p, 2)
+	}
+}
+
+func (c *ctxt7) flushpool(p *obj.Prog, skip int) {
+	if c.blitrl != nil {
+		if skip != 0 {
+			if c.ctxt.Debugvlog && skip == 1 {
+				fmt.Printf("note: flush literal pool at %#x: len=%d ref=%x\n", uint64(p.Pc+4), c.pool.size, c.pool.start)
+			}
+			q := c.newprog()
+			q.As = AB
+			q.To.Type = obj.TYPE_BRANCH
+			q.To.SetTarget(p.Link)
+			q.Link = c.blitrl
+			q.Pos = p.Pos
+			c.blitrl = q
+		} else if p.Pc+int64(c.pool.size)-int64(c.pool.start) < maxPCDisp {
+			return
+		}
+
+		// The line number for constant pool entries doesn't really matter.
+		// We set it to the line number of the preceding instruction so that
+		// there are no deltas to encode in the pc-line tables.
+		for q := c.blitrl; q != nil; q = q.Link {
+			q.Pos = p.Pos
+		}
+
+		c.elitrl.Link = p.Link
+		p.Link = c.blitrl
+
+		c.blitrl = nil /* BUG: should refer back to values until out-of-range */
+		c.elitrl = nil
+		c.pool.size = 0
+		c.pool.start = 0
+	}
+}
+
+/*
+ * MOVD foo(SB), R is actually
+ *   MOVD addr, REGTMP
+ *   MOVD REGTMP, R
+ * where addr is the address of the DWORD containing the address of foo.
+ *
+ * TODO: hash
+ */
+func (c *ctxt7) addpool(p *obj.Prog, a *obj.Addr) {
+	cls := c.aclass(a)
+	lit := c.instoffset
+	t := c.newprog()
+	t.As = AWORD
+	sz := 4
+
+	if a.Type == obj.TYPE_CONST {
+		if lit != int64(int32(lit)) && uint64(lit) != uint64(uint32(lit)) {
+			// out of range -0x80000000 ~ 0xffffffff, must store 64-bit
+			t.As = ADWORD
+			sz = 8
+		} // else store 32-bit
+	} else if p.As == AMOVD && a.Type != obj.TYPE_MEM || cls == C_ADDR || cls == C_VCON || lit != int64(int32(lit)) || uint64(lit) != uint64(uint32(lit)) {
+		// conservative: don't know if we want signed or unsigned extension.
+		// in case of ambiguity, store 64-bit
+		t.As = ADWORD
+		sz = 8
+	}
+
+	switch cls {
+	// TODO(aram): remove.
+	default:
+		if a.Name != obj.NAME_EXTERN {
+			fmt.Printf("addpool: %v in %v shouldn't go to default case\n", DRconv(cls), p)
+		}
+
+		t.To.Offset = a.Offset
+		t.To.Sym = a.Sym
+		t.To.Type = a.Type
+		t.To.Name = a.Name
+
+	/* This is here because MOV uint12<<12, R is disabled in optab.
+	Because of this, we need to load the constant from memory. */
+	case C_ADDCON:
+		fallthrough
+
+	case C_ZAUTO,
+		C_PSAUTO,
+		C_PSAUTO_8,
+		C_PSAUTO_4,
+		C_PPAUTO,
+		C_UAUTO4K_8,
+		C_UAUTO4K_4,
+		C_UAUTO4K_2,
+		C_UAUTO4K,
+		C_UAUTO8K_8,
+		C_UAUTO8K_4,
+		C_UAUTO8K,
+		C_UAUTO16K_8,
+		C_UAUTO16K,
+		C_UAUTO32K,
+		C_NSAUTO_8,
+		C_NSAUTO_4,
+		C_NSAUTO,
+		C_NPAUTO,
+		C_NAUTO4K,
+		C_LAUTO,
+		C_PPOREG,
+		C_PSOREG,
+		C_PSOREG_4,
+		C_PSOREG_8,
+		C_UOREG4K_8,
+		C_UOREG4K_4,
+		C_UOREG4K_2,
+		C_UOREG4K,
+		C_UOREG8K_8,
+		C_UOREG8K_4,
+		C_UOREG8K,
+		C_UOREG16K_8,
+		C_UOREG16K,
+		C_UOREG32K,
+		C_NSOREG_8,
+		C_NSOREG_4,
+		C_NSOREG,
+		C_NPOREG,
+		C_NOREG4K,
+		C_LOREG,
+		C_LACON,
+		C_ADDCON2,
+		C_LCON,
+		C_VCON:
+		if a.Name == obj.NAME_EXTERN {
+			fmt.Printf("addpool: %v in %v needs reloc\n", DRconv(cls), p)
+		}
+
+		t.To.Type = obj.TYPE_CONST
+		t.To.Offset = lit
+		break
+	}
+
+	for q := c.blitrl; q != nil; q = q.Link { /* could hash on t.t0.offset */
+		if q.To == t.To {
+			p.Pool = q
+			return
+		}
+	}
+
+	q := c.newprog()
+	*q = *t
+	q.Pc = int64(c.pool.size)
+	if c.blitrl == nil {
+		c.blitrl = q
+		c.pool.start = uint32(p.Pc)
+	} else {
+		c.elitrl.Link = q
+	}
+	c.elitrl = q
+	c.pool.size = -c.pool.size & (funcAlign - 1)
+	c.pool.size += uint32(sz)
+	p.Pool = q
+}
+
+func (c *ctxt7) regoff(a *obj.Addr) uint32 {
+	c.instoffset = 0
+	c.aclass(a)
+	return uint32(c.instoffset)
+}
+
+func isSTLXRop(op obj.As) bool {
+	switch op {
+	case ASTLXR, ASTLXRW, ASTLXRB, ASTLXRH,
+		ASTXR, ASTXRW, ASTXRB, ASTXRH:
+		return true
+	}
+	return false
+}
+
+func isSTXPop(op obj.As) bool {
+	switch op {
+	case ASTXP, ASTLXP, ASTXPW, ASTLXPW:
+		return true
+	}
+	return false
+}
+
+func isANDop(op obj.As) bool {
+	switch op {
+	case AAND, AORR, AEOR, AANDS, ATST,
+		ABIC, AEON, AORN, ABICS:
+		return true
+	}
+	return false
+}
+
+func isANDWop(op obj.As) bool {
+	switch op {
+	case AANDW, AORRW, AEORW, AANDSW, ATSTW,
+		ABICW, AEONW, AORNW, ABICSW:
+		return true
+	}
+	return false
+}
+
+func isADDop(op obj.As) bool {
+	switch op {
+	case AADD, AADDS, ASUB, ASUBS, ACMN, ACMP:
+		return true
+	}
+	return false
+}
+
+func isADDWop(op obj.As) bool {
+	switch op {
+	case AADDW, AADDSW, ASUBW, ASUBSW, ACMNW, ACMPW:
+		return true
+	}
+	return false
+}
+
+func isRegShiftOrExt(a *obj.Addr) bool {
+	return (a.Index-obj.RBaseARM64)&REG_EXT != 0 || (a.Index-obj.RBaseARM64)&REG_LSL != 0
+}
+
+// Maximum PC-relative displacement.
+// The actual limit is ±2²⁰, but we are conservative
+// to avoid needing to recompute the literal pool flush points
+// as span-dependent jumps are enlarged.
+const maxPCDisp = 512 * 1024
+
+// ispcdisp reports whether v is a valid PC-relative displacement.
+func ispcdisp(v int32) bool {
+	return -maxPCDisp < v && v < maxPCDisp && v&3 == 0
+}
+
+func isaddcon(v int64) bool {
+	/* uimm12 or uimm24? */
+	if v < 0 {
+		return false
+	}
+	if (v & 0xFFF) == 0 {
+		v >>= 12
+	}
+	return v <= 0xFFF
+}
+
+func isaddcon2(v int64) bool {
+	return 0 <= v && v <= 0xFFFFFF
+}
+
+// isbitcon reports whether a constant can be encoded into a logical instruction.
+// bitcon has a binary form of repetition of a bit sequence of length 2, 4, 8, 16, 32, or 64,
+// which itself is a rotate (w.r.t. the length of the unit) of a sequence of ones.
+// special cases: 0 and -1 are not bitcon.
+// this function needs to run against virtually all the constants, so it needs to be fast.
+// for this reason, bitcon testing and bitcon encoding are separate functions.
+func isbitcon(x uint64) bool {
+	if x == 1<<64-1 || x == 0 {
+		return false
+	}
+	// determine the period and sign-extend a unit to 64 bits
+	switch {
+	case x != x>>32|x<<32:
+		// period is 64
+		// nothing to do
+	case x != x>>16|x<<48:
+		// period is 32
+		x = uint64(int64(int32(x)))
+	case x != x>>8|x<<56:
+		// period is 16
+		x = uint64(int64(int16(x)))
+	case x != x>>4|x<<60:
+		// period is 8
+		x = uint64(int64(int8(x)))
+	default:
+		// period is 4 or 2, always true
+		// 0001, 0010, 0100, 1000 -- 0001 rotate
+		// 0011, 0110, 1100, 1001 -- 0011 rotate
+		// 0111, 1011, 1101, 1110 -- 0111 rotate
+		// 0101, 1010             -- 01   rotate, repeat
+		return true
+	}
+	return sequenceOfOnes(x) || sequenceOfOnes(^x)
+}
+
+// sequenceOfOnes tests whether a constant is a sequence of ones in binary, with leading and trailing zeros
+func sequenceOfOnes(x uint64) bool {
+	y := x & -x // lowest set bit of x. x is good iff x+y is a power of 2
+	y += x
+	return (y-1)&y == 0
+}
+
+// bitconEncode returns the encoding of a bitcon used in logical instructions
+// x is known to be a bitcon
+// a bitcon is a sequence of n ones at low bits (i.e. 1<<n-1), right rotated
+// by R bits, and repeated with period of 64, 32, 16, 8, 4, or 2.
+// it is encoded in logical instructions with 3 bitfields
+// N (1 bit) : R (6 bits) : S (6 bits), where
+// N=1           -- period=64
+// N=0, S=0xxxxx -- period=32
+// N=0, S=10xxxx -- period=16
+// N=0, S=110xxx -- period=8
+// N=0, S=1110xx -- period=4
+// N=0, S=11110x -- period=2
+// R is the shift amount, low bits of S = n-1
+func bitconEncode(x uint64, mode int) uint32 {
+	var period uint32
+	// determine the period and sign-extend a unit to 64 bits
+	switch {
+	case x != x>>32|x<<32:
+		period = 64
+	case x != x>>16|x<<48:
+		period = 32
+		x = uint64(int64(int32(x)))
+	case x != x>>8|x<<56:
+		period = 16
+		x = uint64(int64(int16(x)))
+	case x != x>>4|x<<60:
+		period = 8
+		x = uint64(int64(int8(x)))
+	case x != x>>2|x<<62:
+		period = 4
+		x = uint64(int64(x<<60) >> 60)
+	default:
+		period = 2
+		x = uint64(int64(x<<62) >> 62)
+	}
+	neg := false
+	if int64(x) < 0 {
+		x = ^x
+		neg = true
+	}
+	y := x & -x // lowest set bit of x.
+	s := log2(y)
+	n := log2(x+y) - s // x (or ^x) is a sequence of n ones left shifted by s bits
+	if neg {
+		// ^x is a sequence of n ones left shifted by s bits
+		// adjust n, s for x
+		s = n + s
+		n = period - n
+	}
+
+	N := uint32(0)
+	if mode == 64 && period == 64 {
+		N = 1
+	}
+	R := (period - s) & (period - 1) & uint32(mode-1) // shift amount of right rotate
+	S := (n - 1) | 63&^(period<<1-1)                  // low bits = #ones - 1, high bits encodes period
+	return N<<22 | R<<16 | S<<10
+}
+
+func log2(x uint64) uint32 {
+	if x == 0 {
+		panic("log2 of 0")
+	}
+	n := uint32(0)
+	if x >= 1<<32 {
+		x >>= 32
+		n += 32
+	}
+	if x >= 1<<16 {
+		x >>= 16
+		n += 16
+	}
+	if x >= 1<<8 {
+		x >>= 8
+		n += 8
+	}
+	if x >= 1<<4 {
+		x >>= 4
+		n += 4
+	}
+	if x >= 1<<2 {
+		x >>= 2
+		n += 2
+	}
+	if x >= 1<<1 {
+		x >>= 1
+		n += 1
+	}
+	return n
+}
+
+func autoclass(l int64) int {
+	if l == 0 {
+		return C_ZAUTO
+	}
+
+	if l < 0 {
+		if l >= -256 && (l&7) == 0 {
+			return C_NSAUTO_8
+		}
+		if l >= -256 && (l&3) == 0 {
+			return C_NSAUTO_4
+		}
+		if l >= -256 {
+			return C_NSAUTO
+		}
+		if l >= -512 && (l&7) == 0 {
+			return C_NPAUTO
+		}
+		if l >= -4095 {
+			return C_NAUTO4K
+		}
+		return C_LAUTO
+	}
+
+	if l <= 255 {
+		if (l & 7) == 0 {
+			return C_PSAUTO_8
+		}
+		if (l & 3) == 0 {
+			return C_PSAUTO_4
+		}
+		return C_PSAUTO
+	}
+	if l <= 504 && l&7 == 0 {
+		return C_PPAUTO
+	}
+	if l <= 4095 {
+		if l&7 == 0 {
+			return C_UAUTO4K_8
+		}
+		if l&3 == 0 {
+			return C_UAUTO4K_4
+		}
+		if l&1 == 0 {
+			return C_UAUTO4K_2
+		}
+		return C_UAUTO4K
+	}
+	if l <= 8190 {
+		if l&7 == 0 {
+			return C_UAUTO8K_8
+		}
+		if l&3 == 0 {
+			return C_UAUTO8K_4
+		}
+		if l&1 == 0 {
+			return C_UAUTO8K
+		}
+	}
+	if l <= 16380 {
+		if l&7 == 0 {
+			return C_UAUTO16K_8
+		}
+		if l&3 == 0 {
+			return C_UAUTO16K
+		}
+	}
+	if l <= 32760 && (l&7) == 0 {
+		return C_UAUTO32K
+	}
+	return C_LAUTO
+}
+
+func oregclass(l int64) int {
+	return autoclass(l) - C_ZAUTO + C_ZOREG
+}
+
+/*
+ * given an offset v and a class c (see above)
+ * return the offset value to use in the instruction,
+ * scaled if necessary
+ */
+func (c *ctxt7) offsetshift(p *obj.Prog, v int64, cls int) int64 {
+	s := 0
+	if cls >= C_SEXT1 && cls <= C_SEXT16 {
+		s = cls - C_SEXT1
+	} else {
+		switch cls {
+		case C_UAUTO4K, C_UOREG4K, C_ZOREG:
+			s = 0
+		case C_UAUTO8K, C_UOREG8K:
+			s = 1
+		case C_UAUTO16K, C_UOREG16K:
+			s = 2
+		case C_UAUTO32K, C_UOREG32K:
+			s = 3
+		default:
+			c.ctxt.Diag("bad class: %v\n%v", DRconv(cls), p)
+		}
+	}
+	vs := v >> uint(s)
+	if vs<<uint(s) != v {
+		c.ctxt.Diag("odd offset: %d\n%v", v, p)
+	}
+	return vs
+}
+
+/*
+ * if v contains a single 16-bit value aligned
+ * on a 16-bit field, and thus suitable for movk/movn,
+ * return the field index 0 to 3; otherwise return -1
+ */
+func movcon(v int64) int {
+	for s := 0; s < 64; s += 16 {
+		if (uint64(v) &^ (uint64(0xFFFF) << uint(s))) == 0 {
+			return s / 16
+		}
+	}
+	return -1
+}
+
+func rclass(r int16) int {
+	switch {
+	case REG_R0 <= r && r <= REG_R30: // not 31
+		return C_REG
+	case r == REGZERO:
+		return C_ZCON
+	case REG_F0 <= r && r <= REG_F31:
+		return C_FREG
+	case REG_V0 <= r && r <= REG_V31:
+		return C_VREG
+	case COND_EQ <= r && r <= COND_NV:
+		return C_COND
+	case r == REGSP:
+		return C_RSP
+	case r >= REG_ARNG && r < REG_ELEM:
+		return C_ARNG
+	case r >= REG_ELEM && r < REG_ELEM_END:
+		return C_ELEM
+	case r >= REG_UXTB && r < REG_SPECIAL:
+		return C_EXTREG
+	case r >= REG_SPECIAL:
+		return C_SPR
+	}
+	return C_GOK
+}
+
+// con32class reclassifies the constant of 32-bit instruction. Because the constant type is 32-bit,
+// but saved in Offset which type is int64, con32class treats it as uint32 type and reclassifies it.
+func (c *ctxt7) con32class(a *obj.Addr) int {
+	v := uint32(a.Offset)
+	if v == 0 {
+		return C_ZCON
+	}
+	if isaddcon(int64(v)) {
+		if v <= 0xFFF {
+			if isbitcon(uint64(a.Offset)) {
+				return C_ABCON0
+			}
+			return C_ADDCON0
+		}
+		if isbitcon(uint64(a.Offset)) {
+			return C_ABCON
+		}
+		if movcon(int64(v)) >= 0 {
+			return C_AMCON
+		}
+		if movcon(int64(^v)) >= 0 {
+			return C_AMCON
+		}
+		return C_ADDCON
+	}
+
+	t := movcon(int64(v))
+	if t >= 0 {
+		if isbitcon(uint64(a.Offset)) {
+			return C_MBCON
+		}
+		return C_MOVCON
+	}
+
+	t = movcon(int64(^v))
+	if t >= 0 {
+		if isbitcon(uint64(a.Offset)) {
+			return C_MBCON
+		}
+		return C_MOVCON
+	}
+
+	if isbitcon(uint64(a.Offset)) {
+		return C_BITCON
+	}
+
+	if 0 <= v && v <= 0xffffff {
+		return C_ADDCON2
+	}
+	return C_LCON
+}
+
+// con64class reclassifies the constant of C_VCON and C_LCON class.
+func (c *ctxt7) con64class(a *obj.Addr) int {
+	zeroCount := 0
+	negCount := 0
+	for i := uint(0); i < 4; i++ {
+		immh := uint32(a.Offset >> (i * 16) & 0xffff)
+		if immh == 0 {
+			zeroCount++
+		} else if immh == 0xffff {
+			negCount++
+		}
+	}
+	if zeroCount >= 3 || negCount >= 3 {
+		return C_MOVCON
+	} else if zeroCount == 2 || negCount == 2 {
+		return C_MOVCON2
+	} else if zeroCount == 1 || negCount == 1 {
+		return C_MOVCON3
+	} else {
+		return C_VCON
+	}
+}
+
+func (c *ctxt7) aclass(a *obj.Addr) int {
+	switch a.Type {
+	case obj.TYPE_NONE:
+		return C_NONE
+
+	case obj.TYPE_REG:
+		return rclass(a.Reg)
+
+	case obj.TYPE_REGREG:
+		return C_PAIR
+
+	case obj.TYPE_SHIFT:
+		return C_SHIFT
+
+	case obj.TYPE_REGLIST:
+		return C_LIST
+
+	case obj.TYPE_MEM:
+		// The base register should be an integer register.
+		if int16(REG_F0) <= a.Reg && a.Reg <= int16(REG_V31) {
+			break
+		}
+		switch a.Name {
+		case obj.NAME_EXTERN, obj.NAME_STATIC:
+			if a.Sym == nil {
+				break
+			}
+			c.instoffset = a.Offset
+			if a.Sym != nil { // use relocation
+				if a.Sym.Type == objabi.STLSBSS {
+					if c.ctxt.Flag_shared {
+						return C_TLS_IE
+					} else {
+						return C_TLS_LE
+					}
+				}
+				return C_ADDR
+			}
+			return C_LEXT
+
+		case obj.NAME_GOTREF:
+			return C_GOTADDR
+
+		case obj.NAME_AUTO:
+			if a.Reg == REGSP {
+				// unset base register for better printing, since
+				// a.Offset is still relative to pseudo-SP.
+				a.Reg = obj.REG_NONE
+			}
+			// The frame top 8 or 16 bytes are for FP
+			c.instoffset = int64(c.autosize) + a.Offset - int64(c.extrasize)
+			return autoclass(c.instoffset)
+
+		case obj.NAME_PARAM:
+			if a.Reg == REGSP {
+				// unset base register for better printing, since
+				// a.Offset is still relative to pseudo-FP.
+				a.Reg = obj.REG_NONE
+			}
+			c.instoffset = int64(c.autosize) + a.Offset + 8
+			return autoclass(c.instoffset)
+
+		case obj.NAME_NONE:
+			if a.Index != 0 {
+				if a.Offset != 0 {
+					if isRegShiftOrExt(a) {
+						// extended or shifted register offset, (Rn)(Rm.UXTW<<2) or (Rn)(Rm<<2).
+						return C_ROFF
+					}
+					return C_GOK
+				}
+				// register offset, (Rn)(Rm)
+				return C_ROFF
+			}
+			c.instoffset = a.Offset
+			return oregclass(c.instoffset)
+		}
+		return C_GOK
+
+	case obj.TYPE_FCONST:
+		return C_FCON
+
+	case obj.TYPE_TEXTSIZE:
+		return C_TEXTSIZE
+
+	case obj.TYPE_CONST, obj.TYPE_ADDR:
+		switch a.Name {
+		case obj.NAME_NONE:
+			c.instoffset = a.Offset
+			if a.Reg != 0 && a.Reg != REGZERO {
+				break
+			}
+			v := c.instoffset
+			if v == 0 {
+				return C_ZCON
+			}
+			if isaddcon(v) {
+				if v <= 0xFFF {
+					if isbitcon(uint64(v)) {
+						return C_ABCON0
+					}
+					return C_ADDCON0
+				}
+				if isbitcon(uint64(v)) {
+					return C_ABCON
+				}
+				if movcon(v) >= 0 {
+					return C_AMCON
+				}
+				if movcon(^v) >= 0 {
+					return C_AMCON
+				}
+				return C_ADDCON
+			}
+
+			t := movcon(v)
+			if t >= 0 {
+				if isbitcon(uint64(v)) {
+					return C_MBCON
+				}
+				return C_MOVCON
+			}
+
+			t = movcon(^v)
+			if t >= 0 {
+				if isbitcon(uint64(v)) {
+					return C_MBCON
+				}
+				return C_MOVCON
+			}
+
+			if isbitcon(uint64(v)) {
+				return C_BITCON
+			}
+
+			if 0 <= v && v <= 0xffffff {
+				return C_ADDCON2
+			}
+
+			if uint64(v) == uint64(uint32(v)) || v == int64(int32(v)) {
+				return C_LCON
+			}
+			return C_VCON
+
+		case obj.NAME_EXTERN, obj.NAME_STATIC:
+			if a.Sym == nil {
+				return C_GOK
+			}
+			if a.Sym.Type == objabi.STLSBSS {
+				c.ctxt.Diag("taking address of TLS variable is not supported")
+			}
+			c.instoffset = a.Offset
+			return C_VCONADDR
+
+		case obj.NAME_AUTO:
+			if a.Reg == REGSP {
+				// unset base register for better printing, since
+				// a.Offset is still relative to pseudo-SP.
+				a.Reg = obj.REG_NONE
+			}
+			// The frame top 8 or 16 bytes are for FP
+			c.instoffset = int64(c.autosize) + a.Offset - int64(c.extrasize)
+
+		case obj.NAME_PARAM:
+			if a.Reg == REGSP {
+				// unset base register for better printing, since
+				// a.Offset is still relative to pseudo-FP.
+				a.Reg = obj.REG_NONE
+			}
+			c.instoffset = int64(c.autosize) + a.Offset + 8
+		default:
+			return C_GOK
+		}
+		cf := c.instoffset
+		if isaddcon(cf) || isaddcon(-cf) {
+			return C_AACON
+		}
+		if isaddcon2(cf) {
+			return C_AACON2
+		}
+
+		return C_LACON
+
+	case obj.TYPE_BRANCH:
+		return C_SBRA
+	}
+
+	return C_GOK
+}
+
+func oclass(a *obj.Addr) int {
+	return int(a.Class) - 1
+}
+
+func (c *ctxt7) oplook(p *obj.Prog) *Optab {
+	a1 := int(p.Optab)
+	if a1 != 0 {
+		return &optab[a1-1]
+	}
+	a1 = int(p.From.Class)
+	if a1 == 0 {
+		a0 := c.aclass(&p.From)
+		// do not break C_ADDCON2 when S bit is set
+		if (p.As == AADDS || p.As == AADDSW || p.As == ASUBS || p.As == ASUBSW) && a0 == C_ADDCON2 {
+			a0 = C_LCON
+		}
+		a1 = a0 + 1
+		p.From.Class = int8(a1)
+		// more specific classification of 32-bit integers
+		if p.From.Type == obj.TYPE_CONST && p.From.Name == obj.NAME_NONE {
+			if p.As == AMOVW || isADDWop(p.As) {
+				ra0 := c.con32class(&p.From)
+				// do not break C_ADDCON2 when S bit is set
+				if (p.As == AADDSW || p.As == ASUBSW) && ra0 == C_ADDCON2 {
+					ra0 = C_LCON
+				}
+				a1 = ra0 + 1
+				p.From.Class = int8(a1)
+			}
+			if isANDWop(p.As) && a0 != C_BITCON {
+				// For 32-bit logical instruction with constant,
+				// the BITCON test is special in that it looks at
+				// the 64-bit which has the high 32-bit as a copy
+				// of the low 32-bit. We have handled that and
+				// don't pass it to con32class.
+				a1 = c.con32class(&p.From) + 1
+				p.From.Class = int8(a1)
+			}
+			if ((p.As == AMOVD) || isANDop(p.As) || isADDop(p.As)) && (a0 == C_LCON || a0 == C_VCON) {
+				a1 = c.con64class(&p.From) + 1
+				p.From.Class = int8(a1)
+			}
+		}
+	}
+
+	a1--
+	a3 := C_NONE + 1
+	if p.GetFrom3() != nil {
+		a3 = int(p.GetFrom3().Class)
+		if a3 == 0 {
+			a3 = c.aclass(p.GetFrom3()) + 1
+			p.GetFrom3().Class = int8(a3)
+		}
+	}
+
+	a3--
+	a4 := int(p.To.Class)
+	if a4 == 0 {
+		a4 = c.aclass(&p.To) + 1
+		p.To.Class = int8(a4)
+	}
+
+	a4--
+	a2 := C_NONE
+	if p.Reg != 0 {
+		a2 = rclass(p.Reg)
+	}
+
+	if false {
+		fmt.Printf("oplook %v %d %d %d %d\n", p.As, a1, a2, a3, a4)
+		fmt.Printf("\t\t%d %d\n", p.From.Type, p.To.Type)
+	}
+
+	ops := oprange[p.As&obj.AMask]
+	c1 := &xcmp[a1]
+	c2 := &xcmp[a2]
+	c3 := &xcmp[a3]
+	c4 := &xcmp[a4]
+	c5 := &xcmp[p.Scond>>5]
+	for i := range ops {
+		op := &ops[i]
+		if (int(op.a2) == a2 || c2[op.a2]) && c5[op.scond>>5] && c1[op.a1] && c3[op.a3] && c4[op.a4] {
+			p.Optab = uint16(cap(optab) - cap(ops) + i + 1)
+			return op
+		}
+	}
+
+	c.ctxt.Diag("illegal combination: %v %v %v %v %v, %d %d", p, DRconv(a1), DRconv(a2), DRconv(a3), DRconv(a4), p.From.Type, p.To.Type)
+	// Turn illegal instruction into an UNDEF, avoid crashing in asmout
+	return &Optab{obj.AUNDEF, C_NONE, C_NONE, C_NONE, C_NONE, 90, 4, 0, 0, 0}
+}
+
+func cmp(a int, b int) bool {
+	if a == b {
+		return true
+	}
+	switch a {
+	case C_RSP:
+		if b == C_REG {
+			return true
+		}
+
+	case C_REG:
+		if b == C_ZCON {
+			return true
+		}
+
+	case C_ADDCON0:
+		if b == C_ZCON || b == C_ABCON0 {
+			return true
+		}
+
+	case C_ADDCON:
+		if b == C_ZCON || b == C_ABCON0 || b == C_ADDCON0 || b == C_ABCON || b == C_AMCON {
+			return true
+		}
+
+	case C_BITCON:
+		if b == C_ABCON0 || b == C_ABCON || b == C_MBCON {
+			return true
+		}
+
+	case C_MOVCON:
+		if b == C_MBCON || b == C_ZCON || b == C_ADDCON0 || b == C_AMCON {
+			return true
+		}
+
+	case C_ADDCON2:
+		if b == C_ZCON || b == C_ADDCON || b == C_ADDCON0 {
+			return true
+		}
+
+	case C_LCON:
+		if b == C_ZCON || b == C_BITCON || b == C_ADDCON || b == C_ADDCON0 || b == C_ABCON || b == C_ABCON0 || b == C_MBCON || b == C_MOVCON || b == C_ADDCON2 || b == C_AMCON {
+			return true
+		}
+
+	case C_MOVCON2:
+		return cmp(C_LCON, b)
+
+	case C_VCON:
+		return cmp(C_LCON, b)
+
+	case C_LACON:
+		if b == C_AACON || b == C_AACON2 {
+			return true
+		}
+
+	case C_SEXT2:
+		if b == C_SEXT1 {
+			return true
+		}
+
+	case C_SEXT4:
+		if b == C_SEXT1 || b == C_SEXT2 {
+			return true
+		}
+
+	case C_SEXT8:
+		if b >= C_SEXT1 && b <= C_SEXT4 {
+			return true
+		}
+
+	case C_SEXT16:
+		if b >= C_SEXT1 && b <= C_SEXT8 {
+			return true
+		}
+
+	case C_LEXT:
+		if b >= C_SEXT1 && b <= C_SEXT16 {
+			return true
+		}
+
+	case C_NSAUTO_4:
+		if b == C_NSAUTO_8 {
+			return true
+		}
+
+	case C_NSAUTO:
+		switch b {
+		case C_NSAUTO_4, C_NSAUTO_8:
+			return true
+		}
+
+	case C_NPAUTO:
+		switch b {
+		case C_NSAUTO_8:
+			return true
+		}
+
+	case C_NAUTO4K:
+		switch b {
+		case C_NSAUTO_8, C_NSAUTO_4, C_NSAUTO, C_NPAUTO:
+			return true
+		}
+
+	case C_PSAUTO_8:
+		if b == C_ZAUTO {
+			return true
+		}
+
+	case C_PSAUTO_4:
+		switch b {
+		case C_ZAUTO, C_PSAUTO_8:
+			return true
+		}
+
+	case C_PSAUTO:
+		switch b {
+		case C_ZAUTO, C_PSAUTO_8, C_PSAUTO_4:
+			return true
+		}
+
+	case C_PPAUTO:
+		switch b {
+		case C_ZAUTO, C_PSAUTO_8:
+			return true
+		}
+
+	case C_UAUTO4K:
+		switch b {
+		case C_ZAUTO, C_PSAUTO, C_PSAUTO_4, C_PSAUTO_8,
+			C_PPAUTO, C_UAUTO4K_2, C_UAUTO4K_4, C_UAUTO4K_8:
+			return true
+		}
+
+	case C_UAUTO8K:
+		switch b {
+		case C_ZAUTO, C_PSAUTO, C_PSAUTO_4, C_PSAUTO_8, C_PPAUTO,
+			C_UAUTO4K_2, C_UAUTO4K_4, C_UAUTO4K_8, C_UAUTO8K_4, C_UAUTO8K_8:
+			return true
+		}
+
+	case C_UAUTO16K:
+		switch b {
+		case C_ZAUTO, C_PSAUTO, C_PSAUTO_4, C_PSAUTO_8, C_PPAUTO,
+			C_UAUTO4K_4, C_UAUTO4K_8, C_UAUTO8K_4, C_UAUTO8K_8, C_UAUTO16K_8:
+			return true
+		}
+
+	case C_UAUTO32K:
+		switch b {
+		case C_ZAUTO, C_PSAUTO, C_PSAUTO_4, C_PSAUTO_8,
+			C_PPAUTO, C_UAUTO4K_8, C_UAUTO8K_8, C_UAUTO16K_8:
+			return true
+		}
+
+	case C_LAUTO:
+		switch b {
+		case C_ZAUTO, C_NSAUTO, C_NSAUTO_4, C_NSAUTO_8, C_NPAUTO,
+			C_NAUTO4K, C_PSAUTO, C_PSAUTO_4, C_PSAUTO_8, C_PPAUTO,
+			C_UAUTO4K, C_UAUTO4K_2, C_UAUTO4K_4, C_UAUTO4K_8,
+			C_UAUTO8K, C_UAUTO8K_4, C_UAUTO8K_8,
+			C_UAUTO16K, C_UAUTO16K_8,
+			C_UAUTO32K:
+			return true
+		}
+
+	case C_NSOREG_4:
+		if b == C_NSOREG_8 {
+			return true
+		}
+
+	case C_NSOREG:
+		switch b {
+		case C_NSOREG_4, C_NSOREG_8:
+			return true
+		}
+
+	case C_NPOREG:
+		switch b {
+		case C_NSOREG_8:
+			return true
+		}
+
+	case C_NOREG4K:
+		switch b {
+		case C_NSOREG_8, C_NSOREG_4, C_NSOREG, C_NPOREG:
+			return true
+		}
+
+	case C_PSOREG_4:
+		switch b {
+		case C_ZOREG, C_PSOREG_8:
+			return true
+		}
+
+	case C_PSOREG:
+		switch b {
+		case C_ZOREG, C_PSOREG_8, C_PSOREG_4:
+			return true
+		}
+
+	case C_PPOREG:
+		switch b {
+		case C_ZOREG, C_PSOREG_8:
+			return true
+		}
+
+	case C_UOREG4K:
+		switch b {
+		case C_ZOREG, C_PSOREG_4, C_PSOREG_8, C_PSOREG,
+			C_PPOREG, C_UOREG4K_2, C_UOREG4K_4, C_UOREG4K_8:
+			return true
+		}
+
+	case C_UOREG8K:
+		switch b {
+		case C_ZOREG, C_PSOREG_4, C_PSOREG_8, C_PSOREG,
+			C_PPOREG, C_UOREG4K_2, C_UOREG4K_4, C_UOREG4K_8,
+			C_UOREG8K_4, C_UOREG8K_8:
+			return true
+		}
+
+	case C_UOREG16K:
+		switch b {
+		case C_ZOREG, C_PSOREG_4, C_PSOREG_8, C_PSOREG,
+			C_PPOREG, C_UOREG4K_4, C_UOREG4K_8, C_UOREG8K_4,
+			C_UOREG8K_8, C_UOREG16K_8:
+			return true
+		}
+
+	case C_UOREG32K:
+		switch b {
+		case C_ZOREG, C_PSOREG_4, C_PSOREG_8, C_PSOREG,
+			C_PPOREG, C_UOREG4K_8, C_UOREG8K_8, C_UOREG16K_8:
+			return true
+		}
+
+	case C_LOREG:
+		switch b {
+		case C_ZOREG, C_NSOREG, C_NSOREG_4, C_NSOREG_8, C_NPOREG,
+			C_NOREG4K, C_PSOREG_4, C_PSOREG_8, C_PSOREG, C_PPOREG,
+			C_UOREG4K, C_UOREG4K_2, C_UOREG4K_4, C_UOREG4K_8,
+			C_UOREG8K, C_UOREG8K_4, C_UOREG8K_8,
+			C_UOREG16K, C_UOREG16K_8,
+			C_UOREG32K:
+			return true
+		}
+
+	case C_LBRA:
+		if b == C_SBRA {
+			return true
+		}
+	}
+
+	return false
+}
+
+type ocmp []Optab
+
+func (x ocmp) Len() int {
+	return len(x)
+}
+
+func (x ocmp) Swap(i, j int) {
+	x[i], x[j] = x[j], x[i]
+}
+
+func (x ocmp) Less(i, j int) bool {
+	p1 := &x[i]
+	p2 := &x[j]
+	if p1.as != p2.as {
+		return p1.as < p2.as
+	}
+	if p1.a1 != p2.a1 {
+		return p1.a1 < p2.a1
+	}
+	if p1.a2 != p2.a2 {
+		return p1.a2 < p2.a2
+	}
+	if p1.a3 != p2.a3 {
+		return p1.a3 < p2.a3
+	}
+	if p1.a4 != p2.a4 {
+		return p1.a4 < p2.a4
+	}
+	if p1.scond != p2.scond {
+		return p1.scond < p2.scond
+	}
+	return false
+}
+
+func oprangeset(a obj.As, t []Optab) {
+	oprange[a&obj.AMask] = t
+}
+
+func buildop(ctxt *obj.Link) {
+	if oprange[AAND&obj.AMask] != nil {
+		// Already initialized; stop now.
+		// This happens in the cmd/asm tests,
+		// each of which re-initializes the arch.
+		return
+	}
+
+	var n int
+	for i := 0; i < C_GOK; i++ {
+		for n = 0; n < C_GOK; n++ {
+			if cmp(n, i) {
+				xcmp[i][n] = true
+			}
+		}
+	}
+	for n = 0; optab[n].as != obj.AXXX; n++ {
+	}
+	sort.Sort(ocmp(optab[:n]))
+	for i := 0; i < n; i++ {
+		r := optab[i].as
+		start := i
+		for optab[i].as == r {
+			i++
+		}
+		t := optab[start:i]
+		i--
+		oprangeset(r, t)
+		switch r {
+		default:
+			ctxt.Diag("unknown op in build: %v", r)
+			ctxt.DiagFlush()
+			log.Fatalf("bad code")
+
+		case AADD:
+			oprangeset(AADDS, t)
+			oprangeset(ASUB, t)
+			oprangeset(ASUBS, t)
+			oprangeset(AADDW, t)
+			oprangeset(AADDSW, t)
+			oprangeset(ASUBW, t)
+			oprangeset(ASUBSW, t)
+
+		case AAND: /* logical immediate, logical shifted register */
+			oprangeset(AANDW, t)
+			oprangeset(AEOR, t)
+			oprangeset(AEORW, t)
+			oprangeset(AORR, t)
+			oprangeset(AORRW, t)
+			oprangeset(ABIC, t)
+			oprangeset(ABICW, t)
+			oprangeset(AEON, t)
+			oprangeset(AEONW, t)
+			oprangeset(AORN, t)
+			oprangeset(AORNW, t)
+
+		case AANDS: /* logical immediate, logical shifted register, set flags, cannot target RSP */
+			oprangeset(AANDSW, t)
+			oprangeset(ABICS, t)
+			oprangeset(ABICSW, t)
+
+		case ANEG:
+			oprangeset(ANEGS, t)
+			oprangeset(ANEGSW, t)
+			oprangeset(ANEGW, t)
+
+		case AADC: /* rn=Rd */
+			oprangeset(AADCW, t)
+
+			oprangeset(AADCS, t)
+			oprangeset(AADCSW, t)
+			oprangeset(ASBC, t)
+			oprangeset(ASBCW, t)
+			oprangeset(ASBCS, t)
+			oprangeset(ASBCSW, t)
+
+		case ANGC: /* rn=REGZERO */
+			oprangeset(ANGCW, t)
+
+			oprangeset(ANGCS, t)
+			oprangeset(ANGCSW, t)
+
+		case ACMP:
+			oprangeset(ACMPW, t)
+			oprangeset(ACMN, t)
+			oprangeset(ACMNW, t)
+
+		case ATST:
+			oprangeset(ATSTW, t)
+
+			/* register/register, and shifted */
+		case AMVN:
+			oprangeset(AMVNW, t)
+
+		case AMOVK:
+			oprangeset(AMOVKW, t)
+			oprangeset(AMOVN, t)
+			oprangeset(AMOVNW, t)
+			oprangeset(AMOVZ, t)
+			oprangeset(AMOVZW, t)
+
+		case ASWPD:
+			for i := range atomicInstructions {
+				oprangeset(i, t)
+			}
+
+		case ABEQ:
+			oprangeset(ABNE, t)
+			oprangeset(ABCS, t)
+			oprangeset(ABHS, t)
+			oprangeset(ABCC, t)
+			oprangeset(ABLO, t)
+			oprangeset(ABMI, t)
+			oprangeset(ABPL, t)
+			oprangeset(ABVS, t)
+			oprangeset(ABVC, t)
+			oprangeset(ABHI, t)
+			oprangeset(ABLS, t)
+			oprangeset(ABGE, t)
+			oprangeset(ABLT, t)
+			oprangeset(ABGT, t)
+			oprangeset(ABLE, t)
+
+		case ALSL:
+			oprangeset(ALSLW, t)
+			oprangeset(ALSR, t)
+			oprangeset(ALSRW, t)
+			oprangeset(AASR, t)
+			oprangeset(AASRW, t)
+			oprangeset(AROR, t)
+			oprangeset(ARORW, t)
+
+		case ACLS:
+			oprangeset(ACLSW, t)
+			oprangeset(ACLZ, t)
+			oprangeset(ACLZW, t)
+			oprangeset(ARBIT, t)
+			oprangeset(ARBITW, t)
+			oprangeset(AREV, t)
+			oprangeset(AREVW, t)
+			oprangeset(AREV16, t)
+			oprangeset(AREV16W, t)
+			oprangeset(AREV32, t)
+
+		case ASDIV:
+			oprangeset(ASDIVW, t)
+			oprangeset(AUDIV, t)
+			oprangeset(AUDIVW, t)
+			oprangeset(ACRC32B, t)
+			oprangeset(ACRC32CB, t)
+			oprangeset(ACRC32CH, t)
+			oprangeset(ACRC32CW, t)
+			oprangeset(ACRC32CX, t)
+			oprangeset(ACRC32H, t)
+			oprangeset(ACRC32W, t)
+			oprangeset(ACRC32X, t)
+
+		case AMADD:
+			oprangeset(AMADDW, t)
+			oprangeset(AMSUB, t)
+			oprangeset(AMSUBW, t)
+			oprangeset(ASMADDL, t)
+			oprangeset(ASMSUBL, t)
+			oprangeset(AUMADDL, t)
+			oprangeset(AUMSUBL, t)
+
+		case AREM:
+			oprangeset(AREMW, t)
+			oprangeset(AUREM, t)
+			oprangeset(AUREMW, t)
+
+		case AMUL:
+			oprangeset(AMULW, t)
+			oprangeset(AMNEG, t)
+			oprangeset(AMNEGW, t)
+			oprangeset(ASMNEGL, t)
+			oprangeset(ASMULL, t)
+			oprangeset(ASMULH, t)
+			oprangeset(AUMNEGL, t)
+			oprangeset(AUMULH, t)
+			oprangeset(AUMULL, t)
+
+		case AMOVB:
+			oprangeset(AMOVBU, t)
+
+		case AMOVH:
+			oprangeset(AMOVHU, t)
+
+		case AMOVW:
+			oprangeset(AMOVWU, t)
+
+		case ABFM:
+			oprangeset(ABFMW, t)
+			oprangeset(ASBFM, t)
+			oprangeset(ASBFMW, t)
+			oprangeset(AUBFM, t)
+			oprangeset(AUBFMW, t)
+
+		case ABFI:
+			oprangeset(ABFIW, t)
+			oprangeset(ABFXIL, t)
+			oprangeset(ABFXILW, t)
+			oprangeset(ASBFIZ, t)
+			oprangeset(ASBFIZW, t)
+			oprangeset(ASBFX, t)
+			oprangeset(ASBFXW, t)
+			oprangeset(AUBFIZ, t)
+			oprangeset(AUBFIZW, t)
+			oprangeset(AUBFX, t)
+			oprangeset(AUBFXW, t)
+
+		case AEXTR:
+			oprangeset(AEXTRW, t)
+
+		case ASXTB:
+			oprangeset(ASXTBW, t)
+			oprangeset(ASXTH, t)
+			oprangeset(ASXTHW, t)
+			oprangeset(ASXTW, t)
+			oprangeset(AUXTB, t)
+			oprangeset(AUXTH, t)
+			oprangeset(AUXTW, t)
+			oprangeset(AUXTBW, t)
+			oprangeset(AUXTHW, t)
+
+		case ACCMN:
+			oprangeset(ACCMNW, t)
+			oprangeset(ACCMP, t)
+			oprangeset(ACCMPW, t)
+
+		case ACSEL:
+			oprangeset(ACSELW, t)
+			oprangeset(ACSINC, t)
+			oprangeset(ACSINCW, t)
+			oprangeset(ACSINV, t)
+			oprangeset(ACSINVW, t)
+			oprangeset(ACSNEG, t)
+			oprangeset(ACSNEGW, t)
+
+		case ACINC:
+			// aliases Rm=Rn, !cond
+			oprangeset(ACINCW, t)
+			oprangeset(ACINV, t)
+			oprangeset(ACINVW, t)
+			oprangeset(ACNEG, t)
+			oprangeset(ACNEGW, t)
+
+			// aliases, Rm=Rn=REGZERO, !cond
+		case ACSET:
+			oprangeset(ACSETW, t)
+
+			oprangeset(ACSETM, t)
+			oprangeset(ACSETMW, t)
+
+		case AMOVD,
+			AMOVBU,
+			AB,
+			ABL,
+			AWORD,
+			ADWORD,
+			obj.ARET,
+			obj.ATEXT:
+			break
+
+		case ALDP:
+			oprangeset(AFLDPD, t)
+
+		case ASTP:
+			oprangeset(AFSTPD, t)
+
+		case ASTPW:
+			oprangeset(AFSTPS, t)
+
+		case ALDPW:
+			oprangeset(ALDPSW, t)
+			oprangeset(AFLDPS, t)
+
+		case AERET:
+			oprangeset(AWFE, t)
+			oprangeset(AWFI, t)
+			oprangeset(AYIELD, t)
+			oprangeset(ASEV, t)
+			oprangeset(ASEVL, t)
+			oprangeset(ANOOP, t)
+			oprangeset(ADRPS, t)
+
+		case ACBZ:
+			oprangeset(ACBZW, t)
+			oprangeset(ACBNZ, t)
+			oprangeset(ACBNZW, t)
+
+		case ATBZ:
+			oprangeset(ATBNZ, t)
+
+		case AADR, AADRP:
+			break
+
+		case ACLREX:
+			break
+
+		case ASVC:
+			oprangeset(AHVC, t)
+			oprangeset(AHLT, t)
+			oprangeset(ASMC, t)
+			oprangeset(ABRK, t)
+			oprangeset(ADCPS1, t)
+			oprangeset(ADCPS2, t)
+			oprangeset(ADCPS3, t)
+
+		case AFADDS:
+			oprangeset(AFADDD, t)
+			oprangeset(AFSUBS, t)
+			oprangeset(AFSUBD, t)
+			oprangeset(AFMULS, t)
+			oprangeset(AFMULD, t)
+			oprangeset(AFNMULS, t)
+			oprangeset(AFNMULD, t)
+			oprangeset(AFDIVS, t)
+			oprangeset(AFMAXD, t)
+			oprangeset(AFMAXS, t)
+			oprangeset(AFMIND, t)
+			oprangeset(AFMINS, t)
+			oprangeset(AFMAXNMD, t)
+			oprangeset(AFMAXNMS, t)
+			oprangeset(AFMINNMD, t)
+			oprangeset(AFMINNMS, t)
+			oprangeset(AFDIVD, t)
+
+		case AFMSUBD:
+			oprangeset(AFMSUBS, t)
+			oprangeset(AFMADDS, t)
+			oprangeset(AFMADDD, t)
+			oprangeset(AFNMSUBS, t)
+			oprangeset(AFNMSUBD, t)
+			oprangeset(AFNMADDS, t)
+			oprangeset(AFNMADDD, t)
+
+		case AFCVTSD:
+			oprangeset(AFCVTDS, t)
+			oprangeset(AFABSD, t)
+			oprangeset(AFABSS, t)
+			oprangeset(AFNEGD, t)
+			oprangeset(AFNEGS, t)
+			oprangeset(AFSQRTD, t)
+			oprangeset(AFSQRTS, t)
+			oprangeset(AFRINTNS, t)
+			oprangeset(AFRINTND, t)
+			oprangeset(AFRINTPS, t)
+			oprangeset(AFRINTPD, t)
+			oprangeset(AFRINTMS, t)
+			oprangeset(AFRINTMD, t)
+			oprangeset(AFRINTZS, t)
+			oprangeset(AFRINTZD, t)
+			oprangeset(AFRINTAS, t)
+			oprangeset(AFRINTAD, t)
+			oprangeset(AFRINTXS, t)
+			oprangeset(AFRINTXD, t)
+			oprangeset(AFRINTIS, t)
+			oprangeset(AFRINTID, t)
+			oprangeset(AFCVTDH, t)
+			oprangeset(AFCVTHS, t)
+			oprangeset(AFCVTHD, t)
+			oprangeset(AFCVTSH, t)
+
+		case AFCMPS:
+			oprangeset(AFCMPD, t)
+			oprangeset(AFCMPES, t)
+			oprangeset(AFCMPED, t)
+
+		case AFCCMPS:
+			oprangeset(AFCCMPD, t)
+			oprangeset(AFCCMPES, t)
+			oprangeset(AFCCMPED, t)
+
+		case AFCSELD:
+			oprangeset(AFCSELS, t)
+
+		case AFMOVS, AFMOVD, AFMOVQ:
+			break
+
+		case AFCVTZSD:
+			oprangeset(AFCVTZSDW, t)
+			oprangeset(AFCVTZSS, t)
+			oprangeset(AFCVTZSSW, t)
+			oprangeset(AFCVTZUD, t)
+			oprangeset(AFCVTZUDW, t)
+			oprangeset(AFCVTZUS, t)
+			oprangeset(AFCVTZUSW, t)
+
+		case ASCVTFD:
+			oprangeset(ASCVTFS, t)
+			oprangeset(ASCVTFWD, t)
+			oprangeset(ASCVTFWS, t)
+			oprangeset(AUCVTFD, t)
+			oprangeset(AUCVTFS, t)
+			oprangeset(AUCVTFWD, t)
+			oprangeset(AUCVTFWS, t)
+
+		case ASYS:
+			oprangeset(AAT, t)
+			oprangeset(ADC, t)
+			oprangeset(AIC, t)
+			oprangeset(ATLBI, t)
+
+		case ASYSL, AHINT:
+			break
+
+		case ADMB:
+			oprangeset(ADSB, t)
+			oprangeset(AISB, t)
+
+		case AMRS, AMSR:
+			break
+
+		case ALDAR:
+			oprangeset(ALDARW, t)
+			oprangeset(ALDARB, t)
+			oprangeset(ALDARH, t)
+			fallthrough
+
+		case ALDXR:
+			oprangeset(ALDXRB, t)
+			oprangeset(ALDXRH, t)
+			oprangeset(ALDXRW, t)
+
+		case ALDAXR:
+			oprangeset(ALDAXRB, t)
+			oprangeset(ALDAXRH, t)
+			oprangeset(ALDAXRW, t)
+
+		case ALDXP:
+			oprangeset(ALDXPW, t)
+			oprangeset(ALDAXP, t)
+			oprangeset(ALDAXPW, t)
+
+		case ASTLR:
+			oprangeset(ASTLRB, t)
+			oprangeset(ASTLRH, t)
+			oprangeset(ASTLRW, t)
+
+		case ASTXR:
+			oprangeset(ASTXRB, t)
+			oprangeset(ASTXRH, t)
+			oprangeset(ASTXRW, t)
+
+		case ASTLXR:
+			oprangeset(ASTLXRB, t)
+			oprangeset(ASTLXRH, t)
+			oprangeset(ASTLXRW, t)
+
+		case ASTXP:
+			oprangeset(ASTLXP, t)
+			oprangeset(ASTLXPW, t)
+			oprangeset(ASTXPW, t)
+
+		case AVADDP:
+			oprangeset(AVAND, t)
+			oprangeset(AVCMEQ, t)
+			oprangeset(AVORR, t)
+			oprangeset(AVEOR, t)
+			oprangeset(AVBSL, t)
+			oprangeset(AVBIT, t)
+			oprangeset(AVCMTST, t)
+			oprangeset(AVUZP1, t)
+			oprangeset(AVUZP2, t)
+			oprangeset(AVBIF, t)
+
+		case AVADD:
+			oprangeset(AVSUB, t)
+
+		case AAESD:
+			oprangeset(AAESE, t)
+			oprangeset(AAESMC, t)
+			oprangeset(AAESIMC, t)
+			oprangeset(ASHA1SU1, t)
+			oprangeset(ASHA256SU0, t)
+			oprangeset(ASHA512SU0, t)
+
+		case ASHA1C:
+			oprangeset(ASHA1P, t)
+			oprangeset(ASHA1M, t)
+
+		case ASHA256H:
+			oprangeset(ASHA256H2, t)
+			oprangeset(ASHA512H, t)
+			oprangeset(ASHA512H2, t)
+
+		case ASHA1SU0:
+			oprangeset(ASHA256SU1, t)
+			oprangeset(ASHA512SU1, t)
+
+		case AVADDV:
+			oprangeset(AVUADDLV, t)
+
+		case AVFMLA:
+			oprangeset(AVFMLS, t)
+
+		case AVPMULL:
+			oprangeset(AVPMULL2, t)
+
+		case AVUSHR:
+			oprangeset(AVSHL, t)
+			oprangeset(AVSRI, t)
+
+		case AVREV32:
+			oprangeset(AVCNT, t)
+			oprangeset(AVRBIT, t)
+			oprangeset(AVREV64, t)
+			oprangeset(AVREV16, t)
+
+		case AVZIP1:
+			oprangeset(AVZIP2, t)
+
+		case AVUXTL:
+			oprangeset(AVUXTL2, t)
+
+		case AVUSHLL:
+			oprangeset(AVUSHLL2, t)
+
+		case AVLD1R:
+			oprangeset(AVLD2, t)
+			oprangeset(AVLD2R, t)
+			oprangeset(AVLD3, t)
+			oprangeset(AVLD3R, t)
+			oprangeset(AVLD4, t)
+			oprangeset(AVLD4R, t)
+
+		case ASHA1H,
+			AVCNT,
+			AVMOV,
+			AVLD1,
+			AVST1,
+			AVST2,
+			AVST3,
+			AVST4,
+			AVTBL,
+			AVDUP,
+			AVMOVI,
+			APRFM,
+			AVEXT:
+			break
+
+		case obj.ANOP,
+			obj.AUNDEF,
+			obj.AFUNCDATA,
+			obj.APCALIGN,
+			obj.APCDATA,
+			obj.ADUFFZERO,
+			obj.ADUFFCOPY:
+			break
+		}
+	}
+}
+
+// chipfloat7() checks if the immediate constants available in  FMOVS/FMOVD instructions.
+// For details of the range of constants available, see
+// http://infocenter.arm.com/help/topic/com.arm.doc.dui0473m/dom1359731199385.html.
+func (c *ctxt7) chipfloat7(e float64) int {
+	ei := math.Float64bits(e)
+	l := uint32(int32(ei))
+	h := uint32(int32(ei >> 32))
+
+	if l != 0 || h&0xffff != 0 {
+		return -1
+	}
+	h1 := h & 0x7fc00000
+	if h1 != 0x40000000 && h1 != 0x3fc00000 {
+		return -1
+	}
+	n := 0
+
+	// sign bit (a)
+	if h&0x80000000 != 0 {
+		n |= 1 << 7
+	}
+
+	// exp sign bit (b)
+	if h1 == 0x3fc00000 {
+		n |= 1 << 6
+	}
+
+	// rest of exp and mantissa (cd-efgh)
+	n |= int((h >> 16) & 0x3f)
+
+	//print("match %.8lux %.8lux %d\n", l, h, n);
+	return n
+}
+
+/* form offset parameter to SYS; special register number */
+func SYSARG5(op0 int, op1 int, Cn int, Cm int, op2 int) int {
+	return op0<<19 | op1<<16 | Cn<<12 | Cm<<8 | op2<<5
+}
+
+func SYSARG4(op1 int, Cn int, Cm int, op2 int) int {
+	return SYSARG5(0, op1, Cn, Cm, op2)
+}
+
+// checkUnpredictable checks if the sourse and transfer registers are the same register.
+// ARM64 manual says it is "constrained unpredictable" if the src and dst registers of STP/LDP are same.
+func (c *ctxt7) checkUnpredictable(p *obj.Prog, isload bool, wback bool, rn int16, rt1 int16, rt2 int16) {
+	if wback && rn != REGSP && (rn == rt1 || rn == rt2) {
+		c.ctxt.Diag("constrained unpredictable behavior: %v", p)
+	}
+	if isload && rt1 == rt2 {
+		c.ctxt.Diag("constrained unpredictable behavior: %v", p)
+	}
+}
+
+/* checkindex checks if index >= 0 && index <= maxindex */
+func (c *ctxt7) checkindex(p *obj.Prog, index, maxindex int) {
+	if index < 0 || index > maxindex {
+		c.ctxt.Diag("register element index out of range 0 to %d: %v", maxindex, p)
+	}
+}
+
+/* checkoffset checks whether the immediate offset is valid for VLD[1-4].P and VST[1-4].P */
+func (c *ctxt7) checkoffset(p *obj.Prog, as obj.As) {
+	var offset, list, n, expect int64
+	switch as {
+	case AVLD1, AVLD2, AVLD3, AVLD4, AVLD1R, AVLD2R, AVLD3R, AVLD4R:
+		offset = p.From.Offset
+		list = p.To.Offset
+	case AVST1, AVST2, AVST3, AVST4:
+		offset = p.To.Offset
+		list = p.From.Offset
+	default:
+		c.ctxt.Diag("invalid operation on op %v", p.As)
+	}
+	opcode := (list >> 12) & 15
+	q := (list >> 30) & 1
+	size := (list >> 10) & 3
+	if offset == 0 {
+		return
+	}
+	switch opcode {
+	case 0x7:
+		n = 1 // one register
+	case 0xa:
+		n = 2 // two registers
+	case 0x6:
+		n = 3 // three registers
+	case 0x2:
+		n = 4 // four registers
+	default:
+		c.ctxt.Diag("invalid register numbers in ARM64 register list: %v", p)
+	}
+
+	switch as {
+	case AVLD1R, AVLD2R, AVLD3R, AVLD4R:
+		if offset != n*(1<<uint(size)) {
+			c.ctxt.Diag("invalid post-increment offset: %v", p)
+		}
+	default:
+		if !(q == 0 && offset == n*8) && !(q == 1 && offset == n*16) {
+			c.ctxt.Diag("invalid post-increment offset: %v", p)
+		}
+	}
+
+	switch as {
+	case AVLD1, AVST1:
+		return
+	case AVLD1R:
+		expect = 1
+	case AVLD2, AVST2, AVLD2R:
+		expect = 2
+	case AVLD3, AVST3, AVLD3R:
+		expect = 3
+	case AVLD4, AVST4, AVLD4R:
+		expect = 4
+	}
+
+	if expect != n {
+		c.ctxt.Diag("expected %d registers, got %d: %v.", expect, n, p)
+	}
+}
+
+/* checkShiftAmount checks whether the index shift amount is valid */
+/* for load with register offset instructions */
+func (c *ctxt7) checkShiftAmount(p *obj.Prog, a *obj.Addr) {
+	var amount int16
+	amount = (a.Index >> 5) & 7
+	switch p.As {
+	case AMOVB, AMOVBU:
+		if amount != 0 {
+			c.ctxt.Diag("invalid index shift amount: %v", p)
+		}
+	case AMOVH, AMOVHU:
+		if amount != 1 && amount != 0 {
+			c.ctxt.Diag("invalid index shift amount: %v", p)
+		}
+	case AMOVW, AMOVWU, AFMOVS:
+		if amount != 2 && amount != 0 {
+			c.ctxt.Diag("invalid index shift amount: %v", p)
+		}
+	case AMOVD, AFMOVD:
+		if amount != 3 && amount != 0 {
+			c.ctxt.Diag("invalid index shift amount: %v", p)
+		}
+	default:
+		panic("invalid operation")
+	}
+}
+
+func (c *ctxt7) asmout(p *obj.Prog, o *Optab, out []uint32) {
+	var os [5]uint32
+	o1 := uint32(0)
+	o2 := uint32(0)
+	o3 := uint32(0)
+	o4 := uint32(0)
+	o5 := uint32(0)
+	if false { /*debug['P']*/
+		fmt.Printf("%x: %v\ttype %d\n", uint32(p.Pc), p, o.type_)
+	}
+	switch o.type_ {
+	default:
+		c.ctxt.Diag("%v: unknown asm %d", p, o.type_)
+
+	case 0: /* pseudo ops */
+		break
+
+	case 1: /* op Rm,[Rn],Rd; default Rn=Rd -> op Rm<<0,[Rn,]Rd (shifted register) */
+		o1 = c.oprrr(p, p.As)
+
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		r := int(p.Reg)
+		if p.To.Type == obj.TYPE_NONE {
+			rt = REGZERO
+		}
+		if r == 0 {
+			r = rt
+		}
+		o1 |= (uint32(rf&31) << 16) | (uint32(r&31) << 5) | uint32(rt&31)
+
+	case 2: /* add/sub $(uimm12|uimm24)[,R],R; cmp $(uimm12|uimm24),R */
+		o1 = c.opirr(p, p.As)
+
+		rt := int(p.To.Reg)
+		if p.To.Type == obj.TYPE_NONE {
+			if (o1 & Sbit) == 0 {
+				c.ctxt.Diag("ineffective ZR destination\n%v", p)
+			}
+			rt = REGZERO
+		}
+
+		r := int(p.Reg)
+		if r == 0 {
+			r = rt
+		}
+		v := int32(c.regoff(&p.From))
+		o1 = c.oaddi(p, int32(o1), v, r, rt)
+
+	case 3: /* op R<<n[,R],R (shifted register) */
+		o1 = c.oprrr(p, p.As)
+
+		amount := (p.From.Offset >> 10) & 63
+		is64bit := o1 & (1 << 31)
+		if is64bit == 0 && amount >= 32 {
+			c.ctxt.Diag("shift amount out of range 0 to 31: %v", p)
+		}
+		o1 |= uint32(p.From.Offset) /* includes reg, op, etc */
+		rt := int(p.To.Reg)
+		if p.To.Type == obj.TYPE_NONE {
+			rt = REGZERO
+		}
+		r := int(p.Reg)
+		if p.As == AMVN || p.As == AMVNW {
+			r = REGZERO
+		} else if r == 0 {
+			r = rt
+		}
+		o1 |= (uint32(r&31) << 5) | uint32(rt&31)
+
+	case 4: /* mov $addcon, R; mov $recon, R; mov $racon, R; mov $addcon2, R */
+		rt := int(p.To.Reg)
+		r := int(o.param)
+
+		if r == 0 {
+			r = REGZERO
+		} else if r == REGFROM {
+			r = int(p.From.Reg)
+		}
+		if r == 0 {
+			r = REGSP
+		}
+
+		v := int32(c.regoff(&p.From))
+		var op int32
+		if v < 0 {
+			v = -v
+			op = int32(c.opirr(p, ASUB))
+		} else {
+			op = int32(c.opirr(p, AADD))
+		}
+
+		if int(o.size) == 8 {
+			o1 = c.oaddi(p, op, v&0xfff000, r, REGTMP)
+			o2 = c.oaddi(p, op, v&0x000fff, REGTMP, rt)
+			break
+		}
+
+		o1 = c.oaddi(p, op, v, r, rt)
+
+	case 5: /* b s; bl s */
+		o1 = c.opbra(p, p.As)
+
+		if p.To.Sym == nil {
+			o1 |= uint32(c.brdist(p, 0, 26, 2))
+			break
+		}
+
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 4
+		rel.Sym = p.To.Sym
+		rel.Add = p.To.Offset
+		rel.Type = objabi.R_CALLARM64
+
+	case 6: /* b ,O(R); bl ,O(R) */
+		o1 = c.opbrr(p, p.As)
+
+		o1 |= uint32(p.To.Reg&31) << 5
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 0
+		rel.Type = objabi.R_CALLIND
+
+	case 7: /* beq s */
+		o1 = c.opbra(p, p.As)
+
+		o1 |= uint32(c.brdist(p, 0, 19, 2) << 5)
+
+	case 8: /* lsl $c,[R],R -> ubfm $(W-1)-c,$(-c MOD (W-1)),Rn,Rd */
+		rt := int(p.To.Reg)
+
+		rf := int(p.Reg)
+		if rf == 0 {
+			rf = rt
+		}
+		v := int32(p.From.Offset)
+		switch p.As {
+		case AASR:
+			o1 = c.opbfm(p, ASBFM, int(v), 63, rf, rt)
+
+		case AASRW:
+			o1 = c.opbfm(p, ASBFMW, int(v), 31, rf, rt)
+
+		case ALSL:
+			o1 = c.opbfm(p, AUBFM, int((64-v)&63), int(63-v), rf, rt)
+
+		case ALSLW:
+			o1 = c.opbfm(p, AUBFMW, int((32-v)&31), int(31-v), rf, rt)
+
+		case ALSR:
+			o1 = c.opbfm(p, AUBFM, int(v), 63, rf, rt)
+
+		case ALSRW:
+			o1 = c.opbfm(p, AUBFMW, int(v), 31, rf, rt)
+
+		case AROR:
+			o1 = c.opextr(p, AEXTR, v, rf, rf, rt)
+
+		case ARORW:
+			o1 = c.opextr(p, AEXTRW, v, rf, rf, rt)
+
+		default:
+			c.ctxt.Diag("bad shift $con\n%v", p)
+			break
+		}
+
+	case 9: /* lsl Rm,[Rn],Rd -> lslv Rm, Rn, Rd */
+		o1 = c.oprrr(p, p.As)
+
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		o1 |= (uint32(p.From.Reg&31) << 16) | (uint32(r&31) << 5) | uint32(p.To.Reg&31)
+
+	case 10: /* brk/hvc/.../svc [$con] */
+		o1 = c.opimm(p, p.As)
+
+		if p.From.Type != obj.TYPE_NONE {
+			o1 |= uint32((p.From.Offset & 0xffff) << 5)
+		}
+
+	case 11: /* dword */
+		c.aclass(&p.To)
+
+		o1 = uint32(c.instoffset)
+		o2 = uint32(c.instoffset >> 32)
+		if p.To.Sym != nil {
+			rel := obj.Addrel(c.cursym)
+			rel.Off = int32(c.pc)
+			rel.Siz = 8
+			rel.Sym = p.To.Sym
+			rel.Add = p.To.Offset
+			rel.Type = objabi.R_ADDR
+			o2 = 0
+			o1 = o2
+		}
+
+	case 12: /* movT $vcon, reg */
+		// NOTE: this case does not use REGTMP. If it ever does,
+		// remove the NOTUSETMP flag in optab.
+		num := c.omovlconst(p.As, p, &p.From, int(p.To.Reg), os[:])
+		if num == 0 {
+			c.ctxt.Diag("invalid constant: %v", p)
+		}
+		o1 = os[0]
+		o2 = os[1]
+		o3 = os[2]
+		o4 = os[3]
+
+	case 13: /* addop $vcon, [R], R (64 bit literal); cmp $lcon,R -> addop $lcon,R, ZR */
+		o := uint32(0)
+		num := uint8(0)
+		cls := oclass(&p.From)
+		if isADDWop(p.As) {
+			if !cmp(C_LCON, cls) {
+				c.ctxt.Diag("illegal combination: %v", p)
+			}
+			num = c.omovlconst(AMOVW, p, &p.From, REGTMP, os[:])
+		} else {
+			num = c.omovlconst(AMOVD, p, &p.From, REGTMP, os[:])
+		}
+		if num == 0 {
+			c.ctxt.Diag("invalid constant: %v", p)
+		}
+		rt := int(p.To.Reg)
+		if p.To.Type == obj.TYPE_NONE {
+			rt = REGZERO
+		}
+		r := int(p.Reg)
+		if r == 0 {
+			r = rt
+		}
+		if p.To.Type != obj.TYPE_NONE && (p.To.Reg == REGSP || r == REGSP) {
+			o = c.opxrrr(p, p.As, false)
+			o |= REGTMP & 31 << 16
+			o |= LSL0_64
+		} else {
+			o = c.oprrr(p, p.As)
+			o |= REGTMP & 31 << 16 /* shift is 0 */
+		}
+
+		o |= uint32(r&31) << 5
+		o |= uint32(rt & 31)
+
+		os[num] = o
+		o1 = os[0]
+		o2 = os[1]
+		o3 = os[2]
+		o4 = os[3]
+		o5 = os[4]
+
+	case 14: /* word */
+		if c.aclass(&p.To) == C_ADDR {
+			c.ctxt.Diag("address constant needs DWORD\n%v", p)
+		}
+		o1 = uint32(c.instoffset)
+		if p.To.Sym != nil {
+			// This case happens with words generated
+			// in the PC stream as part of the literal pool.
+			rel := obj.Addrel(c.cursym)
+
+			rel.Off = int32(c.pc)
+			rel.Siz = 4
+			rel.Sym = p.To.Sym
+			rel.Add = p.To.Offset
+			rel.Type = objabi.R_ADDR
+			o1 = 0
+		}
+
+	case 15: /* mul/mneg/umulh/umull r,[r,]r; madd/msub/fmadd/fmsub/fnmadd/fnmsub Rm,Ra,Rn,Rd */
+		o1 = c.oprrr(p, p.As)
+
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		var r int
+		var ra int
+		if p.From3Type() == obj.TYPE_REG {
+			r = int(p.GetFrom3().Reg)
+			ra = int(p.Reg)
+			if ra == 0 {
+				ra = REGZERO
+			}
+		} else {
+			r = int(p.Reg)
+			if r == 0 {
+				r = rt
+			}
+			ra = REGZERO
+		}
+
+		o1 |= (uint32(rf&31) << 16) | (uint32(ra&31) << 10) | (uint32(r&31) << 5) | uint32(rt&31)
+
+	case 16: /* XremY R[,R],R -> XdivY; XmsubY */
+		o1 = c.oprrr(p, p.As)
+
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		r := int(p.Reg)
+		if r == 0 {
+			r = rt
+		}
+		o1 |= (uint32(rf&31) << 16) | (uint32(r&31) << 5) | REGTMP&31
+		o2 = c.oprrr(p, AMSUBW)
+		o2 |= o1 & (1 << 31) /* same size */
+		o2 |= (uint32(rf&31) << 16) | (uint32(r&31) << 10) | (REGTMP & 31 << 5) | uint32(rt&31)
+
+	case 17: /* op Rm,[Rn],Rd; default Rn=ZR */
+		o1 = c.oprrr(p, p.As)
+
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		r := int(p.Reg)
+		if p.To.Type == obj.TYPE_NONE {
+			rt = REGZERO
+		}
+		if r == 0 {
+			r = REGZERO
+		}
+		o1 |= (uint32(rf&31) << 16) | (uint32(r&31) << 5) | uint32(rt&31)
+
+	case 18: /* csel cond,Rn,Rm,Rd; cinc/cinv/cneg cond,Rn,Rd; cset cond,Rd */
+		o1 = c.oprrr(p, p.As)
+
+		cond := int(p.From.Reg)
+		if cond < COND_EQ || cond > COND_NV {
+			c.ctxt.Diag("invalid condition: %v", p)
+		} else {
+			cond -= COND_EQ
+		}
+
+		r := int(p.Reg)
+		var rf int
+		if r != 0 {
+			if p.From3Type() == obj.TYPE_NONE {
+				/* CINC/CINV/CNEG */
+				rf = r
+				cond ^= 1
+			} else {
+				rf = int(p.GetFrom3().Reg) /* CSEL */
+			}
+		} else {
+			/* CSET */
+			rf = REGZERO
+			r = rf
+			cond ^= 1
+		}
+
+		rt := int(p.To.Reg)
+		o1 |= (uint32(rf&31) << 16) | (uint32(cond&15) << 12) | (uint32(r&31) << 5) | uint32(rt&31)
+
+	case 19: /* CCMN cond, (Rm|uimm5),Rn, uimm4 -> ccmn Rn,Rm,uimm4,cond */
+		nzcv := int(p.To.Offset)
+
+		cond := int(p.From.Reg)
+		if cond < COND_EQ || cond > COND_NV {
+			c.ctxt.Diag("invalid condition\n%v", p)
+		} else {
+			cond -= COND_EQ
+		}
+		var rf int
+		if p.GetFrom3().Type == obj.TYPE_REG {
+			o1 = c.oprrr(p, p.As)
+			rf = int(p.GetFrom3().Reg) /* Rm */
+		} else {
+			o1 = c.opirr(p, p.As)
+			rf = int(p.GetFrom3().Offset & 0x1F)
+		}
+
+		o1 |= (uint32(rf&31) << 16) | (uint32(cond&15) << 12) | (uint32(p.Reg&31) << 5) | uint32(nzcv)
+
+	case 20: /* movT R,O(R) -> strT */
+		v := int32(c.regoff(&p.To))
+		sz := int32(1 << uint(movesize(p.As)))
+
+		r := int(p.To.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		if v < 0 || v%sz != 0 { /* unscaled 9-bit signed */
+			o1 = c.olsr9s(p, int32(c.opstr9(p, p.As)), v, r, int(p.From.Reg))
+		} else {
+			v = int32(c.offsetshift(p, int64(v), int(o.a4)))
+			o1 = c.olsr12u(p, int32(c.opstr12(p, p.As)), v, r, int(p.From.Reg))
+		}
+
+	case 21: /* movT O(R),R -> ldrT */
+		v := int32(c.regoff(&p.From))
+		sz := int32(1 << uint(movesize(p.As)))
+
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		if v < 0 || v%sz != 0 { /* unscaled 9-bit signed */
+			o1 = c.olsr9s(p, int32(c.opldr9(p, p.As)), v, r, int(p.To.Reg))
+		} else {
+			v = int32(c.offsetshift(p, int64(v), int(o.a1)))
+			//print("offset=%lld v=%ld a1=%d\n", instoffset, v, o->a1);
+			o1 = c.olsr12u(p, int32(c.opldr12(p, p.As)), v, r, int(p.To.Reg))
+		}
+
+	case 22: /* movT (R)O!,R; movT O(R)!, R -> ldrT */
+		if p.From.Reg != REGSP && p.From.Reg == p.To.Reg {
+			c.ctxt.Diag("constrained unpredictable behavior: %v", p)
+		}
+
+		v := int32(p.From.Offset)
+
+		if v < -256 || v > 255 {
+			c.ctxt.Diag("offset out of range [-255,254]: %v", p)
+		}
+		o1 = c.opldrpp(p, p.As)
+		if o.scond == C_XPOST {
+			o1 |= 1 << 10
+		} else {
+			o1 |= 3 << 10
+		}
+		o1 |= ((uint32(v) & 0x1FF) << 12) | (uint32(p.From.Reg&31) << 5) | uint32(p.To.Reg&31)
+
+	case 23: /* movT R,(R)O!; movT O(R)!, R -> strT */
+		if p.To.Reg != REGSP && p.From.Reg == p.To.Reg {
+			c.ctxt.Diag("constrained unpredictable behavior: %v", p)
+		}
+
+		v := int32(p.To.Offset)
+
+		if v < -256 || v > 255 {
+			c.ctxt.Diag("offset out of range [-255,254]: %v", p)
+		}
+		o1 = LD2STR(c.opldrpp(p, p.As))
+		if o.scond == C_XPOST {
+			o1 |= 1 << 10
+		} else {
+			o1 |= 3 << 10
+		}
+		o1 |= ((uint32(v) & 0x1FF) << 12) | (uint32(p.To.Reg&31) << 5) | uint32(p.From.Reg&31)
+
+	case 24: /* mov/mvn Rs,Rd -> add $0,Rs,Rd or orr Rs,ZR,Rd */
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		s := rf == REGSP || rt == REGSP
+		if p.As == AMVN || p.As == AMVNW {
+			if s {
+				c.ctxt.Diag("illegal SP reference\n%v", p)
+			}
+			o1 = c.oprrr(p, p.As)
+			o1 |= (uint32(rf&31) << 16) | (REGZERO & 31 << 5) | uint32(rt&31)
+		} else if s {
+			o1 = c.opirr(p, p.As)
+			o1 |= (uint32(rf&31) << 5) | uint32(rt&31)
+		} else {
+			o1 = c.oprrr(p, p.As)
+			o1 |= (uint32(rf&31) << 16) | (REGZERO & 31 << 5) | uint32(rt&31)
+		}
+
+	case 25: /* negX Rs, Rd -> subX Rs<<0, ZR, Rd */
+		o1 = c.oprrr(p, p.As)
+
+		rf := int(p.From.Reg)
+		if rf == C_NONE {
+			rf = int(p.To.Reg)
+		}
+		rt := int(p.To.Reg)
+		o1 |= (uint32(rf&31) << 16) | (REGZERO & 31 << 5) | uint32(rt&31)
+
+	case 26: /* negX Rm<<s, Rd -> subX Rm<<s, ZR, Rd */
+		o1 = c.oprrr(p, p.As)
+
+		o1 |= uint32(p.From.Offset) /* includes reg, op, etc */
+		rt := int(p.To.Reg)
+		o1 |= (REGZERO & 31 << 5) | uint32(rt&31)
+
+	case 27: /* op Rm<<n[,Rn],Rd (extended register) */
+		if (p.From.Reg-obj.RBaseARM64)&REG_EXT != 0 {
+			amount := (p.From.Reg >> 5) & 7
+			if amount > 4 {
+				c.ctxt.Diag("shift amount out of range 0 to 4: %v", p)
+			}
+			o1 = c.opxrrr(p, p.As, true)
+			o1 |= c.encRegShiftOrExt(&p.From, p.From.Reg) /* includes reg, op, etc */
+		} else {
+			o1 = c.opxrrr(p, p.As, false)
+			o1 |= uint32(p.From.Reg&31) << 16
+		}
+		rt := int(p.To.Reg)
+		if p.To.Type == obj.TYPE_NONE {
+			rt = REGZERO
+		}
+		r := int(p.Reg)
+		if r == 0 {
+			r = rt
+		}
+		o1 |= (uint32(r&31) << 5) | uint32(rt&31)
+
+	case 28: /* logop $vcon, [R], R (64 bit literal) */
+		o := uint32(0)
+		num := uint8(0)
+		cls := oclass(&p.From)
+		if isANDWop(p.As) {
+			if !cmp(C_LCON, cls) {
+				c.ctxt.Diag("illegal combination: %v", p)
+			}
+			num = c.omovlconst(AMOVW, p, &p.From, REGTMP, os[:])
+		} else {
+			num = c.omovlconst(AMOVD, p, &p.From, REGTMP, os[:])
+		}
+
+		if num == 0 {
+			c.ctxt.Diag("invalid constant: %v", p)
+		}
+		rt := int(p.To.Reg)
+		if p.To.Type == obj.TYPE_NONE {
+			rt = REGZERO
+		}
+		r := int(p.Reg)
+		if r == 0 {
+			r = rt
+		}
+		o = c.oprrr(p, p.As)
+		o |= REGTMP & 31 << 16 /* shift is 0 */
+		o |= uint32(r&31) << 5
+		o |= uint32(rt & 31)
+
+		os[num] = o
+		o1 = os[0]
+		o2 = os[1]
+		o3 = os[2]
+		o4 = os[3]
+		o5 = os[4]
+
+	case 29: /* op Rn, Rd */
+		fc := c.aclass(&p.From)
+		tc := c.aclass(&p.To)
+		if (p.As == AFMOVD || p.As == AFMOVS) && (fc == C_REG || fc == C_ZCON || tc == C_REG || tc == C_ZCON) {
+			// FMOV Rx, Fy or FMOV Fy, Rx
+			o1 = FPCVTI(0, 0, 0, 0, 6)
+			if p.As == AFMOVD {
+				o1 |= 1<<31 | 1<<22 // 64-bit
+			}
+			if fc == C_REG || fc == C_ZCON {
+				o1 |= 1 << 16 // FMOV Rx, Fy
+			}
+		} else {
+			o1 = c.oprrr(p, p.As)
+		}
+		o1 |= uint32(p.From.Reg&31)<<5 | uint32(p.To.Reg&31)
+
+	case 30: /* movT R,L(R) -> strT */
+		// if offset L can be split into hi+lo, and both fit into instructions, do
+		//	add $hi, R, Rtmp
+		//	str R, lo(Rtmp)
+		// otherwise, use constant pool
+		//	mov $L, Rtmp (from constant pool)
+		//	str R, (R+Rtmp)
+		s := movesize(o.as)
+		if s < 0 {
+			c.ctxt.Diag("unexpected long move, op %v tab %v\n%v", p.As, o.as, p)
+		}
+
+		r := int(p.To.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+
+		v := int32(c.regoff(&p.To))
+		var hi int32
+		if v < 0 || (v&((1<<uint(s))-1)) != 0 {
+			// negative or unaligned offset, use constant pool
+			goto storeusepool
+		}
+
+		hi = v - (v & (0xFFF << uint(s)))
+		if hi&0xFFF != 0 {
+			c.ctxt.Diag("internal: miscalculated offset %d [%d]\n%v", v, s, p)
+		}
+		if hi&^0xFFF000 != 0 {
+			// hi doesn't fit into an ADD instruction
+			goto storeusepool
+		}
+
+		o1 = c.oaddi(p, int32(c.opirr(p, AADD)), hi, r, REGTMP)
+		o2 = c.olsr12u(p, int32(c.opstr12(p, p.As)), ((v-hi)>>uint(s))&0xFFF, REGTMP, int(p.From.Reg))
+		break
+
+	storeusepool:
+		if r == REGTMP || p.From.Reg == REGTMP {
+			c.ctxt.Diag("REGTMP used in large offset store: %v", p)
+		}
+		o1 = c.omovlit(AMOVD, p, &p.To, REGTMP)
+		o2 = c.olsxrr(p, int32(c.opstrr(p, p.As, false)), int(p.From.Reg), r, REGTMP)
+
+	case 31: /* movT L(R), R -> ldrT */
+		// if offset L can be split into hi+lo, and both fit into instructions, do
+		//	add $hi, R, Rtmp
+		//	ldr lo(Rtmp), R
+		// otherwise, use constant pool
+		//	mov $L, Rtmp (from constant pool)
+		//	ldr (R+Rtmp), R
+		s := movesize(o.as)
+		if s < 0 {
+			c.ctxt.Diag("unexpected long move, op %v tab %v\n%v", p.As, o.as, p)
+		}
+
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+
+		v := int32(c.regoff(&p.From))
+		var hi int32
+		if v < 0 || (v&((1<<uint(s))-1)) != 0 {
+			// negative or unaligned offset, use constant pool
+			goto loadusepool
+		}
+
+		hi = v - (v & (0xFFF << uint(s)))
+		if (hi & 0xFFF) != 0 {
+			c.ctxt.Diag("internal: miscalculated offset %d [%d]\n%v", v, s, p)
+		}
+		if hi&^0xFFF000 != 0 {
+			// hi doesn't fit into an ADD instruction
+			goto loadusepool
+		}
+
+		o1 = c.oaddi(p, int32(c.opirr(p, AADD)), hi, r, REGTMP)
+		o2 = c.olsr12u(p, int32(c.opldr12(p, p.As)), ((v-hi)>>uint(s))&0xFFF, REGTMP, int(p.To.Reg))
+		break
+
+	loadusepool:
+		if r == REGTMP || p.From.Reg == REGTMP {
+			c.ctxt.Diag("REGTMP used in large offset load: %v", p)
+		}
+		o1 = c.omovlit(AMOVD, p, &p.From, REGTMP)
+		o2 = c.olsxrr(p, int32(c.opldrr(p, p.As, false)), int(p.To.Reg), r, REGTMP)
+
+	case 32: /* mov $con, R -> movz/movn */
+		o1 = c.omovconst(p.As, p, &p.From, int(p.To.Reg))
+
+	case 33: /* movk $uimm16 << pos */
+		o1 = c.opirr(p, p.As)
+
+		d := p.From.Offset
+		s := movcon(d)
+		if s < 0 || s >= 4 {
+			c.ctxt.Diag("bad constant for MOVK: %#x\n%v", uint64(d), p)
+		}
+		if (o1&S64) == 0 && s >= 2 {
+			c.ctxt.Diag("illegal bit position\n%v", p)
+		}
+		if ((d >> uint(s*16)) >> 16) != 0 {
+			c.ctxt.Diag("requires uimm16\n%v", p)
+		}
+		rt := int(p.To.Reg)
+
+		o1 |= uint32((((d >> uint(s*16)) & 0xFFFF) << 5) | int64((uint32(s)&3)<<21) | int64(rt&31))
+
+	case 34: /* mov $lacon,R */
+		o1 = c.omovlit(AMOVD, p, &p.From, REGTMP)
+
+		if o1 == 0 {
+			break
+		}
+		o2 = c.opxrrr(p, AADD, false)
+		o2 |= REGTMP & 31 << 16
+		o2 |= LSL0_64
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o2 |= uint32(r&31) << 5
+		o2 |= uint32(p.To.Reg & 31)
+
+	case 35: /* mov SPR,R -> mrs */
+		o1 = c.oprrr(p, AMRS)
+
+		// SysRegEnc function returns the system register encoding and accessFlags.
+		_, v, accessFlags := SysRegEnc(p.From.Reg)
+		if v == 0 {
+			c.ctxt.Diag("illegal system register:\n%v", p)
+		}
+		if (o1 & (v &^ (3 << 19))) != 0 {
+			c.ctxt.Diag("MRS register value overlap\n%v", p)
+		}
+		if accessFlags&SR_READ == 0 {
+			c.ctxt.Diag("system register is not readable: %v", p)
+		}
+
+		o1 |= v
+		o1 |= uint32(p.To.Reg & 31)
+
+	case 36: /* mov R,SPR */
+		o1 = c.oprrr(p, AMSR)
+
+		// SysRegEnc function returns the system register encoding and accessFlags.
+		_, v, accessFlags := SysRegEnc(p.To.Reg)
+		if v == 0 {
+			c.ctxt.Diag("illegal system register:\n%v", p)
+		}
+		if (o1 & (v &^ (3 << 19))) != 0 {
+			c.ctxt.Diag("MSR register value overlap\n%v", p)
+		}
+		if accessFlags&SR_WRITE == 0 {
+			c.ctxt.Diag("system register is not writable: %v", p)
+		}
+
+		o1 |= v
+		o1 |= uint32(p.From.Reg & 31)
+
+	case 37: /* mov $con,PSTATEfield -> MSR [immediate] */
+		if (uint64(p.From.Offset) &^ uint64(0xF)) != 0 {
+			c.ctxt.Diag("illegal immediate for PSTATE field\n%v", p)
+		}
+		o1 = c.opirr(p, AMSR)
+		o1 |= uint32((p.From.Offset & 0xF) << 8) /* Crm */
+		v := uint32(0)
+		for i := 0; i < len(pstatefield); i++ {
+			if pstatefield[i].reg == p.To.Reg {
+				v = pstatefield[i].enc
+				break
+			}
+		}
+
+		if v == 0 {
+			c.ctxt.Diag("illegal PSTATE field for immediate move\n%v", p)
+		}
+		o1 |= v
+
+	case 38: /* clrex [$imm] */
+		o1 = c.opimm(p, p.As)
+
+		if p.To.Type == obj.TYPE_NONE {
+			o1 |= 0xF << 8
+		} else {
+			o1 |= uint32((p.To.Offset & 0xF) << 8)
+		}
+
+	case 39: /* cbz R, rel */
+		o1 = c.opirr(p, p.As)
+
+		o1 |= uint32(p.From.Reg & 31)
+		o1 |= uint32(c.brdist(p, 0, 19, 2) << 5)
+
+	case 40: /* tbz */
+		o1 = c.opirr(p, p.As)
+
+		v := int32(p.From.Offset)
+		if v < 0 || v > 63 {
+			c.ctxt.Diag("illegal bit number\n%v", p)
+		}
+		o1 |= ((uint32(v) & 0x20) << (31 - 5)) | ((uint32(v) & 0x1F) << 19)
+		o1 |= uint32(c.brdist(p, 0, 14, 2) << 5)
+		o1 |= uint32(p.Reg & 31)
+
+	case 41: /* eret, nop, others with no operands */
+		o1 = c.op0(p, p.As)
+
+	case 42: /* bfm R,r,s,R */
+		o1 = c.opbfm(p, p.As, int(p.From.Offset), int(p.GetFrom3().Offset), int(p.Reg), int(p.To.Reg))
+
+	case 43: /* bfm aliases */
+		r := int(p.From.Offset)
+		s := int(p.GetFrom3().Offset)
+		rf := int(p.Reg)
+		rt := int(p.To.Reg)
+		if rf == 0 {
+			rf = rt
+		}
+		switch p.As {
+		case ABFI:
+			if r != 0 {
+				r = 64 - r
+			}
+			o1 = c.opbfm(p, ABFM, r, s-1, rf, rt)
+
+		case ABFIW:
+			if r != 0 {
+				r = 32 - r
+			}
+			o1 = c.opbfm(p, ABFMW, r, s-1, rf, rt)
+
+		case ABFXIL:
+			o1 = c.opbfm(p, ABFM, r, r+s-1, rf, rt)
+
+		case ABFXILW:
+			o1 = c.opbfm(p, ABFMW, r, r+s-1, rf, rt)
+
+		case ASBFIZ:
+			if r != 0 {
+				r = 64 - r
+			}
+			o1 = c.opbfm(p, ASBFM, r, s-1, rf, rt)
+
+		case ASBFIZW:
+			if r != 0 {
+				r = 32 - r
+			}
+			o1 = c.opbfm(p, ASBFMW, r, s-1, rf, rt)
+
+		case ASBFX:
+			o1 = c.opbfm(p, ASBFM, r, r+s-1, rf, rt)
+
+		case ASBFXW:
+			o1 = c.opbfm(p, ASBFMW, r, r+s-1, rf, rt)
+
+		case AUBFIZ:
+			if r != 0 {
+				r = 64 - r
+			}
+			o1 = c.opbfm(p, AUBFM, r, s-1, rf, rt)
+
+		case AUBFIZW:
+			if r != 0 {
+				r = 32 - r
+			}
+			o1 = c.opbfm(p, AUBFMW, r, s-1, rf, rt)
+
+		case AUBFX:
+			o1 = c.opbfm(p, AUBFM, r, r+s-1, rf, rt)
+
+		case AUBFXW:
+			o1 = c.opbfm(p, AUBFMW, r, r+s-1, rf, rt)
+
+		default:
+			c.ctxt.Diag("bad bfm alias\n%v", p)
+			break
+		}
+
+	case 44: /* extr $b, Rn, Rm, Rd */
+		o1 = c.opextr(p, p.As, int32(p.From.Offset), int(p.GetFrom3().Reg), int(p.Reg), int(p.To.Reg))
+
+	case 45: /* sxt/uxt[bhw] R,R; movT R,R -> sxtT R,R */
+		rf := int(p.From.Reg)
+
+		rt := int(p.To.Reg)
+		as := p.As
+		if rf == REGZERO {
+			as = AMOVWU /* clearer in disassembly */
+		}
+		switch as {
+		case AMOVB, ASXTB:
+			o1 = c.opbfm(p, ASBFM, 0, 7, rf, rt)
+
+		case AMOVH, ASXTH:
+			o1 = c.opbfm(p, ASBFM, 0, 15, rf, rt)
+
+		case AMOVW, ASXTW:
+			o1 = c.opbfm(p, ASBFM, 0, 31, rf, rt)
+
+		case AMOVBU, AUXTB:
+			o1 = c.opbfm(p, AUBFM, 0, 7, rf, rt)
+
+		case AMOVHU, AUXTH:
+			o1 = c.opbfm(p, AUBFM, 0, 15, rf, rt)
+
+		case AMOVWU:
+			o1 = c.oprrr(p, as) | (uint32(rf&31) << 16) | (REGZERO & 31 << 5) | uint32(rt&31)
+
+		case AUXTW:
+			o1 = c.opbfm(p, AUBFM, 0, 31, rf, rt)
+
+		case ASXTBW:
+			o1 = c.opbfm(p, ASBFMW, 0, 7, rf, rt)
+
+		case ASXTHW:
+			o1 = c.opbfm(p, ASBFMW, 0, 15, rf, rt)
+
+		case AUXTBW:
+			o1 = c.opbfm(p, AUBFMW, 0, 7, rf, rt)
+
+		case AUXTHW:
+			o1 = c.opbfm(p, AUBFMW, 0, 15, rf, rt)
+
+		default:
+			c.ctxt.Diag("bad sxt %v", as)
+			break
+		}
+
+	case 46: /* cls */
+		o1 = c.opbit(p, p.As)
+
+		o1 |= uint32(p.From.Reg&31) << 5
+		o1 |= uint32(p.To.Reg & 31)
+
+	case 47: /* SWPx/LDADDx/LDANDx/LDEORx/LDORx Rs, (Rb), Rt */
+		rs := p.From.Reg
+		rt := p.RegTo2
+		rb := p.To.Reg
+
+		fields := atomicInstructions[p.As]
+		// rt can't be sp. rt can't be r31 when field A is 0, A bit is the 23rd bit.
+		if rt == REG_RSP || (rt == REGZERO && (fields&(1<<23) == 0)) {
+			c.ctxt.Diag("illegal destination register: %v\n", p)
+		}
+		o1 |= fields | uint32(rs&31)<<16 | uint32(rb&31)<<5 | uint32(rt&31)
+
+	case 48: /* ADD $C_ADDCON2, Rm, Rd */
+		// NOTE: this case does not use REGTMP. If it ever does,
+		// remove the NOTUSETMP flag in optab.
+		op := c.opirr(p, p.As)
+		if op&Sbit != 0 {
+			c.ctxt.Diag("can not break addition/subtraction when S bit is set", p)
+		}
+		rt := int(p.To.Reg)
+		r := int(p.Reg)
+		if r == 0 {
+			r = rt
+		}
+		o1 = c.oaddi(p, int32(op), int32(c.regoff(&p.From))&0x000fff, r, rt)
+		o2 = c.oaddi(p, int32(op), int32(c.regoff(&p.From))&0xfff000, rt, rt)
+
+	case 50: /* sys/sysl */
+		o1 = c.opirr(p, p.As)
+
+		if (p.From.Offset &^ int64(SYSARG4(0x7, 0xF, 0xF, 0x7))) != 0 {
+			c.ctxt.Diag("illegal SYS argument\n%v", p)
+		}
+		o1 |= uint32(p.From.Offset)
+		if p.To.Type == obj.TYPE_REG {
+			o1 |= uint32(p.To.Reg & 31)
+		} else if p.Reg != 0 {
+			o1 |= uint32(p.Reg & 31)
+		} else {
+			o1 |= 0x1F
+		}
+
+	case 51: /* dmb */
+		o1 = c.opirr(p, p.As)
+
+		if p.From.Type == obj.TYPE_CONST {
+			o1 |= uint32((p.From.Offset & 0xF) << 8)
+		}
+
+	case 52: /* hint */
+		o1 = c.opirr(p, p.As)
+
+		o1 |= uint32((p.From.Offset & 0x7F) << 5)
+
+	case 53: /* and/or/eor/bic/tst/... $bitcon, Rn, Rd */
+		a := p.As
+		rt := int(p.To.Reg)
+		if p.To.Type == obj.TYPE_NONE {
+			rt = REGZERO
+		}
+		r := int(p.Reg)
+		if r == 0 {
+			r = rt
+		}
+		mode := 64
+		v := uint64(p.From.Offset)
+		switch p.As {
+		case AANDW, AORRW, AEORW, AANDSW, ATSTW:
+			mode = 32
+		case ABIC, AORN, AEON, ABICS:
+			v = ^v
+		case ABICW, AORNW, AEONW, ABICSW:
+			v = ^v
+			mode = 32
+		}
+		o1 = c.opirr(p, a)
+		o1 |= bitconEncode(v, mode) | uint32(r&31)<<5 | uint32(rt&31)
+
+	case 54: /* floating point arith */
+		o1 = c.oprrr(p, p.As)
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		r := int(p.Reg)
+		if (o1&(0x1F<<24)) == (0x1E<<24) && (o1&(1<<11)) == 0 { /* monadic */
+			r = rf
+			rf = 0
+		} else if r == 0 {
+			r = rt
+		}
+		o1 |= (uint32(rf&31) << 16) | (uint32(r&31) << 5) | uint32(rt&31)
+
+	case 55: /* floating-point constant */
+		var rf int
+		o1 = 0xf<<25 | 1<<21 | 1<<12
+		rf = c.chipfloat7(p.From.Val.(float64))
+		if rf < 0 {
+			c.ctxt.Diag("invalid floating-point immediate\n%v", p)
+		}
+		if p.As == AFMOVD {
+			o1 |= 1 << 22
+		}
+		o1 |= (uint32(rf&0xff) << 13) | uint32(p.To.Reg&31)
+
+	case 56: /* floating point compare */
+		o1 = c.oprrr(p, p.As)
+
+		var rf int
+		if p.From.Type == obj.TYPE_FCONST {
+			o1 |= 8 /* zero */
+			rf = 0
+		} else {
+			rf = int(p.From.Reg)
+		}
+		rt := int(p.Reg)
+		o1 |= uint32(rf&31)<<16 | uint32(rt&31)<<5
+
+	case 57: /* floating point conditional compare */
+		o1 = c.oprrr(p, p.As)
+
+		cond := int(p.From.Reg)
+		if cond < COND_EQ || cond > COND_NV {
+			c.ctxt.Diag("invalid condition\n%v", p)
+		} else {
+			cond -= COND_EQ
+		}
+
+		nzcv := int(p.To.Offset)
+		if nzcv&^0xF != 0 {
+			c.ctxt.Diag("implausible condition\n%v", p)
+		}
+		rf := int(p.Reg)
+		if p.GetFrom3() == nil || p.GetFrom3().Reg < REG_F0 || p.GetFrom3().Reg > REG_F31 {
+			c.ctxt.Diag("illegal FCCMP\n%v", p)
+			break
+		}
+		rt := int(p.GetFrom3().Reg)
+		o1 |= uint32(rf&31)<<16 | uint32(cond&15)<<12 | uint32(rt&31)<<5 | uint32(nzcv)
+
+	case 58: /* ldar/ldarb/ldarh/ldaxp/ldxp/ldaxr/ldxr */
+		o1 = c.opload(p, p.As)
+
+		o1 |= 0x1F << 16
+		o1 |= uint32(p.From.Reg&31) << 5
+		if p.As == ALDXP || p.As == ALDXPW || p.As == ALDAXP || p.As == ALDAXPW {
+			if int(p.To.Reg) == int(p.To.Offset) {
+				c.ctxt.Diag("constrained unpredictable behavior: %v", p)
+			}
+			o1 |= uint32(p.To.Offset&31) << 10
+		} else {
+			o1 |= 0x1F << 10
+		}
+		o1 |= uint32(p.To.Reg & 31)
+
+	case 59: /* stxr/stlxr/stxp/stlxp */
+		s := p.RegTo2
+		n := p.To.Reg
+		t := p.From.Reg
+		if isSTLXRop(p.As) {
+			if s == t || (s == n && n != REGSP) {
+				c.ctxt.Diag("constrained unpredictable behavior: %v", p)
+			}
+		} else if isSTXPop(p.As) {
+			t2 := int16(p.From.Offset)
+			if (s == t || s == t2) || (s == n && n != REGSP) {
+				c.ctxt.Diag("constrained unpredictable behavior: %v", p)
+			}
+		}
+		if s == REG_RSP {
+			c.ctxt.Diag("illegal destination register: %v\n", p)
+		}
+		o1 = c.opstore(p, p.As)
+
+		if p.RegTo2 != obj.REG_NONE {
+			o1 |= uint32(p.RegTo2&31) << 16
+		} else {
+			o1 |= 0x1F << 16
+		}
+		if isSTXPop(p.As) {
+			o1 |= uint32(p.From.Offset&31) << 10
+		}
+		o1 |= uint32(p.To.Reg&31)<<5 | uint32(p.From.Reg&31)
+
+	case 60: /* adrp label,r */
+		d := c.brdist(p, 12, 21, 0)
+
+		o1 = ADR(1, uint32(d), uint32(p.To.Reg))
+
+	case 61: /* adr label, r */
+		d := c.brdist(p, 0, 21, 0)
+
+		o1 = ADR(0, uint32(d), uint32(p.To.Reg))
+
+	case 62: /* op $movcon, [R], R -> mov $movcon, REGTMP + op REGTMP, [R], R */
+		if p.Reg == REGTMP {
+			c.ctxt.Diag("cannot use REGTMP as source: %v\n", p)
+		}
+		if isADDWop(p.As) || isANDWop(p.As) {
+			o1 = c.omovconst(AMOVW, p, &p.From, REGTMP)
+		} else {
+			o1 = c.omovconst(AMOVD, p, &p.From, REGTMP)
+		}
+
+		rt := int(p.To.Reg)
+		if p.To.Type == obj.TYPE_NONE {
+			rt = REGZERO
+		}
+		r := int(p.Reg)
+		if r == 0 {
+			r = rt
+		}
+		if p.To.Reg == REGSP || r == REGSP {
+			o2 = c.opxrrr(p, p.As, false)
+			o2 |= REGTMP & 31 << 16
+			o2 |= LSL0_64
+		} else {
+			o2 = c.oprrr(p, p.As)
+			o2 |= REGTMP & 31 << 16 /* shift is 0 */
+		}
+		o2 |= uint32(r&31) << 5
+		o2 |= uint32(rt & 31)
+
+		/* reloc ops */
+	case 64: /* movT R,addr -> adrp + add + movT R, (REGTMP) */
+		o1 = ADR(1, 0, REGTMP)
+		o2 = c.opirr(p, AADD) | REGTMP&31<<5 | REGTMP&31
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 8
+		rel.Sym = p.To.Sym
+		rel.Add = p.To.Offset
+		rel.Type = objabi.R_ADDRARM64
+		o3 = c.olsr12u(p, int32(c.opstr12(p, p.As)), 0, REGTMP, int(p.From.Reg))
+
+	case 65: /* movT addr,R -> adrp + add + movT (REGTMP), R */
+		o1 = ADR(1, 0, REGTMP)
+		o2 = c.opirr(p, AADD) | REGTMP&31<<5 | REGTMP&31
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 8
+		rel.Sym = p.From.Sym
+		rel.Add = p.From.Offset
+		rel.Type = objabi.R_ADDRARM64
+		o3 = c.olsr12u(p, int32(c.opldr12(p, p.As)), 0, REGTMP, int(p.To.Reg))
+
+	case 66: /* ldp O(R)!, (r1, r2); ldp (R)O!, (r1, r2) */
+		v := int32(c.regoff(&p.From))
+		r := int(p.From.Reg)
+		if r == obj.REG_NONE {
+			r = int(o.param)
+		}
+		if r == obj.REG_NONE {
+			c.ctxt.Diag("invalid ldp source: %v\n", p)
+		}
+		o1 |= c.opldpstp(p, o, v, uint32(r), uint32(p.To.Reg), uint32(p.To.Offset), 1)
+
+	case 67: /* stp (r1, r2), O(R)!; stp (r1, r2), (R)O! */
+		r := int(p.To.Reg)
+		if r == obj.REG_NONE {
+			r = int(o.param)
+		}
+		if r == obj.REG_NONE {
+			c.ctxt.Diag("invalid stp destination: %v\n", p)
+		}
+		v := int32(c.regoff(&p.To))
+		o1 = c.opldpstp(p, o, v, uint32(r), uint32(p.From.Reg), uint32(p.From.Offset), 0)
+
+	case 68: /* movT $vconaddr(SB), reg -> adrp + add + reloc */
+		// NOTE: this case does not use REGTMP. If it ever does,
+		// remove the NOTUSETMP flag in optab.
+		if p.As == AMOVW {
+			c.ctxt.Diag("invalid load of 32-bit address: %v", p)
+		}
+		o1 = ADR(1, 0, uint32(p.To.Reg))
+		o2 = c.opirr(p, AADD) | uint32(p.To.Reg&31)<<5 | uint32(p.To.Reg&31)
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 8
+		rel.Sym = p.From.Sym
+		rel.Add = p.From.Offset
+		rel.Type = objabi.R_ADDRARM64
+
+	case 69: /* LE model movd $tlsvar, reg -> movz reg, 0 + reloc */
+		o1 = c.opirr(p, AMOVZ)
+		o1 |= uint32(p.To.Reg & 31)
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 4
+		rel.Sym = p.From.Sym
+		rel.Type = objabi.R_ARM64_TLS_LE
+		if p.From.Offset != 0 {
+			c.ctxt.Diag("invalid offset on MOVW $tlsvar")
+		}
+
+	case 70: /* IE model movd $tlsvar, reg -> adrp REGTMP, 0; ldr reg, [REGTMP, #0] + relocs */
+		o1 = ADR(1, 0, REGTMP)
+		o2 = c.olsr12u(p, int32(c.opldr12(p, AMOVD)), 0, REGTMP, int(p.To.Reg))
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 8
+		rel.Sym = p.From.Sym
+		rel.Add = 0
+		rel.Type = objabi.R_ARM64_TLS_IE
+		if p.From.Offset != 0 {
+			c.ctxt.Diag("invalid offset on MOVW $tlsvar")
+		}
+
+	case 71: /* movd sym@GOT, reg -> adrp REGTMP, #0; ldr reg, [REGTMP, #0] + relocs */
+		o1 = ADR(1, 0, REGTMP)
+		o2 = c.olsr12u(p, int32(c.opldr12(p, AMOVD)), 0, REGTMP, int(p.To.Reg))
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 8
+		rel.Sym = p.From.Sym
+		rel.Add = 0
+		rel.Type = objabi.R_ARM64_GOTPCREL
+
+	case 72: /* vaddp/vand/vcmeq/vorr/vadd/veor/vfmla/vfmls/vbit/vbsl/vcmtst/vsub/vbif/vuzip1/vuzip2 Vm.<T>, Vn.<T>, Vd.<T> */
+		af := int((p.From.Reg >> 5) & 15)
+		af3 := int((p.Reg >> 5) & 15)
+		at := int((p.To.Reg >> 5) & 15)
+		if af != af3 || af != at {
+			c.ctxt.Diag("operand mismatch: %v", p)
+			break
+		}
+		o1 = c.oprrr(p, p.As)
+		rf := int((p.From.Reg) & 31)
+		rt := int((p.To.Reg) & 31)
+		r := int((p.Reg) & 31)
+
+		Q := 0
+		size := 0
+		switch af {
+		case ARNG_16B:
+			Q = 1
+			size = 0
+		case ARNG_2D:
+			Q = 1
+			size = 3
+		case ARNG_2S:
+			Q = 0
+			size = 2
+		case ARNG_4H:
+			Q = 0
+			size = 1
+		case ARNG_4S:
+			Q = 1
+			size = 2
+		case ARNG_8B:
+			Q = 0
+			size = 0
+		case ARNG_8H:
+			Q = 1
+			size = 1
+		default:
+			c.ctxt.Diag("invalid arrangement: %v", p)
+		}
+
+		switch p.As {
+		case AVORR, AVAND, AVEOR, AVBIT, AVBSL, AVBIF:
+			if af != ARNG_16B && af != ARNG_8B {
+				c.ctxt.Diag("invalid arrangement: %v", p)
+			}
+		case AVFMLA, AVFMLS:
+			if af != ARNG_2D && af != ARNG_2S && af != ARNG_4S {
+				c.ctxt.Diag("invalid arrangement: %v", p)
+			}
+		}
+		switch p.As {
+		case AVAND, AVEOR:
+			size = 0
+		case AVBSL:
+			size = 1
+		case AVORR, AVBIT, AVBIF:
+			size = 2
+		case AVFMLA, AVFMLS:
+			if af == ARNG_2D {
+				size = 1
+			} else {
+				size = 0
+			}
+		}
+
+		o1 |= (uint32(Q&1) << 30) | (uint32(size&3) << 22) | (uint32(rf&31) << 16) | (uint32(r&31) << 5) | uint32(rt&31)
+
+	case 73: /* vmov V.<T>[index], R */
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		imm5 := 0
+		o1 = 7<<25 | 0xf<<10
+		index := int(p.From.Index)
+		switch (p.From.Reg >> 5) & 15 {
+		case ARNG_B:
+			c.checkindex(p, index, 15)
+			imm5 |= 1
+			imm5 |= index << 1
+		case ARNG_H:
+			c.checkindex(p, index, 7)
+			imm5 |= 2
+			imm5 |= index << 2
+		case ARNG_S:
+			c.checkindex(p, index, 3)
+			imm5 |= 4
+			imm5 |= index << 3
+		case ARNG_D:
+			c.checkindex(p, index, 1)
+			imm5 |= 8
+			imm5 |= index << 4
+			o1 |= 1 << 30
+		default:
+			c.ctxt.Diag("invalid arrangement: %v", p)
+		}
+		o1 |= (uint32(imm5&0x1f) << 16) | (uint32(rf&31) << 5) | uint32(rt&31)
+
+	case 74:
+		//	add $O, R, Rtmp or sub $O, R, Rtmp
+		//	ldp (Rtmp), (R1, R2)
+		r := int(p.From.Reg)
+		if r == obj.REG_NONE {
+			r = int(o.param)
+		}
+		if r == obj.REG_NONE {
+			c.ctxt.Diag("invalid ldp source: %v", p)
+		}
+		v := int32(c.regoff(&p.From))
+
+		if v > 0 {
+			if v > 4095 {
+				c.ctxt.Diag("offset out of range: %v", p)
+			}
+			o1 = c.oaddi(p, int32(c.opirr(p, AADD)), v, r, REGTMP)
+		}
+		if v < 0 {
+			if v < -4095 {
+				c.ctxt.Diag("offset out of range: %v", p)
+			}
+			o1 = c.oaddi(p, int32(c.opirr(p, ASUB)), -v, r, REGTMP)
+		}
+		o2 |= c.opldpstp(p, o, 0, uint32(REGTMP), uint32(p.To.Reg), uint32(p.To.Offset), 1)
+
+	case 75:
+		//	mov $L, Rtmp (from constant pool)
+		//	add Rtmp, R, Rtmp
+		//	ldp (Rtmp), (R1, R2)
+		r := int(p.From.Reg)
+		if r == obj.REG_NONE {
+			r = int(o.param)
+		}
+		if r == obj.REG_NONE {
+			c.ctxt.Diag("invalid ldp source: %v", p)
+		}
+		o1 = c.omovlit(AMOVD, p, &p.From, REGTMP)
+		o2 = c.opxrrr(p, AADD, false)
+		o2 |= (REGTMP & 31) << 16
+		o2 |= uint32(r&31) << 5
+		o2 |= uint32(REGTMP & 31)
+		o3 |= c.opldpstp(p, o, 0, uint32(REGTMP), uint32(p.To.Reg), uint32(p.To.Offset), 1)
+
+	case 76:
+		//	add $O, R, Rtmp or sub $O, R, Rtmp
+		//	stp (R1, R2), (Rtmp)
+		r := int(p.To.Reg)
+		if r == obj.REG_NONE {
+			r = int(o.param)
+		}
+		if r == obj.REG_NONE {
+			c.ctxt.Diag("invalid stp destination: %v", p)
+		}
+		v := int32(c.regoff(&p.To))
+		if v > 0 {
+			if v > 4095 {
+				c.ctxt.Diag("offset out of range: %v", p)
+			}
+			o1 = c.oaddi(p, int32(c.opirr(p, AADD)), v, r, REGTMP)
+		}
+		if v < 0 {
+			if v < -4095 {
+				c.ctxt.Diag("offset out of range: %v", p)
+			}
+			o1 = c.oaddi(p, int32(c.opirr(p, ASUB)), -v, r, REGTMP)
+		}
+		o2 |= c.opldpstp(p, o, 0, uint32(REGTMP), uint32(p.From.Reg), uint32(p.From.Offset), 0)
+
+	case 77:
+		//	mov $L, Rtmp (from constant pool)
+		//	add Rtmp, R, Rtmp
+		//	stp (R1, R2), (Rtmp)
+		r := int(p.To.Reg)
+		if r == obj.REG_NONE {
+			r = int(o.param)
+		}
+		if r == obj.REG_NONE {
+			c.ctxt.Diag("invalid stp destination: %v", p)
+		}
+		o1 = c.omovlit(AMOVD, p, &p.To, REGTMP)
+		o2 = c.opxrrr(p, AADD, false)
+		o2 |= REGTMP & 31 << 16
+		o2 |= uint32(r&31) << 5
+		o2 |= uint32(REGTMP & 31)
+		o3 |= c.opldpstp(p, o, 0, uint32(REGTMP), uint32(p.From.Reg), uint32(p.From.Offset), 0)
+
+	case 78: /* vmov R, V.<T>[index] */
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		imm5 := 0
+		o1 = 1<<30 | 7<<25 | 7<<10
+		index := int(p.To.Index)
+		switch (p.To.Reg >> 5) & 15 {
+		case ARNG_B:
+			c.checkindex(p, index, 15)
+			imm5 |= 1
+			imm5 |= index << 1
+		case ARNG_H:
+			c.checkindex(p, index, 7)
+			imm5 |= 2
+			imm5 |= index << 2
+		case ARNG_S:
+			c.checkindex(p, index, 3)
+			imm5 |= 4
+			imm5 |= index << 3
+		case ARNG_D:
+			c.checkindex(p, index, 1)
+			imm5 |= 8
+			imm5 |= index << 4
+		default:
+			c.ctxt.Diag("invalid arrangement: %v", p)
+		}
+		o1 |= (uint32(imm5&0x1f) << 16) | (uint32(rf&31) << 5) | uint32(rt&31)
+
+	case 79: /* vdup Vn.<T>[index], Vd.<T> */
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		o1 = 7<<25 | 1<<10
+		var imm5, Q int
+		index := int(p.From.Index)
+		switch (p.To.Reg >> 5) & 15 {
+		case ARNG_16B:
+			c.checkindex(p, index, 15)
+			Q = 1
+			imm5 = 1
+			imm5 |= index << 1
+		case ARNG_2D:
+			c.checkindex(p, index, 1)
+			Q = 1
+			imm5 = 8
+			imm5 |= index << 4
+		case ARNG_2S:
+			c.checkindex(p, index, 3)
+			Q = 0
+			imm5 = 4
+			imm5 |= index << 3
+		case ARNG_4H:
+			c.checkindex(p, index, 7)
+			Q = 0
+			imm5 = 2
+			imm5 |= index << 2
+		case ARNG_4S:
+			c.checkindex(p, index, 3)
+			Q = 1
+			imm5 = 4
+			imm5 |= index << 3
+		case ARNG_8B:
+			c.checkindex(p, index, 15)
+			Q = 0
+			imm5 = 1
+			imm5 |= index << 1
+		case ARNG_8H:
+			c.checkindex(p, index, 7)
+			Q = 1
+			imm5 = 2
+			imm5 |= index << 2
+		default:
+			c.ctxt.Diag("invalid arrangement: %v", p)
+		}
+		o1 |= (uint32(Q&1) << 30) | (uint32(imm5&0x1f) << 16)
+		o1 |= (uint32(rf&31) << 5) | uint32(rt&31)
+
+	case 80: /* vmov V.<T>[index], Vn */
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		imm5 := 0
+		index := int(p.From.Index)
+		switch p.As {
+		case AVMOV:
+			o1 = 1<<30 | 15<<25 | 1<<10
+			switch (p.From.Reg >> 5) & 15 {
+			case ARNG_B:
+				c.checkindex(p, index, 15)
+				imm5 |= 1
+				imm5 |= index << 1
+			case ARNG_H:
+				c.checkindex(p, index, 7)
+				imm5 |= 2
+				imm5 |= index << 2
+			case ARNG_S:
+				c.checkindex(p, index, 3)
+				imm5 |= 4
+				imm5 |= index << 3
+			case ARNG_D:
+				c.checkindex(p, index, 1)
+				imm5 |= 8
+				imm5 |= index << 4
+			default:
+				c.ctxt.Diag("invalid arrangement: %v", p)
+			}
+		default:
+			c.ctxt.Diag("unsupported op %v", p.As)
+		}
+		o1 |= (uint32(imm5&0x1f) << 16) | (uint32(rf&31) << 5) | uint32(rt&31)
+
+	case 81: /* vld[1-4]|vld[1-4]r (Rn), [Vt1.<T>, Vt2.<T>, ...] */
+		c.checkoffset(p, p.As)
+		r := int(p.From.Reg)
+		o1 = c.oprrr(p, p.As)
+		if o.scond == C_XPOST {
+			o1 |= 1 << 23
+			if p.From.Index == 0 {
+				// immediate offset variant
+				o1 |= 0x1f << 16
+			} else {
+				// register offset variant
+				if isRegShiftOrExt(&p.From) {
+					c.ctxt.Diag("invalid extended register op: %v\n", p)
+				}
+				o1 |= uint32(p.From.Index&0x1f) << 16
+			}
+		}
+		o1 |= uint32(p.To.Offset)
+		// cmd/asm/internal/arch/arm64.go:ARM64RegisterListOffset
+		// add opcode(bit 12-15) for vld1, mask it off if it's not vld1
+		o1 = c.maskOpvldvst(p, o1)
+		o1 |= uint32(r&31) << 5
+
+	case 82: /* vmov Rn, Vd.<T> */
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		o1 = 7<<25 | 3<<10
+		var imm5, Q uint32
+		switch (p.To.Reg >> 5) & 15 {
+		case ARNG_16B:
+			Q = 1
+			imm5 = 1
+		case ARNG_2D:
+			Q = 1
+			imm5 = 8
+		case ARNG_2S:
+			Q = 0
+			imm5 = 4
+		case ARNG_4H:
+			Q = 0
+			imm5 = 2
+		case ARNG_4S:
+			Q = 1
+			imm5 = 4
+		case ARNG_8B:
+			Q = 0
+			imm5 = 1
+		case ARNG_8H:
+			Q = 1
+			imm5 = 2
+		default:
+			c.ctxt.Diag("invalid arrangement on VMOV Rn, Vd.<T>: %v\n", p)
+		}
+		o1 |= (Q & 1 << 30) | (imm5 & 0x1f << 16)
+		o1 |= (uint32(rf&31) << 5) | uint32(rt&31)
+
+	case 83: /* vmov Vn.<T>, Vd.<T> */
+		af := int((p.From.Reg >> 5) & 15)
+		at := int((p.To.Reg >> 5) & 15)
+		if af != at {
+			c.ctxt.Diag("invalid arrangement: %v\n", p)
+		}
+		o1 = c.oprrr(p, p.As)
+		rf := int((p.From.Reg) & 31)
+		rt := int((p.To.Reg) & 31)
+
+		var Q, size uint32
+		switch af {
+		case ARNG_8B:
+			Q = 0
+			size = 0
+		case ARNG_16B:
+			Q = 1
+			size = 0
+		case ARNG_4H:
+			Q = 0
+			size = 1
+		case ARNG_8H:
+			Q = 1
+			size = 1
+		case ARNG_2S:
+			Q = 0
+			size = 2
+		case ARNG_4S:
+			Q = 1
+			size = 2
+		default:
+			c.ctxt.Diag("invalid arrangement: %v\n", p)
+		}
+
+		if (p.As == AVMOV || p.As == AVRBIT || p.As == AVCNT) && (af != ARNG_16B && af != ARNG_8B) {
+			c.ctxt.Diag("invalid arrangement: %v", p)
+		}
+
+		if p.As == AVREV32 && (af == ARNG_2S || af == ARNG_4S) {
+			c.ctxt.Diag("invalid arrangement: %v", p)
+		}
+
+		if p.As == AVREV16 && af != ARNG_8B && af != ARNG_16B {
+			c.ctxt.Diag("invalid arrangement: %v", p)
+		}
+
+		if p.As == AVMOV {
+			o1 |= uint32(rf&31) << 16
+		}
+
+		if p.As == AVRBIT {
+			size = 1
+		}
+
+		o1 |= (Q&1)<<30 | (size&3)<<22 | uint32(rf&31)<<5 | uint32(rt&31)
+
+	case 84: /* vst[1-4] [Vt1.<T>, Vt2.<T>, ...], (Rn) */
+		c.checkoffset(p, p.As)
+		r := int(p.To.Reg)
+		o1 = 3 << 26
+		if o.scond == C_XPOST {
+			o1 |= 1 << 23
+			if p.To.Index == 0 {
+				// immediate offset variant
+				o1 |= 0x1f << 16
+			} else {
+				// register offset variant
+				if isRegShiftOrExt(&p.To) {
+					c.ctxt.Diag("invalid extended register: %v\n", p)
+				}
+				o1 |= uint32(p.To.Index&31) << 16
+			}
+		}
+		o1 |= uint32(p.From.Offset)
+		// cmd/asm/internal/arch/arm64.go:ARM64RegisterListOffset
+		// add opcode(bit 12-15) for vst1, mask it off if it's not vst1
+		o1 = c.maskOpvldvst(p, o1)
+		o1 |= uint32(r&31) << 5
+
+	case 85: /* vaddv/vuaddlv Vn.<T>, Vd*/
+		af := int((p.From.Reg >> 5) & 15)
+		o1 = c.oprrr(p, p.As)
+		rf := int((p.From.Reg) & 31)
+		rt := int((p.To.Reg) & 31)
+		Q := 0
+		size := 0
+		switch af {
+		case ARNG_8B:
+			Q = 0
+			size = 0
+		case ARNG_16B:
+			Q = 1
+			size = 0
+		case ARNG_4H:
+			Q = 0
+			size = 1
+		case ARNG_8H:
+			Q = 1
+			size = 1
+		case ARNG_4S:
+			Q = 1
+			size = 2
+		default:
+			c.ctxt.Diag("invalid arrangement: %v\n", p)
+		}
+		o1 |= (uint32(Q&1) << 30) | (uint32(size&3) << 22) | (uint32(rf&31) << 5) | uint32(rt&31)
+
+	case 86: /* vmovi $imm8, Vd.<T>*/
+		at := int((p.To.Reg >> 5) & 15)
+		r := int(p.From.Offset)
+		if r > 255 || r < 0 {
+			c.ctxt.Diag("immediate constant out of range: %v\n", p)
+		}
+		rt := int((p.To.Reg) & 31)
+		Q := 0
+		switch at {
+		case ARNG_8B:
+			Q = 0
+		case ARNG_16B:
+			Q = 1
+		default:
+			c.ctxt.Diag("invalid arrangement: %v\n", p)
+		}
+		o1 = 0xf<<24 | 0xe<<12 | 1<<10
+		o1 |= (uint32(Q&1) << 30) | (uint32((r>>5)&7) << 16) | (uint32(r&0x1f) << 5) | uint32(rt&31)
+
+	case 87: /* stp (r,r), addr(SB) -> adrp + add + stp */
+		o1 = ADR(1, 0, REGTMP)
+		o2 = c.opirr(p, AADD) | REGTMP&31<<5 | REGTMP&31
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 8
+		rel.Sym = p.To.Sym
+		rel.Add = p.To.Offset
+		rel.Type = objabi.R_ADDRARM64
+		o3 |= c.opldpstp(p, o, 0, uint32(REGTMP), uint32(p.From.Reg), uint32(p.From.Offset), 0)
+
+	case 88: /* ldp addr(SB), (r,r) -> adrp + add + ldp */
+		o1 = ADR(1, 0, REGTMP)
+		o2 = c.opirr(p, AADD) | REGTMP&31<<5 | REGTMP&31
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 8
+		rel.Sym = p.From.Sym
+		rel.Add = p.From.Offset
+		rel.Type = objabi.R_ADDRARM64
+		o3 |= c.opldpstp(p, o, 0, uint32(REGTMP), uint32(p.To.Reg), uint32(p.To.Offset), 1)
+
+	case 89: /* vadd/vsub Vm, Vn, Vd */
+		switch p.As {
+		case AVADD:
+			o1 = 5<<28 | 7<<25 | 7<<21 | 1<<15 | 1<<10
+
+		case AVSUB:
+			o1 = 7<<28 | 7<<25 | 7<<21 | 1<<15 | 1<<10
+
+		default:
+			c.ctxt.Diag("bad opcode: %v\n", p)
+			break
+		}
+
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		r := int(p.Reg)
+		if r == 0 {
+			r = rt
+		}
+		o1 |= (uint32(rf&31) << 16) | (uint32(r&31) << 5) | uint32(rt&31)
+
+	// This is supposed to be something that stops execution.
+	// It's not supposed to be reached, ever, but if it is, we'd
+	// like to be able to tell how we got there. Assemble as
+	// 0xbea71700 which is guaranteed to raise undefined instruction
+	// exception.
+	case 90:
+		o1 = 0xbea71700
+
+	case 91: /* prfm imm(Rn), <prfop | $imm5> */
+		imm := uint32(p.From.Offset)
+		r := p.From.Reg
+		v := uint32(0xff)
+		if p.To.Type == obj.TYPE_CONST {
+			v = uint32(p.To.Offset)
+			if v > 31 {
+				c.ctxt.Diag("illegal prefetch operation\n%v", p)
+			}
+		} else {
+			for i := 0; i < len(prfopfield); i++ {
+				if prfopfield[i].reg == p.To.Reg {
+					v = prfopfield[i].enc
+					break
+				}
+			}
+			if v == 0xff {
+				c.ctxt.Diag("illegal prefetch operation:\n%v", p)
+			}
+		}
+
+		o1 = c.opldrpp(p, p.As)
+		o1 |= (uint32(r&31) << 5) | (uint32((imm>>3)&0xfff) << 10) | (uint32(v & 31))
+
+	case 92: /* vmov Vn.<T>[index], Vd.<T>[index] */
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		imm4 := 0
+		imm5 := 0
+		o1 = 3<<29 | 7<<25 | 1<<10
+		index1 := int(p.To.Index)
+		index2 := int(p.From.Index)
+		if ((p.To.Reg >> 5) & 15) != ((p.From.Reg >> 5) & 15) {
+			c.ctxt.Diag("operand mismatch: %v", p)
+		}
+		switch (p.To.Reg >> 5) & 15 {
+		case ARNG_B:
+			c.checkindex(p, index1, 15)
+			c.checkindex(p, index2, 15)
+			imm5 |= 1
+			imm5 |= index1 << 1
+			imm4 |= index2
+		case ARNG_H:
+			c.checkindex(p, index1, 7)
+			c.checkindex(p, index2, 7)
+			imm5 |= 2
+			imm5 |= index1 << 2
+			imm4 |= index2 << 1
+		case ARNG_S:
+			c.checkindex(p, index1, 3)
+			c.checkindex(p, index2, 3)
+			imm5 |= 4
+			imm5 |= index1 << 3
+			imm4 |= index2 << 2
+		case ARNG_D:
+			c.checkindex(p, index1, 1)
+			c.checkindex(p, index2, 1)
+			imm5 |= 8
+			imm5 |= index1 << 4
+			imm4 |= index2 << 3
+		default:
+			c.ctxt.Diag("invalid arrangement: %v", p)
+		}
+		o1 |= (uint32(imm5&0x1f) << 16) | (uint32(imm4&0xf) << 11) | (uint32(rf&31) << 5) | uint32(rt&31)
+
+	case 93: /* vpmull{2} Vm.<T>, Vn.<T>, Vd */
+		af := int((p.From.Reg >> 5) & 15)
+		at := int((p.To.Reg >> 5) & 15)
+		a := int((p.Reg >> 5) & 15)
+
+		var Q, size uint32
+		if p.As == AVPMULL {
+			Q = 0
+		} else {
+			Q = 1
+		}
+
+		var fArng int
+		switch at {
+		case ARNG_8H:
+			if Q == 0 {
+				fArng = ARNG_8B
+			} else {
+				fArng = ARNG_16B
+			}
+			size = 0
+		case ARNG_1Q:
+			if Q == 0 {
+				fArng = ARNG_1D
+			} else {
+				fArng = ARNG_2D
+			}
+			size = 3
+		default:
+			c.ctxt.Diag("invalid arrangement on Vd.<T>: %v", p)
+		}
+
+		if af != a || af != fArng {
+			c.ctxt.Diag("invalid arrangement: %v", p)
+		}
+
+		o1 = c.oprrr(p, p.As)
+		rf := int((p.From.Reg) & 31)
+		rt := int((p.To.Reg) & 31)
+		r := int((p.Reg) & 31)
+
+		o1 |= ((Q & 1) << 30) | ((size & 3) << 22) | (uint32(rf&31) << 16) | (uint32(r&31) << 5) | uint32(rt&31)
+
+	case 94: /* vext $imm4, Vm.<T>, Vn.<T>, Vd.<T> */
+		af := int(((p.GetFrom3().Reg) >> 5) & 15)
+		at := int((p.To.Reg >> 5) & 15)
+		a := int((p.Reg >> 5) & 15)
+		index := int(p.From.Offset)
+
+		if af != a || af != at {
+			c.ctxt.Diag("invalid arrangement: %v", p)
+			break
+		}
+
+		var Q uint32
+		var b int
+		if af == ARNG_8B {
+			Q = 0
+			b = 7
+		} else if af == ARNG_16B {
+			Q = 1
+			b = 15
+		} else {
+			c.ctxt.Diag("invalid arrangement, should be B8 or B16: %v", p)
+			break
+		}
+
+		if index < 0 || index > b {
+			c.ctxt.Diag("illegal offset: %v", p)
+		}
+
+		o1 = c.opirr(p, p.As)
+		rf := int((p.GetFrom3().Reg) & 31)
+		rt := int((p.To.Reg) & 31)
+		r := int((p.Reg) & 31)
+
+		o1 |= ((Q & 1) << 30) | (uint32(r&31) << 16) | (uint32(index&15) << 11) | (uint32(rf&31) << 5) | uint32(rt&31)
+
+	case 95: /* vushr $shift, Vn.<T>, Vd.<T> */
+		at := int((p.To.Reg >> 5) & 15)
+		af := int((p.Reg >> 5) & 15)
+		shift := int(p.From.Offset)
+
+		if af != at {
+			c.ctxt.Diag("invalid arrangement on op Vn.<T>, Vd.<T>: %v", p)
+		}
+
+		var Q uint32
+		var imax, esize int
+
+		switch af {
+		case ARNG_8B, ARNG_4H, ARNG_2S:
+			Q = 0
+		case ARNG_16B, ARNG_8H, ARNG_4S, ARNG_2D:
+			Q = 1
+		default:
+			c.ctxt.Diag("invalid arrangement on op Vn.<T>, Vd.<T>: %v", p)
+		}
+
+		switch af {
+		case ARNG_8B, ARNG_16B:
+			imax = 15
+			esize = 8
+		case ARNG_4H, ARNG_8H:
+			imax = 31
+			esize = 16
+		case ARNG_2S, ARNG_4S:
+			imax = 63
+			esize = 32
+		case ARNG_2D:
+			imax = 127
+			esize = 64
+		}
+
+		imm := 0
+
+		switch p.As {
+		case AVUSHR, AVSRI:
+			imm = esize*2 - shift
+			if imm < esize || imm > imax {
+				c.ctxt.Diag("shift out of range: %v", p)
+			}
+		case AVSHL:
+			imm = esize + shift
+			if imm > imax {
+				c.ctxt.Diag("shift out of range: %v", p)
+			}
+		default:
+			c.ctxt.Diag("invalid instruction %v\n", p)
+		}
+
+		o1 = c.opirr(p, p.As)
+		rt := int((p.To.Reg) & 31)
+		rf := int((p.Reg) & 31)
+
+		o1 |= ((Q & 1) << 30) | (uint32(imm&127) << 16) | (uint32(rf&31) << 5) | uint32(rt&31)
+
+	case 96: /* vst1 Vt1.<T>[index], offset(Rn) */
+		af := int((p.From.Reg >> 5) & 15)
+		rt := int((p.From.Reg) & 31)
+		rf := int((p.To.Reg) & 31)
+		r := int(p.To.Index & 31)
+		index := int(p.From.Index)
+		offset := int32(c.regoff(&p.To))
+
+		if o.scond == C_XPOST {
+			if (p.To.Index != 0) && (offset != 0) {
+				c.ctxt.Diag("invalid offset: %v", p)
+			}
+			if p.To.Index == 0 && offset == 0 {
+				c.ctxt.Diag("invalid offset: %v", p)
+			}
+		}
+
+		if offset != 0 {
+			r = 31
+		}
+
+		var Q, S, size int
+		var opcode uint32
+		switch af {
+		case ARNG_B:
+			c.checkindex(p, index, 15)
+			if o.scond == C_XPOST && offset != 0 && offset != 1 {
+				c.ctxt.Diag("invalid offset: %v", p)
+			}
+			Q = index >> 3
+			S = (index >> 2) & 1
+			size = index & 3
+			opcode = 0
+		case ARNG_H:
+			c.checkindex(p, index, 7)
+			if o.scond == C_XPOST && offset != 0 && offset != 2 {
+				c.ctxt.Diag("invalid offset: %v", p)
+			}
+			Q = index >> 2
+			S = (index >> 1) & 1
+			size = (index & 1) << 1
+			opcode = 2
+		case ARNG_S:
+			c.checkindex(p, index, 3)
+			if o.scond == C_XPOST && offset != 0 && offset != 4 {
+				c.ctxt.Diag("invalid offset: %v", p)
+			}
+			Q = index >> 1
+			S = index & 1
+			size = 0
+			opcode = 4
+		case ARNG_D:
+			c.checkindex(p, index, 1)
+			if o.scond == C_XPOST && offset != 0 && offset != 8 {
+				c.ctxt.Diag("invalid offset: %v", p)
+			}
+			Q = index
+			S = 0
+			size = 1
+			opcode = 4
+		default:
+			c.ctxt.Diag("invalid arrangement: %v", p)
+		}
+
+		if o.scond == C_XPOST {
+			o1 |= 27 << 23
+		} else {
+			o1 |= 26 << 23
+		}
+
+		o1 |= (uint32(Q&1) << 30) | (uint32(r&31) << 16) | ((opcode & 7) << 13) | (uint32(S&1) << 12) | (uint32(size&3) << 10) | (uint32(rf&31) << 5) | uint32(rt&31)
+
+	case 97: /* vld1 offset(Rn), vt.<T>[index] */
+		at := int((p.To.Reg >> 5) & 15)
+		rt := int((p.To.Reg) & 31)
+		rf := int((p.From.Reg) & 31)
+		r := int(p.From.Index & 31)
+		index := int(p.To.Index)
+		offset := int32(c.regoff(&p.From))
+
+		if o.scond == C_XPOST {
+			if (p.From.Index != 0) && (offset != 0) {
+				c.ctxt.Diag("invalid offset: %v", p)
+			}
+			if p.From.Index == 0 && offset == 0 {
+				c.ctxt.Diag("invalid offset: %v", p)
+			}
+		}
+
+		if offset != 0 {
+			r = 31
+		}
+
+		Q := 0
+		S := 0
+		size := 0
+		var opcode uint32
+		switch at {
+		case ARNG_B:
+			c.checkindex(p, index, 15)
+			if o.scond == C_XPOST && offset != 0 && offset != 1 {
+				c.ctxt.Diag("invalid offset: %v", p)
+			}
+			Q = index >> 3
+			S = (index >> 2) & 1
+			size = index & 3
+			opcode = 0
+		case ARNG_H:
+			c.checkindex(p, index, 7)
+			if o.scond == C_XPOST && offset != 0 && offset != 2 {
+				c.ctxt.Diag("invalid offset: %v", p)
+			}
+			Q = index >> 2
+			S = (index >> 1) & 1
+			size = (index & 1) << 1
+			opcode = 2
+		case ARNG_S:
+			c.checkindex(p, index, 3)
+			if o.scond == C_XPOST && offset != 0 && offset != 4 {
+				c.ctxt.Diag("invalid offset: %v", p)
+			}
+			Q = index >> 1
+			S = index & 1
+			size = 0
+			opcode = 4
+		case ARNG_D:
+			c.checkindex(p, index, 1)
+			if o.scond == C_XPOST && offset != 0 && offset != 8 {
+				c.ctxt.Diag("invalid offset: %v", p)
+			}
+			Q = index
+			S = 0
+			size = 1
+			opcode = 4
+		default:
+			c.ctxt.Diag("invalid arrangement: %v", p)
+		}
+
+		if o.scond == C_XPOST {
+			o1 |= 110 << 21
+		} else {
+			o1 |= 106 << 21
+		}
+
+		o1 |= (uint32(Q&1) << 30) | (uint32(r&31) << 16) | ((opcode & 7) << 13) | (uint32(S&1) << 12) | (uint32(size&3) << 10) | (uint32(rf&31) << 5) | uint32(rt&31)
+
+	case 98: /* MOVD (Rn)(Rm.SXTW[<<amount]),Rd */
+		if isRegShiftOrExt(&p.From) {
+			// extended or shifted offset register.
+			c.checkShiftAmount(p, &p.From)
+
+			o1 = c.opldrr(p, p.As, true)
+			o1 |= c.encRegShiftOrExt(&p.From, p.From.Index) /* includes reg, op, etc */
+		} else {
+			// (Rn)(Rm), no extension or shift.
+			o1 = c.opldrr(p, p.As, false)
+			o1 |= uint32(p.From.Index&31) << 16
+		}
+		o1 |= uint32(p.From.Reg&31) << 5
+		rt := int(p.To.Reg)
+		o1 |= uint32(rt & 31)
+
+	case 99: /* MOVD Rt, (Rn)(Rm.SXTW[<<amount]) */
+		if isRegShiftOrExt(&p.To) {
+			// extended or shifted offset register.
+			c.checkShiftAmount(p, &p.To)
+
+			o1 = c.opstrr(p, p.As, true)
+			o1 |= c.encRegShiftOrExt(&p.To, p.To.Index) /* includes reg, op, etc */
+		} else {
+			// (Rn)(Rm), no extension or shift.
+			o1 = c.opstrr(p, p.As, false)
+			o1 |= uint32(p.To.Index&31) << 16
+		}
+		o1 |= uint32(p.To.Reg&31) << 5
+		rf := int(p.From.Reg)
+		o1 |= uint32(rf & 31)
+
+	case 100: /* VTBL Vn.<T>, [Vt1.<T>, Vt2.<T>, ...], Vd.<T> */
+		af := int((p.From.Reg >> 5) & 15)
+		at := int((p.To.Reg >> 5) & 15)
+		if af != at {
+			c.ctxt.Diag("invalid arrangement: %v\n", p)
+		}
+		var q, len uint32
+		switch af {
+		case ARNG_8B:
+			q = 0
+		case ARNG_16B:
+			q = 1
+		default:
+			c.ctxt.Diag("invalid arrangement: %v", p)
+		}
+		rf := int(p.From.Reg)
+		rt := int(p.To.Reg)
+		offset := int(p.GetFrom3().Offset)
+		opcode := (offset >> 12) & 15
+		switch opcode {
+		case 0x7:
+			len = 0 // one register
+		case 0xa:
+			len = 1 // two register
+		case 0x6:
+			len = 2 // three registers
+		case 0x2:
+			len = 3 // four registers
+		default:
+			c.ctxt.Diag("invalid register numbers in ARM64 register list: %v", p)
+		}
+		o1 = q<<30 | 0xe<<24 | len<<13
+		o1 |= (uint32(rf&31) << 16) | uint32(offset&31)<<5 | uint32(rt&31)
+
+	case 101: // FOMVQ/FMOVD $vcon, Vd -> load from constant pool.
+		o1 = c.omovlit(p.As, p, &p.From, int(p.To.Reg))
+
+	case 102: /* vushll, vushll2, vuxtl, vuxtl2 */
+		o1 = c.opirr(p, p.As)
+		rf := p.Reg
+		af := uint8((p.Reg >> 5) & 15)
+		at := uint8((p.To.Reg >> 5) & 15)
+		shift := int(p.From.Offset)
+		if p.As == AVUXTL || p.As == AVUXTL2 {
+			rf = p.From.Reg
+			af = uint8((p.From.Reg >> 5) & 15)
+			shift = 0
+		}
+
+		pack := func(q, x, y uint8) uint32 {
+			return uint32(q)<<16 | uint32(x)<<8 | uint32(y)
+		}
+
+		var Q uint8 = uint8(o1>>30) & 1
+		var immh, width uint8
+		switch pack(Q, af, at) {
+		case pack(0, ARNG_8B, ARNG_8H):
+			immh, width = 1, 8
+		case pack(1, ARNG_16B, ARNG_8H):
+			immh, width = 1, 8
+		case pack(0, ARNG_4H, ARNG_4S):
+			immh, width = 2, 16
+		case pack(1, ARNG_8H, ARNG_4S):
+			immh, width = 2, 16
+		case pack(0, ARNG_2S, ARNG_2D):
+			immh, width = 4, 32
+		case pack(1, ARNG_4S, ARNG_2D):
+			immh, width = 4, 32
+		default:
+			c.ctxt.Diag("operand mismatch: %v\n", p)
+		}
+		if !(0 <= shift && shift <= int(width-1)) {
+			c.ctxt.Diag("shift amount out of range: %v\n", p)
+		}
+		o1 |= uint32(immh)<<19 | uint32(shift)<<16 | uint32(rf&31)<<5 | uint32(p.To.Reg&31)
+	}
+	out[0] = o1
+	out[1] = o2
+	out[2] = o3
+	out[3] = o4
+	out[4] = o5
+}
+
+/*
+ * basic Rm op Rn -> Rd (using shifted register with 0)
+ * also op Rn -> Rt
+ * also Rm*Rn op Ra -> Rd
+ * also Vm op Vn -> Vd
+ */
+func (c *ctxt7) oprrr(p *obj.Prog, a obj.As) uint32 {
+	switch a {
+	case AADC:
+		return S64 | 0<<30 | 0<<29 | 0xd0<<21 | 0<<10
+
+	case AADCW:
+		return S32 | 0<<30 | 0<<29 | 0xd0<<21 | 0<<10
+
+	case AADCS:
+		return S64 | 0<<30 | 1<<29 | 0xd0<<21 | 0<<10
+
+	case AADCSW:
+		return S32 | 0<<30 | 1<<29 | 0xd0<<21 | 0<<10
+
+	case ANGC, ASBC:
+		return S64 | 1<<30 | 0<<29 | 0xd0<<21 | 0<<10
+
+	case ANGCS, ASBCS:
+		return S64 | 1<<30 | 1<<29 | 0xd0<<21 | 0<<10
+
+	case ANGCW, ASBCW:
+		return S32 | 1<<30 | 0<<29 | 0xd0<<21 | 0<<10
+
+	case ANGCSW, ASBCSW:
+		return S32 | 1<<30 | 1<<29 | 0xd0<<21 | 0<<10
+
+	case AADD:
+		return S64 | 0<<30 | 0<<29 | 0x0b<<24 | 0<<22 | 0<<21 | 0<<10
+
+	case AADDW:
+		return S32 | 0<<30 | 0<<29 | 0x0b<<24 | 0<<22 | 0<<21 | 0<<10
+
+	case ACMN, AADDS:
+		return S64 | 0<<30 | 1<<29 | 0x0b<<24 | 0<<22 | 0<<21 | 0<<10
+
+	case ACMNW, AADDSW:
+		return S32 | 0<<30 | 1<<29 | 0x0b<<24 | 0<<22 | 0<<21 | 0<<10
+
+	case ASUB:
+		return S64 | 1<<30 | 0<<29 | 0x0b<<24 | 0<<22 | 0<<21 | 0<<10
+
+	case ASUBW:
+		return S32 | 1<<30 | 0<<29 | 0x0b<<24 | 0<<22 | 0<<21 | 0<<10
+
+	case ACMP, ASUBS:
+		return S64 | 1<<30 | 1<<29 | 0x0b<<24 | 0<<22 | 0<<21 | 0<<10
+
+	case ACMPW, ASUBSW:
+		return S32 | 1<<30 | 1<<29 | 0x0b<<24 | 0<<22 | 0<<21 | 0<<10
+
+	case AAND:
+		return S64 | 0<<29 | 0xA<<24
+
+	case AANDW:
+		return S32 | 0<<29 | 0xA<<24
+
+	case AMOVD, AORR:
+		return S64 | 1<<29 | 0xA<<24
+
+		//	case AMOVW:
+	case AMOVWU, AORRW:
+		return S32 | 1<<29 | 0xA<<24
+
+	case AEOR:
+		return S64 | 2<<29 | 0xA<<24
+
+	case AEORW:
+		return S32 | 2<<29 | 0xA<<24
+
+	case AANDS, ATST:
+		return S64 | 3<<29 | 0xA<<24
+
+	case AANDSW, ATSTW:
+		return S32 | 3<<29 | 0xA<<24
+
+	case ABIC:
+		return S64 | 0<<29 | 0xA<<24 | 1<<21
+
+	case ABICW:
+		return S32 | 0<<29 | 0xA<<24 | 1<<21
+
+	case ABICS:
+		return S64 | 3<<29 | 0xA<<24 | 1<<21
+
+	case ABICSW:
+		return S32 | 3<<29 | 0xA<<24 | 1<<21
+
+	case AEON:
+		return S64 | 2<<29 | 0xA<<24 | 1<<21
+
+	case AEONW:
+		return S32 | 2<<29 | 0xA<<24 | 1<<21
+
+	case AMVN, AORN:
+		return S64 | 1<<29 | 0xA<<24 | 1<<21
+
+	case AMVNW, AORNW:
+		return S32 | 1<<29 | 0xA<<24 | 1<<21
+
+	case AASR:
+		return S64 | OPDP2(10) /* also ASRV */
+
+	case AASRW:
+		return S32 | OPDP2(10)
+
+	case ALSL:
+		return S64 | OPDP2(8)
+
+	case ALSLW:
+		return S32 | OPDP2(8)
+
+	case ALSR:
+		return S64 | OPDP2(9)
+
+	case ALSRW:
+		return S32 | OPDP2(9)
+
+	case AROR:
+		return S64 | OPDP2(11)
+
+	case ARORW:
+		return S32 | OPDP2(11)
+
+	case ACCMN:
+		return S64 | 0<<30 | 1<<29 | 0xD2<<21 | 0<<11 | 0<<10 | 0<<4 /* cond<<12 | nzcv<<0 */
+
+	case ACCMNW:
+		return S32 | 0<<30 | 1<<29 | 0xD2<<21 | 0<<11 | 0<<10 | 0<<4
+
+	case ACCMP:
+		return S64 | 1<<30 | 1<<29 | 0xD2<<21 | 0<<11 | 0<<10 | 0<<4 /* imm5<<16 | cond<<12 | nzcv<<0 */
+
+	case ACCMPW:
+		return S32 | 1<<30 | 1<<29 | 0xD2<<21 | 0<<11 | 0<<10 | 0<<4
+
+	case ACRC32B:
+		return S32 | OPDP2(16)
+
+	case ACRC32H:
+		return S32 | OPDP2(17)
+
+	case ACRC32W:
+		return S32 | OPDP2(18)
+
+	case ACRC32X:
+		return S64 | OPDP2(19)
+
+	case ACRC32CB:
+		return S32 | OPDP2(20)
+
+	case ACRC32CH:
+		return S32 | OPDP2(21)
+
+	case ACRC32CW:
+		return S32 | OPDP2(22)
+
+	case ACRC32CX:
+		return S64 | OPDP2(23)
+
+	case ACSEL:
+		return S64 | 0<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 0<<10
+
+	case ACSELW:
+		return S32 | 0<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 0<<10
+
+	case ACSET:
+		return S64 | 0<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 1<<10
+
+	case ACSETW:
+		return S32 | 0<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 1<<10
+
+	case ACSETM:
+		return S64 | 1<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 0<<10
+
+	case ACSETMW:
+		return S32 | 1<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 0<<10
+
+	case ACINC, ACSINC:
+		return S64 | 0<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 1<<10
+
+	case ACINCW, ACSINCW:
+		return S32 | 0<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 1<<10
+
+	case ACINV, ACSINV:
+		return S64 | 1<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 0<<10
+
+	case ACINVW, ACSINVW:
+		return S32 | 1<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 0<<10
+
+	case ACNEG, ACSNEG:
+		return S64 | 1<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 1<<10
+
+	case ACNEGW, ACSNEGW:
+		return S32 | 1<<30 | 0<<29 | 0xD4<<21 | 0<<11 | 1<<10
+
+	case AMUL, AMADD:
+		return S64 | 0<<29 | 0x1B<<24 | 0<<21 | 0<<15
+
+	case AMULW, AMADDW:
+		return S32 | 0<<29 | 0x1B<<24 | 0<<21 | 0<<15
+
+	case AMNEG, AMSUB:
+		return S64 | 0<<29 | 0x1B<<24 | 0<<21 | 1<<15
+
+	case AMNEGW, AMSUBW:
+		return S32 | 0<<29 | 0x1B<<24 | 0<<21 | 1<<15
+
+	case AMRS:
+		return SYSOP(1, 2, 0, 0, 0, 0, 0)
+
+	case AMSR:
+		return SYSOP(0, 2, 0, 0, 0, 0, 0)
+
+	case ANEG:
+		return S64 | 1<<30 | 0<<29 | 0xB<<24 | 0<<21
+
+	case ANEGW:
+		return S32 | 1<<30 | 0<<29 | 0xB<<24 | 0<<21
+
+	case ANEGS:
+		return S64 | 1<<30 | 1<<29 | 0xB<<24 | 0<<21
+
+	case ANEGSW:
+		return S32 | 1<<30 | 1<<29 | 0xB<<24 | 0<<21
+
+	case AREM, ASDIV:
+		return S64 | OPDP2(3)
+
+	case AREMW, ASDIVW:
+		return S32 | OPDP2(3)
+
+	case ASMULL, ASMADDL:
+		return OPDP3(1, 0, 1, 0)
+
+	case ASMNEGL, ASMSUBL:
+		return OPDP3(1, 0, 1, 1)
+
+	case ASMULH:
+		return OPDP3(1, 0, 2, 0)
+
+	case AUMULL, AUMADDL:
+		return OPDP3(1, 0, 5, 0)
+
+	case AUMNEGL, AUMSUBL:
+		return OPDP3(1, 0, 5, 1)
+
+	case AUMULH:
+		return OPDP3(1, 0, 6, 0)
+
+	case AUREM, AUDIV:
+		return S64 | OPDP2(2)
+
+	case AUREMW, AUDIVW:
+		return S32 | OPDP2(2)
+
+	case AAESE:
+		return 0x4E<<24 | 2<<20 | 8<<16 | 4<<12 | 2<<10
+
+	case AAESD:
+		return 0x4E<<24 | 2<<20 | 8<<16 | 5<<12 | 2<<10
+
+	case AAESMC:
+		return 0x4E<<24 | 2<<20 | 8<<16 | 6<<12 | 2<<10
+
+	case AAESIMC:
+		return 0x4E<<24 | 2<<20 | 8<<16 | 7<<12 | 2<<10
+
+	case ASHA1C:
+		return 0x5E<<24 | 0<<12
+
+	case ASHA1P:
+		return 0x5E<<24 | 1<<12
+
+	case ASHA1M:
+		return 0x5E<<24 | 2<<12
+
+	case ASHA1SU0:
+		return 0x5E<<24 | 3<<12
+
+	case ASHA256H:
+		return 0x5E<<24 | 4<<12
+
+	case ASHA256H2:
+		return 0x5E<<24 | 5<<12
+
+	case ASHA256SU1:
+		return 0x5E<<24 | 6<<12
+
+	case ASHA1H:
+		return 0x5E<<24 | 2<<20 | 8<<16 | 0<<12 | 2<<10
+
+	case ASHA1SU1:
+		return 0x5E<<24 | 2<<20 | 8<<16 | 1<<12 | 2<<10
+
+	case ASHA256SU0:
+		return 0x5E<<24 | 2<<20 | 8<<16 | 2<<12 | 2<<10
+
+	case ASHA512H:
+		return 0xCE<<24 | 3<<21 | 8<<12
+
+	case ASHA512H2:
+		return 0xCE<<24 | 3<<21 | 8<<12 | 4<<8
+
+	case ASHA512SU1:
+		return 0xCE<<24 | 3<<21 | 8<<12 | 8<<8
+
+	case ASHA512SU0:
+		return 0xCE<<24 | 3<<22 | 8<<12
+
+	case AFCVTZSD:
+		return FPCVTI(1, 0, 1, 3, 0)
+
+	case AFCVTZSDW:
+		return FPCVTI(0, 0, 1, 3, 0)
+
+	case AFCVTZSS:
+		return FPCVTI(1, 0, 0, 3, 0)
+
+	case AFCVTZSSW:
+		return FPCVTI(0, 0, 0, 3, 0)
+
+	case AFCVTZUD:
+		return FPCVTI(1, 0, 1, 3, 1)
+
+	case AFCVTZUDW:
+		return FPCVTI(0, 0, 1, 3, 1)
+
+	case AFCVTZUS:
+		return FPCVTI(1, 0, 0, 3, 1)
+
+	case AFCVTZUSW:
+		return FPCVTI(0, 0, 0, 3, 1)
+
+	case ASCVTFD:
+		return FPCVTI(1, 0, 1, 0, 2)
+
+	case ASCVTFS:
+		return FPCVTI(1, 0, 0, 0, 2)
+
+	case ASCVTFWD:
+		return FPCVTI(0, 0, 1, 0, 2)
+
+	case ASCVTFWS:
+		return FPCVTI(0, 0, 0, 0, 2)
+
+	case AUCVTFD:
+		return FPCVTI(1, 0, 1, 0, 3)
+
+	case AUCVTFS:
+		return FPCVTI(1, 0, 0, 0, 3)
+
+	case AUCVTFWD:
+		return FPCVTI(0, 0, 1, 0, 3)
+
+	case AUCVTFWS:
+		return FPCVTI(0, 0, 0, 0, 3)
+
+	case AFADDS:
+		return FPOP2S(0, 0, 0, 2)
+
+	case AFADDD:
+		return FPOP2S(0, 0, 1, 2)
+
+	case AFSUBS:
+		return FPOP2S(0, 0, 0, 3)
+
+	case AFSUBD:
+		return FPOP2S(0, 0, 1, 3)
+
+	case AFMADDD:
+		return FPOP3S(0, 0, 1, 0, 0)
+
+	case AFMADDS:
+		return FPOP3S(0, 0, 0, 0, 0)
+
+	case AFMSUBD:
+		return FPOP3S(0, 0, 1, 0, 1)
+
+	case AFMSUBS:
+		return FPOP3S(0, 0, 0, 0, 1)
+
+	case AFNMADDD:
+		return FPOP3S(0, 0, 1, 1, 0)
+
+	case AFNMADDS:
+		return FPOP3S(0, 0, 0, 1, 0)
+
+	case AFNMSUBD:
+		return FPOP3S(0, 0, 1, 1, 1)
+
+	case AFNMSUBS:
+		return FPOP3S(0, 0, 0, 1, 1)
+
+	case AFMULS:
+		return FPOP2S(0, 0, 0, 0)
+
+	case AFMULD:
+		return FPOP2S(0, 0, 1, 0)
+
+	case AFDIVS:
+		return FPOP2S(0, 0, 0, 1)
+
+	case AFDIVD:
+		return FPOP2S(0, 0, 1, 1)
+
+	case AFMAXS:
+		return FPOP2S(0, 0, 0, 4)
+
+	case AFMINS:
+		return FPOP2S(0, 0, 0, 5)
+
+	case AFMAXD:
+		return FPOP2S(0, 0, 1, 4)
+
+	case AFMIND:
+		return FPOP2S(0, 0, 1, 5)
+
+	case AFMAXNMS:
+		return FPOP2S(0, 0, 0, 6)
+
+	case AFMAXNMD:
+		return FPOP2S(0, 0, 1, 6)
+
+	case AFMINNMS:
+		return FPOP2S(0, 0, 0, 7)
+
+	case AFMINNMD:
+		return FPOP2S(0, 0, 1, 7)
+
+	case AFNMULS:
+		return FPOP2S(0, 0, 0, 8)
+
+	case AFNMULD:
+		return FPOP2S(0, 0, 1, 8)
+
+	case AFCMPS:
+		return FPCMP(0, 0, 0, 0, 0)
+
+	case AFCMPD:
+		return FPCMP(0, 0, 1, 0, 0)
+
+	case AFCMPES:
+		return FPCMP(0, 0, 0, 0, 16)
+
+	case AFCMPED:
+		return FPCMP(0, 0, 1, 0, 16)
+
+	case AFCCMPS:
+		return FPCCMP(0, 0, 0, 0)
+
+	case AFCCMPD:
+		return FPCCMP(0, 0, 1, 0)
+
+	case AFCCMPES:
+		return FPCCMP(0, 0, 0, 1)
+
+	case AFCCMPED:
+		return FPCCMP(0, 0, 1, 1)
+
+	case AFCSELS:
+		return 0x1E<<24 | 0<<22 | 1<<21 | 3<<10
+
+	case AFCSELD:
+		return 0x1E<<24 | 1<<22 | 1<<21 | 3<<10
+
+	case AFMOVS:
+		return FPOP1S(0, 0, 0, 0)
+
+	case AFABSS:
+		return FPOP1S(0, 0, 0, 1)
+
+	case AFNEGS:
+		return FPOP1S(0, 0, 0, 2)
+
+	case AFSQRTS:
+		return FPOP1S(0, 0, 0, 3)
+
+	case AFCVTSD:
+		return FPOP1S(0, 0, 0, 5)
+
+	case AFCVTSH:
+		return FPOP1S(0, 0, 0, 7)
+
+	case AFRINTNS:
+		return FPOP1S(0, 0, 0, 8)
+
+	case AFRINTPS:
+		return FPOP1S(0, 0, 0, 9)
+
+	case AFRINTMS:
+		return FPOP1S(0, 0, 0, 10)
+
+	case AFRINTZS:
+		return FPOP1S(0, 0, 0, 11)
+
+	case AFRINTAS:
+		return FPOP1S(0, 0, 0, 12)
+
+	case AFRINTXS:
+		return FPOP1S(0, 0, 0, 14)
+
+	case AFRINTIS:
+		return FPOP1S(0, 0, 0, 15)
+
+	case AFMOVD:
+		return FPOP1S(0, 0, 1, 0)
+
+	case AFABSD:
+		return FPOP1S(0, 0, 1, 1)
+
+	case AFNEGD:
+		return FPOP1S(0, 0, 1, 2)
+
+	case AFSQRTD:
+		return FPOP1S(0, 0, 1, 3)
+
+	case AFCVTDS:
+		return FPOP1S(0, 0, 1, 4)
+
+	case AFCVTDH:
+		return FPOP1S(0, 0, 1, 7)
+
+	case AFRINTND:
+		return FPOP1S(0, 0, 1, 8)
+
+	case AFRINTPD:
+		return FPOP1S(0, 0, 1, 9)
+
+	case AFRINTMD:
+		return FPOP1S(0, 0, 1, 10)
+
+	case AFRINTZD:
+		return FPOP1S(0, 0, 1, 11)
+
+	case AFRINTAD:
+		return FPOP1S(0, 0, 1, 12)
+
+	case AFRINTXD:
+		return FPOP1S(0, 0, 1, 14)
+
+	case AFRINTID:
+		return FPOP1S(0, 0, 1, 15)
+
+	case AFCVTHS:
+		return FPOP1S(0, 0, 3, 4)
+
+	case AFCVTHD:
+		return FPOP1S(0, 0, 3, 5)
+
+	case AVADD:
+		return 7<<25 | 1<<21 | 1<<15 | 1<<10
+
+	case AVSUB:
+		return 0x17<<25 | 1<<21 | 1<<15 | 1<<10
+
+	case AVADDP:
+		return 7<<25 | 1<<21 | 1<<15 | 15<<10
+
+	case AVAND:
+		return 7<<25 | 1<<21 | 7<<10
+
+	case AVCMEQ:
+		return 1<<29 | 0x71<<21 | 0x23<<10
+
+	case AVCNT:
+		return 0xE<<24 | 0x10<<17 | 5<<12 | 2<<10
+
+	case AVZIP1:
+		return 0xE<<24 | 3<<12 | 2<<10
+
+	case AVZIP2:
+		return 0xE<<24 | 1<<14 | 3<<12 | 2<<10
+
+	case AVEOR:
+		return 1<<29 | 0x71<<21 | 7<<10
+
+	case AVORR:
+		return 7<<25 | 5<<21 | 7<<10
+
+	case AVREV16:
+		return 3<<26 | 2<<24 | 1<<21 | 3<<11
+
+	case AVREV32:
+		return 11<<26 | 2<<24 | 1<<21 | 1<<11
+
+	case AVREV64:
+		return 3<<26 | 2<<24 | 1<<21 | 1<<11
+
+	case AVMOV:
+		return 7<<25 | 5<<21 | 7<<10
+
+	case AVADDV:
+		return 7<<25 | 3<<20 | 3<<15 | 7<<11
+
+	case AVUADDLV:
+		return 1<<29 | 7<<25 | 3<<20 | 7<<11
+
+	case AVFMLA:
+		return 7<<25 | 0<<23 | 1<<21 | 3<<14 | 3<<10
+
+	case AVFMLS:
+		return 7<<25 | 1<<23 | 1<<21 | 3<<14 | 3<<10
+
+	case AVPMULL, AVPMULL2:
+		return 0xE<<24 | 1<<21 | 0x38<<10
+
+	case AVRBIT:
+		return 0x2E<<24 | 1<<22 | 0x10<<17 | 5<<12 | 2<<10
+
+	case AVLD1, AVLD2, AVLD3, AVLD4:
+		return 3<<26 | 1<<22
+
+	case AVLD1R, AVLD3R:
+		return 0xD<<24 | 1<<22
+
+	case AVLD2R, AVLD4R:
+		return 0xD<<24 | 3<<21
+
+	case AVBIF:
+		return 1<<29 | 7<<25 | 7<<21 | 7<<10
+
+	case AVBIT:
+		return 1<<29 | 0x75<<21 | 7<<10
+
+	case AVBSL:
+		return 1<<29 | 0x73<<21 | 7<<10
+
+	case AVCMTST:
+		return 0xE<<24 | 1<<21 | 0x23<<10
+
+	case AVUZP1:
+		return 7<<25 | 3<<11
+
+	case AVUZP2:
+		return 7<<25 | 1<<14 | 3<<11
+	}
+
+	c.ctxt.Diag("%v: bad rrr %d %v", p, a, a)
+	return 0
+}
+
+/*
+ * imm -> Rd
+ * imm op Rn -> Rd
+ */
+func (c *ctxt7) opirr(p *obj.Prog, a obj.As) uint32 {
+	switch a {
+	/* op $addcon, Rn, Rd */
+	case AMOVD, AADD:
+		return S64 | 0<<30 | 0<<29 | 0x11<<24
+
+	case ACMN, AADDS:
+		return S64 | 0<<30 | 1<<29 | 0x11<<24
+
+	case AMOVW, AADDW:
+		return S32 | 0<<30 | 0<<29 | 0x11<<24
+
+	case ACMNW, AADDSW:
+		return S32 | 0<<30 | 1<<29 | 0x11<<24
+
+	case ASUB:
+		return S64 | 1<<30 | 0<<29 | 0x11<<24
+
+	case ACMP, ASUBS:
+		return S64 | 1<<30 | 1<<29 | 0x11<<24
+
+	case ASUBW:
+		return S32 | 1<<30 | 0<<29 | 0x11<<24
+
+	case ACMPW, ASUBSW:
+		return S32 | 1<<30 | 1<<29 | 0x11<<24
+
+		/* op $imm(SB), Rd; op label, Rd */
+	case AADR:
+		return 0<<31 | 0x10<<24
+
+	case AADRP:
+		return 1<<31 | 0x10<<24
+
+		/* op $bimm, Rn, Rd */
+	case AAND, ABIC:
+		return S64 | 0<<29 | 0x24<<23
+
+	case AANDW, ABICW:
+		return S32 | 0<<29 | 0x24<<23 | 0<<22
+
+	case AORR, AORN:
+		return S64 | 1<<29 | 0x24<<23
+
+	case AORRW, AORNW:
+		return S32 | 1<<29 | 0x24<<23 | 0<<22
+
+	case AEOR, AEON:
+		return S64 | 2<<29 | 0x24<<23
+
+	case AEORW, AEONW:
+		return S32 | 2<<29 | 0x24<<23 | 0<<22
+
+	case AANDS, ABICS, ATST:
+		return S64 | 3<<29 | 0x24<<23
+
+	case AANDSW, ABICSW, ATSTW:
+		return S32 | 3<<29 | 0x24<<23 | 0<<22
+
+	case AASR:
+		return S64 | 0<<29 | 0x26<<23 /* alias of SBFM */
+
+	case AASRW:
+		return S32 | 0<<29 | 0x26<<23 | 0<<22
+
+		/* op $width, $lsb, Rn, Rd */
+	case ABFI:
+		return S64 | 2<<29 | 0x26<<23 | 1<<22
+		/* alias of BFM */
+
+	case ABFIW:
+		return S32 | 2<<29 | 0x26<<23 | 0<<22
+
+		/* op $imms, $immr, Rn, Rd */
+	case ABFM:
+		return S64 | 1<<29 | 0x26<<23 | 1<<22
+
+	case ABFMW:
+		return S32 | 1<<29 | 0x26<<23 | 0<<22
+
+	case ASBFM:
+		return S64 | 0<<29 | 0x26<<23 | 1<<22
+
+	case ASBFMW:
+		return S32 | 0<<29 | 0x26<<23 | 0<<22
+
+	case AUBFM:
+		return S64 | 2<<29 | 0x26<<23 | 1<<22
+
+	case AUBFMW:
+		return S32 | 2<<29 | 0x26<<23 | 0<<22
+
+	case ABFXIL:
+		return S64 | 1<<29 | 0x26<<23 | 1<<22 /* alias of BFM */
+
+	case ABFXILW:
+		return S32 | 1<<29 | 0x26<<23 | 0<<22
+
+	case AEXTR:
+		return S64 | 0<<29 | 0x27<<23 | 1<<22 | 0<<21
+
+	case AEXTRW:
+		return S32 | 0<<29 | 0x27<<23 | 0<<22 | 0<<21
+
+	case ACBNZ:
+		return S64 | 0x1A<<25 | 1<<24
+
+	case ACBNZW:
+		return S32 | 0x1A<<25 | 1<<24
+
+	case ACBZ:
+		return S64 | 0x1A<<25 | 0<<24
+
+	case ACBZW:
+		return S32 | 0x1A<<25 | 0<<24
+
+	case ACCMN:
+		return S64 | 0<<30 | 1<<29 | 0xD2<<21 | 1<<11 | 0<<10 | 0<<4 /* imm5<<16 | cond<<12 | nzcv<<0 */
+
+	case ACCMNW:
+		return S32 | 0<<30 | 1<<29 | 0xD2<<21 | 1<<11 | 0<<10 | 0<<4
+
+	case ACCMP:
+		return S64 | 1<<30 | 1<<29 | 0xD2<<21 | 1<<11 | 0<<10 | 0<<4 /* imm5<<16 | cond<<12 | nzcv<<0 */
+
+	case ACCMPW:
+		return S32 | 1<<30 | 1<<29 | 0xD2<<21 | 1<<11 | 0<<10 | 0<<4
+
+	case AMOVK:
+		return S64 | 3<<29 | 0x25<<23
+
+	case AMOVKW:
+		return S32 | 3<<29 | 0x25<<23
+
+	case AMOVN:
+		return S64 | 0<<29 | 0x25<<23
+
+	case AMOVNW:
+		return S32 | 0<<29 | 0x25<<23
+
+	case AMOVZ:
+		return S64 | 2<<29 | 0x25<<23
+
+	case AMOVZW:
+		return S32 | 2<<29 | 0x25<<23
+
+	case AMSR:
+		return SYSOP(0, 0, 0, 4, 0, 0, 0x1F) /* MSR (immediate) */
+
+	case AAT,
+		ADC,
+		AIC,
+		ATLBI,
+		ASYS:
+		return SYSOP(0, 1, 0, 0, 0, 0, 0)
+
+	case ASYSL:
+		return SYSOP(1, 1, 0, 0, 0, 0, 0)
+
+	case ATBZ:
+		return 0x36 << 24
+
+	case ATBNZ:
+		return 0x37 << 24
+
+	case ADSB:
+		return SYSOP(0, 0, 3, 3, 0, 4, 0x1F)
+
+	case ADMB:
+		return SYSOP(0, 0, 3, 3, 0, 5, 0x1F)
+
+	case AISB:
+		return SYSOP(0, 0, 3, 3, 0, 6, 0x1F)
+
+	case AHINT:
+		return SYSOP(0, 0, 3, 2, 0, 0, 0x1F)
+
+	case AVEXT:
+		return 0x2E<<24 | 0<<23 | 0<<21 | 0<<15
+
+	case AVUSHR:
+		return 0x5E<<23 | 1<<10
+
+	case AVSHL:
+		return 0x1E<<23 | 21<<10
+
+	case AVSRI:
+		return 0x5E<<23 | 17<<10
+
+	case AVUSHLL, AVUXTL:
+		return 1<<29 | 15<<24 | 0x29<<10
+
+	case AVUSHLL2, AVUXTL2:
+		return 3<<29 | 15<<24 | 0x29<<10
+	}
+
+	c.ctxt.Diag("%v: bad irr %v", p, a)
+	return 0
+}
+
+func (c *ctxt7) opbit(p *obj.Prog, a obj.As) uint32 {
+	switch a {
+	case ACLS:
+		return S64 | OPBIT(5)
+
+	case ACLSW:
+		return S32 | OPBIT(5)
+
+	case ACLZ:
+		return S64 | OPBIT(4)
+
+	case ACLZW:
+		return S32 | OPBIT(4)
+
+	case ARBIT:
+		return S64 | OPBIT(0)
+
+	case ARBITW:
+		return S32 | OPBIT(0)
+
+	case AREV:
+		return S64 | OPBIT(3)
+
+	case AREVW:
+		return S32 | OPBIT(2)
+
+	case AREV16:
+		return S64 | OPBIT(1)
+
+	case AREV16W:
+		return S32 | OPBIT(1)
+
+	case AREV32:
+		return S64 | OPBIT(2)
+
+	default:
+		c.ctxt.Diag("bad bit op\n%v", p)
+		return 0
+	}
+}
+
+/*
+ * add/subtract sign or zero-extended register
+ */
+func (c *ctxt7) opxrrr(p *obj.Prog, a obj.As, extend bool) uint32 {
+	extension := uint32(0)
+	if !extend {
+		switch a {
+		case AADD, ACMN, AADDS, ASUB, ACMP, ASUBS:
+			extension = LSL0_64
+
+		case AADDW, ACMNW, AADDSW, ASUBW, ACMPW, ASUBSW:
+			extension = LSL0_32
+		}
+	}
+
+	switch a {
+	case AADD:
+		return S64 | 0<<30 | 0<<29 | 0x0b<<24 | 0<<22 | 1<<21 | extension
+
+	case AADDW:
+		return S32 | 0<<30 | 0<<29 | 0x0b<<24 | 0<<22 | 1<<21 | extension
+
+	case ACMN, AADDS:
+		return S64 | 0<<30 | 1<<29 | 0x0b<<24 | 0<<22 | 1<<21 | extension
+
+	case ACMNW, AADDSW:
+		return S32 | 0<<30 | 1<<29 | 0x0b<<24 | 0<<22 | 1<<21 | extension
+
+	case ASUB:
+		return S64 | 1<<30 | 0<<29 | 0x0b<<24 | 0<<22 | 1<<21 | extension
+
+	case ASUBW:
+		return S32 | 1<<30 | 0<<29 | 0x0b<<24 | 0<<22 | 1<<21 | extension
+
+	case ACMP, ASUBS:
+		return S64 | 1<<30 | 1<<29 | 0x0b<<24 | 0<<22 | 1<<21 | extension
+
+	case ACMPW, ASUBSW:
+		return S32 | 1<<30 | 1<<29 | 0x0b<<24 | 0<<22 | 1<<21 | extension
+	}
+
+	c.ctxt.Diag("bad opxrrr %v\n%v", a, p)
+	return 0
+}
+
+func (c *ctxt7) opimm(p *obj.Prog, a obj.As) uint32 {
+	switch a {
+	case ASVC:
+		return 0xD4<<24 | 0<<21 | 1 /* imm16<<5 */
+
+	case AHVC:
+		return 0xD4<<24 | 0<<21 | 2
+
+	case ASMC:
+		return 0xD4<<24 | 0<<21 | 3
+
+	case ABRK:
+		return 0xD4<<24 | 1<<21 | 0
+
+	case AHLT:
+		return 0xD4<<24 | 2<<21 | 0
+
+	case ADCPS1:
+		return 0xD4<<24 | 5<<21 | 1
+
+	case ADCPS2:
+		return 0xD4<<24 | 5<<21 | 2
+
+	case ADCPS3:
+		return 0xD4<<24 | 5<<21 | 3
+
+	case ACLREX:
+		return SYSOP(0, 0, 3, 3, 0, 2, 0x1F)
+	}
+
+	c.ctxt.Diag("%v: bad imm %v", p, a)
+	return 0
+}
+
+func (c *ctxt7) brdist(p *obj.Prog, preshift int, flen int, shift int) int64 {
+	v := int64(0)
+	t := int64(0)
+	q := p.To.Target()
+	if q == nil {
+		// TODO: don't use brdist for this case, as it isn't a branch.
+		// (Calls from omovlit, and maybe adr/adrp opcodes as well.)
+		q = p.Pool
+	}
+	if q != nil {
+		v = (q.Pc >> uint(preshift)) - (c.pc >> uint(preshift))
+		if (v & ((1 << uint(shift)) - 1)) != 0 {
+			c.ctxt.Diag("misaligned label\n%v", p)
+		}
+		v >>= uint(shift)
+		t = int64(1) << uint(flen-1)
+		if v < -t || v >= t {
+			c.ctxt.Diag("branch too far %#x vs %#x [%p]\n%v\n%v", v, t, c.blitrl, p, q)
+			panic("branch too far")
+		}
+	}
+
+	return v & ((t << 1) - 1)
+}
+
+/*
+ * pc-relative branches
+ */
+func (c *ctxt7) opbra(p *obj.Prog, a obj.As) uint32 {
+	switch a {
+	case ABEQ:
+		return OPBcc(0x0)
+
+	case ABNE:
+		return OPBcc(0x1)
+
+	case ABCS:
+		return OPBcc(0x2)
+
+	case ABHS:
+		return OPBcc(0x2)
+
+	case ABCC:
+		return OPBcc(0x3)
+
+	case ABLO:
+		return OPBcc(0x3)
+
+	case ABMI:
+		return OPBcc(0x4)
+
+	case ABPL:
+		return OPBcc(0x5)
+
+	case ABVS:
+		return OPBcc(0x6)
+
+	case ABVC:
+		return OPBcc(0x7)
+
+	case ABHI:
+		return OPBcc(0x8)
+
+	case ABLS:
+		return OPBcc(0x9)
+
+	case ABGE:
+		return OPBcc(0xa)
+
+	case ABLT:
+		return OPBcc(0xb)
+
+	case ABGT:
+		return OPBcc(0xc)
+
+	case ABLE:
+		return OPBcc(0xd) /* imm19<<5 | cond */
+
+	case AB:
+		return 0<<31 | 5<<26 /* imm26 */
+
+	case obj.ADUFFZERO, obj.ADUFFCOPY, ABL:
+		return 1<<31 | 5<<26
+	}
+
+	c.ctxt.Diag("%v: bad bra %v", p, a)
+	return 0
+}
+
+func (c *ctxt7) opbrr(p *obj.Prog, a obj.As) uint32 {
+	switch a {
+	case ABL:
+		return OPBLR(1) /* BLR */
+
+	case AB:
+		return OPBLR(0) /* BR */
+
+	case obj.ARET:
+		return OPBLR(2) /* RET */
+	}
+
+	c.ctxt.Diag("%v: bad brr %v", p, a)
+	return 0
+}
+
+func (c *ctxt7) op0(p *obj.Prog, a obj.As) uint32 {
+	switch a {
+	case ADRPS:
+		return 0x6B<<25 | 5<<21 | 0x1F<<16 | 0x1F<<5
+
+	case AERET:
+		return 0x6B<<25 | 4<<21 | 0x1F<<16 | 0<<10 | 0x1F<<5
+
+	case ANOOP:
+		return SYSHINT(0)
+
+	case AYIELD:
+		return SYSHINT(1)
+
+	case AWFE:
+		return SYSHINT(2)
+
+	case AWFI:
+		return SYSHINT(3)
+
+	case ASEV:
+		return SYSHINT(4)
+
+	case ASEVL:
+		return SYSHINT(5)
+	}
+
+	c.ctxt.Diag("%v: bad op0 %v", p, a)
+	return 0
+}
+
+/*
+ * register offset
+ */
+func (c *ctxt7) opload(p *obj.Prog, a obj.As) uint32 {
+	switch a {
+	case ALDAR:
+		return LDSTX(3, 1, 1, 0, 1) | 0x1F<<10
+
+	case ALDARW:
+		return LDSTX(2, 1, 1, 0, 1) | 0x1F<<10
+
+	case ALDARB:
+		return LDSTX(0, 1, 1, 0, 1) | 0x1F<<10
+
+	case ALDARH:
+		return LDSTX(1, 1, 1, 0, 1) | 0x1F<<10
+
+	case ALDAXP:
+		return LDSTX(3, 0, 1, 1, 1)
+
+	case ALDAXPW:
+		return LDSTX(2, 0, 1, 1, 1)
+
+	case ALDAXR:
+		return LDSTX(3, 0, 1, 0, 1) | 0x1F<<10
+
+	case ALDAXRW:
+		return LDSTX(2, 0, 1, 0, 1) | 0x1F<<10
+
+	case ALDAXRB:
+		return LDSTX(0, 0, 1, 0, 1) | 0x1F<<10
+
+	case ALDAXRH:
+		return LDSTX(1, 0, 1, 0, 1) | 0x1F<<10
+
+	case ALDXR:
+		return LDSTX(3, 0, 1, 0, 0) | 0x1F<<10
+
+	case ALDXRB:
+		return LDSTX(0, 0, 1, 0, 0) | 0x1F<<10
+
+	case ALDXRH:
+		return LDSTX(1, 0, 1, 0, 0) | 0x1F<<10
+
+	case ALDXRW:
+		return LDSTX(2, 0, 1, 0, 0) | 0x1F<<10
+
+	case ALDXP:
+		return LDSTX(3, 0, 1, 1, 0)
+
+	case ALDXPW:
+		return LDSTX(2, 0, 1, 1, 0)
+
+	case AMOVNP:
+		return S64 | 0<<30 | 5<<27 | 0<<26 | 0<<23 | 1<<22
+
+	case AMOVNPW:
+		return S32 | 0<<30 | 5<<27 | 0<<26 | 0<<23 | 1<<22
+	}
+
+	c.ctxt.Diag("bad opload %v\n%v", a, p)
+	return 0
+}
+
+func (c *ctxt7) opstore(p *obj.Prog, a obj.As) uint32 {
+	switch a {
+	case ASTLR:
+		return LDSTX(3, 1, 0, 0, 1) | 0x1F<<10
+
+	case ASTLRB:
+		return LDSTX(0, 1, 0, 0, 1) | 0x1F<<10
+
+	case ASTLRH:
+		return LDSTX(1, 1, 0, 0, 1) | 0x1F<<10
+
+	case ASTLP:
+		return LDSTX(3, 0, 0, 1, 1)
+
+	case ASTLPW:
+		return LDSTX(2, 0, 0, 1, 1)
+
+	case ASTLRW:
+		return LDSTX(2, 1, 0, 0, 1) | 0x1F<<10
+
+	case ASTLXP:
+		return LDSTX(3, 0, 0, 1, 1)
+
+	case ASTLXPW:
+		return LDSTX(2, 0, 0, 1, 1)
+
+	case ASTLXR:
+		return LDSTX(3, 0, 0, 0, 1) | 0x1F<<10
+
+	case ASTLXRB:
+		return LDSTX(0, 0, 0, 0, 1) | 0x1F<<10
+
+	case ASTLXRH:
+		return LDSTX(1, 0, 0, 0, 1) | 0x1F<<10
+
+	case ASTLXRW:
+		return LDSTX(2, 0, 0, 0, 1) | 0x1F<<10
+
+	case ASTXR:
+		return LDSTX(3, 0, 0, 0, 0) | 0x1F<<10
+
+	case ASTXRB:
+		return LDSTX(0, 0, 0, 0, 0) | 0x1F<<10
+
+	case ASTXRH:
+		return LDSTX(1, 0, 0, 0, 0) | 0x1F<<10
+
+	case ASTXP:
+		return LDSTX(3, 0, 0, 1, 0)
+
+	case ASTXPW:
+		return LDSTX(2, 0, 0, 1, 0)
+
+	case ASTXRW:
+		return LDSTX(2, 0, 0, 0, 0) | 0x1F<<10
+
+	case AMOVNP:
+		return S64 | 0<<30 | 5<<27 | 0<<26 | 0<<23 | 1<<22
+
+	case AMOVNPW:
+		return S32 | 0<<30 | 5<<27 | 0<<26 | 0<<23 | 1<<22
+	}
+
+	c.ctxt.Diag("bad opstore %v\n%v", a, p)
+	return 0
+}
+
+/*
+ * load/store register (unsigned immediate) C3.3.13
+ *	these produce 64-bit values (when there's an option)
+ */
+func (c *ctxt7) olsr12u(p *obj.Prog, o int32, v int32, b int, r int) uint32 {
+	if v < 0 || v >= (1<<12) {
+		c.ctxt.Diag("offset out of range: %d\n%v", v, p)
+	}
+	o |= (v & 0xFFF) << 10
+	o |= int32(b&31) << 5
+	o |= int32(r & 31)
+	return uint32(o)
+}
+
+func (c *ctxt7) opldr12(p *obj.Prog, a obj.As) uint32 {
+	switch a {
+	case AMOVD:
+		return LDSTR12U(3, 0, 1) /* imm12<<10 | Rn<<5 | Rt */
+
+	case AMOVW:
+		return LDSTR12U(2, 0, 2)
+
+	case AMOVWU:
+		return LDSTR12U(2, 0, 1)
+
+	case AMOVH:
+		return LDSTR12U(1, 0, 2)
+
+	case AMOVHU:
+		return LDSTR12U(1, 0, 1)
+
+	case AMOVB:
+		return LDSTR12U(0, 0, 2)
+
+	case AMOVBU:
+		return LDSTR12U(0, 0, 1)
+
+	case AFMOVS:
+		return LDSTR12U(2, 1, 1)
+
+	case AFMOVD:
+		return LDSTR12U(3, 1, 1)
+	}
+
+	c.ctxt.Diag("bad opldr12 %v\n%v", a, p)
+	return 0
+}
+
+func (c *ctxt7) opstr12(p *obj.Prog, a obj.As) uint32 {
+	return LD2STR(c.opldr12(p, a))
+}
+
+/*
+ * load/store register (unscaled immediate) C3.3.12
+ */
+func (c *ctxt7) olsr9s(p *obj.Prog, o int32, v int32, b int, r int) uint32 {
+	if v < -256 || v > 255 {
+		c.ctxt.Diag("offset out of range: %d\n%v", v, p)
+	}
+	o |= (v & 0x1FF) << 12
+	o |= int32(b&31) << 5
+	o |= int32(r & 31)
+	return uint32(o)
+}
+
+func (c *ctxt7) opldr9(p *obj.Prog, a obj.As) uint32 {
+	switch a {
+	case AMOVD:
+		return LDSTR9S(3, 0, 1) /* simm9<<12 | Rn<<5 | Rt */
+
+	case AMOVW:
+		return LDSTR9S(2, 0, 2)
+
+	case AMOVWU:
+		return LDSTR9S(2, 0, 1)
+
+	case AMOVH:
+		return LDSTR9S(1, 0, 2)
+
+	case AMOVHU:
+		return LDSTR9S(1, 0, 1)
+
+	case AMOVB:
+		return LDSTR9S(0, 0, 2)
+
+	case AMOVBU:
+		return LDSTR9S(0, 0, 1)
+
+	case AFMOVS:
+		return LDSTR9S(2, 1, 1)
+
+	case AFMOVD:
+		return LDSTR9S(3, 1, 1)
+	}
+
+	c.ctxt.Diag("bad opldr9 %v\n%v", a, p)
+	return 0
+}
+
+func (c *ctxt7) opstr9(p *obj.Prog, a obj.As) uint32 {
+	return LD2STR(c.opldr9(p, a))
+}
+
+func (c *ctxt7) opldrpp(p *obj.Prog, a obj.As) uint32 {
+	switch a {
+	case AMOVD:
+		return 3<<30 | 7<<27 | 0<<26 | 0<<24 | 1<<22 /* simm9<<12 | Rn<<5 | Rt */
+
+	case AMOVW:
+		return 2<<30 | 7<<27 | 0<<26 | 0<<24 | 2<<22
+
+	case AMOVWU:
+		return 2<<30 | 7<<27 | 0<<26 | 0<<24 | 1<<22
+
+	case AMOVH:
+		return 1<<30 | 7<<27 | 0<<26 | 0<<24 | 2<<22
+
+	case AMOVHU:
+		return 1<<30 | 7<<27 | 0<<26 | 0<<24 | 1<<22
+
+	case AMOVB:
+		return 0<<30 | 7<<27 | 0<<26 | 0<<24 | 2<<22
+
+	case AMOVBU:
+		return 0<<30 | 7<<27 | 0<<26 | 0<<24 | 1<<22
+
+	case AFMOVS:
+		return 2<<30 | 7<<27 | 1<<26 | 0<<24 | 1<<22
+
+	case AFMOVD:
+		return 3<<30 | 7<<27 | 1<<26 | 0<<24 | 1<<22
+
+	case APRFM:
+		return 0xf9<<24 | 2<<22
+
+	}
+
+	c.ctxt.Diag("bad opldr %v\n%v", a, p)
+	return 0
+}
+
+// olsxrr attaches register operands to a load/store opcode supplied in o.
+// The result either encodes a load of r from (r1+r2) or a store of r to (r1+r2).
+func (c *ctxt7) olsxrr(p *obj.Prog, o int32, r int, r1 int, r2 int) uint32 {
+	o |= int32(r1&31) << 5
+	o |= int32(r2&31) << 16
+	o |= int32(r & 31)
+	return uint32(o)
+}
+
+// opldrr returns the ARM64 opcode encoding corresponding to the obj.As opcode
+// for load instruction with register offset.
+// The offset register can be (Rn)(Rm.UXTW<<2) or (Rn)(Rm<<2) or (Rn)(Rm).
+func (c *ctxt7) opldrr(p *obj.Prog, a obj.As, extension bool) uint32 {
+	OptionS := uint32(0x1a)
+	if extension {
+		OptionS = uint32(0) // option value and S value have been encoded into p.From.Offset.
+	}
+	switch a {
+	case AMOVD:
+		return OptionS<<10 | 0x3<<21 | 0x1f<<27
+	case AMOVW:
+		return OptionS<<10 | 0x5<<21 | 0x17<<27
+	case AMOVWU:
+		return OptionS<<10 | 0x3<<21 | 0x17<<27
+	case AMOVH:
+		return OptionS<<10 | 0x5<<21 | 0x0f<<27
+	case AMOVHU:
+		return OptionS<<10 | 0x3<<21 | 0x0f<<27
+	case AMOVB:
+		return OptionS<<10 | 0x5<<21 | 0x07<<27
+	case AMOVBU:
+		return OptionS<<10 | 0x3<<21 | 0x07<<27
+	case AFMOVS:
+		return OptionS<<10 | 0x3<<21 | 0x17<<27 | 1<<26
+	case AFMOVD:
+		return OptionS<<10 | 0x3<<21 | 0x1f<<27 | 1<<26
+	}
+	c.ctxt.Diag("bad opldrr %v\n%v", a, p)
+	return 0
+}
+
+// opstrr returns the ARM64 opcode encoding corresponding to the obj.As opcode
+// for store instruction with register offset.
+// The offset register can be (Rn)(Rm.UXTW<<2) or (Rn)(Rm<<2) or (Rn)(Rm).
+func (c *ctxt7) opstrr(p *obj.Prog, a obj.As, extension bool) uint32 {
+	OptionS := uint32(0x1a)
+	if extension {
+		OptionS = uint32(0) // option value and S value have been encoded into p.To.Offset.
+	}
+	switch a {
+	case AMOVD:
+		return OptionS<<10 | 0x1<<21 | 0x1f<<27
+	case AMOVW, AMOVWU:
+		return OptionS<<10 | 0x1<<21 | 0x17<<27
+	case AMOVH, AMOVHU:
+		return OptionS<<10 | 0x1<<21 | 0x0f<<27
+	case AMOVB, AMOVBU:
+		return OptionS<<10 | 0x1<<21 | 0x07<<27
+	case AFMOVS:
+		return OptionS<<10 | 0x1<<21 | 0x17<<27 | 1<<26
+	case AFMOVD:
+		return OptionS<<10 | 0x1<<21 | 0x1f<<27 | 1<<26
+	}
+	c.ctxt.Diag("bad opstrr %v\n%v", a, p)
+	return 0
+}
+
+func (c *ctxt7) oaddi(p *obj.Prog, o1 int32, v int32, r int, rt int) uint32 {
+	if (v & 0xFFF000) != 0 {
+		if v&0xFFF != 0 {
+			c.ctxt.Diag("%v misuses oaddi", p)
+		}
+		v >>= 12
+		o1 |= 1 << 22
+	}
+
+	o1 |= ((v & 0xFFF) << 10) | (int32(r&31) << 5) | int32(rt&31)
+	return uint32(o1)
+}
+
+/*
+ * load a literal value into dr
+ */
+func (c *ctxt7) omovlit(as obj.As, p *obj.Prog, a *obj.Addr, dr int) uint32 {
+	var o1 int32
+	if p.Pool == nil { /* not in literal pool */
+		c.aclass(a)
+		c.ctxt.Logf("omovlit add %d (%#x)\n", c.instoffset, uint64(c.instoffset))
+
+		/* TODO: could be clever, and use general constant builder */
+		o1 = int32(c.opirr(p, AADD))
+
+		v := int32(c.instoffset)
+		if v != 0 && (v&0xFFF) == 0 {
+			v >>= 12
+			o1 |= 1 << 22 /* shift, by 12 */
+		}
+
+		o1 |= ((v & 0xFFF) << 10) | (REGZERO & 31 << 5) | int32(dr&31)
+	} else {
+		fp, w := 0, 0
+		switch as {
+		case AFMOVS:
+			fp = 1
+			w = 0 /* 32-bit SIMD/FP */
+
+		case AFMOVD:
+			fp = 1
+			w = 1 /* 64-bit SIMD/FP */
+
+		case AFMOVQ:
+			fp = 1
+			w = 2 /* 128-bit SIMD/FP */
+
+		case AMOVD:
+			if p.Pool.As == ADWORD {
+				w = 1 /* 64-bit */
+			} else if p.Pool.To.Offset < 0 {
+				w = 2 /* 32-bit, sign-extended to 64-bit */
+			} else if p.Pool.To.Offset >= 0 {
+				w = 0 /* 32-bit, zero-extended to 64-bit */
+			} else {
+				c.ctxt.Diag("invalid operand %v in %v", a, p)
+			}
+
+		case AMOVBU, AMOVHU, AMOVWU:
+			w = 0 /* 32-bit, zero-extended to 64-bit */
+
+		case AMOVB, AMOVH, AMOVW:
+			w = 2 /* 32-bit, sign-extended to 64-bit */
+
+		default:
+			c.ctxt.Diag("invalid operation %v in %v", as, p)
+		}
+
+		v := int32(c.brdist(p, 0, 19, 2))
+		o1 = (int32(w) << 30) | (int32(fp) << 26) | (3 << 27)
+		o1 |= (v & 0x7FFFF) << 5
+		o1 |= int32(dr & 31)
+	}
+
+	return uint32(o1)
+}
+
+// load a constant (MOVCON or BITCON) in a into rt
+func (c *ctxt7) omovconst(as obj.As, p *obj.Prog, a *obj.Addr, rt int) (o1 uint32) {
+	if cls := oclass(a); cls == C_BITCON || cls == C_ABCON || cls == C_ABCON0 {
+		// or $bitcon, REGZERO, rt
+		mode := 64
+		var as1 obj.As
+		switch as {
+		case AMOVW:
+			as1 = AORRW
+			mode = 32
+		case AMOVD:
+			as1 = AORR
+		}
+		o1 = c.opirr(p, as1)
+		o1 |= bitconEncode(uint64(a.Offset), mode) | uint32(REGZERO&31)<<5 | uint32(rt&31)
+		return o1
+	}
+
+	if as == AMOVW {
+		d := uint32(a.Offset)
+		s := movcon(int64(d))
+		if s < 0 || 16*s >= 32 {
+			d = ^d
+			s = movcon(int64(d))
+			if s < 0 || 16*s >= 32 {
+				c.ctxt.Diag("impossible 32-bit move wide: %#x\n%v", uint32(a.Offset), p)
+			}
+			o1 = c.opirr(p, AMOVNW)
+		} else {
+			o1 = c.opirr(p, AMOVZW)
+		}
+		o1 |= MOVCONST(int64(d), s, rt)
+	}
+	if as == AMOVD {
+		d := a.Offset
+		s := movcon(d)
+		if s < 0 || 16*s >= 64 {
+			d = ^d
+			s = movcon(d)
+			if s < 0 || 16*s >= 64 {
+				c.ctxt.Diag("impossible 64-bit move wide: %#x\n%v", uint64(a.Offset), p)
+			}
+			o1 = c.opirr(p, AMOVN)
+		} else {
+			o1 = c.opirr(p, AMOVZ)
+		}
+		o1 |= MOVCONST(d, s, rt)
+	}
+	return o1
+}
+
+// load a 32-bit/64-bit large constant (LCON or VCON) in a.Offset into rt
+// put the instruction sequence in os and return the number of instructions.
+func (c *ctxt7) omovlconst(as obj.As, p *obj.Prog, a *obj.Addr, rt int, os []uint32) (num uint8) {
+	switch as {
+	case AMOVW:
+		d := uint32(a.Offset)
+		// use MOVZW and MOVKW to load a constant to rt
+		os[0] = c.opirr(p, AMOVZW)
+		os[0] |= MOVCONST(int64(d), 0, rt)
+		os[1] = c.opirr(p, AMOVKW)
+		os[1] |= MOVCONST(int64(d), 1, rt)
+		return 2
+
+	case AMOVD:
+		d := a.Offset
+		dn := ^d
+		var immh [4]uint64
+		var i int
+		zeroCount := int(0)
+		negCount := int(0)
+		for i = 0; i < 4; i++ {
+			immh[i] = uint64((d >> uint(i*16)) & 0xffff)
+			if immh[i] == 0 {
+				zeroCount++
+			} else if immh[i] == 0xffff {
+				negCount++
+			}
+		}
+
+		if zeroCount == 4 || negCount == 4 {
+			c.ctxt.Diag("the immediate should be MOVCON: %v", p)
+		}
+		switch {
+		case zeroCount == 3:
+			// one MOVZ
+			for i = 0; i < 4; i++ {
+				if immh[i] != 0 {
+					os[0] = c.opirr(p, AMOVZ)
+					os[0] |= MOVCONST(d, i, rt)
+					break
+				}
+			}
+			return 1
+
+		case negCount == 3:
+			// one MOVN
+			for i = 0; i < 4; i++ {
+				if immh[i] != 0xffff {
+					os[0] = c.opirr(p, AMOVN)
+					os[0] |= MOVCONST(dn, i, rt)
+					break
+				}
+			}
+			return 1
+
+		case zeroCount == 2:
+			// one MOVZ and one MOVK
+			for i = 0; i < 4; i++ {
+				if immh[i] != 0 {
+					os[0] = c.opirr(p, AMOVZ)
+					os[0] |= MOVCONST(d, i, rt)
+					i++
+					break
+				}
+			}
+			for ; i < 4; i++ {
+				if immh[i] != 0 {
+					os[1] = c.opirr(p, AMOVK)
+					os[1] |= MOVCONST(d, i, rt)
+				}
+			}
+			return 2
+
+		case negCount == 2:
+			// one MOVN and one MOVK
+			for i = 0; i < 4; i++ {
+				if immh[i] != 0xffff {
+					os[0] = c.opirr(p, AMOVN)
+					os[0] |= MOVCONST(dn, i, rt)
+					i++
+					break
+				}
+			}
+			for ; i < 4; i++ {
+				if immh[i] != 0xffff {
+					os[1] = c.opirr(p, AMOVK)
+					os[1] |= MOVCONST(d, i, rt)
+				}
+			}
+			return 2
+
+		case zeroCount == 1:
+			// one MOVZ and two MOVKs
+			for i = 0; i < 4; i++ {
+				if immh[i] != 0 {
+					os[0] = c.opirr(p, AMOVZ)
+					os[0] |= MOVCONST(d, i, rt)
+					i++
+					break
+				}
+			}
+
+			for j := 1; i < 4; i++ {
+				if immh[i] != 0 {
+					os[j] = c.opirr(p, AMOVK)
+					os[j] |= MOVCONST(d, i, rt)
+					j++
+				}
+			}
+			return 3
+
+		case negCount == 1:
+			// one MOVN and two MOVKs
+			for i = 0; i < 4; i++ {
+				if immh[i] != 0xffff {
+					os[0] = c.opirr(p, AMOVN)
+					os[0] |= MOVCONST(dn, i, rt)
+					i++
+					break
+				}
+			}
+
+			for j := 1; i < 4; i++ {
+				if immh[i] != 0xffff {
+					os[j] = c.opirr(p, AMOVK)
+					os[j] |= MOVCONST(d, i, rt)
+					j++
+				}
+			}
+			return 3
+
+		default:
+			// one MOVZ and 3 MOVKs
+			os[0] = c.opirr(p, AMOVZ)
+			os[0] |= MOVCONST(d, 0, rt)
+			for i = 1; i < 4; i++ {
+				os[i] = c.opirr(p, AMOVK)
+				os[i] |= MOVCONST(d, i, rt)
+			}
+			return 4
+		}
+	default:
+		return 0
+	}
+}
+
+func (c *ctxt7) opbfm(p *obj.Prog, a obj.As, r int, s int, rf int, rt int) uint32 {
+	var b uint32
+	o := c.opirr(p, a)
+	if (o & (1 << 31)) == 0 {
+		b = 32
+	} else {
+		b = 64
+	}
+	if r < 0 || uint32(r) >= b {
+		c.ctxt.Diag("illegal bit number\n%v", p)
+	}
+	o |= (uint32(r) & 0x3F) << 16
+	if s < 0 || uint32(s) >= b {
+		c.ctxt.Diag("illegal bit number\n%v", p)
+	}
+	o |= (uint32(s) & 0x3F) << 10
+	o |= (uint32(rf&31) << 5) | uint32(rt&31)
+	return o
+}
+
+func (c *ctxt7) opextr(p *obj.Prog, a obj.As, v int32, rn int, rm int, rt int) uint32 {
+	var b uint32
+	o := c.opirr(p, a)
+	if (o & (1 << 31)) != 0 {
+		b = 63
+	} else {
+		b = 31
+	}
+	if v < 0 || uint32(v) > b {
+		c.ctxt.Diag("illegal bit number\n%v", p)
+	}
+	o |= uint32(v) << 10
+	o |= uint32(rn&31) << 5
+	o |= uint32(rm&31) << 16
+	o |= uint32(rt & 31)
+	return o
+}
+
+/* genrate instruction encoding for LDP/LDPW/LDPSW/STP/STPW */
+func (c *ctxt7) opldpstp(p *obj.Prog, o *Optab, vo int32, rbase, rl, rh, ldp uint32) uint32 {
+	wback := false
+	if o.scond == C_XPOST || o.scond == C_XPRE {
+		wback = true
+	}
+	switch p.As {
+	case ALDP, ALDPW, ALDPSW:
+		c.checkUnpredictable(p, true, wback, p.From.Reg, p.To.Reg, int16(p.To.Offset))
+	case ASTP, ASTPW:
+		if wback == true {
+			c.checkUnpredictable(p, false, true, p.To.Reg, p.From.Reg, int16(p.From.Offset))
+		}
+	case AFLDPD, AFLDPS:
+		c.checkUnpredictable(p, true, false, p.From.Reg, p.To.Reg, int16(p.To.Offset))
+	}
+	var ret uint32
+	// check offset
+	switch p.As {
+	case AFLDPD, AFSTPD:
+		if vo < -512 || vo > 504 || vo%8 != 0 {
+			c.ctxt.Diag("invalid offset %v\n", p)
+		}
+		vo /= 8
+		ret = 1<<30 | 1<<26
+	case ALDP, ASTP:
+		if vo < -512 || vo > 504 || vo%8 != 0 {
+			c.ctxt.Diag("invalid offset %v\n", p)
+		}
+		vo /= 8
+		ret = 2 << 30
+	case AFLDPS, AFSTPS:
+		if vo < -256 || vo > 252 || vo%4 != 0 {
+			c.ctxt.Diag("invalid offset %v\n", p)
+		}
+		vo /= 4
+		ret = 1 << 26
+	case ALDPW, ASTPW:
+		if vo < -256 || vo > 252 || vo%4 != 0 {
+			c.ctxt.Diag("invalid offset %v\n", p)
+		}
+		vo /= 4
+		ret = 0
+	case ALDPSW:
+		if vo < -256 || vo > 252 || vo%4 != 0 {
+			c.ctxt.Diag("invalid offset %v\n", p)
+		}
+		vo /= 4
+		ret = 1 << 30
+	default:
+		c.ctxt.Diag("invalid instruction %v\n", p)
+	}
+	// check register pair
+	switch p.As {
+	case AFLDPD, AFLDPS, AFSTPD, AFSTPS:
+		if rl < REG_F0 || REG_F31 < rl || rh < REG_F0 || REG_F31 < rh {
+			c.ctxt.Diag("invalid register pair %v\n", p)
+		}
+	case ALDP, ALDPW, ALDPSW:
+		if rl < REG_R0 || REG_R30 < rl || rh < REG_R0 || REG_R30 < rh {
+			c.ctxt.Diag("invalid register pair %v\n", p)
+		}
+	case ASTP, ASTPW:
+		if rl < REG_R0 || REG_R31 < rl || rh < REG_R0 || REG_R31 < rh {
+			c.ctxt.Diag("invalid register pair %v\n", p)
+		}
+	}
+	// other conditional flag bits
+	switch o.scond {
+	case C_XPOST:
+		ret |= 1 << 23
+	case C_XPRE:
+		ret |= 3 << 23
+	default:
+		ret |= 2 << 23
+	}
+	ret |= 5<<27 | (ldp&1)<<22 | uint32(vo&0x7f)<<15 | (rh&31)<<10 | (rbase&31)<<5 | (rl & 31)
+	return ret
+}
+
+func (c *ctxt7) maskOpvldvst(p *obj.Prog, o1 uint32) uint32 {
+	if p.As == AVLD1 || p.As == AVST1 {
+		return o1
+	}
+
+	o1 &^= 0xf000 // mask out "opcode" field (bit 12-15)
+	switch p.As {
+	case AVLD1R, AVLD2R:
+		o1 |= 0xC << 12
+	case AVLD3R, AVLD4R:
+		o1 |= 0xE << 12
+	case AVLD2, AVST2:
+		o1 |= 8 << 12
+	case AVLD3, AVST3:
+		o1 |= 4 << 12
+	case AVLD4, AVST4:
+	default:
+		c.ctxt.Diag("unsupported instruction:%v\n", p.As)
+	}
+	return o1
+}
+
+/*
+ * size in log2(bytes)
+ */
+func movesize(a obj.As) int {
+	switch a {
+	case AMOVD:
+		return 3
+
+	case AMOVW, AMOVWU:
+		return 2
+
+	case AMOVH, AMOVHU:
+		return 1
+
+	case AMOVB, AMOVBU:
+		return 0
+
+	case AFMOVS:
+		return 2
+
+	case AFMOVD:
+		return 3
+
+	default:
+		return -1
+	}
+}
+
+// rm is the Rm register value, o is the extension, amount is the left shift value.
+func roff(rm int16, o uint32, amount int16) uint32 {
+	return uint32(rm&31)<<16 | o<<13 | uint32(amount)<<10
+}
+
+// encRegShiftOrExt returns the encoding of shifted/extended register, Rx<<n and Rx.UXTW<<n, etc.
+func (c *ctxt7) encRegShiftOrExt(a *obj.Addr, r int16) uint32 {
+	var num, rm int16
+	num = (r >> 5) & 7
+	rm = r & 31
+	switch {
+	case REG_UXTB <= r && r < REG_UXTH:
+		return roff(rm, 0, num)
+	case REG_UXTH <= r && r < REG_UXTW:
+		return roff(rm, 1, num)
+	case REG_UXTW <= r && r < REG_UXTX:
+		if a.Type == obj.TYPE_MEM {
+			if num == 0 {
+				return roff(rm, 2, 2)
+			} else {
+				return roff(rm, 2, 6)
+			}
+		} else {
+			return roff(rm, 2, num)
+		}
+	case REG_UXTX <= r && r < REG_SXTB:
+		return roff(rm, 3, num)
+	case REG_SXTB <= r && r < REG_SXTH:
+		return roff(rm, 4, num)
+	case REG_SXTH <= r && r < REG_SXTW:
+		return roff(rm, 5, num)
+	case REG_SXTW <= r && r < REG_SXTX:
+		if a.Type == obj.TYPE_MEM {
+			if num == 0 {
+				return roff(rm, 6, 2)
+			} else {
+				return roff(rm, 6, 6)
+			}
+		} else {
+			return roff(rm, 6, num)
+		}
+	case REG_SXTX <= r && r < REG_SPECIAL:
+		if a.Type == obj.TYPE_MEM {
+			if num == 0 {
+				return roff(rm, 7, 2)
+			} else {
+				return roff(rm, 7, 6)
+			}
+		} else {
+			return roff(rm, 7, num)
+		}
+	case REG_LSL <= r && r < (REG_LSL+1<<8):
+		return roff(rm, 3, 6)
+	default:
+		c.ctxt.Diag("unsupported register extension type.")
+	}
+
+	return 0
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/doc.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/doc.go
new file mode 100644
index 000000000..751521754
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/doc.go
@@ -0,0 +1,249 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Package arm64 implements an ARM64 assembler. Go assembly syntax is different from GNU ARM64
+syntax, but we can still follow the general rules to map between them.
+
+Instructions mnemonics mapping rules
+
+1. Most instructions use width suffixes of instruction names to indicate operand width rather than
+using different register names.
+
+  Examples:
+    ADC R24, R14, R12          <=>     adc x12, x24
+    ADDW R26->24, R21, R15     <=>     add w15, w21, w26, asr #24
+    FCMPS F2, F3               <=>     fcmp s3, s2
+    FCMPD F2, F3               <=>     fcmp d3, d2
+    FCVTDH F2, F3              <=>     fcvt h3, d2
+
+2. Go uses .P and .W suffixes to indicate post-increment and pre-increment.
+
+  Examples:
+    MOVD.P -8(R10), R8         <=>      ldr x8, [x10],#-8
+    MOVB.W 16(R16), R10        <=>      ldrsb x10, [x16,#16]!
+    MOVBU.W 16(R16), R10       <=>      ldrb x10, [x16,#16]!
+
+3. Go uses a series of MOV instructions as load and store.
+
+64-bit variant ldr, str, stur => MOVD;
+32-bit variant str, stur, ldrsw => MOVW;
+32-bit variant ldr => MOVWU;
+ldrb => MOVBU; ldrh => MOVHU;
+ldrsb, sturb, strb => MOVB;
+ldrsh, sturh, strh =>  MOVH.
+
+4. Go moves conditions into opcode suffix, like BLT.
+
+5. Go adds a V prefix for most floating-point and SIMD instructions, except cryptographic extension
+instructions and floating-point(scalar) instructions.
+
+  Examples:
+    VADD V5.H8, V18.H8, V9.H8         <=>      add v9.8h, v18.8h, v5.8h
+    VLD1.P (R6)(R11), [V31.D1]        <=>      ld1 {v31.1d}, [x6], x11
+    VFMLA V29.S2, V20.S2, V14.S2      <=>      fmla v14.2s, v20.2s, v29.2s
+    AESD V22.B16, V19.B16             <=>      aesd v19.16b, v22.16b
+    SCVTFWS R3, F16                   <=>      scvtf s17, w6
+
+6. Align directive
+
+Go asm supports the PCALIGN directive, which indicates that the next instruction should be aligned
+to a specified boundary by padding with NOOP instruction. The alignment value supported on arm64
+must be a power of 2 and in the range of [8, 2048].
+
+  Examples:
+    PCALIGN $16
+    MOVD $2, R0          // This instruction is aligned with 16 bytes.
+    PCALIGN $1024
+    MOVD $3, R1          // This instruction is aligned with 1024 bytes.
+
+PCALIGN also changes the function alignment. If a function has one or more PCALIGN directives,
+its address will be aligned to the same or coarser boundary, which is the maximum of all the
+alignment values.
+
+In the following example, the function Add is aligned with 128 bytes.
+  Examples:
+    TEXT ·Add(SB),$40-16
+    MOVD $2, R0
+    PCALIGN $32
+    MOVD $4, R1
+    PCALIGN $128
+    MOVD $8, R2
+    RET
+
+On arm64, functions in Go are aligned to 16 bytes by default, we can also use PCALGIN to set the
+function alignment. The functions that need to be aligned are preferably using NOFRAME and NOSPLIT
+to avoid the impact of the prologues inserted by the assembler, so that the function address will
+have the same alignment as the first hand-written instruction.
+
+In the following example, PCALIGN at the entry of the function Add will align its address to 2048 bytes.
+
+  Examples:
+    TEXT ·Add(SB),NOSPLIT|NOFRAME,$0
+      PCALIGN $2048
+      MOVD $1, R0
+      MOVD $1, R1
+      RET
+
+Special Cases.
+
+(1) umov is written as VMOV.
+
+(2) br is renamed JMP, blr is renamed CALL.
+
+(3) No need to add "W" suffix: LDARB, LDARH, LDAXRB, LDAXRH, LDTRH, LDXRB, LDXRH.
+
+(4) In Go assembly syntax, NOP is a zero-width pseudo-instruction serves generic purpose, nothing
+related to real ARM64 instruction. NOOP serves for the hardware nop instruction. NOOP is an alias of
+HINT $0.
+
+  Examples:
+    VMOV V13.B[1], R20      <=>      mov x20, v13.b[1]
+    VMOV V13.H[1], R20      <=>      mov w20, v13.h[1]
+    JMP (R3)                <=>      br x3
+    CALL (R17)              <=>      blr x17
+    LDAXRB (R19), R16       <=>      ldaxrb w16, [x19]
+    NOOP                    <=>      nop
+
+
+Register mapping rules
+
+1. All basic register names are written as Rn.
+
+2. Go uses ZR as the zero register and RSP as the stack pointer.
+
+3. Bn, Hn, Dn, Sn and Qn instructions are written as Fn in floating-point instructions and as Vn
+in SIMD instructions.
+
+
+Argument mapping rules
+
+1. The operands appear in left-to-right assignment order.
+
+Go reverses the arguments of most instructions.
+
+    Examples:
+      ADD R11.SXTB<<1, RSP, R25      <=>      add x25, sp, w11, sxtb #1
+      VADD V16, V19, V14             <=>      add d14, d19, d16
+
+Special Cases.
+
+(1) Argument order is the same as in the GNU ARM64 syntax: cbz, cbnz and some store instructions,
+such as str, stur, strb, sturb, strh, sturh stlr, stlrb. stlrh, st1.
+
+  Examples:
+    MOVD R29, 384(R19)    <=>    str x29, [x19,#384]
+    MOVB.P R30, 30(R4)    <=>    strb w30, [x4],#30
+    STLRH R21, (R19)      <=>    stlrh w21, [x19]
+
+(2) MADD, MADDW, MSUB, MSUBW, SMADDL, SMSUBL, UMADDL, UMSUBL <Rm>, <Ra>, <Rn>, <Rd>
+
+  Examples:
+    MADD R2, R30, R22, R6       <=>    madd x6, x22, x2, x30
+    SMSUBL R10, R3, R17, R27    <=>    smsubl x27, w17, w10, x3
+
+(3) FMADDD, FMADDS, FMSUBD, FMSUBS, FNMADDD, FNMADDS, FNMSUBD, FNMSUBS <Fm>, <Fa>, <Fn>, <Fd>
+
+  Examples:
+    FMADDD F30, F20, F3, F29    <=>    fmadd d29, d3, d30, d20
+    FNMSUBS F7, F25, F7, F22    <=>    fnmsub s22, s7, s7, s25
+
+(4) BFI, BFXIL, SBFIZ, SBFX, UBFIZ, UBFX $<lsb>, <Rn>, $<width>, <Rd>
+
+  Examples:
+    BFIW $16, R20, $6, R0      <=>    bfi w0, w20, #16, #6
+    UBFIZ $34, R26, $5, R20    <=>    ubfiz x20, x26, #34, #5
+
+(5) FCCMPD, FCCMPS, FCCMPED, FCCMPES <cond>, Fm. Fn, $<nzcv>
+
+  Examples:
+    FCCMPD AL, F8, F26, $0     <=>    fccmp d26, d8, #0x0, al
+    FCCMPS VS, F29, F4, $4     <=>    fccmp s4, s29, #0x4, vs
+    FCCMPED LE, F20, F5, $13   <=>    fccmpe d5, d20, #0xd, le
+    FCCMPES NE, F26, F10, $0   <=>    fccmpe s10, s26, #0x0, ne
+
+(6) CCMN, CCMNW, CCMP, CCMPW <cond>, <Rn>, $<imm>, $<nzcv>
+
+  Examples:
+    CCMP MI, R22, $12, $13     <=>    ccmp x22, #0xc, #0xd, mi
+    CCMNW AL, R1, $11, $8      <=>    ccmn w1, #0xb, #0x8, al
+
+(7) CCMN, CCMNW, CCMP, CCMPW <cond>, <Rn>, <Rm>, $<nzcv>
+
+  Examples:
+    CCMN VS, R13, R22, $10     <=>    ccmn x13, x22, #0xa, vs
+    CCMPW HS, R19, R14, $11    <=>    ccmp w19, w14, #0xb, cs
+
+(9) CSEL, CSELW, CSNEG, CSNEGW, CSINC, CSINCW <cond>, <Rn>, <Rm>, <Rd> ;
+FCSELD, FCSELS <cond>, <Fn>, <Fm>, <Fd>
+
+  Examples:
+    CSEL GT, R0, R19, R1        <=>    csel x1, x0, x19, gt
+    CSNEGW GT, R7, R17, R8      <=>    csneg w8, w7, w17, gt
+    FCSELD EQ, F15, F18, F16    <=>    fcsel d16, d15, d18, eq
+
+(10) TBNZ, TBZ $<imm>, <Rt>, <label>
+
+
+(11) STLXR, STLXRW, STXR, STXRW, STLXRB, STLXRH, STXRB, STXRH  <Rf>, (<Rn|RSP>), <Rs>
+
+  Examples:
+    STLXR ZR, (R15), R16    <=>    stlxr w16, xzr, [x15]
+    STXRB R9, (R21), R19    <=>    stxrb w19, w9, [x21]
+
+(12) STLXP, STLXPW, STXP, STXPW (<Rf1>, <Rf2>), (<Rn|RSP>), <Rs>
+
+  Examples:
+    STLXP (R17, R19), (R4), R5      <=>    stlxp w5, x17, x19, [x4]
+    STXPW (R30, R25), (R22), R13    <=>    stxp w13, w30, w25, [x22]
+
+2. Expressions for special arguments.
+
+#<immediate> is written as $<immediate>.
+
+Optionally-shifted immediate.
+
+  Examples:
+    ADD $(3151<<12), R14, R20     <=>    add x20, x14, #0xc4f, lsl #12
+    ADDW $1864, R25, R6           <=>    add w6, w25, #0x748
+
+Optionally-shifted registers are written as <Rm>{<shift><amount>}.
+The <shift> can be <<(lsl), >>(lsr), ->(asr), @>(ror).
+
+  Examples:
+    ADD R19>>30, R10, R24     <=>    add x24, x10, x19, lsr #30
+    ADDW R26->24, R21, R15    <=>    add w15, w21, w26, asr #24
+
+Extended registers are written as <Rm>{.<extend>{<<<amount>}}.
+<extend> can be UXTB, UXTH, UXTW, UXTX, SXTB, SXTH, SXTW or SXTX.
+
+  Examples:
+    ADDS R19.UXTB<<4, R9, R26     <=>    adds x26, x9, w19, uxtb #4
+    ADDSW R14.SXTX, R14, R6       <=>    adds w6, w14, w14, sxtx
+
+Memory references: [<Xn|SP>{,#0}] is written as (Rn|RSP), a base register and an immediate
+offset is written as imm(Rn|RSP), a base register and an offset register is written as (Rn|RSP)(Rm).
+
+  Examples:
+    LDAR (R22), R9                  <=>    ldar x9, [x22]
+    LDP 28(R17), (R15, R23)         <=>    ldp x15, x23, [x17,#28]
+    MOVWU (R4)(R12<<2), R8          <=>    ldr w8, [x4, x12, lsl #2]
+    MOVD (R7)(R11.UXTW<<3), R25     <=>    ldr x25, [x7,w11,uxtw #3]
+    MOVBU (R27)(R23), R14           <=>    ldrb w14, [x27,x23]
+
+Register pairs are written as (Rt1, Rt2).
+
+  Examples:
+    LDP.P -240(R11), (R12, R26)    <=>    ldp x12, x26, [x11],#-240
+
+Register with arrangement and register with arrangement and index.
+
+  Examples:
+    VADD V5.H8, V18.H8, V9.H8                     <=>    add v9.8h, v18.8h, v5.8h
+    VLD1 (R2), [V21.B16]                          <=>    ld1 {v21.16b}, [x2]
+    VST1.P V9.S[1], (R16)(R21)                    <=>    st1 {v9.s}[1], [x16], x28
+    VST1.P [V13.H8, V14.H8, V15.H8], (R3)(R14)    <=>    st1 {v13.8h-v15.8h}, [x3], x14
+    VST1.P [V14.D1, V15.D1], (R7)(R23)            <=>    st1 {v14.1d, v15.1d}, [x7], x23
+*/
+package arm64
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/list7.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/list7.go
new file mode 100644
index 000000000..1906c5fb9
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/list7.go
@@ -0,0 +1,288 @@
+// cmd/7l/list.c and cmd/7l/sub.c from Vita Nuova.
+// https://code.google.com/p/ken-cc/source/browse/
+//
+// 	Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
+// 	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+// 	Portions Copyright © 1997-1999 Vita Nuova Limited
+// 	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+// 	Portions Copyright © 2004,2006 Bruce Ellis
+// 	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+// 	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+// 	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package arm64
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"fmt"
+)
+
+var strcond = [16]string{
+	"EQ",
+	"NE",
+	"HS",
+	"LO",
+	"MI",
+	"PL",
+	"VS",
+	"VC",
+	"HI",
+	"LS",
+	"GE",
+	"LT",
+	"GT",
+	"LE",
+	"AL",
+	"NV",
+}
+
+func init() {
+	obj.RegisterRegister(obj.RBaseARM64, REG_SPECIAL+1024, rconv)
+	obj.RegisterOpcode(obj.ABaseARM64, Anames)
+	obj.RegisterRegisterList(obj.RegListARM64Lo, obj.RegListARM64Hi, rlconv)
+	obj.RegisterOpSuffix("arm64", obj.CConvARM)
+}
+
+func arrange(a int) string {
+	switch a {
+	case ARNG_8B:
+		return "B8"
+	case ARNG_16B:
+		return "B16"
+	case ARNG_4H:
+		return "H4"
+	case ARNG_8H:
+		return "H8"
+	case ARNG_2S:
+		return "S2"
+	case ARNG_4S:
+		return "S4"
+	case ARNG_1D:
+		return "D1"
+	case ARNG_2D:
+		return "D2"
+	case ARNG_B:
+		return "B"
+	case ARNG_H:
+		return "H"
+	case ARNG_S:
+		return "S"
+	case ARNG_D:
+		return "D"
+	case ARNG_1Q:
+		return "Q1"
+	default:
+		return ""
+	}
+}
+
+func rconv(r int) string {
+	ext := (r >> 5) & 7
+	if r == REGG {
+		return "g"
+	}
+	switch {
+	case REG_R0 <= r && r <= REG_R30:
+		return fmt.Sprintf("R%d", r-REG_R0)
+	case r == REG_R31:
+		return "ZR"
+	case REG_F0 <= r && r <= REG_F31:
+		return fmt.Sprintf("F%d", r-REG_F0)
+	case REG_V0 <= r && r <= REG_V31:
+		return fmt.Sprintf("V%d", r-REG_V0)
+	case COND_EQ <= r && r <= COND_NV:
+		return strcond[r-COND_EQ]
+	case r == REGSP:
+		return "RSP"
+	case r == REG_DAIFSet:
+		return "DAIFSet"
+	case r == REG_DAIFClr:
+		return "DAIFClr"
+	case r == REG_PLDL1KEEP:
+		return "PLDL1KEEP"
+	case r == REG_PLDL1STRM:
+		return "PLDL1STRM"
+	case r == REG_PLDL2KEEP:
+		return "PLDL2KEEP"
+	case r == REG_PLDL2STRM:
+		return "PLDL2STRM"
+	case r == REG_PLDL3KEEP:
+		return "PLDL3KEEP"
+	case r == REG_PLDL3STRM:
+		return "PLDL3STRM"
+	case r == REG_PLIL1KEEP:
+		return "PLIL1KEEP"
+	case r == REG_PLIL1STRM:
+		return "PLIL1STRM"
+	case r == REG_PLIL2KEEP:
+		return "PLIL2KEEP"
+	case r == REG_PLIL2STRM:
+		return "PLIL2STRM"
+	case r == REG_PLIL3KEEP:
+		return "PLIL3KEEP"
+	case r == REG_PLIL3STRM:
+		return "PLIL3STRM"
+	case r == REG_PSTL1KEEP:
+		return "PSTL1KEEP"
+	case r == REG_PSTL1STRM:
+		return "PSTL1STRM"
+	case r == REG_PSTL2KEEP:
+		return "PSTL2KEEP"
+	case r == REG_PSTL2STRM:
+		return "PSTL2STRM"
+	case r == REG_PSTL3KEEP:
+		return "PSTL3KEEP"
+	case r == REG_PSTL3STRM:
+		return "PSTL3STRM"
+	case REG_UXTB <= r && r < REG_UXTH:
+		if ext != 0 {
+			return fmt.Sprintf("%s.UXTB<<%d", regname(r), ext)
+		} else {
+			return fmt.Sprintf("%s.UXTB", regname(r))
+		}
+	case REG_UXTH <= r && r < REG_UXTW:
+		if ext != 0 {
+			return fmt.Sprintf("%s.UXTH<<%d", regname(r), ext)
+		} else {
+			return fmt.Sprintf("%s.UXTH", regname(r))
+		}
+	case REG_UXTW <= r && r < REG_UXTX:
+		if ext != 0 {
+			return fmt.Sprintf("%s.UXTW<<%d", regname(r), ext)
+		} else {
+			return fmt.Sprintf("%s.UXTW", regname(r))
+		}
+	case REG_UXTX <= r && r < REG_SXTB:
+		if ext != 0 {
+			return fmt.Sprintf("%s.UXTX<<%d", regname(r), ext)
+		} else {
+			return fmt.Sprintf("%s.UXTX", regname(r))
+		}
+	case REG_SXTB <= r && r < REG_SXTH:
+		if ext != 0 {
+			return fmt.Sprintf("%s.SXTB<<%d", regname(r), ext)
+		} else {
+			return fmt.Sprintf("%s.SXTB", regname(r))
+		}
+	case REG_SXTH <= r && r < REG_SXTW:
+		if ext != 0 {
+			return fmt.Sprintf("%s.SXTH<<%d", regname(r), ext)
+		} else {
+			return fmt.Sprintf("%s.SXTH", regname(r))
+		}
+	case REG_SXTW <= r && r < REG_SXTX:
+		if ext != 0 {
+			return fmt.Sprintf("%s.SXTW<<%d", regname(r), ext)
+		} else {
+			return fmt.Sprintf("%s.SXTW", regname(r))
+		}
+	case REG_SXTX <= r && r < REG_SPECIAL:
+		if ext != 0 {
+			return fmt.Sprintf("%s.SXTX<<%d", regname(r), ext)
+		} else {
+			return fmt.Sprintf("%s.SXTX", regname(r))
+		}
+	// bits 0-4 indicate register, bits 5-7 indicate shift amount, bit 8 equals to 0.
+	case REG_LSL <= r && r < (REG_LSL+1<<8):
+		return fmt.Sprintf("R%d<<%d", r&31, (r>>5)&7)
+	case REG_ARNG <= r && r < REG_ELEM:
+		return fmt.Sprintf("V%d.%s", r&31, arrange((r>>5)&15))
+	case REG_ELEM <= r && r < REG_ELEM_END:
+		return fmt.Sprintf("V%d.%s", r&31, arrange((r>>5)&15))
+	}
+	// Return system register name.
+	name, _, _ := SysRegEnc(int16(r))
+	if name != "" {
+		return name
+	}
+	return fmt.Sprintf("badreg(%d)", r)
+}
+
+func DRconv(a int) string {
+	if a >= C_NONE && a <= C_NCLASS {
+		return cnames7[a]
+	}
+	return "C_??"
+}
+
+func rlconv(list int64) string {
+	str := ""
+
+	// ARM64 register list follows ARM64 instruction decode schema
+	// | 31 | 30 | ... | 15 - 12 | 11 - 10 | ... |
+	// +----+----+-----+---------+---------+-----+
+	// |    | Q  | ... | opcode  |   size  | ... |
+
+	firstReg := int(list & 31)
+	opcode := (list >> 12) & 15
+	var regCnt int
+	var t string
+	switch opcode {
+	case 0x7:
+		regCnt = 1
+	case 0xa:
+		regCnt = 2
+	case 0x6:
+		regCnt = 3
+	case 0x2:
+		regCnt = 4
+	default:
+		regCnt = -1
+	}
+	// Q:size
+	arng := ((list>>30)&1)<<2 | (list>>10)&3
+	switch arng {
+	case 0:
+		t = "B8"
+	case 4:
+		t = "B16"
+	case 1:
+		t = "H4"
+	case 5:
+		t = "H8"
+	case 2:
+		t = "S2"
+	case 6:
+		t = "S4"
+	case 3:
+		t = "D1"
+	case 7:
+		t = "D2"
+	}
+	for i := 0; i < regCnt; i++ {
+		if str == "" {
+			str += "["
+		} else {
+			str += ","
+		}
+		str += fmt.Sprintf("V%d.", (firstReg+i)&31)
+		str += t
+	}
+	str += "]"
+	return str
+}
+
+func regname(r int) string {
+	if r&31 == 31 {
+		return "ZR"
+	}
+	return fmt.Sprintf("R%d", r&31)
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/obj7.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/obj7.go
new file mode 100644
index 000000000..d2d935bd4
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/obj7.go
@@ -0,0 +1,998 @@
+// cmd/7l/noop.c, cmd/7l/obj.c, cmd/ld/pass.c from Vita Nuova.
+// https://code.google.com/p/ken-cc/source/browse/
+//
+// 	Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
+// 	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+// 	Portions Copyright © 1997-1999 Vita Nuova Limited
+// 	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+// 	Portions Copyright © 2004,2006 Bruce Ellis
+// 	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+// 	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+// 	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package arm64
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"github.com/twitchyliquid64/golang-asm/src"
+	"github.com/twitchyliquid64/golang-asm/sys"
+	"math"
+)
+
+var complements = []obj.As{
+	AADD:  ASUB,
+	AADDW: ASUBW,
+	ASUB:  AADD,
+	ASUBW: AADDW,
+	ACMP:  ACMN,
+	ACMPW: ACMNW,
+	ACMN:  ACMP,
+	ACMNW: ACMPW,
+}
+
+func (c *ctxt7) stacksplit(p *obj.Prog, framesize int32) *obj.Prog {
+	// MOV	g_stackguard(g), R1
+	p = obj.Appendp(p, c.newprog)
+
+	p.As = AMOVD
+	p.From.Type = obj.TYPE_MEM
+	p.From.Reg = REGG
+	p.From.Offset = 2 * int64(c.ctxt.Arch.PtrSize) // G.stackguard0
+	if c.cursym.CFunc() {
+		p.From.Offset = 3 * int64(c.ctxt.Arch.PtrSize) // G.stackguard1
+	}
+	p.To.Type = obj.TYPE_REG
+	p.To.Reg = REG_R1
+
+	// Mark the stack bound check and morestack call async nonpreemptible.
+	// If we get preempted here, when resumed the preemption request is
+	// cleared, but we'll still call morestack, which will double the stack
+	// unnecessarily. See issue #35470.
+	p = c.ctxt.StartUnsafePoint(p, c.newprog)
+
+	q := (*obj.Prog)(nil)
+	if framesize <= objabi.StackSmall {
+		// small stack: SP < stackguard
+		//	MOV	SP, R2
+		//	CMP	stackguard, R2
+		p = obj.Appendp(p, c.newprog)
+
+		p.As = AMOVD
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REGSP
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R2
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = ACMP
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R1
+		p.Reg = REG_R2
+	} else if framesize <= objabi.StackBig {
+		// large stack: SP-framesize < stackguard-StackSmall
+		//	SUB	$(framesize-StackSmall), SP, R2
+		//	CMP	stackguard, R2
+		p = obj.Appendp(p, c.newprog)
+
+		p.As = ASUB
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = int64(framesize) - objabi.StackSmall
+		p.Reg = REGSP
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R2
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = ACMP
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R1
+		p.Reg = REG_R2
+	} else {
+		// Such a large stack we need to protect against wraparound
+		// if SP is close to zero.
+		//	SP-stackguard+StackGuard < framesize + (StackGuard-StackSmall)
+		// The +StackGuard on both sides is required to keep the left side positive:
+		// SP is allowed to be slightly below stackguard. See stack.h.
+		//	CMP	$StackPreempt, R1
+		//	BEQ	label_of_call_to_morestack
+		//	ADD	$StackGuard, SP, R2
+		//	SUB	R1, R2
+		//	MOV	$(framesize+(StackGuard-StackSmall)), R3
+		//	CMP	R3, R2
+		p = obj.Appendp(p, c.newprog)
+
+		p.As = ACMP
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = objabi.StackPreempt
+		p.Reg = REG_R1
+
+		p = obj.Appendp(p, c.newprog)
+		q = p
+		p.As = ABEQ
+		p.To.Type = obj.TYPE_BRANCH
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = AADD
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = int64(objabi.StackGuard)
+		p.Reg = REGSP
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R2
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = ASUB
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R1
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R2
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = AMOVD
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = int64(framesize) + (int64(objabi.StackGuard) - objabi.StackSmall)
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R3
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = ACMP
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R3
+		p.Reg = REG_R2
+	}
+
+	// BLS	do-morestack
+	bls := obj.Appendp(p, c.newprog)
+	bls.As = ABLS
+	bls.To.Type = obj.TYPE_BRANCH
+
+	end := c.ctxt.EndUnsafePoint(bls, c.newprog, -1)
+
+	var last *obj.Prog
+	for last = c.cursym.Func.Text; last.Link != nil; last = last.Link {
+	}
+
+	// Now we are at the end of the function, but logically
+	// we are still in function prologue. We need to fix the
+	// SP data and PCDATA.
+	spfix := obj.Appendp(last, c.newprog)
+	spfix.As = obj.ANOP
+	spfix.Spadj = -framesize
+
+	pcdata := c.ctxt.EmitEntryStackMap(c.cursym, spfix, c.newprog)
+	pcdata = c.ctxt.StartUnsafePoint(pcdata, c.newprog)
+
+	// MOV	LR, R3
+	movlr := obj.Appendp(pcdata, c.newprog)
+	movlr.As = AMOVD
+	movlr.From.Type = obj.TYPE_REG
+	movlr.From.Reg = REGLINK
+	movlr.To.Type = obj.TYPE_REG
+	movlr.To.Reg = REG_R3
+	if q != nil {
+		q.To.SetTarget(movlr)
+	}
+	bls.To.SetTarget(movlr)
+
+	debug := movlr
+	if false {
+		debug = obj.Appendp(debug, c.newprog)
+		debug.As = AMOVD
+		debug.From.Type = obj.TYPE_CONST
+		debug.From.Offset = int64(framesize)
+		debug.To.Type = obj.TYPE_REG
+		debug.To.Reg = REGTMP
+	}
+
+	// BL	runtime.morestack(SB)
+	call := obj.Appendp(debug, c.newprog)
+	call.As = ABL
+	call.To.Type = obj.TYPE_BRANCH
+	morestack := "runtime.morestack"
+	switch {
+	case c.cursym.CFunc():
+		morestack = "runtime.morestackc"
+	case !c.cursym.Func.Text.From.Sym.NeedCtxt():
+		morestack = "runtime.morestack_noctxt"
+	}
+	call.To.Sym = c.ctxt.Lookup(morestack)
+
+	pcdata = c.ctxt.EndUnsafePoint(call, c.newprog, -1)
+
+	// B	start
+	jmp := obj.Appendp(pcdata, c.newprog)
+	jmp.As = AB
+	jmp.To.Type = obj.TYPE_BRANCH
+	jmp.To.SetTarget(c.cursym.Func.Text.Link)
+	jmp.Spadj = +framesize
+
+	return end
+}
+
+func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
+	c := ctxt7{ctxt: ctxt, newprog: newprog}
+
+	p.From.Class = 0
+	p.To.Class = 0
+
+	// $0 results in C_ZCON, which matches both C_REG and various
+	// C_xCON, however the C_REG cases in asmout don't expect a
+	// constant, so they will use the register fields and assemble
+	// a R0. To prevent that, rewrite $0 as ZR.
+	if p.From.Type == obj.TYPE_CONST && p.From.Offset == 0 {
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REGZERO
+	}
+	if p.To.Type == obj.TYPE_CONST && p.To.Offset == 0 {
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REGZERO
+	}
+
+	// Rewrite BR/BL to symbol as TYPE_BRANCH.
+	switch p.As {
+	case AB,
+		ABL,
+		obj.ARET,
+		obj.ADUFFZERO,
+		obj.ADUFFCOPY:
+		if p.To.Sym != nil {
+			p.To.Type = obj.TYPE_BRANCH
+		}
+		break
+	}
+
+	// Rewrite float constants to values stored in memory.
+	switch p.As {
+	case AFMOVS:
+		if p.From.Type == obj.TYPE_FCONST {
+			f64 := p.From.Val.(float64)
+			f32 := float32(f64)
+			if c.chipfloat7(f64) > 0 {
+				break
+			}
+			if math.Float32bits(f32) == 0 {
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REGZERO
+				break
+			}
+			p.From.Type = obj.TYPE_MEM
+			p.From.Sym = c.ctxt.Float32Sym(f32)
+			p.From.Name = obj.NAME_EXTERN
+			p.From.Offset = 0
+		}
+
+	case AFMOVD:
+		if p.From.Type == obj.TYPE_FCONST {
+			f64 := p.From.Val.(float64)
+			if c.chipfloat7(f64) > 0 {
+				break
+			}
+			if math.Float64bits(f64) == 0 {
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REGZERO
+				break
+			}
+			p.From.Type = obj.TYPE_MEM
+			p.From.Sym = c.ctxt.Float64Sym(f64)
+			p.From.Name = obj.NAME_EXTERN
+			p.From.Offset = 0
+		}
+
+		break
+	}
+
+	// Rewrite negative immediates as positive immediates with
+	// complementary instruction.
+	switch p.As {
+	case AADD, ASUB, ACMP, ACMN:
+		if p.From.Type == obj.TYPE_CONST && p.From.Offset < 0 && p.From.Offset != -1<<63 {
+			p.From.Offset = -p.From.Offset
+			p.As = complements[p.As]
+		}
+	case AADDW, ASUBW, ACMPW, ACMNW:
+		if p.From.Type == obj.TYPE_CONST && p.From.Offset < 0 && int32(p.From.Offset) != -1<<31 {
+			p.From.Offset = -p.From.Offset
+			p.As = complements[p.As]
+		}
+	}
+
+	// For 32-bit logical instruction with constant,
+	// rewrite the high 32-bit to be a repetition of
+	// the low 32-bit, so that the BITCON test can be
+	// shared for both 32-bit and 64-bit. 32-bit ops
+	// will zero the high 32-bit of the destination
+	// register anyway.
+	if isANDWop(p.As) && p.From.Type == obj.TYPE_CONST {
+		v := p.From.Offset & 0xffffffff
+		p.From.Offset = v | v<<32
+	}
+
+	if c.ctxt.Flag_dynlink {
+		c.rewriteToUseGot(p)
+	}
+}
+
+// Rewrite p, if necessary, to access global data via the global offset table.
+func (c *ctxt7) rewriteToUseGot(p *obj.Prog) {
+	if p.As == obj.ADUFFCOPY || p.As == obj.ADUFFZERO {
+		//     ADUFFxxx $offset
+		// becomes
+		//     MOVD runtime.duffxxx@GOT, REGTMP
+		//     ADD $offset, REGTMP
+		//     CALL REGTMP
+		var sym *obj.LSym
+		if p.As == obj.ADUFFZERO {
+			sym = c.ctxt.Lookup("runtime.duffzero")
+		} else {
+			sym = c.ctxt.Lookup("runtime.duffcopy")
+		}
+		offset := p.To.Offset
+		p.As = AMOVD
+		p.From.Type = obj.TYPE_MEM
+		p.From.Name = obj.NAME_GOTREF
+		p.From.Sym = sym
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REGTMP
+		p.To.Name = obj.NAME_NONE
+		p.To.Offset = 0
+		p.To.Sym = nil
+		p1 := obj.Appendp(p, c.newprog)
+		p1.As = AADD
+		p1.From.Type = obj.TYPE_CONST
+		p1.From.Offset = offset
+		p1.To.Type = obj.TYPE_REG
+		p1.To.Reg = REGTMP
+		p2 := obj.Appendp(p1, c.newprog)
+		p2.As = obj.ACALL
+		p2.To.Type = obj.TYPE_REG
+		p2.To.Reg = REGTMP
+	}
+
+	// We only care about global data: NAME_EXTERN means a global
+	// symbol in the Go sense, and p.Sym.Local is true for a few
+	// internally defined symbols.
+	if p.From.Type == obj.TYPE_ADDR && p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
+		// MOVD $sym, Rx becomes MOVD sym@GOT, Rx
+		// MOVD $sym+<off>, Rx becomes MOVD sym@GOT, Rx; ADD <off>, Rx
+		if p.As != AMOVD {
+			c.ctxt.Diag("do not know how to handle TYPE_ADDR in %v with -dynlink", p)
+		}
+		if p.To.Type != obj.TYPE_REG {
+			c.ctxt.Diag("do not know how to handle LEAQ-type insn to non-register in %v with -dynlink", p)
+		}
+		p.From.Type = obj.TYPE_MEM
+		p.From.Name = obj.NAME_GOTREF
+		if p.From.Offset != 0 {
+			q := obj.Appendp(p, c.newprog)
+			q.As = AADD
+			q.From.Type = obj.TYPE_CONST
+			q.From.Offset = p.From.Offset
+			q.To = p.To
+			p.From.Offset = 0
+		}
+	}
+	if p.GetFrom3() != nil && p.GetFrom3().Name == obj.NAME_EXTERN {
+		c.ctxt.Diag("don't know how to handle %v with -dynlink", p)
+	}
+	var source *obj.Addr
+	// MOVx sym, Ry becomes MOVD sym@GOT, REGTMP; MOVx (REGTMP), Ry
+	// MOVx Ry, sym becomes MOVD sym@GOT, REGTMP; MOVD Ry, (REGTMP)
+	// An addition may be inserted between the two MOVs if there is an offset.
+	if p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
+		if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
+			c.ctxt.Diag("cannot handle NAME_EXTERN on both sides in %v with -dynlink", p)
+		}
+		source = &p.From
+	} else if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
+		source = &p.To
+	} else {
+		return
+	}
+	if p.As == obj.ATEXT || p.As == obj.AFUNCDATA || p.As == obj.ACALL || p.As == obj.ARET || p.As == obj.AJMP {
+		return
+	}
+	if source.Sym.Type == objabi.STLSBSS {
+		return
+	}
+	if source.Type != obj.TYPE_MEM {
+		c.ctxt.Diag("don't know how to handle %v with -dynlink", p)
+	}
+	p1 := obj.Appendp(p, c.newprog)
+	p2 := obj.Appendp(p1, c.newprog)
+	p1.As = AMOVD
+	p1.From.Type = obj.TYPE_MEM
+	p1.From.Sym = source.Sym
+	p1.From.Name = obj.NAME_GOTREF
+	p1.To.Type = obj.TYPE_REG
+	p1.To.Reg = REGTMP
+
+	p2.As = p.As
+	p2.From = p.From
+	p2.To = p.To
+	if p.From.Name == obj.NAME_EXTERN {
+		p2.From.Reg = REGTMP
+		p2.From.Name = obj.NAME_NONE
+		p2.From.Sym = nil
+	} else if p.To.Name == obj.NAME_EXTERN {
+		p2.To.Reg = REGTMP
+		p2.To.Name = obj.NAME_NONE
+		p2.To.Sym = nil
+	} else {
+		return
+	}
+	obj.Nopout(p)
+}
+
+func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
+	if cursym.Func.Text == nil || cursym.Func.Text.Link == nil {
+		return
+	}
+
+	c := ctxt7{ctxt: ctxt, newprog: newprog, cursym: cursym}
+
+	p := c.cursym.Func.Text
+	textstksiz := p.To.Offset
+	if textstksiz == -8 {
+		// Historical way to mark NOFRAME.
+		p.From.Sym.Set(obj.AttrNoFrame, true)
+		textstksiz = 0
+	}
+	if textstksiz < 0 {
+		c.ctxt.Diag("negative frame size %d - did you mean NOFRAME?", textstksiz)
+	}
+	if p.From.Sym.NoFrame() {
+		if textstksiz != 0 {
+			c.ctxt.Diag("NOFRAME functions must have a frame size of 0, not %d", textstksiz)
+		}
+	}
+
+	c.cursym.Func.Args = p.To.Val.(int32)
+	c.cursym.Func.Locals = int32(textstksiz)
+
+	/*
+	 * find leaf subroutines
+	 */
+	for p := c.cursym.Func.Text; p != nil; p = p.Link {
+		switch p.As {
+		case obj.ATEXT:
+			p.Mark |= LEAF
+
+		case ABL,
+			obj.ADUFFZERO,
+			obj.ADUFFCOPY:
+			c.cursym.Func.Text.Mark &^= LEAF
+		}
+	}
+
+	var q *obj.Prog
+	var q1 *obj.Prog
+	var retjmp *obj.LSym
+	for p := c.cursym.Func.Text; p != nil; p = p.Link {
+		o := p.As
+		switch o {
+		case obj.ATEXT:
+			c.cursym.Func.Text = p
+			c.autosize = int32(textstksiz)
+
+			if p.Mark&LEAF != 0 && c.autosize == 0 {
+				// A leaf function with no locals has no frame.
+				p.From.Sym.Set(obj.AttrNoFrame, true)
+			}
+
+			if !p.From.Sym.NoFrame() {
+				// If there is a stack frame at all, it includes
+				// space to save the LR.
+				c.autosize += 8
+			}
+
+			if c.autosize != 0 {
+				extrasize := int32(0)
+				if c.autosize%16 == 8 {
+					// Allocate extra 8 bytes on the frame top to save FP
+					extrasize = 8
+				} else if c.autosize&(16-1) == 0 {
+					// Allocate extra 16 bytes to save FP for the old frame whose size is 8 mod 16
+					extrasize = 16
+				} else {
+					c.ctxt.Diag("%v: unaligned frame size %d - must be 16 aligned", p, c.autosize-8)
+				}
+				c.autosize += extrasize
+				c.cursym.Func.Locals += extrasize
+
+				// low 32 bits for autosize
+				// high 32 bits for extrasize
+				p.To.Offset = int64(c.autosize) | int64(extrasize)<<32
+			} else {
+				// NOFRAME
+				p.To.Offset = 0
+			}
+
+			if c.autosize == 0 && c.cursym.Func.Text.Mark&LEAF == 0 {
+				if c.ctxt.Debugvlog {
+					c.ctxt.Logf("save suppressed in: %s\n", c.cursym.Func.Text.From.Sym.Name)
+				}
+				c.cursym.Func.Text.Mark |= LEAF
+			}
+
+			if cursym.Func.Text.Mark&LEAF != 0 {
+				cursym.Set(obj.AttrLeaf, true)
+				if p.From.Sym.NoFrame() {
+					break
+				}
+			}
+
+			if !p.From.Sym.NoSplit() {
+				p = c.stacksplit(p, c.autosize) // emit split check
+			}
+
+			var prologueEnd *obj.Prog
+
+			aoffset := c.autosize
+			if aoffset > 0xF0 {
+				aoffset = 0xF0
+			}
+
+			// Frame is non-empty. Make sure to save link register, even if
+			// it is a leaf function, so that traceback works.
+			q = p
+			if c.autosize > aoffset {
+				// Frame size is too large for a MOVD.W instruction.
+				// Store link register before decrementing SP, so if a signal comes
+				// during the execution of the function prologue, the traceback
+				// code will not see a half-updated stack frame.
+				// This sequence is not async preemptible, as if we open a frame
+				// at the current SP, it will clobber the saved LR.
+				q = c.ctxt.StartUnsafePoint(q, c.newprog)
+
+				q = obj.Appendp(q, c.newprog)
+				q.Pos = p.Pos
+				q.As = ASUB
+				q.From.Type = obj.TYPE_CONST
+				q.From.Offset = int64(c.autosize)
+				q.Reg = REGSP
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REGTMP
+
+				prologueEnd = q
+
+				q = obj.Appendp(q, c.newprog)
+				q.Pos = p.Pos
+				q.As = AMOVD
+				q.From.Type = obj.TYPE_REG
+				q.From.Reg = REGLINK
+				q.To.Type = obj.TYPE_MEM
+				q.To.Reg = REGTMP
+
+				q1 = obj.Appendp(q, c.newprog)
+				q1.Pos = p.Pos
+				q1.As = AMOVD
+				q1.From.Type = obj.TYPE_REG
+				q1.From.Reg = REGTMP
+				q1.To.Type = obj.TYPE_REG
+				q1.To.Reg = REGSP
+				q1.Spadj = c.autosize
+
+				if c.ctxt.Headtype == objabi.Hdarwin {
+					// iOS does not support SA_ONSTACK. We will run the signal handler
+					// on the G stack. If we write below SP, it may be clobbered by
+					// the signal handler. So we save LR after decrementing SP.
+					q1 = obj.Appendp(q1, c.newprog)
+					q1.Pos = p.Pos
+					q1.As = AMOVD
+					q1.From.Type = obj.TYPE_REG
+					q1.From.Reg = REGLINK
+					q1.To.Type = obj.TYPE_MEM
+					q1.To.Reg = REGSP
+				}
+
+				q1 = c.ctxt.EndUnsafePoint(q1, c.newprog, -1)
+			} else {
+				// small frame, update SP and save LR in a single MOVD.W instruction
+				q1 = obj.Appendp(q, c.newprog)
+				q1.As = AMOVD
+				q1.Pos = p.Pos
+				q1.From.Type = obj.TYPE_REG
+				q1.From.Reg = REGLINK
+				q1.To.Type = obj.TYPE_MEM
+				q1.Scond = C_XPRE
+				q1.To.Offset = int64(-aoffset)
+				q1.To.Reg = REGSP
+				q1.Spadj = aoffset
+
+				prologueEnd = q1
+			}
+
+			prologueEnd.Pos = prologueEnd.Pos.WithXlogue(src.PosPrologueEnd)
+
+			if objabi.Framepointer_enabled {
+				q1 = obj.Appendp(q1, c.newprog)
+				q1.Pos = p.Pos
+				q1.As = AMOVD
+				q1.From.Type = obj.TYPE_REG
+				q1.From.Reg = REGFP
+				q1.To.Type = obj.TYPE_MEM
+				q1.To.Reg = REGSP
+				q1.To.Offset = -8
+
+				q1 = obj.Appendp(q1, c.newprog)
+				q1.Pos = p.Pos
+				q1.As = ASUB
+				q1.From.Type = obj.TYPE_CONST
+				q1.From.Offset = 8
+				q1.Reg = REGSP
+				q1.To.Type = obj.TYPE_REG
+				q1.To.Reg = REGFP
+			}
+
+			if c.cursym.Func.Text.From.Sym.Wrapper() {
+				// if(g->panic != nil && g->panic->argp == FP) g->panic->argp = bottom-of-frame
+				//
+				//	MOV  g_panic(g), R1
+				//	CBNZ checkargp
+				// end:
+				//	NOP
+				// ... function body ...
+				// checkargp:
+				//	MOV  panic_argp(R1), R2
+				//	ADD  $(autosize+8), RSP, R3
+				//	CMP  R2, R3
+				//	BNE  end
+				//	ADD  $8, RSP, R4
+				//	MOVD R4, panic_argp(R1)
+				//	B    end
+				//
+				// The NOP is needed to give the jumps somewhere to land.
+				// It is a liblink NOP, not an ARM64 NOP: it encodes to 0 instruction bytes.
+				q = q1
+
+				// MOV g_panic(g), R1
+				q = obj.Appendp(q, c.newprog)
+				q.As = AMOVD
+				q.From.Type = obj.TYPE_MEM
+				q.From.Reg = REGG
+				q.From.Offset = 4 * int64(c.ctxt.Arch.PtrSize) // G.panic
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R1
+
+				// CBNZ R1, checkargp
+				cbnz := obj.Appendp(q, c.newprog)
+				cbnz.As = ACBNZ
+				cbnz.From.Type = obj.TYPE_REG
+				cbnz.From.Reg = REG_R1
+				cbnz.To.Type = obj.TYPE_BRANCH
+
+				// Empty branch target at the top of the function body
+				end := obj.Appendp(cbnz, c.newprog)
+				end.As = obj.ANOP
+
+				// find the end of the function
+				var last *obj.Prog
+				for last = end; last.Link != nil; last = last.Link {
+				}
+
+				// MOV panic_argp(R1), R2
+				mov := obj.Appendp(last, c.newprog)
+				mov.As = AMOVD
+				mov.From.Type = obj.TYPE_MEM
+				mov.From.Reg = REG_R1
+				mov.From.Offset = 0 // Panic.argp
+				mov.To.Type = obj.TYPE_REG
+				mov.To.Reg = REG_R2
+
+				// CBNZ branches to the MOV above
+				cbnz.To.SetTarget(mov)
+
+				// ADD $(autosize+8), SP, R3
+				q = obj.Appendp(mov, c.newprog)
+				q.As = AADD
+				q.From.Type = obj.TYPE_CONST
+				q.From.Offset = int64(c.autosize) + 8
+				q.Reg = REGSP
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R3
+
+				// CMP R2, R3
+				q = obj.Appendp(q, c.newprog)
+				q.As = ACMP
+				q.From.Type = obj.TYPE_REG
+				q.From.Reg = REG_R2
+				q.Reg = REG_R3
+
+				// BNE end
+				q = obj.Appendp(q, c.newprog)
+				q.As = ABNE
+				q.To.Type = obj.TYPE_BRANCH
+				q.To.SetTarget(end)
+
+				// ADD $8, SP, R4
+				q = obj.Appendp(q, c.newprog)
+				q.As = AADD
+				q.From.Type = obj.TYPE_CONST
+				q.From.Offset = 8
+				q.Reg = REGSP
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R4
+
+				// MOV R4, panic_argp(R1)
+				q = obj.Appendp(q, c.newprog)
+				q.As = AMOVD
+				q.From.Type = obj.TYPE_REG
+				q.From.Reg = REG_R4
+				q.To.Type = obj.TYPE_MEM
+				q.To.Reg = REG_R1
+				q.To.Offset = 0 // Panic.argp
+
+				// B end
+				q = obj.Appendp(q, c.newprog)
+				q.As = AB
+				q.To.Type = obj.TYPE_BRANCH
+				q.To.SetTarget(end)
+			}
+
+		case obj.ARET:
+			nocache(p)
+			if p.From.Type == obj.TYPE_CONST {
+				c.ctxt.Diag("using BECOME (%v) is not supported!", p)
+				break
+			}
+
+			retjmp = p.To.Sym
+			p.To = obj.Addr{}
+			if c.cursym.Func.Text.Mark&LEAF != 0 {
+				if c.autosize != 0 {
+					p.As = AADD
+					p.From.Type = obj.TYPE_CONST
+					p.From.Offset = int64(c.autosize)
+					p.To.Type = obj.TYPE_REG
+					p.To.Reg = REGSP
+					p.Spadj = -c.autosize
+
+					if objabi.Framepointer_enabled {
+						p = obj.Appendp(p, c.newprog)
+						p.As = ASUB
+						p.From.Type = obj.TYPE_CONST
+						p.From.Offset = 8
+						p.Reg = REGSP
+						p.To.Type = obj.TYPE_REG
+						p.To.Reg = REGFP
+					}
+				}
+			} else {
+				/* want write-back pre-indexed SP+autosize -> SP, loading REGLINK*/
+
+				if objabi.Framepointer_enabled {
+					p.As = AMOVD
+					p.From.Type = obj.TYPE_MEM
+					p.From.Reg = REGSP
+					p.From.Offset = -8
+					p.To.Type = obj.TYPE_REG
+					p.To.Reg = REGFP
+					p = obj.Appendp(p, c.newprog)
+				}
+
+				aoffset := c.autosize
+
+				if aoffset <= 0xF0 {
+					p.As = AMOVD
+					p.From.Type = obj.TYPE_MEM
+					p.Scond = C_XPOST
+					p.From.Offset = int64(aoffset)
+					p.From.Reg = REGSP
+					p.To.Type = obj.TYPE_REG
+					p.To.Reg = REGLINK
+					p.Spadj = -aoffset
+				} else {
+					p.As = AMOVD
+					p.From.Type = obj.TYPE_MEM
+					p.From.Offset = 0
+					p.From.Reg = REGSP
+					p.To.Type = obj.TYPE_REG
+					p.To.Reg = REGLINK
+
+					q = newprog()
+					q.As = AADD
+					q.From.Type = obj.TYPE_CONST
+					q.From.Offset = int64(aoffset)
+					q.To.Type = obj.TYPE_REG
+					q.To.Reg = REGSP
+					q.Link = p.Link
+					q.Spadj = int32(-q.From.Offset)
+					q.Pos = p.Pos
+					p.Link = q
+					p = q
+				}
+			}
+
+			if p.As != obj.ARET {
+				q = newprog()
+				q.Pos = p.Pos
+				q.Link = p.Link
+				p.Link = q
+				p = q
+			}
+
+			if retjmp != nil { // retjmp
+				p.As = AB
+				p.To.Type = obj.TYPE_BRANCH
+				p.To.Sym = retjmp
+				p.Spadj = +c.autosize
+				break
+			}
+
+			p.As = obj.ARET
+			p.To.Type = obj.TYPE_MEM
+			p.To.Offset = 0
+			p.To.Reg = REGLINK
+			p.Spadj = +c.autosize
+
+		case AADD, ASUB:
+			if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.From.Type == obj.TYPE_CONST {
+				if p.As == AADD {
+					p.Spadj = int32(-p.From.Offset)
+				} else {
+					p.Spadj = int32(+p.From.Offset)
+				}
+			}
+
+		case obj.AGETCALLERPC:
+			if cursym.Leaf() {
+				/* MOVD LR, Rd */
+				p.As = AMOVD
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REGLINK
+			} else {
+				/* MOVD (RSP), Rd */
+				p.As = AMOVD
+				p.From.Type = obj.TYPE_MEM
+				p.From.Reg = REGSP
+			}
+
+		case obj.ADUFFCOPY:
+			if objabi.Framepointer_enabled {
+				//  ADR	ret_addr, R27
+				//  STP	(FP, R27), -24(SP)
+				//  SUB	24, SP, FP
+				//  DUFFCOPY
+				// ret_addr:
+				//  SUB	8, SP, FP
+
+				q1 := p
+				// copy DUFFCOPY from q1 to q4
+				q4 := obj.Appendp(p, c.newprog)
+				q4.Pos = p.Pos
+				q4.As = obj.ADUFFCOPY
+				q4.To = p.To
+
+				q1.As = AADR
+				q1.From.Type = obj.TYPE_BRANCH
+				q1.To.Type = obj.TYPE_REG
+				q1.To.Reg = REG_R27
+
+				q2 := obj.Appendp(q1, c.newprog)
+				q2.Pos = p.Pos
+				q2.As = ASTP
+				q2.From.Type = obj.TYPE_REGREG
+				q2.From.Reg = REGFP
+				q2.From.Offset = int64(REG_R27)
+				q2.To.Type = obj.TYPE_MEM
+				q2.To.Reg = REGSP
+				q2.To.Offset = -24
+
+				// maintaine FP for DUFFCOPY
+				q3 := obj.Appendp(q2, c.newprog)
+				q3.Pos = p.Pos
+				q3.As = ASUB
+				q3.From.Type = obj.TYPE_CONST
+				q3.From.Offset = 24
+				q3.Reg = REGSP
+				q3.To.Type = obj.TYPE_REG
+				q3.To.Reg = REGFP
+
+				q5 := obj.Appendp(q4, c.newprog)
+				q5.Pos = p.Pos
+				q5.As = ASUB
+				q5.From.Type = obj.TYPE_CONST
+				q5.From.Offset = 8
+				q5.Reg = REGSP
+				q5.To.Type = obj.TYPE_REG
+				q5.To.Reg = REGFP
+				q1.From.SetTarget(q5)
+				p = q5
+			}
+
+		case obj.ADUFFZERO:
+			if objabi.Framepointer_enabled {
+				//  ADR	ret_addr, R27
+				//  STP	(FP, R27), -24(SP)
+				//  SUB	24, SP, FP
+				//  DUFFZERO
+				// ret_addr:
+				//  SUB	8, SP, FP
+
+				q1 := p
+				// copy DUFFZERO from q1 to q4
+				q4 := obj.Appendp(p, c.newprog)
+				q4.Pos = p.Pos
+				q4.As = obj.ADUFFZERO
+				q4.To = p.To
+
+				q1.As = AADR
+				q1.From.Type = obj.TYPE_BRANCH
+				q1.To.Type = obj.TYPE_REG
+				q1.To.Reg = REG_R27
+
+				q2 := obj.Appendp(q1, c.newprog)
+				q2.Pos = p.Pos
+				q2.As = ASTP
+				q2.From.Type = obj.TYPE_REGREG
+				q2.From.Reg = REGFP
+				q2.From.Offset = int64(REG_R27)
+				q2.To.Type = obj.TYPE_MEM
+				q2.To.Reg = REGSP
+				q2.To.Offset = -24
+
+				// maintaine FP for DUFFZERO
+				q3 := obj.Appendp(q2, c.newprog)
+				q3.Pos = p.Pos
+				q3.As = ASUB
+				q3.From.Type = obj.TYPE_CONST
+				q3.From.Offset = 24
+				q3.Reg = REGSP
+				q3.To.Type = obj.TYPE_REG
+				q3.To.Reg = REGFP
+
+				q5 := obj.Appendp(q4, c.newprog)
+				q5.Pos = p.Pos
+				q5.As = ASUB
+				q5.From.Type = obj.TYPE_CONST
+				q5.From.Offset = 8
+				q5.Reg = REGSP
+				q5.To.Type = obj.TYPE_REG
+				q5.To.Reg = REGFP
+				q1.From.SetTarget(q5)
+				p = q5
+			}
+		}
+	}
+}
+
+func nocache(p *obj.Prog) {
+	p.Optab = 0
+	p.From.Class = 0
+	p.To.Class = 0
+}
+
+var unaryDst = map[obj.As]bool{
+	AWORD:  true,
+	ADWORD: true,
+	ABL:    true,
+	AB:     true,
+	ACLREX: true,
+}
+
+var Linkarm64 = obj.LinkArch{
+	Arch:           sys.ArchARM64,
+	Init:           buildop,
+	Preprocess:     preprocess,
+	Assemble:       span7,
+	Progedit:       progedit,
+	UnaryDst:       unaryDst,
+	DWARFRegisters: ARM64DWARFRegisters,
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/sysRegEnc.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/sysRegEnc.go
new file mode 100644
index 000000000..7760a4483
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/arm64/sysRegEnc.go
@@ -0,0 +1,895 @@
+// Code generated by arm64gen -i ./files -o sysRegEnc.go. DO NOT EDIT.
+
+package arm64
+
+const (
+	SYSREG_BEGIN = REG_SPECIAL + iota
+	REG_ACTLR_EL1
+	REG_AFSR0_EL1
+	REG_AFSR1_EL1
+	REG_AIDR_EL1
+	REG_AMAIR_EL1
+	REG_AMCFGR_EL0
+	REG_AMCGCR_EL0
+	REG_AMCNTENCLR0_EL0
+	REG_AMCNTENCLR1_EL0
+	REG_AMCNTENSET0_EL0
+	REG_AMCNTENSET1_EL0
+	REG_AMCR_EL0
+	REG_AMEVCNTR00_EL0
+	REG_AMEVCNTR01_EL0
+	REG_AMEVCNTR02_EL0
+	REG_AMEVCNTR03_EL0
+	REG_AMEVCNTR04_EL0
+	REG_AMEVCNTR05_EL0
+	REG_AMEVCNTR06_EL0
+	REG_AMEVCNTR07_EL0
+	REG_AMEVCNTR08_EL0
+	REG_AMEVCNTR09_EL0
+	REG_AMEVCNTR010_EL0
+	REG_AMEVCNTR011_EL0
+	REG_AMEVCNTR012_EL0
+	REG_AMEVCNTR013_EL0
+	REG_AMEVCNTR014_EL0
+	REG_AMEVCNTR015_EL0
+	REG_AMEVCNTR10_EL0
+	REG_AMEVCNTR11_EL0
+	REG_AMEVCNTR12_EL0
+	REG_AMEVCNTR13_EL0
+	REG_AMEVCNTR14_EL0
+	REG_AMEVCNTR15_EL0
+	REG_AMEVCNTR16_EL0
+	REG_AMEVCNTR17_EL0
+	REG_AMEVCNTR18_EL0
+	REG_AMEVCNTR19_EL0
+	REG_AMEVCNTR110_EL0
+	REG_AMEVCNTR111_EL0
+	REG_AMEVCNTR112_EL0
+	REG_AMEVCNTR113_EL0
+	REG_AMEVCNTR114_EL0
+	REG_AMEVCNTR115_EL0
+	REG_AMEVTYPER00_EL0
+	REG_AMEVTYPER01_EL0
+	REG_AMEVTYPER02_EL0
+	REG_AMEVTYPER03_EL0
+	REG_AMEVTYPER04_EL0
+	REG_AMEVTYPER05_EL0
+	REG_AMEVTYPER06_EL0
+	REG_AMEVTYPER07_EL0
+	REG_AMEVTYPER08_EL0
+	REG_AMEVTYPER09_EL0
+	REG_AMEVTYPER010_EL0
+	REG_AMEVTYPER011_EL0
+	REG_AMEVTYPER012_EL0
+	REG_AMEVTYPER013_EL0
+	REG_AMEVTYPER014_EL0
+	REG_AMEVTYPER015_EL0
+	REG_AMEVTYPER10_EL0
+	REG_AMEVTYPER11_EL0
+	REG_AMEVTYPER12_EL0
+	REG_AMEVTYPER13_EL0
+	REG_AMEVTYPER14_EL0
+	REG_AMEVTYPER15_EL0
+	REG_AMEVTYPER16_EL0
+	REG_AMEVTYPER17_EL0
+	REG_AMEVTYPER18_EL0
+	REG_AMEVTYPER19_EL0
+	REG_AMEVTYPER110_EL0
+	REG_AMEVTYPER111_EL0
+	REG_AMEVTYPER112_EL0
+	REG_AMEVTYPER113_EL0
+	REG_AMEVTYPER114_EL0
+	REG_AMEVTYPER115_EL0
+	REG_AMUSERENR_EL0
+	REG_APDAKeyHi_EL1
+	REG_APDAKeyLo_EL1
+	REG_APDBKeyHi_EL1
+	REG_APDBKeyLo_EL1
+	REG_APGAKeyHi_EL1
+	REG_APGAKeyLo_EL1
+	REG_APIAKeyHi_EL1
+	REG_APIAKeyLo_EL1
+	REG_APIBKeyHi_EL1
+	REG_APIBKeyLo_EL1
+	REG_CCSIDR2_EL1
+	REG_CCSIDR_EL1
+	REG_CLIDR_EL1
+	REG_CNTFRQ_EL0
+	REG_CNTKCTL_EL1
+	REG_CNTP_CTL_EL0
+	REG_CNTP_CVAL_EL0
+	REG_CNTP_TVAL_EL0
+	REG_CNTPCT_EL0
+	REG_CNTPS_CTL_EL1
+	REG_CNTPS_CVAL_EL1
+	REG_CNTPS_TVAL_EL1
+	REG_CNTV_CTL_EL0
+	REG_CNTV_CVAL_EL0
+	REG_CNTV_TVAL_EL0
+	REG_CNTVCT_EL0
+	REG_CONTEXTIDR_EL1
+	REG_CPACR_EL1
+	REG_CSSELR_EL1
+	REG_CTR_EL0
+	REG_CurrentEL
+	REG_DAIF
+	REG_DBGAUTHSTATUS_EL1
+	REG_DBGBCR0_EL1
+	REG_DBGBCR1_EL1
+	REG_DBGBCR2_EL1
+	REG_DBGBCR3_EL1
+	REG_DBGBCR4_EL1
+	REG_DBGBCR5_EL1
+	REG_DBGBCR6_EL1
+	REG_DBGBCR7_EL1
+	REG_DBGBCR8_EL1
+	REG_DBGBCR9_EL1
+	REG_DBGBCR10_EL1
+	REG_DBGBCR11_EL1
+	REG_DBGBCR12_EL1
+	REG_DBGBCR13_EL1
+	REG_DBGBCR14_EL1
+	REG_DBGBCR15_EL1
+	REG_DBGBVR0_EL1
+	REG_DBGBVR1_EL1
+	REG_DBGBVR2_EL1
+	REG_DBGBVR3_EL1
+	REG_DBGBVR4_EL1
+	REG_DBGBVR5_EL1
+	REG_DBGBVR6_EL1
+	REG_DBGBVR7_EL1
+	REG_DBGBVR8_EL1
+	REG_DBGBVR9_EL1
+	REG_DBGBVR10_EL1
+	REG_DBGBVR11_EL1
+	REG_DBGBVR12_EL1
+	REG_DBGBVR13_EL1
+	REG_DBGBVR14_EL1
+	REG_DBGBVR15_EL1
+	REG_DBGCLAIMCLR_EL1
+	REG_DBGCLAIMSET_EL1
+	REG_DBGDTR_EL0
+	REG_DBGDTRRX_EL0
+	REG_DBGDTRTX_EL0
+	REG_DBGPRCR_EL1
+	REG_DBGWCR0_EL1
+	REG_DBGWCR1_EL1
+	REG_DBGWCR2_EL1
+	REG_DBGWCR3_EL1
+	REG_DBGWCR4_EL1
+	REG_DBGWCR5_EL1
+	REG_DBGWCR6_EL1
+	REG_DBGWCR7_EL1
+	REG_DBGWCR8_EL1
+	REG_DBGWCR9_EL1
+	REG_DBGWCR10_EL1
+	REG_DBGWCR11_EL1
+	REG_DBGWCR12_EL1
+	REG_DBGWCR13_EL1
+	REG_DBGWCR14_EL1
+	REG_DBGWCR15_EL1
+	REG_DBGWVR0_EL1
+	REG_DBGWVR1_EL1
+	REG_DBGWVR2_EL1
+	REG_DBGWVR3_EL1
+	REG_DBGWVR4_EL1
+	REG_DBGWVR5_EL1
+	REG_DBGWVR6_EL1
+	REG_DBGWVR7_EL1
+	REG_DBGWVR8_EL1
+	REG_DBGWVR9_EL1
+	REG_DBGWVR10_EL1
+	REG_DBGWVR11_EL1
+	REG_DBGWVR12_EL1
+	REG_DBGWVR13_EL1
+	REG_DBGWVR14_EL1
+	REG_DBGWVR15_EL1
+	REG_DCZID_EL0
+	REG_DISR_EL1
+	REG_DIT
+	REG_DLR_EL0
+	REG_DSPSR_EL0
+	REG_ELR_EL1
+	REG_ERRIDR_EL1
+	REG_ERRSELR_EL1
+	REG_ERXADDR_EL1
+	REG_ERXCTLR_EL1
+	REG_ERXFR_EL1
+	REG_ERXMISC0_EL1
+	REG_ERXMISC1_EL1
+	REG_ERXMISC2_EL1
+	REG_ERXMISC3_EL1
+	REG_ERXPFGCDN_EL1
+	REG_ERXPFGCTL_EL1
+	REG_ERXPFGF_EL1
+	REG_ERXSTATUS_EL1
+	REG_ESR_EL1
+	REG_FAR_EL1
+	REG_FPCR
+	REG_FPSR
+	REG_GCR_EL1
+	REG_GMID_EL1
+	REG_ICC_AP0R0_EL1
+	REG_ICC_AP0R1_EL1
+	REG_ICC_AP0R2_EL1
+	REG_ICC_AP0R3_EL1
+	REG_ICC_AP1R0_EL1
+	REG_ICC_AP1R1_EL1
+	REG_ICC_AP1R2_EL1
+	REG_ICC_AP1R3_EL1
+	REG_ICC_ASGI1R_EL1
+	REG_ICC_BPR0_EL1
+	REG_ICC_BPR1_EL1
+	REG_ICC_CTLR_EL1
+	REG_ICC_DIR_EL1
+	REG_ICC_EOIR0_EL1
+	REG_ICC_EOIR1_EL1
+	REG_ICC_HPPIR0_EL1
+	REG_ICC_HPPIR1_EL1
+	REG_ICC_IAR0_EL1
+	REG_ICC_IAR1_EL1
+	REG_ICC_IGRPEN0_EL1
+	REG_ICC_IGRPEN1_EL1
+	REG_ICC_PMR_EL1
+	REG_ICC_RPR_EL1
+	REG_ICC_SGI0R_EL1
+	REG_ICC_SGI1R_EL1
+	REG_ICC_SRE_EL1
+	REG_ICV_AP0R0_EL1
+	REG_ICV_AP0R1_EL1
+	REG_ICV_AP0R2_EL1
+	REG_ICV_AP0R3_EL1
+	REG_ICV_AP1R0_EL1
+	REG_ICV_AP1R1_EL1
+	REG_ICV_AP1R2_EL1
+	REG_ICV_AP1R3_EL1
+	REG_ICV_BPR0_EL1
+	REG_ICV_BPR1_EL1
+	REG_ICV_CTLR_EL1
+	REG_ICV_DIR_EL1
+	REG_ICV_EOIR0_EL1
+	REG_ICV_EOIR1_EL1
+	REG_ICV_HPPIR0_EL1
+	REG_ICV_HPPIR1_EL1
+	REG_ICV_IAR0_EL1
+	REG_ICV_IAR1_EL1
+	REG_ICV_IGRPEN0_EL1
+	REG_ICV_IGRPEN1_EL1
+	REG_ICV_PMR_EL1
+	REG_ICV_RPR_EL1
+	REG_ID_AA64AFR0_EL1
+	REG_ID_AA64AFR1_EL1
+	REG_ID_AA64DFR0_EL1
+	REG_ID_AA64DFR1_EL1
+	REG_ID_AA64ISAR0_EL1
+	REG_ID_AA64ISAR1_EL1
+	REG_ID_AA64MMFR0_EL1
+	REG_ID_AA64MMFR1_EL1
+	REG_ID_AA64MMFR2_EL1
+	REG_ID_AA64PFR0_EL1
+	REG_ID_AA64PFR1_EL1
+	REG_ID_AA64ZFR0_EL1
+	REG_ID_AFR0_EL1
+	REG_ID_DFR0_EL1
+	REG_ID_ISAR0_EL1
+	REG_ID_ISAR1_EL1
+	REG_ID_ISAR2_EL1
+	REG_ID_ISAR3_EL1
+	REG_ID_ISAR4_EL1
+	REG_ID_ISAR5_EL1
+	REG_ID_ISAR6_EL1
+	REG_ID_MMFR0_EL1
+	REG_ID_MMFR1_EL1
+	REG_ID_MMFR2_EL1
+	REG_ID_MMFR3_EL1
+	REG_ID_MMFR4_EL1
+	REG_ID_PFR0_EL1
+	REG_ID_PFR1_EL1
+	REG_ID_PFR2_EL1
+	REG_ISR_EL1
+	REG_LORC_EL1
+	REG_LOREA_EL1
+	REG_LORID_EL1
+	REG_LORN_EL1
+	REG_LORSA_EL1
+	REG_MAIR_EL1
+	REG_MDCCINT_EL1
+	REG_MDCCSR_EL0
+	REG_MDRAR_EL1
+	REG_MDSCR_EL1
+	REG_MIDR_EL1
+	REG_MPAM0_EL1
+	REG_MPAM1_EL1
+	REG_MPAMIDR_EL1
+	REG_MPIDR_EL1
+	REG_MVFR0_EL1
+	REG_MVFR1_EL1
+	REG_MVFR2_EL1
+	REG_NZCV
+	REG_OSDLR_EL1
+	REG_OSDTRRX_EL1
+	REG_OSDTRTX_EL1
+	REG_OSECCR_EL1
+	REG_OSLAR_EL1
+	REG_OSLSR_EL1
+	REG_PAN
+	REG_PAR_EL1
+	REG_PMBIDR_EL1
+	REG_PMBLIMITR_EL1
+	REG_PMBPTR_EL1
+	REG_PMBSR_EL1
+	REG_PMCCFILTR_EL0
+	REG_PMCCNTR_EL0
+	REG_PMCEID0_EL0
+	REG_PMCEID1_EL0
+	REG_PMCNTENCLR_EL0
+	REG_PMCNTENSET_EL0
+	REG_PMCR_EL0
+	REG_PMEVCNTR0_EL0
+	REG_PMEVCNTR1_EL0
+	REG_PMEVCNTR2_EL0
+	REG_PMEVCNTR3_EL0
+	REG_PMEVCNTR4_EL0
+	REG_PMEVCNTR5_EL0
+	REG_PMEVCNTR6_EL0
+	REG_PMEVCNTR7_EL0
+	REG_PMEVCNTR8_EL0
+	REG_PMEVCNTR9_EL0
+	REG_PMEVCNTR10_EL0
+	REG_PMEVCNTR11_EL0
+	REG_PMEVCNTR12_EL0
+	REG_PMEVCNTR13_EL0
+	REG_PMEVCNTR14_EL0
+	REG_PMEVCNTR15_EL0
+	REG_PMEVCNTR16_EL0
+	REG_PMEVCNTR17_EL0
+	REG_PMEVCNTR18_EL0
+	REG_PMEVCNTR19_EL0
+	REG_PMEVCNTR20_EL0
+	REG_PMEVCNTR21_EL0
+	REG_PMEVCNTR22_EL0
+	REG_PMEVCNTR23_EL0
+	REG_PMEVCNTR24_EL0
+	REG_PMEVCNTR25_EL0
+	REG_PMEVCNTR26_EL0
+	REG_PMEVCNTR27_EL0
+	REG_PMEVCNTR28_EL0
+	REG_PMEVCNTR29_EL0
+	REG_PMEVCNTR30_EL0
+	REG_PMEVTYPER0_EL0
+	REG_PMEVTYPER1_EL0
+	REG_PMEVTYPER2_EL0
+	REG_PMEVTYPER3_EL0
+	REG_PMEVTYPER4_EL0
+	REG_PMEVTYPER5_EL0
+	REG_PMEVTYPER6_EL0
+	REG_PMEVTYPER7_EL0
+	REG_PMEVTYPER8_EL0
+	REG_PMEVTYPER9_EL0
+	REG_PMEVTYPER10_EL0
+	REG_PMEVTYPER11_EL0
+	REG_PMEVTYPER12_EL0
+	REG_PMEVTYPER13_EL0
+	REG_PMEVTYPER14_EL0
+	REG_PMEVTYPER15_EL0
+	REG_PMEVTYPER16_EL0
+	REG_PMEVTYPER17_EL0
+	REG_PMEVTYPER18_EL0
+	REG_PMEVTYPER19_EL0
+	REG_PMEVTYPER20_EL0
+	REG_PMEVTYPER21_EL0
+	REG_PMEVTYPER22_EL0
+	REG_PMEVTYPER23_EL0
+	REG_PMEVTYPER24_EL0
+	REG_PMEVTYPER25_EL0
+	REG_PMEVTYPER26_EL0
+	REG_PMEVTYPER27_EL0
+	REG_PMEVTYPER28_EL0
+	REG_PMEVTYPER29_EL0
+	REG_PMEVTYPER30_EL0
+	REG_PMINTENCLR_EL1
+	REG_PMINTENSET_EL1
+	REG_PMMIR_EL1
+	REG_PMOVSCLR_EL0
+	REG_PMOVSSET_EL0
+	REG_PMSCR_EL1
+	REG_PMSELR_EL0
+	REG_PMSEVFR_EL1
+	REG_PMSFCR_EL1
+	REG_PMSICR_EL1
+	REG_PMSIDR_EL1
+	REG_PMSIRR_EL1
+	REG_PMSLATFR_EL1
+	REG_PMSWINC_EL0
+	REG_PMUSERENR_EL0
+	REG_PMXEVCNTR_EL0
+	REG_PMXEVTYPER_EL0
+	REG_REVIDR_EL1
+	REG_RGSR_EL1
+	REG_RMR_EL1
+	REG_RNDR
+	REG_RNDRRS
+	REG_RVBAR_EL1
+	REG_SCTLR_EL1
+	REG_SCXTNUM_EL0
+	REG_SCXTNUM_EL1
+	REG_SP_EL0
+	REG_SP_EL1
+	REG_SPSel
+	REG_SPSR_abt
+	REG_SPSR_EL1
+	REG_SPSR_fiq
+	REG_SPSR_irq
+	REG_SPSR_und
+	REG_SSBS
+	REG_TCO
+	REG_TCR_EL1
+	REG_TFSR_EL1
+	REG_TFSRE0_EL1
+	REG_TPIDR_EL0
+	REG_TPIDR_EL1
+	REG_TPIDRRO_EL0
+	REG_TRFCR_EL1
+	REG_TTBR0_EL1
+	REG_TTBR1_EL1
+	REG_UAO
+	REG_VBAR_EL1
+	REG_ZCR_EL1
+	SYSREG_END
+)
+
+const (
+	SR_READ = 1 << iota
+	SR_WRITE
+)
+
+var SystemReg = []struct {
+	Name string
+	Reg  int16
+	Enc  uint32
+	// AccessFlags is the readable and writeable property of system register.
+	AccessFlags uint8
+}{
+	{"ACTLR_EL1", REG_ACTLR_EL1, 0x181020, SR_READ | SR_WRITE},
+	{"AFSR0_EL1", REG_AFSR0_EL1, 0x185100, SR_READ | SR_WRITE},
+	{"AFSR1_EL1", REG_AFSR1_EL1, 0x185120, SR_READ | SR_WRITE},
+	{"AIDR_EL1", REG_AIDR_EL1, 0x1900e0, SR_READ},
+	{"AMAIR_EL1", REG_AMAIR_EL1, 0x18a300, SR_READ | SR_WRITE},
+	{"AMCFGR_EL0", REG_AMCFGR_EL0, 0x1bd220, SR_READ},
+	{"AMCGCR_EL0", REG_AMCGCR_EL0, 0x1bd240, SR_READ},
+	{"AMCNTENCLR0_EL0", REG_AMCNTENCLR0_EL0, 0x1bd280, SR_READ | SR_WRITE},
+	{"AMCNTENCLR1_EL0", REG_AMCNTENCLR1_EL0, 0x1bd300, SR_READ | SR_WRITE},
+	{"AMCNTENSET0_EL0", REG_AMCNTENSET0_EL0, 0x1bd2a0, SR_READ | SR_WRITE},
+	{"AMCNTENSET1_EL0", REG_AMCNTENSET1_EL0, 0x1bd320, SR_READ | SR_WRITE},
+	{"AMCR_EL0", REG_AMCR_EL0, 0x1bd200, SR_READ | SR_WRITE},
+	{"AMEVCNTR00_EL0", REG_AMEVCNTR00_EL0, 0x1bd400, SR_READ | SR_WRITE},
+	{"AMEVCNTR01_EL0", REG_AMEVCNTR01_EL0, 0x1bd420, SR_READ | SR_WRITE},
+	{"AMEVCNTR02_EL0", REG_AMEVCNTR02_EL0, 0x1bd440, SR_READ | SR_WRITE},
+	{"AMEVCNTR03_EL0", REG_AMEVCNTR03_EL0, 0x1bd460, SR_READ | SR_WRITE},
+	{"AMEVCNTR04_EL0", REG_AMEVCNTR04_EL0, 0x1bd480, SR_READ | SR_WRITE},
+	{"AMEVCNTR05_EL0", REG_AMEVCNTR05_EL0, 0x1bd4a0, SR_READ | SR_WRITE},
+	{"AMEVCNTR06_EL0", REG_AMEVCNTR06_EL0, 0x1bd4c0, SR_READ | SR_WRITE},
+	{"AMEVCNTR07_EL0", REG_AMEVCNTR07_EL0, 0x1bd4e0, SR_READ | SR_WRITE},
+	{"AMEVCNTR08_EL0", REG_AMEVCNTR08_EL0, 0x1bd500, SR_READ | SR_WRITE},
+	{"AMEVCNTR09_EL0", REG_AMEVCNTR09_EL0, 0x1bd520, SR_READ | SR_WRITE},
+	{"AMEVCNTR010_EL0", REG_AMEVCNTR010_EL0, 0x1bd540, SR_READ | SR_WRITE},
+	{"AMEVCNTR011_EL0", REG_AMEVCNTR011_EL0, 0x1bd560, SR_READ | SR_WRITE},
+	{"AMEVCNTR012_EL0", REG_AMEVCNTR012_EL0, 0x1bd580, SR_READ | SR_WRITE},
+	{"AMEVCNTR013_EL0", REG_AMEVCNTR013_EL0, 0x1bd5a0, SR_READ | SR_WRITE},
+	{"AMEVCNTR014_EL0", REG_AMEVCNTR014_EL0, 0x1bd5c0, SR_READ | SR_WRITE},
+	{"AMEVCNTR015_EL0", REG_AMEVCNTR015_EL0, 0x1bd5e0, SR_READ | SR_WRITE},
+	{"AMEVCNTR10_EL0", REG_AMEVCNTR10_EL0, 0x1bdc00, SR_READ | SR_WRITE},
+	{"AMEVCNTR11_EL0", REG_AMEVCNTR11_EL0, 0x1bdc20, SR_READ | SR_WRITE},
+	{"AMEVCNTR12_EL0", REG_AMEVCNTR12_EL0, 0x1bdc40, SR_READ | SR_WRITE},
+	{"AMEVCNTR13_EL0", REG_AMEVCNTR13_EL0, 0x1bdc60, SR_READ | SR_WRITE},
+	{"AMEVCNTR14_EL0", REG_AMEVCNTR14_EL0, 0x1bdc80, SR_READ | SR_WRITE},
+	{"AMEVCNTR15_EL0", REG_AMEVCNTR15_EL0, 0x1bdca0, SR_READ | SR_WRITE},
+	{"AMEVCNTR16_EL0", REG_AMEVCNTR16_EL0, 0x1bdcc0, SR_READ | SR_WRITE},
+	{"AMEVCNTR17_EL0", REG_AMEVCNTR17_EL0, 0x1bdce0, SR_READ | SR_WRITE},
+	{"AMEVCNTR18_EL0", REG_AMEVCNTR18_EL0, 0x1bdd00, SR_READ | SR_WRITE},
+	{"AMEVCNTR19_EL0", REG_AMEVCNTR19_EL0, 0x1bdd20, SR_READ | SR_WRITE},
+	{"AMEVCNTR110_EL0", REG_AMEVCNTR110_EL0, 0x1bdd40, SR_READ | SR_WRITE},
+	{"AMEVCNTR111_EL0", REG_AMEVCNTR111_EL0, 0x1bdd60, SR_READ | SR_WRITE},
+	{"AMEVCNTR112_EL0", REG_AMEVCNTR112_EL0, 0x1bdd80, SR_READ | SR_WRITE},
+	{"AMEVCNTR113_EL0", REG_AMEVCNTR113_EL0, 0x1bdda0, SR_READ | SR_WRITE},
+	{"AMEVCNTR114_EL0", REG_AMEVCNTR114_EL0, 0x1bddc0, SR_READ | SR_WRITE},
+	{"AMEVCNTR115_EL0", REG_AMEVCNTR115_EL0, 0x1bdde0, SR_READ | SR_WRITE},
+	{"AMEVTYPER00_EL0", REG_AMEVTYPER00_EL0, 0x1bd600, SR_READ},
+	{"AMEVTYPER01_EL0", REG_AMEVTYPER01_EL0, 0x1bd620, SR_READ},
+	{"AMEVTYPER02_EL0", REG_AMEVTYPER02_EL0, 0x1bd640, SR_READ},
+	{"AMEVTYPER03_EL0", REG_AMEVTYPER03_EL0, 0x1bd660, SR_READ},
+	{"AMEVTYPER04_EL0", REG_AMEVTYPER04_EL0, 0x1bd680, SR_READ},
+	{"AMEVTYPER05_EL0", REG_AMEVTYPER05_EL0, 0x1bd6a0, SR_READ},
+	{"AMEVTYPER06_EL0", REG_AMEVTYPER06_EL0, 0x1bd6c0, SR_READ},
+	{"AMEVTYPER07_EL0", REG_AMEVTYPER07_EL0, 0x1bd6e0, SR_READ},
+	{"AMEVTYPER08_EL0", REG_AMEVTYPER08_EL0, 0x1bd700, SR_READ},
+	{"AMEVTYPER09_EL0", REG_AMEVTYPER09_EL0, 0x1bd720, SR_READ},
+	{"AMEVTYPER010_EL0", REG_AMEVTYPER010_EL0, 0x1bd740, SR_READ},
+	{"AMEVTYPER011_EL0", REG_AMEVTYPER011_EL0, 0x1bd760, SR_READ},
+	{"AMEVTYPER012_EL0", REG_AMEVTYPER012_EL0, 0x1bd780, SR_READ},
+	{"AMEVTYPER013_EL0", REG_AMEVTYPER013_EL0, 0x1bd7a0, SR_READ},
+	{"AMEVTYPER014_EL0", REG_AMEVTYPER014_EL0, 0x1bd7c0, SR_READ},
+	{"AMEVTYPER015_EL0", REG_AMEVTYPER015_EL0, 0x1bd7e0, SR_READ},
+	{"AMEVTYPER10_EL0", REG_AMEVTYPER10_EL0, 0x1bde00, SR_READ | SR_WRITE},
+	{"AMEVTYPER11_EL0", REG_AMEVTYPER11_EL0, 0x1bde20, SR_READ | SR_WRITE},
+	{"AMEVTYPER12_EL0", REG_AMEVTYPER12_EL0, 0x1bde40, SR_READ | SR_WRITE},
+	{"AMEVTYPER13_EL0", REG_AMEVTYPER13_EL0, 0x1bde60, SR_READ | SR_WRITE},
+	{"AMEVTYPER14_EL0", REG_AMEVTYPER14_EL0, 0x1bde80, SR_READ | SR_WRITE},
+	{"AMEVTYPER15_EL0", REG_AMEVTYPER15_EL0, 0x1bdea0, SR_READ | SR_WRITE},
+	{"AMEVTYPER16_EL0", REG_AMEVTYPER16_EL0, 0x1bdec0, SR_READ | SR_WRITE},
+	{"AMEVTYPER17_EL0", REG_AMEVTYPER17_EL0, 0x1bdee0, SR_READ | SR_WRITE},
+	{"AMEVTYPER18_EL0", REG_AMEVTYPER18_EL0, 0x1bdf00, SR_READ | SR_WRITE},
+	{"AMEVTYPER19_EL0", REG_AMEVTYPER19_EL0, 0x1bdf20, SR_READ | SR_WRITE},
+	{"AMEVTYPER110_EL0", REG_AMEVTYPER110_EL0, 0x1bdf40, SR_READ | SR_WRITE},
+	{"AMEVTYPER111_EL0", REG_AMEVTYPER111_EL0, 0x1bdf60, SR_READ | SR_WRITE},
+	{"AMEVTYPER112_EL0", REG_AMEVTYPER112_EL0, 0x1bdf80, SR_READ | SR_WRITE},
+	{"AMEVTYPER113_EL0", REG_AMEVTYPER113_EL0, 0x1bdfa0, SR_READ | SR_WRITE},
+	{"AMEVTYPER114_EL0", REG_AMEVTYPER114_EL0, 0x1bdfc0, SR_READ | SR_WRITE},
+	{"AMEVTYPER115_EL0", REG_AMEVTYPER115_EL0, 0x1bdfe0, SR_READ | SR_WRITE},
+	{"AMUSERENR_EL0", REG_AMUSERENR_EL0, 0x1bd260, SR_READ | SR_WRITE},
+	{"APDAKeyHi_EL1", REG_APDAKeyHi_EL1, 0x182220, SR_READ | SR_WRITE},
+	{"APDAKeyLo_EL1", REG_APDAKeyLo_EL1, 0x182200, SR_READ | SR_WRITE},
+	{"APDBKeyHi_EL1", REG_APDBKeyHi_EL1, 0x182260, SR_READ | SR_WRITE},
+	{"APDBKeyLo_EL1", REG_APDBKeyLo_EL1, 0x182240, SR_READ | SR_WRITE},
+	{"APGAKeyHi_EL1", REG_APGAKeyHi_EL1, 0x182320, SR_READ | SR_WRITE},
+	{"APGAKeyLo_EL1", REG_APGAKeyLo_EL1, 0x182300, SR_READ | SR_WRITE},
+	{"APIAKeyHi_EL1", REG_APIAKeyHi_EL1, 0x182120, SR_READ | SR_WRITE},
+	{"APIAKeyLo_EL1", REG_APIAKeyLo_EL1, 0x182100, SR_READ | SR_WRITE},
+	{"APIBKeyHi_EL1", REG_APIBKeyHi_EL1, 0x182160, SR_READ | SR_WRITE},
+	{"APIBKeyLo_EL1", REG_APIBKeyLo_EL1, 0x182140, SR_READ | SR_WRITE},
+	{"CCSIDR2_EL1", REG_CCSIDR2_EL1, 0x190040, SR_READ},
+	{"CCSIDR_EL1", REG_CCSIDR_EL1, 0x190000, SR_READ},
+	{"CLIDR_EL1", REG_CLIDR_EL1, 0x190020, SR_READ},
+	{"CNTFRQ_EL0", REG_CNTFRQ_EL0, 0x1be000, SR_READ | SR_WRITE},
+	{"CNTKCTL_EL1", REG_CNTKCTL_EL1, 0x18e100, SR_READ | SR_WRITE},
+	{"CNTP_CTL_EL0", REG_CNTP_CTL_EL0, 0x1be220, SR_READ | SR_WRITE},
+	{"CNTP_CVAL_EL0", REG_CNTP_CVAL_EL0, 0x1be240, SR_READ | SR_WRITE},
+	{"CNTP_TVAL_EL0", REG_CNTP_TVAL_EL0, 0x1be200, SR_READ | SR_WRITE},
+	{"CNTPCT_EL0", REG_CNTPCT_EL0, 0x1be020, SR_READ},
+	{"CNTPS_CTL_EL1", REG_CNTPS_CTL_EL1, 0x1fe220, SR_READ | SR_WRITE},
+	{"CNTPS_CVAL_EL1", REG_CNTPS_CVAL_EL1, 0x1fe240, SR_READ | SR_WRITE},
+	{"CNTPS_TVAL_EL1", REG_CNTPS_TVAL_EL1, 0x1fe200, SR_READ | SR_WRITE},
+	{"CNTV_CTL_EL0", REG_CNTV_CTL_EL0, 0x1be320, SR_READ | SR_WRITE},
+	{"CNTV_CVAL_EL0", REG_CNTV_CVAL_EL0, 0x1be340, SR_READ | SR_WRITE},
+	{"CNTV_TVAL_EL0", REG_CNTV_TVAL_EL0, 0x1be300, SR_READ | SR_WRITE},
+	{"CNTVCT_EL0", REG_CNTVCT_EL0, 0x1be040, SR_READ},
+	{"CONTEXTIDR_EL1", REG_CONTEXTIDR_EL1, 0x18d020, SR_READ | SR_WRITE},
+	{"CPACR_EL1", REG_CPACR_EL1, 0x181040, SR_READ | SR_WRITE},
+	{"CSSELR_EL1", REG_CSSELR_EL1, 0x1a0000, SR_READ | SR_WRITE},
+	{"CTR_EL0", REG_CTR_EL0, 0x1b0020, SR_READ},
+	{"CurrentEL", REG_CurrentEL, 0x184240, SR_READ},
+	{"DAIF", REG_DAIF, 0x1b4220, SR_READ | SR_WRITE},
+	{"DBGAUTHSTATUS_EL1", REG_DBGAUTHSTATUS_EL1, 0x107ec0, SR_READ},
+	{"DBGBCR0_EL1", REG_DBGBCR0_EL1, 0x1000a0, SR_READ | SR_WRITE},
+	{"DBGBCR1_EL1", REG_DBGBCR1_EL1, 0x1001a0, SR_READ | SR_WRITE},
+	{"DBGBCR2_EL1", REG_DBGBCR2_EL1, 0x1002a0, SR_READ | SR_WRITE},
+	{"DBGBCR3_EL1", REG_DBGBCR3_EL1, 0x1003a0, SR_READ | SR_WRITE},
+	{"DBGBCR4_EL1", REG_DBGBCR4_EL1, 0x1004a0, SR_READ | SR_WRITE},
+	{"DBGBCR5_EL1", REG_DBGBCR5_EL1, 0x1005a0, SR_READ | SR_WRITE},
+	{"DBGBCR6_EL1", REG_DBGBCR6_EL1, 0x1006a0, SR_READ | SR_WRITE},
+	{"DBGBCR7_EL1", REG_DBGBCR7_EL1, 0x1007a0, SR_READ | SR_WRITE},
+	{"DBGBCR8_EL1", REG_DBGBCR8_EL1, 0x1008a0, SR_READ | SR_WRITE},
+	{"DBGBCR9_EL1", REG_DBGBCR9_EL1, 0x1009a0, SR_READ | SR_WRITE},
+	{"DBGBCR10_EL1", REG_DBGBCR10_EL1, 0x100aa0, SR_READ | SR_WRITE},
+	{"DBGBCR11_EL1", REG_DBGBCR11_EL1, 0x100ba0, SR_READ | SR_WRITE},
+	{"DBGBCR12_EL1", REG_DBGBCR12_EL1, 0x100ca0, SR_READ | SR_WRITE},
+	{"DBGBCR13_EL1", REG_DBGBCR13_EL1, 0x100da0, SR_READ | SR_WRITE},
+	{"DBGBCR14_EL1", REG_DBGBCR14_EL1, 0x100ea0, SR_READ | SR_WRITE},
+	{"DBGBCR15_EL1", REG_DBGBCR15_EL1, 0x100fa0, SR_READ | SR_WRITE},
+	{"DBGBVR0_EL1", REG_DBGBVR0_EL1, 0x100080, SR_READ | SR_WRITE},
+	{"DBGBVR1_EL1", REG_DBGBVR1_EL1, 0x100180, SR_READ | SR_WRITE},
+	{"DBGBVR2_EL1", REG_DBGBVR2_EL1, 0x100280, SR_READ | SR_WRITE},
+	{"DBGBVR3_EL1", REG_DBGBVR3_EL1, 0x100380, SR_READ | SR_WRITE},
+	{"DBGBVR4_EL1", REG_DBGBVR4_EL1, 0x100480, SR_READ | SR_WRITE},
+	{"DBGBVR5_EL1", REG_DBGBVR5_EL1, 0x100580, SR_READ | SR_WRITE},
+	{"DBGBVR6_EL1", REG_DBGBVR6_EL1, 0x100680, SR_READ | SR_WRITE},
+	{"DBGBVR7_EL1", REG_DBGBVR7_EL1, 0x100780, SR_READ | SR_WRITE},
+	{"DBGBVR8_EL1", REG_DBGBVR8_EL1, 0x100880, SR_READ | SR_WRITE},
+	{"DBGBVR9_EL1", REG_DBGBVR9_EL1, 0x100980, SR_READ | SR_WRITE},
+	{"DBGBVR10_EL1", REG_DBGBVR10_EL1, 0x100a80, SR_READ | SR_WRITE},
+	{"DBGBVR11_EL1", REG_DBGBVR11_EL1, 0x100b80, SR_READ | SR_WRITE},
+	{"DBGBVR12_EL1", REG_DBGBVR12_EL1, 0x100c80, SR_READ | SR_WRITE},
+	{"DBGBVR13_EL1", REG_DBGBVR13_EL1, 0x100d80, SR_READ | SR_WRITE},
+	{"DBGBVR14_EL1", REG_DBGBVR14_EL1, 0x100e80, SR_READ | SR_WRITE},
+	{"DBGBVR15_EL1", REG_DBGBVR15_EL1, 0x100f80, SR_READ | SR_WRITE},
+	{"DBGCLAIMCLR_EL1", REG_DBGCLAIMCLR_EL1, 0x1079c0, SR_READ | SR_WRITE},
+	{"DBGCLAIMSET_EL1", REG_DBGCLAIMSET_EL1, 0x1078c0, SR_READ | SR_WRITE},
+	{"DBGDTR_EL0", REG_DBGDTR_EL0, 0x130400, SR_READ | SR_WRITE},
+	{"DBGDTRRX_EL0", REG_DBGDTRRX_EL0, 0x130500, SR_READ},
+	{"DBGDTRTX_EL0", REG_DBGDTRTX_EL0, 0x130500, SR_WRITE},
+	{"DBGPRCR_EL1", REG_DBGPRCR_EL1, 0x101480, SR_READ | SR_WRITE},
+	{"DBGWCR0_EL1", REG_DBGWCR0_EL1, 0x1000e0, SR_READ | SR_WRITE},
+	{"DBGWCR1_EL1", REG_DBGWCR1_EL1, 0x1001e0, SR_READ | SR_WRITE},
+	{"DBGWCR2_EL1", REG_DBGWCR2_EL1, 0x1002e0, SR_READ | SR_WRITE},
+	{"DBGWCR3_EL1", REG_DBGWCR3_EL1, 0x1003e0, SR_READ | SR_WRITE},
+	{"DBGWCR4_EL1", REG_DBGWCR4_EL1, 0x1004e0, SR_READ | SR_WRITE},
+	{"DBGWCR5_EL1", REG_DBGWCR5_EL1, 0x1005e0, SR_READ | SR_WRITE},
+	{"DBGWCR6_EL1", REG_DBGWCR6_EL1, 0x1006e0, SR_READ | SR_WRITE},
+	{"DBGWCR7_EL1", REG_DBGWCR7_EL1, 0x1007e0, SR_READ | SR_WRITE},
+	{"DBGWCR8_EL1", REG_DBGWCR8_EL1, 0x1008e0, SR_READ | SR_WRITE},
+	{"DBGWCR9_EL1", REG_DBGWCR9_EL1, 0x1009e0, SR_READ | SR_WRITE},
+	{"DBGWCR10_EL1", REG_DBGWCR10_EL1, 0x100ae0, SR_READ | SR_WRITE},
+	{"DBGWCR11_EL1", REG_DBGWCR11_EL1, 0x100be0, SR_READ | SR_WRITE},
+	{"DBGWCR12_EL1", REG_DBGWCR12_EL1, 0x100ce0, SR_READ | SR_WRITE},
+	{"DBGWCR13_EL1", REG_DBGWCR13_EL1, 0x100de0, SR_READ | SR_WRITE},
+	{"DBGWCR14_EL1", REG_DBGWCR14_EL1, 0x100ee0, SR_READ | SR_WRITE},
+	{"DBGWCR15_EL1", REG_DBGWCR15_EL1, 0x100fe0, SR_READ | SR_WRITE},
+	{"DBGWVR0_EL1", REG_DBGWVR0_EL1, 0x1000c0, SR_READ | SR_WRITE},
+	{"DBGWVR1_EL1", REG_DBGWVR1_EL1, 0x1001c0, SR_READ | SR_WRITE},
+	{"DBGWVR2_EL1", REG_DBGWVR2_EL1, 0x1002c0, SR_READ | SR_WRITE},
+	{"DBGWVR3_EL1", REG_DBGWVR3_EL1, 0x1003c0, SR_READ | SR_WRITE},
+	{"DBGWVR4_EL1", REG_DBGWVR4_EL1, 0x1004c0, SR_READ | SR_WRITE},
+	{"DBGWVR5_EL1", REG_DBGWVR5_EL1, 0x1005c0, SR_READ | SR_WRITE},
+	{"DBGWVR6_EL1", REG_DBGWVR6_EL1, 0x1006c0, SR_READ | SR_WRITE},
+	{"DBGWVR7_EL1", REG_DBGWVR7_EL1, 0x1007c0, SR_READ | SR_WRITE},
+	{"DBGWVR8_EL1", REG_DBGWVR8_EL1, 0x1008c0, SR_READ | SR_WRITE},
+	{"DBGWVR9_EL1", REG_DBGWVR9_EL1, 0x1009c0, SR_READ | SR_WRITE},
+	{"DBGWVR10_EL1", REG_DBGWVR10_EL1, 0x100ac0, SR_READ | SR_WRITE},
+	{"DBGWVR11_EL1", REG_DBGWVR11_EL1, 0x100bc0, SR_READ | SR_WRITE},
+	{"DBGWVR12_EL1", REG_DBGWVR12_EL1, 0x100cc0, SR_READ | SR_WRITE},
+	{"DBGWVR13_EL1", REG_DBGWVR13_EL1, 0x100dc0, SR_READ | SR_WRITE},
+	{"DBGWVR14_EL1", REG_DBGWVR14_EL1, 0x100ec0, SR_READ | SR_WRITE},
+	{"DBGWVR15_EL1", REG_DBGWVR15_EL1, 0x100fc0, SR_READ | SR_WRITE},
+	{"DCZID_EL0", REG_DCZID_EL0, 0x1b00e0, SR_READ},
+	{"DISR_EL1", REG_DISR_EL1, 0x18c120, SR_READ | SR_WRITE},
+	{"DIT", REG_DIT, 0x1b42a0, SR_READ | SR_WRITE},
+	{"DLR_EL0", REG_DLR_EL0, 0x1b4520, SR_READ | SR_WRITE},
+	{"DSPSR_EL0", REG_DSPSR_EL0, 0x1b4500, SR_READ | SR_WRITE},
+	{"ELR_EL1", REG_ELR_EL1, 0x184020, SR_READ | SR_WRITE},
+	{"ERRIDR_EL1", REG_ERRIDR_EL1, 0x185300, SR_READ},
+	{"ERRSELR_EL1", REG_ERRSELR_EL1, 0x185320, SR_READ | SR_WRITE},
+	{"ERXADDR_EL1", REG_ERXADDR_EL1, 0x185460, SR_READ | SR_WRITE},
+	{"ERXCTLR_EL1", REG_ERXCTLR_EL1, 0x185420, SR_READ | SR_WRITE},
+	{"ERXFR_EL1", REG_ERXFR_EL1, 0x185400, SR_READ},
+	{"ERXMISC0_EL1", REG_ERXMISC0_EL1, 0x185500, SR_READ | SR_WRITE},
+	{"ERXMISC1_EL1", REG_ERXMISC1_EL1, 0x185520, SR_READ | SR_WRITE},
+	{"ERXMISC2_EL1", REG_ERXMISC2_EL1, 0x185540, SR_READ | SR_WRITE},
+	{"ERXMISC3_EL1", REG_ERXMISC3_EL1, 0x185560, SR_READ | SR_WRITE},
+	{"ERXPFGCDN_EL1", REG_ERXPFGCDN_EL1, 0x1854c0, SR_READ | SR_WRITE},
+	{"ERXPFGCTL_EL1", REG_ERXPFGCTL_EL1, 0x1854a0, SR_READ | SR_WRITE},
+	{"ERXPFGF_EL1", REG_ERXPFGF_EL1, 0x185480, SR_READ},
+	{"ERXSTATUS_EL1", REG_ERXSTATUS_EL1, 0x185440, SR_READ | SR_WRITE},
+	{"ESR_EL1", REG_ESR_EL1, 0x185200, SR_READ | SR_WRITE},
+	{"FAR_EL1", REG_FAR_EL1, 0x186000, SR_READ | SR_WRITE},
+	{"FPCR", REG_FPCR, 0x1b4400, SR_READ | SR_WRITE},
+	{"FPSR", REG_FPSR, 0x1b4420, SR_READ | SR_WRITE},
+	{"GCR_EL1", REG_GCR_EL1, 0x1810c0, SR_READ | SR_WRITE},
+	{"GMID_EL1", REG_GMID_EL1, 0x31400, SR_READ},
+	{"ICC_AP0R0_EL1", REG_ICC_AP0R0_EL1, 0x18c880, SR_READ | SR_WRITE},
+	{"ICC_AP0R1_EL1", REG_ICC_AP0R1_EL1, 0x18c8a0, SR_READ | SR_WRITE},
+	{"ICC_AP0R2_EL1", REG_ICC_AP0R2_EL1, 0x18c8c0, SR_READ | SR_WRITE},
+	{"ICC_AP0R3_EL1", REG_ICC_AP0R3_EL1, 0x18c8e0, SR_READ | SR_WRITE},
+	{"ICC_AP1R0_EL1", REG_ICC_AP1R0_EL1, 0x18c900, SR_READ | SR_WRITE},
+	{"ICC_AP1R1_EL1", REG_ICC_AP1R1_EL1, 0x18c920, SR_READ | SR_WRITE},
+	{"ICC_AP1R2_EL1", REG_ICC_AP1R2_EL1, 0x18c940, SR_READ | SR_WRITE},
+	{"ICC_AP1R3_EL1", REG_ICC_AP1R3_EL1, 0x18c960, SR_READ | SR_WRITE},
+	{"ICC_ASGI1R_EL1", REG_ICC_ASGI1R_EL1, 0x18cbc0, SR_WRITE},
+	{"ICC_BPR0_EL1", REG_ICC_BPR0_EL1, 0x18c860, SR_READ | SR_WRITE},
+	{"ICC_BPR1_EL1", REG_ICC_BPR1_EL1, 0x18cc60, SR_READ | SR_WRITE},
+	{"ICC_CTLR_EL1", REG_ICC_CTLR_EL1, 0x18cc80, SR_READ | SR_WRITE},
+	{"ICC_DIR_EL1", REG_ICC_DIR_EL1, 0x18cb20, SR_WRITE},
+	{"ICC_EOIR0_EL1", REG_ICC_EOIR0_EL1, 0x18c820, SR_WRITE},
+	{"ICC_EOIR1_EL1", REG_ICC_EOIR1_EL1, 0x18cc20, SR_WRITE},
+	{"ICC_HPPIR0_EL1", REG_ICC_HPPIR0_EL1, 0x18c840, SR_READ},
+	{"ICC_HPPIR1_EL1", REG_ICC_HPPIR1_EL1, 0x18cc40, SR_READ},
+	{"ICC_IAR0_EL1", REG_ICC_IAR0_EL1, 0x18c800, SR_READ},
+	{"ICC_IAR1_EL1", REG_ICC_IAR1_EL1, 0x18cc00, SR_READ},
+	{"ICC_IGRPEN0_EL1", REG_ICC_IGRPEN0_EL1, 0x18ccc0, SR_READ | SR_WRITE},
+	{"ICC_IGRPEN1_EL1", REG_ICC_IGRPEN1_EL1, 0x18cce0, SR_READ | SR_WRITE},
+	{"ICC_PMR_EL1", REG_ICC_PMR_EL1, 0x184600, SR_READ | SR_WRITE},
+	{"ICC_RPR_EL1", REG_ICC_RPR_EL1, 0x18cb60, SR_READ},
+	{"ICC_SGI0R_EL1", REG_ICC_SGI0R_EL1, 0x18cbe0, SR_WRITE},
+	{"ICC_SGI1R_EL1", REG_ICC_SGI1R_EL1, 0x18cba0, SR_WRITE},
+	{"ICC_SRE_EL1", REG_ICC_SRE_EL1, 0x18cca0, SR_READ | SR_WRITE},
+	{"ICV_AP0R0_EL1", REG_ICV_AP0R0_EL1, 0x18c880, SR_READ | SR_WRITE},
+	{"ICV_AP0R1_EL1", REG_ICV_AP0R1_EL1, 0x18c8a0, SR_READ | SR_WRITE},
+	{"ICV_AP0R2_EL1", REG_ICV_AP0R2_EL1, 0x18c8c0, SR_READ | SR_WRITE},
+	{"ICV_AP0R3_EL1", REG_ICV_AP0R3_EL1, 0x18c8e0, SR_READ | SR_WRITE},
+	{"ICV_AP1R0_EL1", REG_ICV_AP1R0_EL1, 0x18c900, SR_READ | SR_WRITE},
+	{"ICV_AP1R1_EL1", REG_ICV_AP1R1_EL1, 0x18c920, SR_READ | SR_WRITE},
+	{"ICV_AP1R2_EL1", REG_ICV_AP1R2_EL1, 0x18c940, SR_READ | SR_WRITE},
+	{"ICV_AP1R3_EL1", REG_ICV_AP1R3_EL1, 0x18c960, SR_READ | SR_WRITE},
+	{"ICV_BPR0_EL1", REG_ICV_BPR0_EL1, 0x18c860, SR_READ | SR_WRITE},
+	{"ICV_BPR1_EL1", REG_ICV_BPR1_EL1, 0x18cc60, SR_READ | SR_WRITE},
+	{"ICV_CTLR_EL1", REG_ICV_CTLR_EL1, 0x18cc80, SR_READ | SR_WRITE},
+	{"ICV_DIR_EL1", REG_ICV_DIR_EL1, 0x18cb20, SR_WRITE},
+	{"ICV_EOIR0_EL1", REG_ICV_EOIR0_EL1, 0x18c820, SR_WRITE},
+	{"ICV_EOIR1_EL1", REG_ICV_EOIR1_EL1, 0x18cc20, SR_WRITE},
+	{"ICV_HPPIR0_EL1", REG_ICV_HPPIR0_EL1, 0x18c840, SR_READ},
+	{"ICV_HPPIR1_EL1", REG_ICV_HPPIR1_EL1, 0x18cc40, SR_READ},
+	{"ICV_IAR0_EL1", REG_ICV_IAR0_EL1, 0x18c800, SR_READ},
+	{"ICV_IAR1_EL1", REG_ICV_IAR1_EL1, 0x18cc00, SR_READ},
+	{"ICV_IGRPEN0_EL1", REG_ICV_IGRPEN0_EL1, 0x18ccc0, SR_READ | SR_WRITE},
+	{"ICV_IGRPEN1_EL1", REG_ICV_IGRPEN1_EL1, 0x18cce0, SR_READ | SR_WRITE},
+	{"ICV_PMR_EL1", REG_ICV_PMR_EL1, 0x184600, SR_READ | SR_WRITE},
+	{"ICV_RPR_EL1", REG_ICV_RPR_EL1, 0x18cb60, SR_READ},
+	{"ID_AA64AFR0_EL1", REG_ID_AA64AFR0_EL1, 0x180580, SR_READ},
+	{"ID_AA64AFR1_EL1", REG_ID_AA64AFR1_EL1, 0x1805a0, SR_READ},
+	{"ID_AA64DFR0_EL1", REG_ID_AA64DFR0_EL1, 0x180500, SR_READ},
+	{"ID_AA64DFR1_EL1", REG_ID_AA64DFR1_EL1, 0x180520, SR_READ},
+	{"ID_AA64ISAR0_EL1", REG_ID_AA64ISAR0_EL1, 0x180600, SR_READ},
+	{"ID_AA64ISAR1_EL1", REG_ID_AA64ISAR1_EL1, 0x180620, SR_READ},
+	{"ID_AA64MMFR0_EL1", REG_ID_AA64MMFR0_EL1, 0x180700, SR_READ},
+	{"ID_AA64MMFR1_EL1", REG_ID_AA64MMFR1_EL1, 0x180720, SR_READ},
+	{"ID_AA64MMFR2_EL1", REG_ID_AA64MMFR2_EL1, 0x180740, SR_READ},
+	{"ID_AA64PFR0_EL1", REG_ID_AA64PFR0_EL1, 0x180400, SR_READ},
+	{"ID_AA64PFR1_EL1", REG_ID_AA64PFR1_EL1, 0x180420, SR_READ},
+	{"ID_AA64ZFR0_EL1", REG_ID_AA64ZFR0_EL1, 0x180480, SR_READ},
+	{"ID_AFR0_EL1", REG_ID_AFR0_EL1, 0x180160, SR_READ},
+	{"ID_DFR0_EL1", REG_ID_DFR0_EL1, 0x180140, SR_READ},
+	{"ID_ISAR0_EL1", REG_ID_ISAR0_EL1, 0x180200, SR_READ},
+	{"ID_ISAR1_EL1", REG_ID_ISAR1_EL1, 0x180220, SR_READ},
+	{"ID_ISAR2_EL1", REG_ID_ISAR2_EL1, 0x180240, SR_READ},
+	{"ID_ISAR3_EL1", REG_ID_ISAR3_EL1, 0x180260, SR_READ},
+	{"ID_ISAR4_EL1", REG_ID_ISAR4_EL1, 0x180280, SR_READ},
+	{"ID_ISAR5_EL1", REG_ID_ISAR5_EL1, 0x1802a0, SR_READ},
+	{"ID_ISAR6_EL1", REG_ID_ISAR6_EL1, 0x1802e0, SR_READ},
+	{"ID_MMFR0_EL1", REG_ID_MMFR0_EL1, 0x180180, SR_READ},
+	{"ID_MMFR1_EL1", REG_ID_MMFR1_EL1, 0x1801a0, SR_READ},
+	{"ID_MMFR2_EL1", REG_ID_MMFR2_EL1, 0x1801c0, SR_READ},
+	{"ID_MMFR3_EL1", REG_ID_MMFR3_EL1, 0x1801e0, SR_READ},
+	{"ID_MMFR4_EL1", REG_ID_MMFR4_EL1, 0x1802c0, SR_READ},
+	{"ID_PFR0_EL1", REG_ID_PFR0_EL1, 0x180100, SR_READ},
+	{"ID_PFR1_EL1", REG_ID_PFR1_EL1, 0x180120, SR_READ},
+	{"ID_PFR2_EL1", REG_ID_PFR2_EL1, 0x180380, SR_READ},
+	{"ISR_EL1", REG_ISR_EL1, 0x18c100, SR_READ},
+	{"LORC_EL1", REG_LORC_EL1, 0x18a460, SR_READ | SR_WRITE},
+	{"LOREA_EL1", REG_LOREA_EL1, 0x18a420, SR_READ | SR_WRITE},
+	{"LORID_EL1", REG_LORID_EL1, 0x18a4e0, SR_READ},
+	{"LORN_EL1", REG_LORN_EL1, 0x18a440, SR_READ | SR_WRITE},
+	{"LORSA_EL1", REG_LORSA_EL1, 0x18a400, SR_READ | SR_WRITE},
+	{"MAIR_EL1", REG_MAIR_EL1, 0x18a200, SR_READ | SR_WRITE},
+	{"MDCCINT_EL1", REG_MDCCINT_EL1, 0x100200, SR_READ | SR_WRITE},
+	{"MDCCSR_EL0", REG_MDCCSR_EL0, 0x130100, SR_READ},
+	{"MDRAR_EL1", REG_MDRAR_EL1, 0x101000, SR_READ},
+	{"MDSCR_EL1", REG_MDSCR_EL1, 0x100240, SR_READ | SR_WRITE},
+	{"MIDR_EL1", REG_MIDR_EL1, 0x180000, SR_READ},
+	{"MPAM0_EL1", REG_MPAM0_EL1, 0x18a520, SR_READ | SR_WRITE},
+	{"MPAM1_EL1", REG_MPAM1_EL1, 0x18a500, SR_READ | SR_WRITE},
+	{"MPAMIDR_EL1", REG_MPAMIDR_EL1, 0x18a480, SR_READ},
+	{"MPIDR_EL1", REG_MPIDR_EL1, 0x1800a0, SR_READ},
+	{"MVFR0_EL1", REG_MVFR0_EL1, 0x180300, SR_READ},
+	{"MVFR1_EL1", REG_MVFR1_EL1, 0x180320, SR_READ},
+	{"MVFR2_EL1", REG_MVFR2_EL1, 0x180340, SR_READ},
+	{"NZCV", REG_NZCV, 0x1b4200, SR_READ | SR_WRITE},
+	{"OSDLR_EL1", REG_OSDLR_EL1, 0x101380, SR_READ | SR_WRITE},
+	{"OSDTRRX_EL1", REG_OSDTRRX_EL1, 0x100040, SR_READ | SR_WRITE},
+	{"OSDTRTX_EL1", REG_OSDTRTX_EL1, 0x100340, SR_READ | SR_WRITE},
+	{"OSECCR_EL1", REG_OSECCR_EL1, 0x100640, SR_READ | SR_WRITE},
+	{"OSLAR_EL1", REG_OSLAR_EL1, 0x101080, SR_WRITE},
+	{"OSLSR_EL1", REG_OSLSR_EL1, 0x101180, SR_READ},
+	{"PAN", REG_PAN, 0x184260, SR_READ | SR_WRITE},
+	{"PAR_EL1", REG_PAR_EL1, 0x187400, SR_READ | SR_WRITE},
+	{"PMBIDR_EL1", REG_PMBIDR_EL1, 0x189ae0, SR_READ},
+	{"PMBLIMITR_EL1", REG_PMBLIMITR_EL1, 0x189a00, SR_READ | SR_WRITE},
+	{"PMBPTR_EL1", REG_PMBPTR_EL1, 0x189a20, SR_READ | SR_WRITE},
+	{"PMBSR_EL1", REG_PMBSR_EL1, 0x189a60, SR_READ | SR_WRITE},
+	{"PMCCFILTR_EL0", REG_PMCCFILTR_EL0, 0x1befe0, SR_READ | SR_WRITE},
+	{"PMCCNTR_EL0", REG_PMCCNTR_EL0, 0x1b9d00, SR_READ | SR_WRITE},
+	{"PMCEID0_EL0", REG_PMCEID0_EL0, 0x1b9cc0, SR_READ},
+	{"PMCEID1_EL0", REG_PMCEID1_EL0, 0x1b9ce0, SR_READ},
+	{"PMCNTENCLR_EL0", REG_PMCNTENCLR_EL0, 0x1b9c40, SR_READ | SR_WRITE},
+	{"PMCNTENSET_EL0", REG_PMCNTENSET_EL0, 0x1b9c20, SR_READ | SR_WRITE},
+	{"PMCR_EL0", REG_PMCR_EL0, 0x1b9c00, SR_READ | SR_WRITE},
+	{"PMEVCNTR0_EL0", REG_PMEVCNTR0_EL0, 0x1be800, SR_READ | SR_WRITE},
+	{"PMEVCNTR1_EL0", REG_PMEVCNTR1_EL0, 0x1be820, SR_READ | SR_WRITE},
+	{"PMEVCNTR2_EL0", REG_PMEVCNTR2_EL0, 0x1be840, SR_READ | SR_WRITE},
+	{"PMEVCNTR3_EL0", REG_PMEVCNTR3_EL0, 0x1be860, SR_READ | SR_WRITE},
+	{"PMEVCNTR4_EL0", REG_PMEVCNTR4_EL0, 0x1be880, SR_READ | SR_WRITE},
+	{"PMEVCNTR5_EL0", REG_PMEVCNTR5_EL0, 0x1be8a0, SR_READ | SR_WRITE},
+	{"PMEVCNTR6_EL0", REG_PMEVCNTR6_EL0, 0x1be8c0, SR_READ | SR_WRITE},
+	{"PMEVCNTR7_EL0", REG_PMEVCNTR7_EL0, 0x1be8e0, SR_READ | SR_WRITE},
+	{"PMEVCNTR8_EL0", REG_PMEVCNTR8_EL0, 0x1be900, SR_READ | SR_WRITE},
+	{"PMEVCNTR9_EL0", REG_PMEVCNTR9_EL0, 0x1be920, SR_READ | SR_WRITE},
+	{"PMEVCNTR10_EL0", REG_PMEVCNTR10_EL0, 0x1be940, SR_READ | SR_WRITE},
+	{"PMEVCNTR11_EL0", REG_PMEVCNTR11_EL0, 0x1be960, SR_READ | SR_WRITE},
+	{"PMEVCNTR12_EL0", REG_PMEVCNTR12_EL0, 0x1be980, SR_READ | SR_WRITE},
+	{"PMEVCNTR13_EL0", REG_PMEVCNTR13_EL0, 0x1be9a0, SR_READ | SR_WRITE},
+	{"PMEVCNTR14_EL0", REG_PMEVCNTR14_EL0, 0x1be9c0, SR_READ | SR_WRITE},
+	{"PMEVCNTR15_EL0", REG_PMEVCNTR15_EL0, 0x1be9e0, SR_READ | SR_WRITE},
+	{"PMEVCNTR16_EL0", REG_PMEVCNTR16_EL0, 0x1bea00, SR_READ | SR_WRITE},
+	{"PMEVCNTR17_EL0", REG_PMEVCNTR17_EL0, 0x1bea20, SR_READ | SR_WRITE},
+	{"PMEVCNTR18_EL0", REG_PMEVCNTR18_EL0, 0x1bea40, SR_READ | SR_WRITE},
+	{"PMEVCNTR19_EL0", REG_PMEVCNTR19_EL0, 0x1bea60, SR_READ | SR_WRITE},
+	{"PMEVCNTR20_EL0", REG_PMEVCNTR20_EL0, 0x1bea80, SR_READ | SR_WRITE},
+	{"PMEVCNTR21_EL0", REG_PMEVCNTR21_EL0, 0x1beaa0, SR_READ | SR_WRITE},
+	{"PMEVCNTR22_EL0", REG_PMEVCNTR22_EL0, 0x1beac0, SR_READ | SR_WRITE},
+	{"PMEVCNTR23_EL0", REG_PMEVCNTR23_EL0, 0x1beae0, SR_READ | SR_WRITE},
+	{"PMEVCNTR24_EL0", REG_PMEVCNTR24_EL0, 0x1beb00, SR_READ | SR_WRITE},
+	{"PMEVCNTR25_EL0", REG_PMEVCNTR25_EL0, 0x1beb20, SR_READ | SR_WRITE},
+	{"PMEVCNTR26_EL0", REG_PMEVCNTR26_EL0, 0x1beb40, SR_READ | SR_WRITE},
+	{"PMEVCNTR27_EL0", REG_PMEVCNTR27_EL0, 0x1beb60, SR_READ | SR_WRITE},
+	{"PMEVCNTR28_EL0", REG_PMEVCNTR28_EL0, 0x1beb80, SR_READ | SR_WRITE},
+	{"PMEVCNTR29_EL0", REG_PMEVCNTR29_EL0, 0x1beba0, SR_READ | SR_WRITE},
+	{"PMEVCNTR30_EL0", REG_PMEVCNTR30_EL0, 0x1bebc0, SR_READ | SR_WRITE},
+	{"PMEVTYPER0_EL0", REG_PMEVTYPER0_EL0, 0x1bec00, SR_READ | SR_WRITE},
+	{"PMEVTYPER1_EL0", REG_PMEVTYPER1_EL0, 0x1bec20, SR_READ | SR_WRITE},
+	{"PMEVTYPER2_EL0", REG_PMEVTYPER2_EL0, 0x1bec40, SR_READ | SR_WRITE},
+	{"PMEVTYPER3_EL0", REG_PMEVTYPER3_EL0, 0x1bec60, SR_READ | SR_WRITE},
+	{"PMEVTYPER4_EL0", REG_PMEVTYPER4_EL0, 0x1bec80, SR_READ | SR_WRITE},
+	{"PMEVTYPER5_EL0", REG_PMEVTYPER5_EL0, 0x1beca0, SR_READ | SR_WRITE},
+	{"PMEVTYPER6_EL0", REG_PMEVTYPER6_EL0, 0x1becc0, SR_READ | SR_WRITE},
+	{"PMEVTYPER7_EL0", REG_PMEVTYPER7_EL0, 0x1bece0, SR_READ | SR_WRITE},
+	{"PMEVTYPER8_EL0", REG_PMEVTYPER8_EL0, 0x1bed00, SR_READ | SR_WRITE},
+	{"PMEVTYPER9_EL0", REG_PMEVTYPER9_EL0, 0x1bed20, SR_READ | SR_WRITE},
+	{"PMEVTYPER10_EL0", REG_PMEVTYPER10_EL0, 0x1bed40, SR_READ | SR_WRITE},
+	{"PMEVTYPER11_EL0", REG_PMEVTYPER11_EL0, 0x1bed60, SR_READ | SR_WRITE},
+	{"PMEVTYPER12_EL0", REG_PMEVTYPER12_EL0, 0x1bed80, SR_READ | SR_WRITE},
+	{"PMEVTYPER13_EL0", REG_PMEVTYPER13_EL0, 0x1beda0, SR_READ | SR_WRITE},
+	{"PMEVTYPER14_EL0", REG_PMEVTYPER14_EL0, 0x1bedc0, SR_READ | SR_WRITE},
+	{"PMEVTYPER15_EL0", REG_PMEVTYPER15_EL0, 0x1bede0, SR_READ | SR_WRITE},
+	{"PMEVTYPER16_EL0", REG_PMEVTYPER16_EL0, 0x1bee00, SR_READ | SR_WRITE},
+	{"PMEVTYPER17_EL0", REG_PMEVTYPER17_EL0, 0x1bee20, SR_READ | SR_WRITE},
+	{"PMEVTYPER18_EL0", REG_PMEVTYPER18_EL0, 0x1bee40, SR_READ | SR_WRITE},
+	{"PMEVTYPER19_EL0", REG_PMEVTYPER19_EL0, 0x1bee60, SR_READ | SR_WRITE},
+	{"PMEVTYPER20_EL0", REG_PMEVTYPER20_EL0, 0x1bee80, SR_READ | SR_WRITE},
+	{"PMEVTYPER21_EL0", REG_PMEVTYPER21_EL0, 0x1beea0, SR_READ | SR_WRITE},
+	{"PMEVTYPER22_EL0", REG_PMEVTYPER22_EL0, 0x1beec0, SR_READ | SR_WRITE},
+	{"PMEVTYPER23_EL0", REG_PMEVTYPER23_EL0, 0x1beee0, SR_READ | SR_WRITE},
+	{"PMEVTYPER24_EL0", REG_PMEVTYPER24_EL0, 0x1bef00, SR_READ | SR_WRITE},
+	{"PMEVTYPER25_EL0", REG_PMEVTYPER25_EL0, 0x1bef20, SR_READ | SR_WRITE},
+	{"PMEVTYPER26_EL0", REG_PMEVTYPER26_EL0, 0x1bef40, SR_READ | SR_WRITE},
+	{"PMEVTYPER27_EL0", REG_PMEVTYPER27_EL0, 0x1bef60, SR_READ | SR_WRITE},
+	{"PMEVTYPER28_EL0", REG_PMEVTYPER28_EL0, 0x1bef80, SR_READ | SR_WRITE},
+	{"PMEVTYPER29_EL0", REG_PMEVTYPER29_EL0, 0x1befa0, SR_READ | SR_WRITE},
+	{"PMEVTYPER30_EL0", REG_PMEVTYPER30_EL0, 0x1befc0, SR_READ | SR_WRITE},
+	{"PMINTENCLR_EL1", REG_PMINTENCLR_EL1, 0x189e40, SR_READ | SR_WRITE},
+	{"PMINTENSET_EL1", REG_PMINTENSET_EL1, 0x189e20, SR_READ | SR_WRITE},
+	{"PMMIR_EL1", REG_PMMIR_EL1, 0x189ec0, SR_READ},
+	{"PMOVSCLR_EL0", REG_PMOVSCLR_EL0, 0x1b9c60, SR_READ | SR_WRITE},
+	{"PMOVSSET_EL0", REG_PMOVSSET_EL0, 0x1b9e60, SR_READ | SR_WRITE},
+	{"PMSCR_EL1", REG_PMSCR_EL1, 0x189900, SR_READ | SR_WRITE},
+	{"PMSELR_EL0", REG_PMSELR_EL0, 0x1b9ca0, SR_READ | SR_WRITE},
+	{"PMSEVFR_EL1", REG_PMSEVFR_EL1, 0x1899a0, SR_READ | SR_WRITE},
+	{"PMSFCR_EL1", REG_PMSFCR_EL1, 0x189980, SR_READ | SR_WRITE},
+	{"PMSICR_EL1", REG_PMSICR_EL1, 0x189940, SR_READ | SR_WRITE},
+	{"PMSIDR_EL1", REG_PMSIDR_EL1, 0x1899e0, SR_READ},
+	{"PMSIRR_EL1", REG_PMSIRR_EL1, 0x189960, SR_READ | SR_WRITE},
+	{"PMSLATFR_EL1", REG_PMSLATFR_EL1, 0x1899c0, SR_READ | SR_WRITE},
+	{"PMSWINC_EL0", REG_PMSWINC_EL0, 0x1b9c80, SR_WRITE},
+	{"PMUSERENR_EL0", REG_PMUSERENR_EL0, 0x1b9e00, SR_READ | SR_WRITE},
+	{"PMXEVCNTR_EL0", REG_PMXEVCNTR_EL0, 0x1b9d40, SR_READ | SR_WRITE},
+	{"PMXEVTYPER_EL0", REG_PMXEVTYPER_EL0, 0x1b9d20, SR_READ | SR_WRITE},
+	{"REVIDR_EL1", REG_REVIDR_EL1, 0x1800c0, SR_READ},
+	{"RGSR_EL1", REG_RGSR_EL1, 0x1810a0, SR_READ | SR_WRITE},
+	{"RMR_EL1", REG_RMR_EL1, 0x18c040, SR_READ | SR_WRITE},
+	{"RNDR", REG_RNDR, 0x1b2400, SR_READ},
+	{"RNDRRS", REG_RNDRRS, 0x1b2420, SR_READ},
+	{"RVBAR_EL1", REG_RVBAR_EL1, 0x18c020, SR_READ},
+	{"SCTLR_EL1", REG_SCTLR_EL1, 0x181000, SR_READ | SR_WRITE},
+	{"SCXTNUM_EL0", REG_SCXTNUM_EL0, 0x1bd0e0, SR_READ | SR_WRITE},
+	{"SCXTNUM_EL1", REG_SCXTNUM_EL1, 0x18d0e0, SR_READ | SR_WRITE},
+	{"SP_EL0", REG_SP_EL0, 0x184100, SR_READ | SR_WRITE},
+	{"SP_EL1", REG_SP_EL1, 0x1c4100, SR_READ | SR_WRITE},
+	{"SPSel", REG_SPSel, 0x184200, SR_READ | SR_WRITE},
+	{"SPSR_abt", REG_SPSR_abt, 0x1c4320, SR_READ | SR_WRITE},
+	{"SPSR_EL1", REG_SPSR_EL1, 0x184000, SR_READ | SR_WRITE},
+	{"SPSR_fiq", REG_SPSR_fiq, 0x1c4360, SR_READ | SR_WRITE},
+	{"SPSR_irq", REG_SPSR_irq, 0x1c4300, SR_READ | SR_WRITE},
+	{"SPSR_und", REG_SPSR_und, 0x1c4340, SR_READ | SR_WRITE},
+	{"SSBS", REG_SSBS, 0x1b42c0, SR_READ | SR_WRITE},
+	{"TCO", REG_TCO, 0x1b42e0, SR_READ | SR_WRITE},
+	{"TCR_EL1", REG_TCR_EL1, 0x182040, SR_READ | SR_WRITE},
+	{"TFSR_EL1", REG_TFSR_EL1, 0x185600, SR_READ | SR_WRITE},
+	{"TFSRE0_EL1", REG_TFSRE0_EL1, 0x185620, SR_READ | SR_WRITE},
+	{"TPIDR_EL0", REG_TPIDR_EL0, 0x1bd040, SR_READ | SR_WRITE},
+	{"TPIDR_EL1", REG_TPIDR_EL1, 0x18d080, SR_READ | SR_WRITE},
+	{"TPIDRRO_EL0", REG_TPIDRRO_EL0, 0x1bd060, SR_READ | SR_WRITE},
+	{"TRFCR_EL1", REG_TRFCR_EL1, 0x181220, SR_READ | SR_WRITE},
+	{"TTBR0_EL1", REG_TTBR0_EL1, 0x182000, SR_READ | SR_WRITE},
+	{"TTBR1_EL1", REG_TTBR1_EL1, 0x182020, SR_READ | SR_WRITE},
+	{"UAO", REG_UAO, 0x184280, SR_READ | SR_WRITE},
+	{"VBAR_EL1", REG_VBAR_EL1, 0x18c000, SR_READ | SR_WRITE},
+	{"ZCR_EL1", REG_ZCR_EL1, 0x181200, SR_READ | SR_WRITE},
+}
+
+func SysRegEnc(r int16) (string, uint32, uint8) {
+	// The automatic generator guarantees that the order
+	// of Reg in SystemReg struct is consistent with the
+	// order of system register declarations
+	if r <= SYSREG_BEGIN || r >= SYSREG_END {
+		return "", 0, 0
+	}
+	v := SystemReg[r-SYSREG_BEGIN-1]
+	return v.Name, v.Enc, v.AccessFlags
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/data.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/data.go
new file mode 100644
index 000000000..a63213b19
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/data.go
@@ -0,0 +1,200 @@
+// Derived from Inferno utils/6l/obj.c and utils/6l/span.c
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/obj.c
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/span.c
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package obj
+
+import (
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"log"
+	"math"
+)
+
+// Grow increases the length of s.P to lsiz.
+func (s *LSym) Grow(lsiz int64) {
+	siz := int(lsiz)
+	if int64(siz) != lsiz {
+		log.Fatalf("LSym.Grow size %d too long", lsiz)
+	}
+	if len(s.P) >= siz {
+		return
+	}
+	s.P = append(s.P, make([]byte, siz-len(s.P))...)
+}
+
+// GrowCap increases the capacity of s.P to c.
+func (s *LSym) GrowCap(c int64) {
+	if int64(cap(s.P)) >= c {
+		return
+	}
+	if s.P == nil {
+		s.P = make([]byte, 0, c)
+		return
+	}
+	b := make([]byte, len(s.P), c)
+	copy(b, s.P)
+	s.P = b
+}
+
+// prepwrite prepares to write data of size siz into s at offset off.
+func (s *LSym) prepwrite(ctxt *Link, off int64, siz int) {
+	if off < 0 || siz < 0 || off >= 1<<30 {
+		ctxt.Diag("prepwrite: bad off=%d siz=%d s=%v", off, siz, s)
+	}
+	switch s.Type {
+	case objabi.Sxxx, objabi.SBSS:
+		s.Type = objabi.SDATA
+	case objabi.SNOPTRBSS:
+		s.Type = objabi.SNOPTRDATA
+	case objabi.STLSBSS:
+		ctxt.Diag("cannot supply data for %v var %v", s.Type, s.Name)
+	}
+	l := off + int64(siz)
+	s.Grow(l)
+	if l > s.Size {
+		s.Size = l
+	}
+}
+
+// WriteFloat32 writes f into s at offset off.
+func (s *LSym) WriteFloat32(ctxt *Link, off int64, f float32) {
+	s.prepwrite(ctxt, off, 4)
+	ctxt.Arch.ByteOrder.PutUint32(s.P[off:], math.Float32bits(f))
+}
+
+// WriteFloat64 writes f into s at offset off.
+func (s *LSym) WriteFloat64(ctxt *Link, off int64, f float64) {
+	s.prepwrite(ctxt, off, 8)
+	ctxt.Arch.ByteOrder.PutUint64(s.P[off:], math.Float64bits(f))
+}
+
+// WriteInt writes an integer i of size siz into s at offset off.
+func (s *LSym) WriteInt(ctxt *Link, off int64, siz int, i int64) {
+	s.prepwrite(ctxt, off, siz)
+	switch siz {
+	default:
+		ctxt.Diag("WriteInt: bad integer size: %d", siz)
+	case 1:
+		s.P[off] = byte(i)
+	case 2:
+		ctxt.Arch.ByteOrder.PutUint16(s.P[off:], uint16(i))
+	case 4:
+		ctxt.Arch.ByteOrder.PutUint32(s.P[off:], uint32(i))
+	case 8:
+		ctxt.Arch.ByteOrder.PutUint64(s.P[off:], uint64(i))
+	}
+}
+
+func (s *LSym) writeAddr(ctxt *Link, off int64, siz int, rsym *LSym, roff int64, rtype objabi.RelocType) {
+	// Allow 4-byte addresses for DWARF.
+	if siz != ctxt.Arch.PtrSize && siz != 4 {
+		ctxt.Diag("WriteAddr: bad address size %d in %s", siz, s.Name)
+	}
+	s.prepwrite(ctxt, off, siz)
+	r := Addrel(s)
+	r.Off = int32(off)
+	if int64(r.Off) != off {
+		ctxt.Diag("WriteAddr: off overflow %d in %s", off, s.Name)
+	}
+	r.Siz = uint8(siz)
+	r.Sym = rsym
+	r.Type = rtype
+	r.Add = roff
+}
+
+// WriteAddr writes an address of size siz into s at offset off.
+// rsym and roff specify the relocation for the address.
+func (s *LSym) WriteAddr(ctxt *Link, off int64, siz int, rsym *LSym, roff int64) {
+	s.writeAddr(ctxt, off, siz, rsym, roff, objabi.R_ADDR)
+}
+
+// WriteCURelativeAddr writes a pointer-sized address into s at offset off.
+// rsym and roff specify the relocation for the address which will be
+// resolved by the linker to an offset from the DW_AT_low_pc attribute of
+// the DWARF Compile Unit of rsym.
+func (s *LSym) WriteCURelativeAddr(ctxt *Link, off int64, rsym *LSym, roff int64) {
+	s.writeAddr(ctxt, off, ctxt.Arch.PtrSize, rsym, roff, objabi.R_ADDRCUOFF)
+}
+
+// WriteOff writes a 4 byte offset to rsym+roff into s at offset off.
+// After linking the 4 bytes stored at s+off will be
+// rsym+roff-(start of section that s is in).
+func (s *LSym) WriteOff(ctxt *Link, off int64, rsym *LSym, roff int64) {
+	s.prepwrite(ctxt, off, 4)
+	r := Addrel(s)
+	r.Off = int32(off)
+	if int64(r.Off) != off {
+		ctxt.Diag("WriteOff: off overflow %d in %s", off, s.Name)
+	}
+	r.Siz = 4
+	r.Sym = rsym
+	r.Type = objabi.R_ADDROFF
+	r.Add = roff
+}
+
+// WriteWeakOff writes a weak 4 byte offset to rsym+roff into s at offset off.
+// After linking the 4 bytes stored at s+off will be
+// rsym+roff-(start of section that s is in).
+func (s *LSym) WriteWeakOff(ctxt *Link, off int64, rsym *LSym, roff int64) {
+	s.prepwrite(ctxt, off, 4)
+	r := Addrel(s)
+	r.Off = int32(off)
+	if int64(r.Off) != off {
+		ctxt.Diag("WriteOff: off overflow %d in %s", off, s.Name)
+	}
+	r.Siz = 4
+	r.Sym = rsym
+	r.Type = objabi.R_WEAKADDROFF
+	r.Add = roff
+}
+
+// WriteString writes a string of size siz into s at offset off.
+func (s *LSym) WriteString(ctxt *Link, off int64, siz int, str string) {
+	if siz < len(str) {
+		ctxt.Diag("WriteString: bad string size: %d < %d", siz, len(str))
+	}
+	s.prepwrite(ctxt, off, siz)
+	copy(s.P[off:off+int64(siz)], str)
+}
+
+// WriteBytes writes a slice of bytes into s at offset off.
+func (s *LSym) WriteBytes(ctxt *Link, off int64, b []byte) int64 {
+	s.prepwrite(ctxt, off, len(b))
+	copy(s.P[off:], b)
+	return off + int64(len(b))
+}
+
+func Addrel(s *LSym) *Reloc {
+	if s.R == nil {
+		s.R = make([]Reloc, 0, 4)
+	}
+	s.R = append(s.R, Reloc{})
+	return &s.R[len(s.R)-1]
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/dwarf.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/dwarf.go
new file mode 100644
index 000000000..1e0a9a73f
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/dwarf.go
@@ -0,0 +1,690 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Writes dwarf information to object files.
+
+package obj
+
+import (
+	"github.com/twitchyliquid64/golang-asm/dwarf"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"github.com/twitchyliquid64/golang-asm/src"
+	"fmt"
+	"sort"
+	"sync"
+)
+
+// Generate a sequence of opcodes that is as short as possible.
+// See section 6.2.5
+const (
+	LINE_BASE   = -4
+	LINE_RANGE  = 10
+	PC_RANGE    = (255 - OPCODE_BASE) / LINE_RANGE
+	OPCODE_BASE = 11
+)
+
+// generateDebugLinesSymbol fills the debug lines symbol of a given function.
+//
+// It's worth noting that this function doesn't generate the full debug_lines
+// DWARF section, saving that for the linker. This function just generates the
+// state machine part of debug_lines. The full table is generated by the
+// linker.  Also, we use the file numbers from the full package (not just the
+// function in question) when generating the state machine. We do this so we
+// don't have to do a fixup on the indices when writing the full section.
+func (ctxt *Link) generateDebugLinesSymbol(s, lines *LSym) {
+	dctxt := dwCtxt{ctxt}
+
+	// Emit a LNE_set_address extended opcode, so as to establish the
+	// starting text address of this function.
+	dctxt.AddUint8(lines, 0)
+	dwarf.Uleb128put(dctxt, lines, 1+int64(ctxt.Arch.PtrSize))
+	dctxt.AddUint8(lines, dwarf.DW_LNE_set_address)
+	dctxt.AddAddress(lines, s, 0)
+
+	// Set up the debug_lines state machine to the default values
+	// we expect at the start of a new sequence.
+	stmt := true
+	line := int64(1)
+	pc := s.Func.Text.Pc
+	var lastpc int64 // last PC written to line table, not last PC in func
+	name := ""
+	prologue, wrotePrologue := false, false
+	// Walk the progs, generating the DWARF table.
+	for p := s.Func.Text; p != nil; p = p.Link {
+		prologue = prologue || (p.Pos.Xlogue() == src.PosPrologueEnd)
+		// If we're not at a real instruction, keep looping!
+		if p.Pos.Line() == 0 || (p.Link != nil && p.Link.Pc == p.Pc) {
+			continue
+		}
+		newStmt := p.Pos.IsStmt() != src.PosNotStmt
+		newName, newLine := linkgetlineFromPos(ctxt, p.Pos)
+
+		// Output debug info.
+		wrote := false
+		if name != newName {
+			newFile := ctxt.PosTable.FileIndex(newName) + 1 // 1 indexing for the table.
+			dctxt.AddUint8(lines, dwarf.DW_LNS_set_file)
+			dwarf.Uleb128put(dctxt, lines, int64(newFile))
+			name = newName
+			wrote = true
+		}
+		if prologue && !wrotePrologue {
+			dctxt.AddUint8(lines, uint8(dwarf.DW_LNS_set_prologue_end))
+			wrotePrologue = true
+			wrote = true
+		}
+		if stmt != newStmt {
+			dctxt.AddUint8(lines, uint8(dwarf.DW_LNS_negate_stmt))
+			stmt = newStmt
+			wrote = true
+		}
+
+		if line != int64(newLine) || wrote {
+			pcdelta := p.Pc - pc
+			lastpc = p.Pc
+			putpclcdelta(ctxt, dctxt, lines, uint64(pcdelta), int64(newLine)-line)
+			line, pc = int64(newLine), p.Pc
+		}
+	}
+
+	// Because these symbols will be concatenated together by the
+	// linker, we need to reset the state machine that controls the
+	// debug symbols. Do this using an end-of-sequence operator.
+	//
+	// Note: at one point in time, Delve did not support multiple end
+	// sequence ops within a compilation unit (bug for this:
+	// https://github.com/go-delve/delve/issues/1694), however the bug
+	// has since been fixed (Oct 2019).
+	//
+	// Issue 38192: the DWARF standard specifies that when you issue
+	// an end-sequence op, the PC value should be one past the last
+	// text address in the translation unit, so apply a delta to the
+	// text address before the end sequence op. If this isn't done,
+	// GDB will assign a line number of zero the last row in the line
+	// table, which we don't want.
+	lastlen := uint64(s.Size - (lastpc - s.Func.Text.Pc))
+	putpclcdelta(ctxt, dctxt, lines, lastlen, 0)
+	dctxt.AddUint8(lines, 0) // start extended opcode
+	dwarf.Uleb128put(dctxt, lines, 1)
+	dctxt.AddUint8(lines, dwarf.DW_LNE_end_sequence)
+}
+
+func putpclcdelta(linkctxt *Link, dctxt dwCtxt, s *LSym, deltaPC uint64, deltaLC int64) {
+	// Choose a special opcode that minimizes the number of bytes needed to
+	// encode the remaining PC delta and LC delta.
+	var opcode int64
+	if deltaLC < LINE_BASE {
+		if deltaPC >= PC_RANGE {
+			opcode = OPCODE_BASE + (LINE_RANGE * PC_RANGE)
+		} else {
+			opcode = OPCODE_BASE + (LINE_RANGE * int64(deltaPC))
+		}
+	} else if deltaLC < LINE_BASE+LINE_RANGE {
+		if deltaPC >= PC_RANGE {
+			opcode = OPCODE_BASE + (deltaLC - LINE_BASE) + (LINE_RANGE * PC_RANGE)
+			if opcode > 255 {
+				opcode -= LINE_RANGE
+			}
+		} else {
+			opcode = OPCODE_BASE + (deltaLC - LINE_BASE) + (LINE_RANGE * int64(deltaPC))
+		}
+	} else {
+		if deltaPC <= PC_RANGE {
+			opcode = OPCODE_BASE + (LINE_RANGE - 1) + (LINE_RANGE * int64(deltaPC))
+			if opcode > 255 {
+				opcode = 255
+			}
+		} else {
+			// Use opcode 249 (pc+=23, lc+=5) or 255 (pc+=24, lc+=1).
+			//
+			// Let x=deltaPC-PC_RANGE.  If we use opcode 255, x will be the remaining
+			// deltaPC that we need to encode separately before emitting 255.  If we
+			// use opcode 249, we will need to encode x+1.  If x+1 takes one more
+			// byte to encode than x, then we use opcode 255.
+			//
+			// In all other cases x and x+1 take the same number of bytes to encode,
+			// so we use opcode 249, which may save us a byte in encoding deltaLC,
+			// for similar reasons.
+			switch deltaPC - PC_RANGE {
+			// PC_RANGE is the largest deltaPC we can encode in one byte, using
+			// DW_LNS_const_add_pc.
+			//
+			// (1<<16)-1 is the largest deltaPC we can encode in three bytes, using
+			// DW_LNS_fixed_advance_pc.
+			//
+			// (1<<(7n))-1 is the largest deltaPC we can encode in n+1 bytes for
+			// n=1,3,4,5,..., using DW_LNS_advance_pc.
+			case PC_RANGE, (1 << 7) - 1, (1 << 16) - 1, (1 << 21) - 1, (1 << 28) - 1,
+				(1 << 35) - 1, (1 << 42) - 1, (1 << 49) - 1, (1 << 56) - 1, (1 << 63) - 1:
+				opcode = 255
+			default:
+				opcode = OPCODE_BASE + LINE_RANGE*PC_RANGE - 1 // 249
+			}
+		}
+	}
+	if opcode < OPCODE_BASE || opcode > 255 {
+		panic(fmt.Sprintf("produced invalid special opcode %d", opcode))
+	}
+
+	// Subtract from deltaPC and deltaLC the amounts that the opcode will add.
+	deltaPC -= uint64((opcode - OPCODE_BASE) / LINE_RANGE)
+	deltaLC -= (opcode-OPCODE_BASE)%LINE_RANGE + LINE_BASE
+
+	// Encode deltaPC.
+	if deltaPC != 0 {
+		if deltaPC <= PC_RANGE {
+			// Adjust the opcode so that we can use the 1-byte DW_LNS_const_add_pc
+			// instruction.
+			opcode -= LINE_RANGE * int64(PC_RANGE-deltaPC)
+			if opcode < OPCODE_BASE {
+				panic(fmt.Sprintf("produced invalid special opcode %d", opcode))
+			}
+			dctxt.AddUint8(s, dwarf.DW_LNS_const_add_pc)
+		} else if (1<<14) <= deltaPC && deltaPC < (1<<16) {
+			dctxt.AddUint8(s, dwarf.DW_LNS_fixed_advance_pc)
+			dctxt.AddUint16(s, uint16(deltaPC))
+		} else {
+			dctxt.AddUint8(s, dwarf.DW_LNS_advance_pc)
+			dwarf.Uleb128put(dctxt, s, int64(deltaPC))
+		}
+	}
+
+	// Encode deltaLC.
+	if deltaLC != 0 {
+		dctxt.AddUint8(s, dwarf.DW_LNS_advance_line)
+		dwarf.Sleb128put(dctxt, s, deltaLC)
+	}
+
+	// Output the special opcode.
+	dctxt.AddUint8(s, uint8(opcode))
+}
+
+// implement dwarf.Context
+type dwCtxt struct{ *Link }
+
+func (c dwCtxt) PtrSize() int {
+	return c.Arch.PtrSize
+}
+func (c dwCtxt) AddInt(s dwarf.Sym, size int, i int64) {
+	ls := s.(*LSym)
+	ls.WriteInt(c.Link, ls.Size, size, i)
+}
+func (c dwCtxt) AddUint16(s dwarf.Sym, i uint16) {
+	c.AddInt(s, 2, int64(i))
+}
+func (c dwCtxt) AddUint8(s dwarf.Sym, i uint8) {
+	b := []byte{byte(i)}
+	c.AddBytes(s, b)
+}
+func (c dwCtxt) AddBytes(s dwarf.Sym, b []byte) {
+	ls := s.(*LSym)
+	ls.WriteBytes(c.Link, ls.Size, b)
+}
+func (c dwCtxt) AddString(s dwarf.Sym, v string) {
+	ls := s.(*LSym)
+	ls.WriteString(c.Link, ls.Size, len(v), v)
+	ls.WriteInt(c.Link, ls.Size, 1, 0)
+}
+func (c dwCtxt) AddAddress(s dwarf.Sym, data interface{}, value int64) {
+	ls := s.(*LSym)
+	size := c.PtrSize()
+	if data != nil {
+		rsym := data.(*LSym)
+		ls.WriteAddr(c.Link, ls.Size, size, rsym, value)
+	} else {
+		ls.WriteInt(c.Link, ls.Size, size, value)
+	}
+}
+func (c dwCtxt) AddCURelativeAddress(s dwarf.Sym, data interface{}, value int64) {
+	ls := s.(*LSym)
+	rsym := data.(*LSym)
+	ls.WriteCURelativeAddr(c.Link, ls.Size, rsym, value)
+}
+func (c dwCtxt) AddSectionOffset(s dwarf.Sym, size int, t interface{}, ofs int64) {
+	panic("should be used only in the linker")
+}
+func (c dwCtxt) AddDWARFAddrSectionOffset(s dwarf.Sym, t interface{}, ofs int64) {
+	size := 4
+	if isDwarf64(c.Link) {
+		size = 8
+	}
+
+	ls := s.(*LSym)
+	rsym := t.(*LSym)
+	ls.WriteAddr(c.Link, ls.Size, size, rsym, ofs)
+	r := &ls.R[len(ls.R)-1]
+	r.Type = objabi.R_DWARFSECREF
+}
+
+func (c dwCtxt) AddFileRef(s dwarf.Sym, f interface{}) {
+	ls := s.(*LSym)
+	rsym := f.(*LSym)
+	fidx := c.Link.PosTable.FileIndex(rsym.Name)
+	// Note the +1 here -- the value we're writing is going to be an
+	// index into the DWARF line table file section, whose entries
+	// are numbered starting at 1, not 0.
+	ls.WriteInt(c.Link, ls.Size, 4, int64(fidx+1))
+}
+
+func (c dwCtxt) CurrentOffset(s dwarf.Sym) int64 {
+	ls := s.(*LSym)
+	return ls.Size
+}
+
+// Here "from" is a symbol corresponding to an inlined or concrete
+// function, "to" is the symbol for the corresponding abstract
+// function, and "dclIdx" is the index of the symbol of interest with
+// respect to the Dcl slice of the original pre-optimization version
+// of the inlined function.
+func (c dwCtxt) RecordDclReference(from dwarf.Sym, to dwarf.Sym, dclIdx int, inlIndex int) {
+	ls := from.(*LSym)
+	tls := to.(*LSym)
+	ridx := len(ls.R) - 1
+	c.Link.DwFixups.ReferenceChildDIE(ls, ridx, tls, dclIdx, inlIndex)
+}
+
+func (c dwCtxt) RecordChildDieOffsets(s dwarf.Sym, vars []*dwarf.Var, offsets []int32) {
+	ls := s.(*LSym)
+	c.Link.DwFixups.RegisterChildDIEOffsets(ls, vars, offsets)
+}
+
+func (c dwCtxt) Logf(format string, args ...interface{}) {
+	c.Link.Logf(format, args...)
+}
+
+func isDwarf64(ctxt *Link) bool {
+	return ctxt.Headtype == objabi.Haix
+}
+
+func (ctxt *Link) dwarfSym(s *LSym) (dwarfInfoSym, dwarfLocSym, dwarfRangesSym, dwarfAbsFnSym, dwarfDebugLines *LSym) {
+	if s.Type != objabi.STEXT {
+		ctxt.Diag("dwarfSym of non-TEXT %v", s)
+	}
+	if s.Func.dwarfInfoSym == nil {
+		s.Func.dwarfInfoSym = &LSym{
+			Type: objabi.SDWARFFCN,
+		}
+		if ctxt.Flag_locationlists {
+			s.Func.dwarfLocSym = &LSym{
+				Type: objabi.SDWARFLOC,
+			}
+		}
+		s.Func.dwarfRangesSym = &LSym{
+			Type: objabi.SDWARFRANGE,
+		}
+		s.Func.dwarfDebugLinesSym = &LSym{
+			Type: objabi.SDWARFLINES,
+		}
+		if s.WasInlined() {
+			s.Func.dwarfAbsFnSym = ctxt.DwFixups.AbsFuncDwarfSym(s)
+		}
+	}
+	return s.Func.dwarfInfoSym, s.Func.dwarfLocSym, s.Func.dwarfRangesSym, s.Func.dwarfAbsFnSym, s.Func.dwarfDebugLinesSym
+}
+
+func (s *LSym) Length(dwarfContext interface{}) int64 {
+	return s.Size
+}
+
+// fileSymbol returns a symbol corresponding to the source file of the
+// first instruction (prog) of the specified function. This will
+// presumably be the file in which the function is defined.
+func (ctxt *Link) fileSymbol(fn *LSym) *LSym {
+	p := fn.Func.Text
+	if p != nil {
+		f, _ := linkgetlineFromPos(ctxt, p.Pos)
+		fsym := ctxt.Lookup(f)
+		return fsym
+	}
+	return nil
+}
+
+// populateDWARF fills in the DWARF Debugging Information Entries for
+// TEXT symbol 's'. The various DWARF symbols must already have been
+// initialized in InitTextSym.
+func (ctxt *Link) populateDWARF(curfn interface{}, s *LSym, myimportpath string) {
+	info, loc, ranges, absfunc, lines := ctxt.dwarfSym(s)
+	if info.Size != 0 {
+		ctxt.Diag("makeFuncDebugEntry double process %v", s)
+	}
+	var scopes []dwarf.Scope
+	var inlcalls dwarf.InlCalls
+	if ctxt.DebugInfo != nil {
+		scopes, inlcalls = ctxt.DebugInfo(s, info, curfn)
+	}
+	var err error
+	dwctxt := dwCtxt{ctxt}
+	filesym := ctxt.fileSymbol(s)
+	fnstate := &dwarf.FnState{
+		Name:          s.Name,
+		Importpath:    myimportpath,
+		Info:          info,
+		Filesym:       filesym,
+		Loc:           loc,
+		Ranges:        ranges,
+		Absfn:         absfunc,
+		StartPC:       s,
+		Size:          s.Size,
+		External:      !s.Static(),
+		Scopes:        scopes,
+		InlCalls:      inlcalls,
+		UseBASEntries: ctxt.UseBASEntries,
+	}
+	if absfunc != nil {
+		err = dwarf.PutAbstractFunc(dwctxt, fnstate)
+		if err != nil {
+			ctxt.Diag("emitting DWARF for %s failed: %v", s.Name, err)
+		}
+		err = dwarf.PutConcreteFunc(dwctxt, fnstate)
+	} else {
+		err = dwarf.PutDefaultFunc(dwctxt, fnstate)
+	}
+	if err != nil {
+		ctxt.Diag("emitting DWARF for %s failed: %v", s.Name, err)
+	}
+	// Fill in the debug lines symbol.
+	ctxt.generateDebugLinesSymbol(s, lines)
+}
+
+// DwarfIntConst creates a link symbol for an integer constant with the
+// given name, type and value.
+func (ctxt *Link) DwarfIntConst(myimportpath, name, typename string, val int64) {
+	if myimportpath == "" {
+		return
+	}
+	s := ctxt.LookupInit(dwarf.ConstInfoPrefix+myimportpath, func(s *LSym) {
+		s.Type = objabi.SDWARFCONST
+		ctxt.Data = append(ctxt.Data, s)
+	})
+	dwarf.PutIntConst(dwCtxt{ctxt}, s, ctxt.Lookup(dwarf.InfoPrefix+typename), myimportpath+"."+name, val)
+}
+
+func (ctxt *Link) DwarfAbstractFunc(curfn interface{}, s *LSym, myimportpath string) {
+	absfn := ctxt.DwFixups.AbsFuncDwarfSym(s)
+	if absfn.Size != 0 {
+		ctxt.Diag("internal error: DwarfAbstractFunc double process %v", s)
+	}
+	if s.Func == nil {
+		s.Func = new(FuncInfo)
+	}
+	scopes, _ := ctxt.DebugInfo(s, absfn, curfn)
+	dwctxt := dwCtxt{ctxt}
+	filesym := ctxt.fileSymbol(s)
+	fnstate := dwarf.FnState{
+		Name:          s.Name,
+		Importpath:    myimportpath,
+		Info:          absfn,
+		Filesym:       filesym,
+		Absfn:         absfn,
+		External:      !s.Static(),
+		Scopes:        scopes,
+		UseBASEntries: ctxt.UseBASEntries,
+	}
+	if err := dwarf.PutAbstractFunc(dwctxt, &fnstate); err != nil {
+		ctxt.Diag("emitting DWARF for %s failed: %v", s.Name, err)
+	}
+}
+
+// This table is designed to aid in the creation of references between
+// DWARF subprogram DIEs.
+//
+// In most cases when one DWARF DIE has to refer to another DWARF DIE,
+// the target of the reference has an LSym, which makes it easy to use
+// the existing relocation mechanism. For DWARF inlined routine DIEs,
+// however, the subprogram DIE has to refer to a child
+// parameter/variable DIE of the abstract subprogram. This child DIE
+// doesn't have an LSym, and also of interest is the fact that when
+// DWARF generation is happening for inlined function F within caller
+// G, it's possible that DWARF generation hasn't happened yet for F,
+// so there is no way to know the offset of a child DIE within F's
+// abstract function. Making matters more complex, each inlined
+// instance of F may refer to a subset of the original F's variables
+// (depending on what happens with optimization, some vars may be
+// eliminated).
+//
+// The fixup table below helps overcome this hurdle. At the point
+// where a parameter/variable reference is made (via a call to
+// "ReferenceChildDIE"), a fixup record is generate that records
+// the relocation that is targeting that child variable. At a later
+// point when the abstract function DIE is emitted, there will be
+// a call to "RegisterChildDIEOffsets", at which point the offsets
+// needed to apply fixups are captured. Finally, once the parallel
+// portion of the compilation is done, fixups can actually be applied
+// during the "Finalize" method (this can't be done during the
+// parallel portion of the compile due to the possibility of data
+// races).
+//
+// This table is also used to record the "precursor" function node for
+// each function that is the target of an inline -- child DIE references
+// have to be made with respect to the original pre-optimization
+// version of the function (to allow for the fact that each inlined
+// body may be optimized differently).
+type DwarfFixupTable struct {
+	ctxt      *Link
+	mu        sync.Mutex
+	symtab    map[*LSym]int // maps abstract fn LSYM to index in svec
+	svec      []symFixups
+	precursor map[*LSym]fnState // maps fn Lsym to precursor Node, absfn sym
+}
+
+type symFixups struct {
+	fixups   []relFixup
+	doffsets []declOffset
+	inlIndex int32
+	defseen  bool
+}
+
+type declOffset struct {
+	// Index of variable within DCL list of pre-optimization function
+	dclIdx int32
+	// Offset of var's child DIE with respect to containing subprogram DIE
+	offset int32
+}
+
+type relFixup struct {
+	refsym *LSym
+	relidx int32
+	dclidx int32
+}
+
+type fnState struct {
+	// precursor function (really *gc.Node)
+	precursor interface{}
+	// abstract function symbol
+	absfn *LSym
+}
+
+func NewDwarfFixupTable(ctxt *Link) *DwarfFixupTable {
+	return &DwarfFixupTable{
+		ctxt:      ctxt,
+		symtab:    make(map[*LSym]int),
+		precursor: make(map[*LSym]fnState),
+	}
+}
+
+func (ft *DwarfFixupTable) GetPrecursorFunc(s *LSym) interface{} {
+	if fnstate, found := ft.precursor[s]; found {
+		return fnstate.precursor
+	}
+	return nil
+}
+
+func (ft *DwarfFixupTable) SetPrecursorFunc(s *LSym, fn interface{}) {
+	if _, found := ft.precursor[s]; found {
+		ft.ctxt.Diag("internal error: DwarfFixupTable.SetPrecursorFunc double call on %v", s)
+	}
+
+	// initialize abstract function symbol now. This is done here so
+	// as to avoid data races later on during the parallel portion of
+	// the back end.
+	absfn := ft.ctxt.LookupDerived(s, dwarf.InfoPrefix+s.Name+dwarf.AbstractFuncSuffix)
+	absfn.Set(AttrDuplicateOK, true)
+	absfn.Type = objabi.SDWARFABSFCN
+	ft.ctxt.Data = append(ft.ctxt.Data, absfn)
+
+	// In the case of "late" inlining (inlines that happen during
+	// wrapper generation as opposed to the main inlining phase) it's
+	// possible that we didn't cache the abstract function sym for the
+	// text symbol -- do so now if needed. See issue 38068.
+	if s.Func != nil && s.Func.dwarfAbsFnSym == nil {
+		s.Func.dwarfAbsFnSym = absfn
+	}
+
+	ft.precursor[s] = fnState{precursor: fn, absfn: absfn}
+}
+
+// Make a note of a child DIE reference: relocation 'ridx' within symbol 's'
+// is targeting child 'c' of DIE with symbol 'tgt'.
+func (ft *DwarfFixupTable) ReferenceChildDIE(s *LSym, ridx int, tgt *LSym, dclidx int, inlIndex int) {
+	// Protect against concurrent access if multiple backend workers
+	ft.mu.Lock()
+	defer ft.mu.Unlock()
+
+	// Create entry for symbol if not already present.
+	idx, found := ft.symtab[tgt]
+	if !found {
+		ft.svec = append(ft.svec, symFixups{inlIndex: int32(inlIndex)})
+		idx = len(ft.svec) - 1
+		ft.symtab[tgt] = idx
+	}
+
+	// Do we have child DIE offsets available? If so, then apply them,
+	// otherwise create a fixup record.
+	sf := &ft.svec[idx]
+	if len(sf.doffsets) > 0 {
+		found := false
+		for _, do := range sf.doffsets {
+			if do.dclIdx == int32(dclidx) {
+				off := do.offset
+				s.R[ridx].Add += int64(off)
+				found = true
+				break
+			}
+		}
+		if !found {
+			ft.ctxt.Diag("internal error: DwarfFixupTable.ReferenceChildDIE unable to locate child DIE offset for dclIdx=%d src=%v tgt=%v", dclidx, s, tgt)
+		}
+	} else {
+		sf.fixups = append(sf.fixups, relFixup{s, int32(ridx), int32(dclidx)})
+	}
+}
+
+// Called once DWARF generation is complete for a given abstract function,
+// whose children might have been referenced via a call above. Stores
+// the offsets for any child DIEs (vars, params) so that they can be
+// consumed later in on DwarfFixupTable.Finalize, which applies any
+// outstanding fixups.
+func (ft *DwarfFixupTable) RegisterChildDIEOffsets(s *LSym, vars []*dwarf.Var, coffsets []int32) {
+	// Length of these two slices should agree
+	if len(vars) != len(coffsets) {
+		ft.ctxt.Diag("internal error: RegisterChildDIEOffsets vars/offsets length mismatch")
+		return
+	}
+
+	// Generate the slice of declOffset's based in vars/coffsets
+	doffsets := make([]declOffset, len(coffsets))
+	for i := range coffsets {
+		doffsets[i].dclIdx = vars[i].ChildIndex
+		doffsets[i].offset = coffsets[i]
+	}
+
+	ft.mu.Lock()
+	defer ft.mu.Unlock()
+
+	// Store offsets for this symbol.
+	idx, found := ft.symtab[s]
+	if !found {
+		sf := symFixups{inlIndex: -1, defseen: true, doffsets: doffsets}
+		ft.svec = append(ft.svec, sf)
+		ft.symtab[s] = len(ft.svec) - 1
+	} else {
+		sf := &ft.svec[idx]
+		sf.doffsets = doffsets
+		sf.defseen = true
+	}
+}
+
+func (ft *DwarfFixupTable) processFixups(slot int, s *LSym) {
+	sf := &ft.svec[slot]
+	for _, f := range sf.fixups {
+		dfound := false
+		for _, doffset := range sf.doffsets {
+			if doffset.dclIdx == f.dclidx {
+				f.refsym.R[f.relidx].Add += int64(doffset.offset)
+				dfound = true
+				break
+			}
+		}
+		if !dfound {
+			ft.ctxt.Diag("internal error: DwarfFixupTable has orphaned fixup on %v targeting %v relidx=%d dclidx=%d", f.refsym, s, f.relidx, f.dclidx)
+		}
+	}
+}
+
+// return the LSym corresponding to the 'abstract subprogram' DWARF
+// info entry for a function.
+func (ft *DwarfFixupTable) AbsFuncDwarfSym(fnsym *LSym) *LSym {
+	// Protect against concurrent access if multiple backend workers
+	ft.mu.Lock()
+	defer ft.mu.Unlock()
+
+	if fnstate, found := ft.precursor[fnsym]; found {
+		return fnstate.absfn
+	}
+	ft.ctxt.Diag("internal error: AbsFuncDwarfSym requested for %v, not seen during inlining", fnsym)
+	return nil
+}
+
+// Called after all functions have been compiled; the main job of this
+// function is to identify cases where there are outstanding fixups.
+// This scenario crops up when we have references to variables of an
+// inlined routine, but that routine is defined in some other package.
+// This helper walks through and locate these fixups, then invokes a
+// helper to create an abstract subprogram DIE for each one.
+func (ft *DwarfFixupTable) Finalize(myimportpath string, trace bool) {
+	if trace {
+		ft.ctxt.Logf("DwarfFixupTable.Finalize invoked for %s\n", myimportpath)
+	}
+
+	// Collect up the keys from the precursor map, then sort the
+	// resulting list (don't want to rely on map ordering here).
+	fns := make([]*LSym, len(ft.precursor))
+	idx := 0
+	for fn := range ft.precursor {
+		fns[idx] = fn
+		idx++
+	}
+	sort.Sort(BySymName(fns))
+
+	// Should not be called during parallel portion of compilation.
+	if ft.ctxt.InParallel {
+		ft.ctxt.Diag("internal error: DwarfFixupTable.Finalize call during parallel backend")
+	}
+
+	// Generate any missing abstract functions.
+	for _, s := range fns {
+		absfn := ft.AbsFuncDwarfSym(s)
+		slot, found := ft.symtab[absfn]
+		if !found || !ft.svec[slot].defseen {
+			ft.ctxt.GenAbstractFunc(s)
+		}
+	}
+
+	// Apply fixups.
+	for _, s := range fns {
+		absfn := ft.AbsFuncDwarfSym(s)
+		slot, found := ft.symtab[absfn]
+		if !found {
+			ft.ctxt.Diag("internal error: DwarfFixupTable.Finalize orphan abstract function for %v", s)
+		} else {
+			ft.processFixups(slot, s)
+		}
+	}
+}
+
+type BySymName []*LSym
+
+func (s BySymName) Len() int           { return len(s) }
+func (s BySymName) Less(i, j int) bool { return s[i].Name < s[j].Name }
+func (s BySymName) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/go.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/go.go
new file mode 100644
index 000000000..dbe9b406d
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/go.go
@@ -0,0 +1,16 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package obj
+
+// go-specific code shared across loaders (5l, 6l, 8l).
+
+func Nopout(p *Prog) {
+	p.As = ANOP
+	p.Scond = 0
+	p.From = Addr{}
+	p.RestArgs = nil
+	p.Reg = 0
+	p.To = Addr{}
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/inl.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/inl.go
new file mode 100644
index 000000000..511aa65a2
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/inl.go
@@ -0,0 +1,131 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package obj
+
+import "github.com/twitchyliquid64/golang-asm/src"
+
+// InlTree is a collection of inlined calls. The Parent field of an
+// InlinedCall is the index of another InlinedCall in InlTree.
+//
+// The compiler maintains a global inlining tree and adds a node to it
+// every time a function is inlined. For example, suppose f() calls g()
+// and g has two calls to h(), and that f, g, and h are inlineable:
+//
+//  1 func main() {
+//  2     f()
+//  3 }
+//  4 func f() {
+//  5     g()
+//  6 }
+//  7 func g() {
+//  8     h()
+//  9     h()
+// 10 }
+// 11 func h() {
+// 12     println("H")
+// 13 }
+//
+// Assuming the global tree starts empty, inlining will produce the
+// following tree:
+//
+//   []InlinedCall{
+//     {Parent: -1, Func: "f", Pos: <line 2>},
+//     {Parent:  0, Func: "g", Pos: <line 5>},
+//     {Parent:  1, Func: "h", Pos: <line 8>},
+//     {Parent:  1, Func: "h", Pos: <line 9>},
+//   }
+//
+// The nodes of h inlined into main will have inlining indexes 2 and 3.
+//
+// Eventually, the compiler extracts a per-function inlining tree from
+// the global inlining tree (see pcln.go).
+type InlTree struct {
+	nodes []InlinedCall
+}
+
+// InlinedCall is a node in an InlTree.
+type InlinedCall struct {
+	Parent   int      // index of the parent in the InlTree or < 0 if outermost call
+	Pos      src.XPos // position of the inlined call
+	Func     *LSym    // function that was inlined
+	ParentPC int32    // PC of instruction just before inlined body. Only valid in local trees.
+}
+
+// Add adds a new call to the tree, returning its index.
+func (tree *InlTree) Add(parent int, pos src.XPos, func_ *LSym) int {
+	r := len(tree.nodes)
+	call := InlinedCall{
+		Parent: parent,
+		Pos:    pos,
+		Func:   func_,
+	}
+	tree.nodes = append(tree.nodes, call)
+	return r
+}
+
+func (tree *InlTree) Parent(inlIndex int) int {
+	return tree.nodes[inlIndex].Parent
+}
+
+func (tree *InlTree) InlinedFunction(inlIndex int) *LSym {
+	return tree.nodes[inlIndex].Func
+}
+
+func (tree *InlTree) CallPos(inlIndex int) src.XPos {
+	return tree.nodes[inlIndex].Pos
+}
+
+func (tree *InlTree) setParentPC(inlIndex int, pc int32) {
+	tree.nodes[inlIndex].ParentPC = pc
+}
+
+// OutermostPos returns the outermost position corresponding to xpos,
+// which is where xpos was ultimately inlined to. In the example for
+// InlTree, main() contains inlined AST nodes from h(), but the
+// outermost position for those nodes is line 2.
+func (ctxt *Link) OutermostPos(xpos src.XPos) src.Pos {
+	pos := ctxt.InnermostPos(xpos)
+
+	outerxpos := xpos
+	for ix := pos.Base().InliningIndex(); ix >= 0; {
+		call := ctxt.InlTree.nodes[ix]
+		ix = call.Parent
+		outerxpos = call.Pos
+	}
+	return ctxt.PosTable.Pos(outerxpos)
+}
+
+// InnermostPos returns the innermost position corresponding to xpos,
+// that is, the code that is inlined and that inlines nothing else.
+// In the example for InlTree above, the code for println within h
+// would have an innermost position with line number 12, whether
+// h was not inlined, inlined into g, g-then-f, or g-then-f-then-main.
+// This corresponds to what someone debugging main, f, g, or h might
+// expect to see while single-stepping.
+func (ctxt *Link) InnermostPos(xpos src.XPos) src.Pos {
+	return ctxt.PosTable.Pos(xpos)
+}
+
+// AllPos returns a slice of the positions inlined at xpos, from
+// innermost (index zero) to outermost.  To avoid gratuitous allocation
+// the result is passed in and extended if necessary.
+func (ctxt *Link) AllPos(xpos src.XPos, result []src.Pos) []src.Pos {
+	pos := ctxt.InnermostPos(xpos)
+	result = result[:0]
+	result = append(result, ctxt.PosTable.Pos(xpos))
+	for ix := pos.Base().InliningIndex(); ix >= 0; {
+		call := ctxt.InlTree.nodes[ix]
+		ix = call.Parent
+		result = append(result, ctxt.PosTable.Pos(call.Pos))
+	}
+	return result
+}
+
+func dumpInlTree(ctxt *Link, tree InlTree) {
+	for i, call := range tree.nodes {
+		pos := ctxt.PosTable.Pos(call.Pos)
+		ctxt.Logf("%0d | %0d | %s (%s) pc=%d\n", i, call.Parent, call.Func, pos, call.ParentPC)
+	}
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/ld.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/ld.go
new file mode 100644
index 000000000..4ba52c778
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/ld.go
@@ -0,0 +1,85 @@
+// Derived from Inferno utils/6l/obj.c and utils/6l/span.c
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/obj.c
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/span.c
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package obj
+
+/*
+ * add library to library list.
+ *	srcref: src file referring to package
+ *	objref: object file referring to package
+ *	file: object file, e.g., /home/rsc/go/pkg/container/vector.a
+ *	pkg: package import path, e.g. container/vector
+ */
+
+const (
+	LOG = 5
+)
+
+func mkfwd(sym *LSym) {
+	var dwn [LOG]int32
+	var cnt [LOG]int32
+	var lst [LOG]*Prog
+
+	for i := 0; i < LOG; i++ {
+		if i == 0 {
+			cnt[i] = 1
+		} else {
+			cnt[i] = LOG * cnt[i-1]
+		}
+		dwn[i] = 1
+		lst[i] = nil
+	}
+
+	i := 0
+	for p := sym.Func.Text; p != nil && p.Link != nil; p = p.Link {
+		i--
+		if i < 0 {
+			i = LOG - 1
+		}
+		p.Forwd = nil
+		dwn[i]--
+		if dwn[i] <= 0 {
+			dwn[i] = cnt[i]
+			if lst[i] != nil {
+				lst[i].Forwd = p
+			}
+			lst[i] = p
+		}
+	}
+}
+
+func Appendp(q *Prog, newprog ProgAlloc) *Prog {
+	p := newprog()
+	p.Link = q.Link
+	q.Link = p
+	p.Pos = q.Pos
+	return p
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/line.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/line.go
new file mode 100644
index 000000000..af8857124
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/line.go
@@ -0,0 +1,30 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package obj
+
+import (
+	"github.com/twitchyliquid64/golang-asm/goobj"
+	"github.com/twitchyliquid64/golang-asm/src"
+)
+
+// AddImport adds a package to the list of imported packages.
+func (ctxt *Link) AddImport(pkg string, fingerprint goobj.FingerprintType) {
+	ctxt.Imports = append(ctxt.Imports, goobj.ImportedPkg{Pkg: pkg, Fingerprint: fingerprint})
+}
+
+func linkgetlineFromPos(ctxt *Link, xpos src.XPos) (f string, l int32) {
+	pos := ctxt.PosTable.Pos(xpos)
+	if !pos.IsKnown() {
+		pos = src.Pos{}
+	}
+	// TODO(gri) Should this use relative or absolute line number?
+	return pos.SymFilename(), int32(pos.RelLine())
+}
+
+// getFileIndexAndLine returns the file index (local to the CU), and the line number for a position.
+func getFileIndexAndLine(ctxt *Link, xpos src.XPos) (int, int32) {
+	f, l := linkgetlineFromPos(ctxt, xpos)
+	return ctxt.PosTable.FileIndex(f), l
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/link.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/link.go
new file mode 100644
index 000000000..a7f854669
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/link.go
@@ -0,0 +1,771 @@
+// Derived from Inferno utils/6l/l.h and related files.
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/l.h
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package obj
+
+import (
+	"bufio"
+	"github.com/twitchyliquid64/golang-asm/dwarf"
+	"github.com/twitchyliquid64/golang-asm/goobj"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"github.com/twitchyliquid64/golang-asm/src"
+	"github.com/twitchyliquid64/golang-asm/sys"
+	"fmt"
+	"sync"
+)
+
+// An Addr is an argument to an instruction.
+// The general forms and their encodings are:
+//
+//	sym±offset(symkind)(reg)(index*scale)
+//		Memory reference at address &sym(symkind) + offset + reg + index*scale.
+//		Any of sym(symkind), ±offset, (reg), (index*scale), and *scale can be omitted.
+//		If (reg) and *scale are both omitted, the resulting expression (index) is parsed as (reg).
+//		To force a parsing as index*scale, write (index*1).
+//		Encoding:
+//			type = TYPE_MEM
+//			name = symkind (NAME_AUTO, ...) or 0 (NAME_NONE)
+//			sym = sym
+//			offset = ±offset
+//			reg = reg (REG_*)
+//			index = index (REG_*)
+//			scale = scale (1, 2, 4, 8)
+//
+//	$<mem>
+//		Effective address of memory reference <mem>, defined above.
+//		Encoding: same as memory reference, but type = TYPE_ADDR.
+//
+//	$<±integer value>
+//		This is a special case of $<mem>, in which only ±offset is present.
+//		It has a separate type for easy recognition.
+//		Encoding:
+//			type = TYPE_CONST
+//			offset = ±integer value
+//
+//	*<mem>
+//		Indirect reference through memory reference <mem>, defined above.
+//		Only used on x86 for CALL/JMP *sym(SB), which calls/jumps to a function
+//		pointer stored in the data word sym(SB), not a function named sym(SB).
+//		Encoding: same as above, but type = TYPE_INDIR.
+//
+//	$*$<mem>
+//		No longer used.
+//		On machines with actual SB registers, $*$<mem> forced the
+//		instruction encoding to use a full 32-bit constant, never a
+//		reference relative to SB.
+//
+//	$<floating point literal>
+//		Floating point constant value.
+//		Encoding:
+//			type = TYPE_FCONST
+//			val = floating point value
+//
+//	$<string literal, up to 8 chars>
+//		String literal value (raw bytes used for DATA instruction).
+//		Encoding:
+//			type = TYPE_SCONST
+//			val = string
+//
+//	<register name>
+//		Any register: integer, floating point, control, segment, and so on.
+//		If looking for specific register kind, must check type and reg value range.
+//		Encoding:
+//			type = TYPE_REG
+//			reg = reg (REG_*)
+//
+//	x(PC)
+//		Encoding:
+//			type = TYPE_BRANCH
+//			val = Prog* reference OR ELSE offset = target pc (branch takes priority)
+//
+//	$±x-±y
+//		Final argument to TEXT, specifying local frame size x and argument size y.
+//		In this form, x and y are integer literals only, not arbitrary expressions.
+//		This avoids parsing ambiguities due to the use of - as a separator.
+//		The ± are optional.
+//		If the final argument to TEXT omits the -±y, the encoding should still
+//		use TYPE_TEXTSIZE (not TYPE_CONST), with u.argsize = ArgsSizeUnknown.
+//		Encoding:
+//			type = TYPE_TEXTSIZE
+//			offset = x
+//			val = int32(y)
+//
+//	reg<<shift, reg>>shift, reg->shift, reg@>shift
+//		Shifted register value, for ARM and ARM64.
+//		In this form, reg must be a register and shift can be a register or an integer constant.
+//		Encoding:
+//			type = TYPE_SHIFT
+//		On ARM:
+//			offset = (reg&15) | shifttype<<5 | count
+//			shifttype = 0, 1, 2, 3 for <<, >>, ->, @>
+//			count = (reg&15)<<8 | 1<<4 for a register shift count, (n&31)<<7 for an integer constant.
+//		On ARM64:
+//			offset = (reg&31)<<16 | shifttype<<22 | (count&63)<<10
+//			shifttype = 0, 1, 2 for <<, >>, ->
+//
+//	(reg, reg)
+//		A destination register pair. When used as the last argument of an instruction,
+//		this form makes clear that both registers are destinations.
+//		Encoding:
+//			type = TYPE_REGREG
+//			reg = first register
+//			offset = second register
+//
+//	[reg, reg, reg-reg]
+//		Register list for ARM, ARM64, 386/AMD64.
+//		Encoding:
+//			type = TYPE_REGLIST
+//		On ARM:
+//			offset = bit mask of registers in list; R0 is low bit.
+//		On ARM64:
+//			offset = register count (Q:size) | arrangement (opcode) | first register
+//		On 386/AMD64:
+//			reg = range low register
+//			offset = 2 packed registers + kind tag (see x86.EncodeRegisterRange)
+//
+//	reg, reg
+//		Register pair for ARM.
+//		TYPE_REGREG2
+//
+//	(reg+reg)
+//		Register pair for PPC64.
+//		Encoding:
+//			type = TYPE_MEM
+//			reg = first register
+//			index = second register
+//			scale = 1
+//
+//	reg.[US]XT[BHWX]
+//		Register extension for ARM64
+//		Encoding:
+//			type = TYPE_REG
+//			reg = REG_[US]XT[BHWX] + register + shift amount
+//			offset = ((reg&31) << 16) | (exttype << 13) | (amount<<10)
+//
+//	reg.<T>
+//		Register arrangement for ARM64 SIMD register
+//		e.g.: V1.S4, V2.S2, V7.D2, V2.H4, V6.B16
+//		Encoding:
+//			type = TYPE_REG
+//			reg = REG_ARNG + register + arrangement
+//
+//	reg.<T>[index]
+//		Register element for ARM64
+//		Encoding:
+//			type = TYPE_REG
+//			reg = REG_ELEM + register + arrangement
+//			index = element index
+
+type Addr struct {
+	Reg    int16
+	Index  int16
+	Scale  int16 // Sometimes holds a register.
+	Type   AddrType
+	Name   AddrName
+	Class  int8
+	Offset int64
+	Sym    *LSym
+
+	// argument value:
+	//	for TYPE_SCONST, a string
+	//	for TYPE_FCONST, a float64
+	//	for TYPE_BRANCH, a *Prog (optional)
+	//	for TYPE_TEXTSIZE, an int32 (optional)
+	Val interface{}
+}
+
+type AddrName int8
+
+const (
+	NAME_NONE AddrName = iota
+	NAME_EXTERN
+	NAME_STATIC
+	NAME_AUTO
+	NAME_PARAM
+	// A reference to name@GOT(SB) is a reference to the entry in the global offset
+	// table for 'name'.
+	NAME_GOTREF
+	// Indicates that this is a reference to a TOC anchor.
+	NAME_TOCREF
+)
+
+//go:generate stringer -type AddrType
+
+type AddrType uint8
+
+const (
+	TYPE_NONE AddrType = iota
+	TYPE_BRANCH
+	TYPE_TEXTSIZE
+	TYPE_MEM
+	TYPE_CONST
+	TYPE_FCONST
+	TYPE_SCONST
+	TYPE_REG
+	TYPE_ADDR
+	TYPE_SHIFT
+	TYPE_REGREG
+	TYPE_REGREG2
+	TYPE_INDIR
+	TYPE_REGLIST
+)
+
+func (a *Addr) Target() *Prog {
+	if a.Type == TYPE_BRANCH && a.Val != nil {
+		return a.Val.(*Prog)
+	}
+	return nil
+}
+func (a *Addr) SetTarget(t *Prog) {
+	if a.Type != TYPE_BRANCH {
+		panic("setting branch target when type is not TYPE_BRANCH")
+	}
+	a.Val = t
+}
+
+// Prog describes a single machine instruction.
+//
+// The general instruction form is:
+//
+//	(1) As.Scond From [, ...RestArgs], To
+//	(2) As.Scond From, Reg [, ...RestArgs], To, RegTo2
+//
+// where As is an opcode and the others are arguments:
+// From, Reg are sources, and To, RegTo2 are destinations.
+// RestArgs can hold additional sources and destinations.
+// Usually, not all arguments are present.
+// For example, MOVL R1, R2 encodes using only As=MOVL, From=R1, To=R2.
+// The Scond field holds additional condition bits for systems (like arm)
+// that have generalized conditional execution.
+// (2) form is present for compatibility with older code,
+// to avoid too much changes in a single swing.
+// (1) scheme is enough to express any kind of operand combination.
+//
+// Jump instructions use the To.Val field to point to the target *Prog,
+// which must be in the same linked list as the jump instruction.
+//
+// The Progs for a given function are arranged in a list linked through the Link field.
+//
+// Each Prog is charged to a specific source line in the debug information,
+// specified by Pos.Line().
+// Every Prog has a Ctxt field that defines its context.
+// For performance reasons, Progs usually are usually bulk allocated, cached, and reused;
+// those bulk allocators should always be used, rather than new(Prog).
+//
+// The other fields not yet mentioned are for use by the back ends and should
+// be left zeroed by creators of Prog lists.
+type Prog struct {
+	Ctxt     *Link    // linker context
+	Link     *Prog    // next Prog in linked list
+	From     Addr     // first source operand
+	RestArgs []Addr   // can pack any operands that not fit into {Prog.From, Prog.To}
+	To       Addr     // destination operand (second is RegTo2 below)
+	Pool     *Prog    // constant pool entry, for arm,arm64 back ends
+	Forwd    *Prog    // for x86 back end
+	Rel      *Prog    // for x86, arm back ends
+	Pc       int64    // for back ends or assembler: virtual or actual program counter, depending on phase
+	Pos      src.XPos // source position of this instruction
+	Spadj    int32    // effect of instruction on stack pointer (increment or decrement amount)
+	As       As       // assembler opcode
+	Reg      int16    // 2nd source operand
+	RegTo2   int16    // 2nd destination operand
+	Mark     uint16   // bitmask of arch-specific items
+	Optab    uint16   // arch-specific opcode index
+	Scond    uint8    // bits that describe instruction suffixes (e.g. ARM conditions)
+	Back     uint8    // for x86 back end: backwards branch state
+	Ft       uint8    // for x86 back end: type index of Prog.From
+	Tt       uint8    // for x86 back end: type index of Prog.To
+	Isize    uint8    // for x86 back end: size of the instruction in bytes
+}
+
+// From3Type returns p.GetFrom3().Type, or TYPE_NONE when
+// p.GetFrom3() returns nil.
+//
+// Deprecated: for the same reasons as Prog.GetFrom3.
+func (p *Prog) From3Type() AddrType {
+	if p.RestArgs == nil {
+		return TYPE_NONE
+	}
+	return p.RestArgs[0].Type
+}
+
+// GetFrom3 returns second source operand (the first is Prog.From).
+// In combination with Prog.From and Prog.To it makes common 3 operand
+// case easier to use.
+//
+// Should be used only when RestArgs is set with SetFrom3.
+//
+// Deprecated: better use RestArgs directly or define backend-specific getters.
+// Introduced to simplify transition to []Addr.
+// Usage of this is discouraged due to fragility and lack of guarantees.
+func (p *Prog) GetFrom3() *Addr {
+	if p.RestArgs == nil {
+		return nil
+	}
+	return &p.RestArgs[0]
+}
+
+// SetFrom3 assigns []Addr{a} to p.RestArgs.
+// In pair with Prog.GetFrom3 it can help in emulation of Prog.From3.
+//
+// Deprecated: for the same reasons as Prog.GetFrom3.
+func (p *Prog) SetFrom3(a Addr) {
+	p.RestArgs = []Addr{a}
+}
+
+// An As denotes an assembler opcode.
+// There are some portable opcodes, declared here in package obj,
+// that are common to all architectures.
+// However, the majority of opcodes are arch-specific
+// and are declared in their respective architecture's subpackage.
+type As int16
+
+// These are the portable opcodes.
+const (
+	AXXX As = iota
+	ACALL
+	ADUFFCOPY
+	ADUFFZERO
+	AEND
+	AFUNCDATA
+	AJMP
+	ANOP
+	APCALIGN
+	APCDATA
+	ARET
+	AGETCALLERPC
+	ATEXT
+	AUNDEF
+	A_ARCHSPECIFIC
+)
+
+// Each architecture is allotted a distinct subspace of opcode values
+// for declaring its arch-specific opcodes.
+// Within this subspace, the first arch-specific opcode should be
+// at offset A_ARCHSPECIFIC.
+//
+// Subspaces are aligned to a power of two so opcodes can be masked
+// with AMask and used as compact array indices.
+const (
+	ABase386 = (1 + iota) << 11
+	ABaseARM
+	ABaseAMD64
+	ABasePPC64
+	ABaseARM64
+	ABaseMIPS
+	ABaseRISCV
+	ABaseS390X
+	ABaseWasm
+
+	AllowedOpCodes = 1 << 11            // The number of opcodes available for any given architecture.
+	AMask          = AllowedOpCodes - 1 // AND with this to use the opcode as an array index.
+)
+
+// An LSym is the sort of symbol that is written to an object file.
+// It represents Go symbols in a flat pkg+"."+name namespace.
+type LSym struct {
+	Name string
+	Type objabi.SymKind
+	Attribute
+
+	RefIdx int // Index of this symbol in the symbol reference list.
+	Size   int64
+	Gotype *LSym
+	P      []byte
+	R      []Reloc
+
+	Func *FuncInfo
+
+	Pkg    string
+	PkgIdx int32
+	SymIdx int32 // TODO: replace RefIdx
+}
+
+// A FuncInfo contains extra fields for STEXT symbols.
+type FuncInfo struct {
+	Args     int32
+	Locals   int32
+	Align    int32
+	FuncID   objabi.FuncID
+	Text     *Prog
+	Autot    map[*LSym]struct{}
+	Pcln     Pcln
+	InlMarks []InlMark
+
+	dwarfInfoSym       *LSym
+	dwarfLocSym        *LSym
+	dwarfRangesSym     *LSym
+	dwarfAbsFnSym      *LSym
+	dwarfDebugLinesSym *LSym
+
+	GCArgs             *LSym
+	GCLocals           *LSym
+	GCRegs             *LSym // Only if !go115ReduceLiveness
+	StackObjects       *LSym
+	OpenCodedDeferInfo *LSym
+
+	FuncInfoSym *LSym
+}
+
+type InlMark struct {
+	// When unwinding from an instruction in an inlined body, mark
+	// where we should unwind to.
+	// id records the global inlining id of the inlined body.
+	// p records the location of an instruction in the parent (inliner) frame.
+	p  *Prog
+	id int32
+}
+
+// Mark p as the instruction to set as the pc when
+// "unwinding" the inlining global frame id. Usually it should be
+// instruction with a file:line at the callsite, and occur
+// just before the body of the inlined function.
+func (fi *FuncInfo) AddInlMark(p *Prog, id int32) {
+	fi.InlMarks = append(fi.InlMarks, InlMark{p: p, id: id})
+}
+
+// Record the type symbol for an auto variable so that the linker
+// an emit DWARF type information for the type.
+func (fi *FuncInfo) RecordAutoType(gotype *LSym) {
+	if fi.Autot == nil {
+		fi.Autot = make(map[*LSym]struct{})
+	}
+	fi.Autot[gotype] = struct{}{}
+}
+
+//go:generate stringer -type ABI
+
+// ABI is the calling convention of a text symbol.
+type ABI uint8
+
+const (
+	// ABI0 is the stable stack-based ABI. It's important that the
+	// value of this is "0": we can't distinguish between
+	// references to data and ABI0 text symbols in assembly code,
+	// and hence this doesn't distinguish between symbols without
+	// an ABI and text symbols with ABI0.
+	ABI0 ABI = iota
+
+	// ABIInternal is the internal ABI that may change between Go
+	// versions. All Go functions use the internal ABI and the
+	// compiler generates wrappers for calls to and from other
+	// ABIs.
+	ABIInternal
+
+	ABICount
+)
+
+// Attribute is a set of symbol attributes.
+type Attribute uint32
+
+const (
+	AttrDuplicateOK Attribute = 1 << iota
+	AttrCFunc
+	AttrNoSplit
+	AttrLeaf
+	AttrWrapper
+	AttrNeedCtxt
+	AttrNoFrame
+	AttrOnList
+	AttrStatic
+
+	// MakeTypelink means that the type should have an entry in the typelink table.
+	AttrMakeTypelink
+
+	// ReflectMethod means the function may call reflect.Type.Method or
+	// reflect.Type.MethodByName. Matching is imprecise (as reflect.Type
+	// can be used through a custom interface), so ReflectMethod may be
+	// set in some cases when the reflect package is not called.
+	//
+	// Used by the linker to determine what methods can be pruned.
+	AttrReflectMethod
+
+	// Local means make the symbol local even when compiling Go code to reference Go
+	// symbols in other shared libraries, as in this mode symbols are global by
+	// default. "local" here means in the sense of the dynamic linker, i.e. not
+	// visible outside of the module (shared library or executable) that contains its
+	// definition. (When not compiling to support Go shared libraries, all symbols are
+	// local in this sense unless there is a cgo_export_* directive).
+	AttrLocal
+
+	// For function symbols; indicates that the specified function was the
+	// target of an inline during compilation
+	AttrWasInlined
+
+	// TopFrame means that this function is an entry point and unwinders should not
+	// keep unwinding beyond this frame.
+	AttrTopFrame
+
+	// Indexed indicates this symbol has been assigned with an index (when using the
+	// new object file format).
+	AttrIndexed
+
+	// Only applied on type descriptor symbols, UsedInIface indicates this type is
+	// converted to an interface.
+	//
+	// Used by the linker to determine what methods can be pruned.
+	AttrUsedInIface
+
+	// ContentAddressable indicates this is a content-addressable symbol.
+	AttrContentAddressable
+
+	// attrABIBase is the value at which the ABI is encoded in
+	// Attribute. This must be last; all bits after this are
+	// assumed to be an ABI value.
+	//
+	// MUST BE LAST since all bits above this comprise the ABI.
+	attrABIBase
+)
+
+func (a Attribute) DuplicateOK() bool        { return a&AttrDuplicateOK != 0 }
+func (a Attribute) MakeTypelink() bool       { return a&AttrMakeTypelink != 0 }
+func (a Attribute) CFunc() bool              { return a&AttrCFunc != 0 }
+func (a Attribute) NoSplit() bool            { return a&AttrNoSplit != 0 }
+func (a Attribute) Leaf() bool               { return a&AttrLeaf != 0 }
+func (a Attribute) OnList() bool             { return a&AttrOnList != 0 }
+func (a Attribute) ReflectMethod() bool      { return a&AttrReflectMethod != 0 }
+func (a Attribute) Local() bool              { return a&AttrLocal != 0 }
+func (a Attribute) Wrapper() bool            { return a&AttrWrapper != 0 }
+func (a Attribute) NeedCtxt() bool           { return a&AttrNeedCtxt != 0 }
+func (a Attribute) NoFrame() bool            { return a&AttrNoFrame != 0 }
+func (a Attribute) Static() bool             { return a&AttrStatic != 0 }
+func (a Attribute) WasInlined() bool         { return a&AttrWasInlined != 0 }
+func (a Attribute) TopFrame() bool           { return a&AttrTopFrame != 0 }
+func (a Attribute) Indexed() bool            { return a&AttrIndexed != 0 }
+func (a Attribute) UsedInIface() bool        { return a&AttrUsedInIface != 0 }
+func (a Attribute) ContentAddressable() bool { return a&AttrContentAddressable != 0 }
+
+func (a *Attribute) Set(flag Attribute, value bool) {
+	if value {
+		*a |= flag
+	} else {
+		*a &^= flag
+	}
+}
+
+func (a Attribute) ABI() ABI { return ABI(a / attrABIBase) }
+func (a *Attribute) SetABI(abi ABI) {
+	const mask = 1 // Only one ABI bit for now.
+	*a = (*a &^ (mask * attrABIBase)) | Attribute(abi)*attrABIBase
+}
+
+var textAttrStrings = [...]struct {
+	bit Attribute
+	s   string
+}{
+	{bit: AttrDuplicateOK, s: "DUPOK"},
+	{bit: AttrMakeTypelink, s: ""},
+	{bit: AttrCFunc, s: "CFUNC"},
+	{bit: AttrNoSplit, s: "NOSPLIT"},
+	{bit: AttrLeaf, s: "LEAF"},
+	{bit: AttrOnList, s: ""},
+	{bit: AttrReflectMethod, s: "REFLECTMETHOD"},
+	{bit: AttrLocal, s: "LOCAL"},
+	{bit: AttrWrapper, s: "WRAPPER"},
+	{bit: AttrNeedCtxt, s: "NEEDCTXT"},
+	{bit: AttrNoFrame, s: "NOFRAME"},
+	{bit: AttrStatic, s: "STATIC"},
+	{bit: AttrWasInlined, s: ""},
+	{bit: AttrTopFrame, s: "TOPFRAME"},
+	{bit: AttrIndexed, s: ""},
+	{bit: AttrContentAddressable, s: ""},
+}
+
+// TextAttrString formats a for printing in as part of a TEXT prog.
+func (a Attribute) TextAttrString() string {
+	var s string
+	for _, x := range textAttrStrings {
+		if a&x.bit != 0 {
+			if x.s != "" {
+				s += x.s + "|"
+			}
+			a &^= x.bit
+		}
+	}
+	switch a.ABI() {
+	case ABI0:
+	case ABIInternal:
+		s += "ABIInternal|"
+		a.SetABI(0) // Clear ABI so we don't print below.
+	}
+	if a != 0 {
+		s += fmt.Sprintf("UnknownAttribute(%d)|", a)
+	}
+	// Chop off trailing |, if present.
+	if len(s) > 0 {
+		s = s[:len(s)-1]
+	}
+	return s
+}
+
+func (s *LSym) String() string {
+	return s.Name
+}
+
+// The compiler needs *LSym to be assignable to cmd/compile/internal/ssa.Sym.
+func (s *LSym) CanBeAnSSASym() {
+}
+
+type Pcln struct {
+	Pcsp        Pcdata
+	Pcfile      Pcdata
+	Pcline      Pcdata
+	Pcinline    Pcdata
+	Pcdata      []Pcdata
+	Funcdata    []*LSym
+	Funcdataoff []int64
+	UsedFiles   map[goobj.CUFileIndex]struct{} // file indices used while generating pcfile
+	InlTree     InlTree                        // per-function inlining tree extracted from the global tree
+}
+
+type Reloc struct {
+	Off  int32
+	Siz  uint8
+	Type objabi.RelocType
+	Add  int64
+	Sym  *LSym
+}
+
+type Auto struct {
+	Asym    *LSym
+	Aoffset int32
+	Name    AddrName
+	Gotype  *LSym
+}
+
+type Pcdata struct {
+	P []byte
+}
+
+// Link holds the context for writing object code from a compiler
+// to be linker input or for reading that input into the linker.
+type Link struct {
+	Headtype           objabi.HeadType
+	Arch               *LinkArch
+	Debugasm           int
+	Debugvlog          bool
+	Debugpcln          string
+	Flag_shared        bool
+	Flag_dynlink       bool
+	Flag_linkshared    bool
+	Flag_optimize      bool
+	Flag_locationlists bool
+	Retpoline          bool // emit use of retpoline stubs for indirect jmp/call
+	Bso                *bufio.Writer
+	Pathname           string
+	Pkgpath            string           // the current package's import path, "" if unknown
+	hashmu             sync.Mutex       // protects hash, funchash
+	hash               map[string]*LSym // name -> sym mapping
+	funchash           map[string]*LSym // name -> sym mapping for ABIInternal syms
+	statichash         map[string]*LSym // name -> sym mapping for static syms
+	PosTable           src.PosTable
+	InlTree            InlTree // global inlining tree used by gc/inl.go
+	DwFixups           *DwarfFixupTable
+	Imports            []goobj.ImportedPkg
+	DiagFunc           func(string, ...interface{})
+	DiagFlush          func()
+	DebugInfo          func(fn *LSym, info *LSym, curfn interface{}) ([]dwarf.Scope, dwarf.InlCalls) // if non-nil, curfn is a *gc.Node
+	GenAbstractFunc    func(fn *LSym)
+	Errors             int
+
+	InParallel    bool // parallel backend phase in effect
+	UseBASEntries bool // use Base Address Selection Entries in location lists and PC ranges
+	IsAsm         bool // is the source assembly language, which may contain surprising idioms (e.g., call tables)
+
+	// state for writing objects
+	Text []*LSym
+	Data []*LSym
+
+	// ABIAliases are text symbols that should be aliased to all
+	// ABIs. These symbols may only be referenced and not defined
+	// by this object, since the need for an alias may appear in a
+	// different object than the definition. Hence, this
+	// information can't be carried in the symbol definition.
+	//
+	// TODO(austin): Replace this with ABI wrappers once the ABIs
+	// actually diverge.
+	ABIAliases []*LSym
+
+	// Constant symbols (e.g. $i64.*) are data symbols created late
+	// in the concurrent phase. To ensure a deterministic order, we
+	// add them to a separate list, sort at the end, and append it
+	// to Data.
+	constSyms []*LSym
+
+	// pkgIdx maps package path to index. The index is used for
+	// symbol reference in the object file.
+	pkgIdx map[string]int32
+
+	defs         []*LSym // list of defined symbols in the current package
+	hashed64defs []*LSym // list of defined short (64-bit or less) hashed (content-addressable) symbols
+	hasheddefs   []*LSym // list of defined hashed (content-addressable) symbols
+	nonpkgdefs   []*LSym // list of defined non-package symbols
+	nonpkgrefs   []*LSym // list of referenced non-package symbols
+
+	Fingerprint goobj.FingerprintType // fingerprint of symbol indices, to catch index mismatch
+}
+
+func (ctxt *Link) Diag(format string, args ...interface{}) {
+	ctxt.Errors++
+	ctxt.DiagFunc(format, args...)
+}
+
+func (ctxt *Link) Logf(format string, args ...interface{}) {
+	fmt.Fprintf(ctxt.Bso, format, args...)
+	ctxt.Bso.Flush()
+}
+
+// The smallest possible offset from the hardware stack pointer to a local
+// variable on the stack. Architectures that use a link register save its value
+// on the stack in the function prologue and so always have a pointer between
+// the hardware stack pointer and the local variable area.
+func (ctxt *Link) FixedFrameSize() int64 {
+	switch ctxt.Arch.Family {
+	case sys.AMD64, sys.I386, sys.Wasm:
+		return 0
+	case sys.PPC64:
+		// PIC code on ppc64le requires 32 bytes of stack, and it's easier to
+		// just use that much stack always on ppc64x.
+		return int64(4 * ctxt.Arch.PtrSize)
+	default:
+		return int64(ctxt.Arch.PtrSize)
+	}
+}
+
+// LinkArch is the definition of a single architecture.
+type LinkArch struct {
+	*sys.Arch
+	Init           func(*Link)
+	Preprocess     func(*Link, *LSym, ProgAlloc)
+	Assemble       func(*Link, *LSym, ProgAlloc)
+	Progedit       func(*Link, *Prog, ProgAlloc)
+	UnaryDst       map[As]bool // Instruction takes one operand, a destination.
+	DWARFRegisters map[int16]int16
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/a.out.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/a.out.go
new file mode 100644
index 000000000..95c077c04
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/a.out.go
@@ -0,0 +1,481 @@
+// cmd/9c/9.out.h from Vita Nuova.
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2008 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package mips
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+)
+
+//go:generate go run ../stringer.go -i $GOFILE -o anames.go -p mips
+
+/*
+ * mips 64
+ */
+const (
+	NSNAME = 8
+	NSYM   = 50
+	NREG   = 32 /* number of general registers */
+	NFREG  = 32 /* number of floating point registers */
+	NWREG  = 32 /* number of MSA registers */
+)
+
+const (
+	REG_R0 = obj.RBaseMIPS + iota // must be a multiple of 32
+	REG_R1
+	REG_R2
+	REG_R3
+	REG_R4
+	REG_R5
+	REG_R6
+	REG_R7
+	REG_R8
+	REG_R9
+	REG_R10
+	REG_R11
+	REG_R12
+	REG_R13
+	REG_R14
+	REG_R15
+	REG_R16
+	REG_R17
+	REG_R18
+	REG_R19
+	REG_R20
+	REG_R21
+	REG_R22
+	REG_R23
+	REG_R24
+	REG_R25
+	REG_R26
+	REG_R27
+	REG_R28
+	REG_R29
+	REG_R30
+	REG_R31
+
+	REG_F0 // must be a multiple of 32
+	REG_F1
+	REG_F2
+	REG_F3
+	REG_F4
+	REG_F5
+	REG_F6
+	REG_F7
+	REG_F8
+	REG_F9
+	REG_F10
+	REG_F11
+	REG_F12
+	REG_F13
+	REG_F14
+	REG_F15
+	REG_F16
+	REG_F17
+	REG_F18
+	REG_F19
+	REG_F20
+	REG_F21
+	REG_F22
+	REG_F23
+	REG_F24
+	REG_F25
+	REG_F26
+	REG_F27
+	REG_F28
+	REG_F29
+	REG_F30
+	REG_F31
+
+	// co-processor 0 control registers
+	REG_M0 // must be a multiple of 32
+	REG_M1
+	REG_M2
+	REG_M3
+	REG_M4
+	REG_M5
+	REG_M6
+	REG_M7
+	REG_M8
+	REG_M9
+	REG_M10
+	REG_M11
+	REG_M12
+	REG_M13
+	REG_M14
+	REG_M15
+	REG_M16
+	REG_M17
+	REG_M18
+	REG_M19
+	REG_M20
+	REG_M21
+	REG_M22
+	REG_M23
+	REG_M24
+	REG_M25
+	REG_M26
+	REG_M27
+	REG_M28
+	REG_M29
+	REG_M30
+	REG_M31
+
+	// FPU control registers
+	REG_FCR0 // must be a multiple of 32
+	REG_FCR1
+	REG_FCR2
+	REG_FCR3
+	REG_FCR4
+	REG_FCR5
+	REG_FCR6
+	REG_FCR7
+	REG_FCR8
+	REG_FCR9
+	REG_FCR10
+	REG_FCR11
+	REG_FCR12
+	REG_FCR13
+	REG_FCR14
+	REG_FCR15
+	REG_FCR16
+	REG_FCR17
+	REG_FCR18
+	REG_FCR19
+	REG_FCR20
+	REG_FCR21
+	REG_FCR22
+	REG_FCR23
+	REG_FCR24
+	REG_FCR25
+	REG_FCR26
+	REG_FCR27
+	REG_FCR28
+	REG_FCR29
+	REG_FCR30
+	REG_FCR31
+
+	// MSA registers
+	// The lower bits of W registers are alias to F registers
+	REG_W0 // must be a multiple of 32
+	REG_W1
+	REG_W2
+	REG_W3
+	REG_W4
+	REG_W5
+	REG_W6
+	REG_W7
+	REG_W8
+	REG_W9
+	REG_W10
+	REG_W11
+	REG_W12
+	REG_W13
+	REG_W14
+	REG_W15
+	REG_W16
+	REG_W17
+	REG_W18
+	REG_W19
+	REG_W20
+	REG_W21
+	REG_W22
+	REG_W23
+	REG_W24
+	REG_W25
+	REG_W26
+	REG_W27
+	REG_W28
+	REG_W29
+	REG_W30
+	REG_W31
+
+	REG_HI
+	REG_LO
+
+	REG_LAST = REG_LO // the last defined register
+
+	REG_SPECIAL = REG_M0
+
+	REGZERO = REG_R0 /* set to zero */
+	REGSP   = REG_R29
+	REGSB   = REG_R28
+	REGLINK = REG_R31
+	REGRET  = REG_R1
+	REGARG  = -1      /* -1 disables passing the first argument in register */
+	REGRT1  = REG_R1  /* reserved for runtime, duffzero and duffcopy */
+	REGRT2  = REG_R2  /* reserved for runtime, duffcopy */
+	REGCTXT = REG_R22 /* context for closures */
+	REGG    = REG_R30 /* G */
+	REGTMP  = REG_R23 /* used by the linker */
+	FREGRET = REG_F0
+)
+
+// https://llvm.org/svn/llvm-project/llvm/trunk/lib/Target/Mips/MipsRegisterInfo.td search for DwarfRegNum
+// https://gcc.gnu.org/viewcvs/gcc/trunk/gcc/config/mips/mips.c?view=co&revision=258099&content-type=text%2Fplain search for mips_dwarf_regno
+// For now, this is adequate for both 32 and 64 bit.
+var MIPSDWARFRegisters = map[int16]int16{}
+
+func init() {
+	// f assigns dwarfregisters[from:to] = (base):(to-from+base)
+	f := func(from, to, base int16) {
+		for r := int16(from); r <= to; r++ {
+			MIPSDWARFRegisters[r] = (r - from) + base
+		}
+	}
+	f(REG_R0, REG_R31, 0)
+	f(REG_F0, REG_F31, 32) // For 32-bit MIPS, compiler only uses even numbered registers --  see cmd/compile/internal/ssa/gen/MIPSOps.go
+	MIPSDWARFRegisters[REG_HI] = 64
+	MIPSDWARFRegisters[REG_LO] = 65
+	// The lower bits of W registers are alias to F registers
+	f(REG_W0, REG_W31, 32)
+}
+
+const (
+	BIG = 32766
+)
+
+const (
+	/* mark flags */
+	FOLL    = 1 << 0
+	LABEL   = 1 << 1
+	LEAF    = 1 << 2
+	SYNC    = 1 << 3
+	BRANCH  = 1 << 4
+	LOAD    = 1 << 5
+	FCMP    = 1 << 6
+	NOSCHED = 1 << 7
+
+	NSCHED = 20
+)
+
+const (
+	C_NONE = iota
+	C_REG
+	C_FREG
+	C_FCREG
+	C_MREG /* special processor register */
+	C_WREG /* MSA registers */
+	C_HI
+	C_LO
+	C_ZCON
+	C_SCON /* 16 bit signed */
+	C_UCON /* 32 bit signed, low 16 bits 0 */
+	C_ADD0CON
+	C_AND0CON
+	C_ADDCON /* -0x8000 <= v < 0 */
+	C_ANDCON /* 0 < v <= 0xFFFF */
+	C_LCON   /* other 32 */
+	C_DCON   /* other 64 (could subdivide further) */
+	C_SACON  /* $n(REG) where n <= int16 */
+	C_SECON
+	C_LACON /* $n(REG) where int16 < n <= int32 */
+	C_LECON
+	C_DACON /* $n(REG) where int32 < n */
+	C_STCON /* $tlsvar */
+	C_SBRA
+	C_LBRA
+	C_SAUTO
+	C_LAUTO
+	C_SEXT
+	C_LEXT
+	C_ZOREG
+	C_SOREG
+	C_LOREG
+	C_GOK
+	C_ADDR
+	C_TLS
+	C_TEXTSIZE
+
+	C_NCLASS /* must be the last */
+)
+
+const (
+	AABSD = obj.ABaseMIPS + obj.A_ARCHSPECIFIC + iota
+	AABSF
+	AABSW
+	AADD
+	AADDD
+	AADDF
+	AADDU
+	AADDW
+	AAND
+	ABEQ
+	ABFPF
+	ABFPT
+	ABGEZ
+	ABGEZAL
+	ABGTZ
+	ABLEZ
+	ABLTZ
+	ABLTZAL
+	ABNE
+	ABREAK
+	ACLO
+	ACLZ
+	ACMOVF
+	ACMOVN
+	ACMOVT
+	ACMOVZ
+	ACMPEQD
+	ACMPEQF
+	ACMPGED
+	ACMPGEF
+	ACMPGTD
+	ACMPGTF
+	ADIV
+	ADIVD
+	ADIVF
+	ADIVU
+	ADIVW
+	AGOK
+	ALL
+	ALLV
+	ALUI
+	AMADD
+	AMOVB
+	AMOVBU
+	AMOVD
+	AMOVDF
+	AMOVDW
+	AMOVF
+	AMOVFD
+	AMOVFW
+	AMOVH
+	AMOVHU
+	AMOVW
+	AMOVWD
+	AMOVWF
+	AMOVWL
+	AMOVWR
+	AMSUB
+	AMUL
+	AMULD
+	AMULF
+	AMULU
+	AMULW
+	ANEGD
+	ANEGF
+	ANEGW
+	ANEGV
+	ANOOP // hardware nop
+	ANOR
+	AOR
+	AREM
+	AREMU
+	ARFE
+	ASC
+	ASCV
+	ASGT
+	ASGTU
+	ASLL
+	ASQRTD
+	ASQRTF
+	ASRA
+	ASRL
+	ASUB
+	ASUBD
+	ASUBF
+	ASUBU
+	ASUBW
+	ASYNC
+	ASYSCALL
+	ATEQ
+	ATLBP
+	ATLBR
+	ATLBWI
+	ATLBWR
+	ATNE
+	AWORD
+	AXOR
+
+	/* 64-bit */
+	AMOVV
+	AMOVVL
+	AMOVVR
+	ASLLV
+	ASRAV
+	ASRLV
+	ADIVV
+	ADIVVU
+	AREMV
+	AREMVU
+	AMULV
+	AMULVU
+	AADDV
+	AADDVU
+	ASUBV
+	ASUBVU
+
+	/* 64-bit FP */
+	ATRUNCFV
+	ATRUNCDV
+	ATRUNCFW
+	ATRUNCDW
+	AMOVWU
+	AMOVFV
+	AMOVDV
+	AMOVVF
+	AMOVVD
+
+	/* MSA */
+	AVMOVB
+	AVMOVH
+	AVMOVW
+	AVMOVD
+
+	ALAST
+
+	// aliases
+	AJMP = obj.AJMP
+	AJAL = obj.ACALL
+	ARET = obj.ARET
+)
+
+func init() {
+	// The asm encoder generally assumes that the lowest 5 bits of the
+	// REG_XX constants match the machine instruction encoding, i.e.
+	// the lowest 5 bits is the register number.
+	// Check this here.
+	if REG_R0%32 != 0 {
+		panic("REG_R0 is not a multiple of 32")
+	}
+	if REG_F0%32 != 0 {
+		panic("REG_F0 is not a multiple of 32")
+	}
+	if REG_M0%32 != 0 {
+		panic("REG_M0 is not a multiple of 32")
+	}
+	if REG_FCR0%32 != 0 {
+		panic("REG_FCR0 is not a multiple of 32")
+	}
+	if REG_W0%32 != 0 {
+		panic("REG_W0 is not a multiple of 32")
+	}
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/anames.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/anames.go
new file mode 100644
index 000000000..122b87ba6
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/anames.go
@@ -0,0 +1,135 @@
+// Code generated by stringer -i a.out.go -o anames.go -p mips; DO NOT EDIT.
+
+package mips
+
+import "github.com/twitchyliquid64/golang-asm/obj"
+
+var Anames = []string{
+	obj.A_ARCHSPECIFIC: "ABSD",
+	"ABSF",
+	"ABSW",
+	"ADD",
+	"ADDD",
+	"ADDF",
+	"ADDU",
+	"ADDW",
+	"AND",
+	"BEQ",
+	"BFPF",
+	"BFPT",
+	"BGEZ",
+	"BGEZAL",
+	"BGTZ",
+	"BLEZ",
+	"BLTZ",
+	"BLTZAL",
+	"BNE",
+	"BREAK",
+	"CLO",
+	"CLZ",
+	"CMOVF",
+	"CMOVN",
+	"CMOVT",
+	"CMOVZ",
+	"CMPEQD",
+	"CMPEQF",
+	"CMPGED",
+	"CMPGEF",
+	"CMPGTD",
+	"CMPGTF",
+	"DIV",
+	"DIVD",
+	"DIVF",
+	"DIVU",
+	"DIVW",
+	"GOK",
+	"LL",
+	"LLV",
+	"LUI",
+	"MADD",
+	"MOVB",
+	"MOVBU",
+	"MOVD",
+	"MOVDF",
+	"MOVDW",
+	"MOVF",
+	"MOVFD",
+	"MOVFW",
+	"MOVH",
+	"MOVHU",
+	"MOVW",
+	"MOVWD",
+	"MOVWF",
+	"MOVWL",
+	"MOVWR",
+	"MSUB",
+	"MUL",
+	"MULD",
+	"MULF",
+	"MULU",
+	"MULW",
+	"NEGD",
+	"NEGF",
+	"NEGW",
+	"NEGV",
+	"NOOP",
+	"NOR",
+	"OR",
+	"REM",
+	"REMU",
+	"RFE",
+	"SC",
+	"SCV",
+	"SGT",
+	"SGTU",
+	"SLL",
+	"SQRTD",
+	"SQRTF",
+	"SRA",
+	"SRL",
+	"SUB",
+	"SUBD",
+	"SUBF",
+	"SUBU",
+	"SUBW",
+	"SYNC",
+	"SYSCALL",
+	"TEQ",
+	"TLBP",
+	"TLBR",
+	"TLBWI",
+	"TLBWR",
+	"TNE",
+	"WORD",
+	"XOR",
+	"MOVV",
+	"MOVVL",
+	"MOVVR",
+	"SLLV",
+	"SRAV",
+	"SRLV",
+	"DIVV",
+	"DIVVU",
+	"REMV",
+	"REMVU",
+	"MULV",
+	"MULVU",
+	"ADDV",
+	"ADDVU",
+	"SUBV",
+	"SUBVU",
+	"TRUNCFV",
+	"TRUNCDV",
+	"TRUNCFW",
+	"TRUNCDW",
+	"MOVWU",
+	"MOVFV",
+	"MOVDV",
+	"MOVVF",
+	"MOVVD",
+	"VMOVB",
+	"VMOVH",
+	"VMOVW",
+	"VMOVD",
+	"LAST",
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/anames0.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/anames0.go
new file mode 100644
index 000000000..c30069673
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/anames0.go
@@ -0,0 +1,45 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package mips
+
+var cnames0 = []string{
+	"NONE",
+	"REG",
+	"FREG",
+	"FCREG",
+	"MREG",
+	"WREG",
+	"HI",
+	"LO",
+	"ZCON",
+	"SCON",
+	"UCON",
+	"ADD0CON",
+	"AND0CON",
+	"ADDCON",
+	"ANDCON",
+	"LCON",
+	"DCON",
+	"SACON",
+	"SECON",
+	"LACON",
+	"LECON",
+	"DACON",
+	"STCON",
+	"SBRA",
+	"LBRA",
+	"SAUTO",
+	"LAUTO",
+	"SEXT",
+	"LEXT",
+	"ZOREG",
+	"SOREG",
+	"LOREG",
+	"GOK",
+	"ADDR",
+	"TLS",
+	"TEXTSIZE",
+	"NCLASS",
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/asm0.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/asm0.go
new file mode 100644
index 000000000..61bc24699
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/asm0.go
@@ -0,0 +1,2108 @@
+// cmd/9l/optab.c, cmd/9l/asmout.c from Vita Nuova.
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2008 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package mips
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"github.com/twitchyliquid64/golang-asm/sys"
+	"fmt"
+	"log"
+	"sort"
+)
+
+// ctxt0 holds state while assembling a single function.
+// Each function gets a fresh ctxt0.
+// This allows for multiple functions to be safely concurrently assembled.
+type ctxt0 struct {
+	ctxt       *obj.Link
+	newprog    obj.ProgAlloc
+	cursym     *obj.LSym
+	autosize   int32
+	instoffset int64
+	pc         int64
+}
+
+// Instruction layout.
+
+const (
+	mips64FuncAlign = 8
+)
+
+const (
+	r0iszero = 1
+)
+
+type Optab struct {
+	as     obj.As
+	a1     uint8
+	a2     uint8
+	a3     uint8
+	type_  int8
+	size   int8
+	param  int16
+	family sys.ArchFamily // 0 means both sys.MIPS and sys.MIPS64
+	flag   uint8
+}
+
+const (
+	// Optab.flag
+	NOTUSETMP = 1 << iota // p expands to multiple instructions, but does NOT use REGTMP
+)
+
+var optab = []Optab{
+	{obj.ATEXT, C_LEXT, C_NONE, C_TEXTSIZE, 0, 0, 0, sys.MIPS64, 0},
+	{obj.ATEXT, C_ADDR, C_NONE, C_TEXTSIZE, 0, 0, 0, 0, 0},
+
+	{AMOVW, C_REG, C_NONE, C_REG, 1, 4, 0, 0, 0},
+	{AMOVV, C_REG, C_NONE, C_REG, 1, 4, 0, sys.MIPS64, 0},
+	{AMOVB, C_REG, C_NONE, C_REG, 12, 8, 0, 0, NOTUSETMP},
+	{AMOVBU, C_REG, C_NONE, C_REG, 13, 4, 0, 0, 0},
+	{AMOVWU, C_REG, C_NONE, C_REG, 14, 8, 0, sys.MIPS64, NOTUSETMP},
+
+	{ASUB, C_REG, C_REG, C_REG, 2, 4, 0, 0, 0},
+	{ASUBV, C_REG, C_REG, C_REG, 2, 4, 0, sys.MIPS64, 0},
+	{AADD, C_REG, C_REG, C_REG, 2, 4, 0, 0, 0},
+	{AADDV, C_REG, C_REG, C_REG, 2, 4, 0, sys.MIPS64, 0},
+	{AAND, C_REG, C_REG, C_REG, 2, 4, 0, 0, 0},
+	{ASUB, C_REG, C_NONE, C_REG, 2, 4, 0, 0, 0},
+	{ASUBV, C_REG, C_NONE, C_REG, 2, 4, 0, sys.MIPS64, 0},
+	{AADD, C_REG, C_NONE, C_REG, 2, 4, 0, 0, 0},
+	{AADDV, C_REG, C_NONE, C_REG, 2, 4, 0, sys.MIPS64, 0},
+	{AAND, C_REG, C_NONE, C_REG, 2, 4, 0, 0, 0},
+	{ACMOVN, C_REG, C_REG, C_REG, 2, 4, 0, 0, 0},
+	{ANEGW, C_REG, C_NONE, C_REG, 2, 4, 0, 0, 0},
+	{ANEGV, C_REG, C_NONE, C_REG, 2, 4, 0, sys.MIPS64, 0},
+
+	{ASLL, C_REG, C_NONE, C_REG, 9, 4, 0, 0, 0},
+	{ASLL, C_REG, C_REG, C_REG, 9, 4, 0, 0, 0},
+	{ASLLV, C_REG, C_NONE, C_REG, 9, 4, 0, sys.MIPS64, 0},
+	{ASLLV, C_REG, C_REG, C_REG, 9, 4, 0, sys.MIPS64, 0},
+	{ACLO, C_REG, C_NONE, C_REG, 9, 4, 0, 0, 0},
+
+	{AADDF, C_FREG, C_NONE, C_FREG, 32, 4, 0, 0, 0},
+	{AADDF, C_FREG, C_REG, C_FREG, 32, 4, 0, 0, 0},
+	{ACMPEQF, C_FREG, C_REG, C_NONE, 32, 4, 0, 0, 0},
+	{AABSF, C_FREG, C_NONE, C_FREG, 33, 4, 0, 0, 0},
+	{AMOVVF, C_FREG, C_NONE, C_FREG, 33, 4, 0, sys.MIPS64, 0},
+	{AMOVF, C_FREG, C_NONE, C_FREG, 33, 4, 0, 0, 0},
+	{AMOVD, C_FREG, C_NONE, C_FREG, 33, 4, 0, 0, 0},
+
+	{AMOVW, C_REG, C_NONE, C_SEXT, 7, 4, REGSB, sys.MIPS64, 0},
+	{AMOVWU, C_REG, C_NONE, C_SEXT, 7, 4, REGSB, sys.MIPS64, 0},
+	{AMOVV, C_REG, C_NONE, C_SEXT, 7, 4, REGSB, sys.MIPS64, 0},
+	{AMOVB, C_REG, C_NONE, C_SEXT, 7, 4, REGSB, sys.MIPS64, 0},
+	{AMOVBU, C_REG, C_NONE, C_SEXT, 7, 4, REGSB, sys.MIPS64, 0},
+	{AMOVWL, C_REG, C_NONE, C_SEXT, 7, 4, REGSB, sys.MIPS64, 0},
+	{AMOVVL, C_REG, C_NONE, C_SEXT, 7, 4, REGSB, sys.MIPS64, 0},
+	{AMOVW, C_REG, C_NONE, C_SAUTO, 7, 4, REGSP, 0, 0},
+	{AMOVWU, C_REG, C_NONE, C_SAUTO, 7, 4, REGSP, sys.MIPS64, 0},
+	{AMOVV, C_REG, C_NONE, C_SAUTO, 7, 4, REGSP, sys.MIPS64, 0},
+	{AMOVB, C_REG, C_NONE, C_SAUTO, 7, 4, REGSP, 0, 0},
+	{AMOVBU, C_REG, C_NONE, C_SAUTO, 7, 4, REGSP, 0, 0},
+	{AMOVWL, C_REG, C_NONE, C_SAUTO, 7, 4, REGSP, 0, 0},
+	{AMOVVL, C_REG, C_NONE, C_SAUTO, 7, 4, REGSP, sys.MIPS64, 0},
+	{AMOVW, C_REG, C_NONE, C_SOREG, 7, 4, REGZERO, 0, 0},
+	{AMOVWU, C_REG, C_NONE, C_SOREG, 7, 4, REGZERO, sys.MIPS64, 0},
+	{AMOVV, C_REG, C_NONE, C_SOREG, 7, 4, REGZERO, sys.MIPS64, 0},
+	{AMOVB, C_REG, C_NONE, C_SOREG, 7, 4, REGZERO, 0, 0},
+	{AMOVBU, C_REG, C_NONE, C_SOREG, 7, 4, REGZERO, 0, 0},
+	{AMOVWL, C_REG, C_NONE, C_SOREG, 7, 4, REGZERO, 0, 0},
+	{AMOVVL, C_REG, C_NONE, C_SOREG, 7, 4, REGZERO, sys.MIPS64, 0},
+	{ASC, C_REG, C_NONE, C_SOREG, 7, 4, REGZERO, 0, 0},
+	{ASCV, C_REG, C_NONE, C_SOREG, 7, 4, REGZERO, sys.MIPS64, 0},
+
+	{AMOVW, C_SEXT, C_NONE, C_REG, 8, 4, REGSB, sys.MIPS64, 0},
+	{AMOVWU, C_SEXT, C_NONE, C_REG, 8, 4, REGSB, sys.MIPS64, 0},
+	{AMOVV, C_SEXT, C_NONE, C_REG, 8, 4, REGSB, sys.MIPS64, 0},
+	{AMOVB, C_SEXT, C_NONE, C_REG, 8, 4, REGSB, sys.MIPS64, 0},
+	{AMOVBU, C_SEXT, C_NONE, C_REG, 8, 4, REGSB, sys.MIPS64, 0},
+	{AMOVWL, C_SEXT, C_NONE, C_REG, 8, 4, REGSB, sys.MIPS64, 0},
+	{AMOVVL, C_SEXT, C_NONE, C_REG, 8, 4, REGSB, sys.MIPS64, 0},
+	{AMOVW, C_SAUTO, C_NONE, C_REG, 8, 4, REGSP, 0, 0},
+	{AMOVWU, C_SAUTO, C_NONE, C_REG, 8, 4, REGSP, sys.MIPS64, 0},
+	{AMOVV, C_SAUTO, C_NONE, C_REG, 8, 4, REGSP, sys.MIPS64, 0},
+	{AMOVB, C_SAUTO, C_NONE, C_REG, 8, 4, REGSP, 0, 0},
+	{AMOVBU, C_SAUTO, C_NONE, C_REG, 8, 4, REGSP, 0, 0},
+	{AMOVWL, C_SAUTO, C_NONE, C_REG, 8, 4, REGSP, 0, 0},
+	{AMOVVL, C_SAUTO, C_NONE, C_REG, 8, 4, REGSP, sys.MIPS64, 0},
+	{AMOVW, C_SOREG, C_NONE, C_REG, 8, 4, REGZERO, 0, 0},
+	{AMOVWU, C_SOREG, C_NONE, C_REG, 8, 4, REGZERO, sys.MIPS64, 0},
+	{AMOVV, C_SOREG, C_NONE, C_REG, 8, 4, REGZERO, sys.MIPS64, 0},
+	{AMOVB, C_SOREG, C_NONE, C_REG, 8, 4, REGZERO, 0, 0},
+	{AMOVBU, C_SOREG, C_NONE, C_REG, 8, 4, REGZERO, 0, 0},
+	{AMOVWL, C_SOREG, C_NONE, C_REG, 8, 4, REGZERO, 0, 0},
+	{AMOVVL, C_SOREG, C_NONE, C_REG, 8, 4, REGZERO, sys.MIPS64, 0},
+	{ALL, C_SOREG, C_NONE, C_REG, 8, 4, REGZERO, 0, 0},
+	{ALLV, C_SOREG, C_NONE, C_REG, 8, 4, REGZERO, sys.MIPS64, 0},
+
+	{AMOVW, C_REG, C_NONE, C_LEXT, 35, 12, REGSB, sys.MIPS64, 0},
+	{AMOVWU, C_REG, C_NONE, C_LEXT, 35, 12, REGSB, sys.MIPS64, 0},
+	{AMOVV, C_REG, C_NONE, C_LEXT, 35, 12, REGSB, sys.MIPS64, 0},
+	{AMOVB, C_REG, C_NONE, C_LEXT, 35, 12, REGSB, sys.MIPS64, 0},
+	{AMOVBU, C_REG, C_NONE, C_LEXT, 35, 12, REGSB, sys.MIPS64, 0},
+	{AMOVW, C_REG, C_NONE, C_LAUTO, 35, 12, REGSP, 0, 0},
+	{AMOVWU, C_REG, C_NONE, C_LAUTO, 35, 12, REGSP, sys.MIPS64, 0},
+	{AMOVV, C_REG, C_NONE, C_LAUTO, 35, 12, REGSP, sys.MIPS64, 0},
+	{AMOVB, C_REG, C_NONE, C_LAUTO, 35, 12, REGSP, 0, 0},
+	{AMOVBU, C_REG, C_NONE, C_LAUTO, 35, 12, REGSP, 0, 0},
+	{AMOVW, C_REG, C_NONE, C_LOREG, 35, 12, REGZERO, 0, 0},
+	{AMOVWU, C_REG, C_NONE, C_LOREG, 35, 12, REGZERO, sys.MIPS64, 0},
+	{AMOVV, C_REG, C_NONE, C_LOREG, 35, 12, REGZERO, sys.MIPS64, 0},
+	{AMOVB, C_REG, C_NONE, C_LOREG, 35, 12, REGZERO, 0, 0},
+	{AMOVBU, C_REG, C_NONE, C_LOREG, 35, 12, REGZERO, 0, 0},
+	{ASC, C_REG, C_NONE, C_LOREG, 35, 12, REGZERO, 0, 0},
+	{AMOVW, C_REG, C_NONE, C_ADDR, 50, 8, 0, sys.MIPS, 0},
+	{AMOVW, C_REG, C_NONE, C_ADDR, 50, 12, 0, sys.MIPS64, 0},
+	{AMOVWU, C_REG, C_NONE, C_ADDR, 50, 12, 0, sys.MIPS64, 0},
+	{AMOVV, C_REG, C_NONE, C_ADDR, 50, 12, 0, sys.MIPS64, 0},
+	{AMOVB, C_REG, C_NONE, C_ADDR, 50, 8, 0, sys.MIPS, 0},
+	{AMOVB, C_REG, C_NONE, C_ADDR, 50, 12, 0, sys.MIPS64, 0},
+	{AMOVBU, C_REG, C_NONE, C_ADDR, 50, 8, 0, sys.MIPS, 0},
+	{AMOVBU, C_REG, C_NONE, C_ADDR, 50, 12, 0, sys.MIPS64, 0},
+	{AMOVW, C_REG, C_NONE, C_TLS, 53, 8, 0, 0, NOTUSETMP},
+	{AMOVWU, C_REG, C_NONE, C_TLS, 53, 8, 0, sys.MIPS64, NOTUSETMP},
+	{AMOVV, C_REG, C_NONE, C_TLS, 53, 8, 0, sys.MIPS64, NOTUSETMP},
+	{AMOVB, C_REG, C_NONE, C_TLS, 53, 8, 0, 0, NOTUSETMP},
+	{AMOVBU, C_REG, C_NONE, C_TLS, 53, 8, 0, 0, NOTUSETMP},
+
+	{AMOVW, C_LEXT, C_NONE, C_REG, 36, 12, REGSB, sys.MIPS64, 0},
+	{AMOVWU, C_LEXT, C_NONE, C_REG, 36, 12, REGSB, sys.MIPS64, 0},
+	{AMOVV, C_LEXT, C_NONE, C_REG, 36, 12, REGSB, sys.MIPS64, 0},
+	{AMOVB, C_LEXT, C_NONE, C_REG, 36, 12, REGSB, sys.MIPS64, 0},
+	{AMOVBU, C_LEXT, C_NONE, C_REG, 36, 12, REGSB, sys.MIPS64, 0},
+	{AMOVW, C_LAUTO, C_NONE, C_REG, 36, 12, REGSP, 0, 0},
+	{AMOVWU, C_LAUTO, C_NONE, C_REG, 36, 12, REGSP, sys.MIPS64, 0},
+	{AMOVV, C_LAUTO, C_NONE, C_REG, 36, 12, REGSP, sys.MIPS64, 0},
+	{AMOVB, C_LAUTO, C_NONE, C_REG, 36, 12, REGSP, 0, 0},
+	{AMOVBU, C_LAUTO, C_NONE, C_REG, 36, 12, REGSP, 0, 0},
+	{AMOVW, C_LOREG, C_NONE, C_REG, 36, 12, REGZERO, 0, 0},
+	{AMOVWU, C_LOREG, C_NONE, C_REG, 36, 12, REGZERO, sys.MIPS64, 0},
+	{AMOVV, C_LOREG, C_NONE, C_REG, 36, 12, REGZERO, sys.MIPS64, 0},
+	{AMOVB, C_LOREG, C_NONE, C_REG, 36, 12, REGZERO, 0, 0},
+	{AMOVBU, C_LOREG, C_NONE, C_REG, 36, 12, REGZERO, 0, 0},
+	{AMOVW, C_ADDR, C_NONE, C_REG, 51, 8, 0, sys.MIPS, 0},
+	{AMOVW, C_ADDR, C_NONE, C_REG, 51, 12, 0, sys.MIPS64, 0},
+	{AMOVWU, C_ADDR, C_NONE, C_REG, 51, 12, 0, sys.MIPS64, 0},
+	{AMOVV, C_ADDR, C_NONE, C_REG, 51, 12, 0, sys.MIPS64, 0},
+	{AMOVB, C_ADDR, C_NONE, C_REG, 51, 8, 0, sys.MIPS, 0},
+	{AMOVB, C_ADDR, C_NONE, C_REG, 51, 12, 0, sys.MIPS64, 0},
+	{AMOVBU, C_ADDR, C_NONE, C_REG, 51, 8, 0, sys.MIPS, 0},
+	{AMOVBU, C_ADDR, C_NONE, C_REG, 51, 12, 0, sys.MIPS64, 0},
+	{AMOVW, C_TLS, C_NONE, C_REG, 54, 8, 0, 0, NOTUSETMP},
+	{AMOVWU, C_TLS, C_NONE, C_REG, 54, 8, 0, sys.MIPS64, NOTUSETMP},
+	{AMOVV, C_TLS, C_NONE, C_REG, 54, 8, 0, sys.MIPS64, NOTUSETMP},
+	{AMOVB, C_TLS, C_NONE, C_REG, 54, 8, 0, 0, NOTUSETMP},
+	{AMOVBU, C_TLS, C_NONE, C_REG, 54, 8, 0, 0, NOTUSETMP},
+
+	{AMOVW, C_SECON, C_NONE, C_REG, 3, 4, REGSB, sys.MIPS64, 0},
+	{AMOVV, C_SECON, C_NONE, C_REG, 3, 4, REGSB, sys.MIPS64, 0},
+	{AMOVW, C_SACON, C_NONE, C_REG, 3, 4, REGSP, 0, 0},
+	{AMOVV, C_SACON, C_NONE, C_REG, 3, 4, REGSP, sys.MIPS64, 0},
+	{AMOVW, C_LECON, C_NONE, C_REG, 52, 8, REGSB, sys.MIPS, NOTUSETMP},
+	{AMOVW, C_LECON, C_NONE, C_REG, 52, 12, REGSB, sys.MIPS64, NOTUSETMP},
+	{AMOVV, C_LECON, C_NONE, C_REG, 52, 12, REGSB, sys.MIPS64, NOTUSETMP},
+
+	{AMOVW, C_LACON, C_NONE, C_REG, 26, 12, REGSP, 0, 0},
+	{AMOVV, C_LACON, C_NONE, C_REG, 26, 12, REGSP, sys.MIPS64, 0},
+	{AMOVW, C_ADDCON, C_NONE, C_REG, 3, 4, REGZERO, 0, 0},
+	{AMOVV, C_ADDCON, C_NONE, C_REG, 3, 4, REGZERO, sys.MIPS64, 0},
+	{AMOVW, C_ANDCON, C_NONE, C_REG, 3, 4, REGZERO, 0, 0},
+	{AMOVV, C_ANDCON, C_NONE, C_REG, 3, 4, REGZERO, sys.MIPS64, 0},
+	{AMOVW, C_STCON, C_NONE, C_REG, 55, 8, 0, 0, NOTUSETMP},
+	{AMOVV, C_STCON, C_NONE, C_REG, 55, 8, 0, sys.MIPS64, NOTUSETMP},
+
+	{AMOVW, C_UCON, C_NONE, C_REG, 24, 4, 0, 0, 0},
+	{AMOVV, C_UCON, C_NONE, C_REG, 24, 4, 0, sys.MIPS64, 0},
+	{AMOVW, C_LCON, C_NONE, C_REG, 19, 8, 0, 0, NOTUSETMP},
+	{AMOVV, C_LCON, C_NONE, C_REG, 19, 8, 0, sys.MIPS64, NOTUSETMP},
+
+	{AMOVW, C_HI, C_NONE, C_REG, 20, 4, 0, 0, 0},
+	{AMOVV, C_HI, C_NONE, C_REG, 20, 4, 0, sys.MIPS64, 0},
+	{AMOVW, C_LO, C_NONE, C_REG, 20, 4, 0, 0, 0},
+	{AMOVV, C_LO, C_NONE, C_REG, 20, 4, 0, sys.MIPS64, 0},
+	{AMOVW, C_REG, C_NONE, C_HI, 21, 4, 0, 0, 0},
+	{AMOVV, C_REG, C_NONE, C_HI, 21, 4, 0, sys.MIPS64, 0},
+	{AMOVW, C_REG, C_NONE, C_LO, 21, 4, 0, 0, 0},
+	{AMOVV, C_REG, C_NONE, C_LO, 21, 4, 0, sys.MIPS64, 0},
+
+	{AMUL, C_REG, C_REG, C_NONE, 22, 4, 0, 0, 0},
+	{AMUL, C_REG, C_REG, C_REG, 22, 4, 0, 0, 0},
+	{AMULV, C_REG, C_REG, C_NONE, 22, 4, 0, sys.MIPS64, 0},
+
+	{AADD, C_ADD0CON, C_REG, C_REG, 4, 4, 0, 0, 0},
+	{AADD, C_ADD0CON, C_NONE, C_REG, 4, 4, 0, 0, 0},
+	{AADD, C_ANDCON, C_REG, C_REG, 10, 8, 0, 0, 0},
+	{AADD, C_ANDCON, C_NONE, C_REG, 10, 8, 0, 0, 0},
+
+	{AADDV, C_ADD0CON, C_REG, C_REG, 4, 4, 0, sys.MIPS64, 0},
+	{AADDV, C_ADD0CON, C_NONE, C_REG, 4, 4, 0, sys.MIPS64, 0},
+	{AADDV, C_ANDCON, C_REG, C_REG, 10, 8, 0, sys.MIPS64, 0},
+	{AADDV, C_ANDCON, C_NONE, C_REG, 10, 8, 0, sys.MIPS64, 0},
+
+	{AAND, C_AND0CON, C_REG, C_REG, 4, 4, 0, 0, 0},
+	{AAND, C_AND0CON, C_NONE, C_REG, 4, 4, 0, 0, 0},
+	{AAND, C_ADDCON, C_REG, C_REG, 10, 8, 0, 0, 0},
+	{AAND, C_ADDCON, C_NONE, C_REG, 10, 8, 0, 0, 0},
+
+	{AADD, C_UCON, C_REG, C_REG, 25, 8, 0, 0, 0},
+	{AADD, C_UCON, C_NONE, C_REG, 25, 8, 0, 0, 0},
+	{AADDV, C_UCON, C_REG, C_REG, 25, 8, 0, sys.MIPS64, 0},
+	{AADDV, C_UCON, C_NONE, C_REG, 25, 8, 0, sys.MIPS64, 0},
+	{AAND, C_UCON, C_REG, C_REG, 25, 8, 0, 0, 0},
+	{AAND, C_UCON, C_NONE, C_REG, 25, 8, 0, 0, 0},
+
+	{AADD, C_LCON, C_NONE, C_REG, 23, 12, 0, 0, 0},
+	{AADDV, C_LCON, C_NONE, C_REG, 23, 12, 0, sys.MIPS64, 0},
+	{AAND, C_LCON, C_NONE, C_REG, 23, 12, 0, 0, 0},
+	{AADD, C_LCON, C_REG, C_REG, 23, 12, 0, 0, 0},
+	{AADDV, C_LCON, C_REG, C_REG, 23, 12, 0, sys.MIPS64, 0},
+	{AAND, C_LCON, C_REG, C_REG, 23, 12, 0, 0, 0},
+
+	{ASLL, C_SCON, C_REG, C_REG, 16, 4, 0, 0, 0},
+	{ASLL, C_SCON, C_NONE, C_REG, 16, 4, 0, 0, 0},
+
+	{ASLLV, C_SCON, C_REG, C_REG, 16, 4, 0, sys.MIPS64, 0},
+	{ASLLV, C_SCON, C_NONE, C_REG, 16, 4, 0, sys.MIPS64, 0},
+
+	{ASYSCALL, C_NONE, C_NONE, C_NONE, 5, 4, 0, 0, 0},
+
+	{ABEQ, C_REG, C_REG, C_SBRA, 6, 4, 0, 0, 0},
+	{ABEQ, C_REG, C_NONE, C_SBRA, 6, 4, 0, 0, 0},
+	{ABLEZ, C_REG, C_NONE, C_SBRA, 6, 4, 0, 0, 0},
+	{ABFPT, C_NONE, C_NONE, C_SBRA, 6, 8, 0, 0, NOTUSETMP},
+
+	{AJMP, C_NONE, C_NONE, C_LBRA, 11, 4, 0, 0, 0},
+	{AJAL, C_NONE, C_NONE, C_LBRA, 11, 4, 0, 0, 0},
+
+	{AJMP, C_NONE, C_NONE, C_ZOREG, 18, 4, REGZERO, 0, 0},
+	{AJAL, C_NONE, C_NONE, C_ZOREG, 18, 4, REGLINK, 0, 0},
+
+	{AMOVW, C_SEXT, C_NONE, C_FREG, 27, 4, REGSB, sys.MIPS64, 0},
+	{AMOVF, C_SEXT, C_NONE, C_FREG, 27, 4, REGSB, sys.MIPS64, 0},
+	{AMOVD, C_SEXT, C_NONE, C_FREG, 27, 4, REGSB, sys.MIPS64, 0},
+	{AMOVW, C_SAUTO, C_NONE, C_FREG, 27, 4, REGSP, sys.MIPS64, 0},
+	{AMOVF, C_SAUTO, C_NONE, C_FREG, 27, 4, REGSP, 0, 0},
+	{AMOVD, C_SAUTO, C_NONE, C_FREG, 27, 4, REGSP, 0, 0},
+	{AMOVW, C_SOREG, C_NONE, C_FREG, 27, 4, REGZERO, sys.MIPS64, 0},
+	{AMOVF, C_SOREG, C_NONE, C_FREG, 27, 4, REGZERO, 0, 0},
+	{AMOVD, C_SOREG, C_NONE, C_FREG, 27, 4, REGZERO, 0, 0},
+
+	{AMOVW, C_LEXT, C_NONE, C_FREG, 27, 12, REGSB, sys.MIPS64, 0},
+	{AMOVF, C_LEXT, C_NONE, C_FREG, 27, 12, REGSB, sys.MIPS64, 0},
+	{AMOVD, C_LEXT, C_NONE, C_FREG, 27, 12, REGSB, sys.MIPS64, 0},
+	{AMOVW, C_LAUTO, C_NONE, C_FREG, 27, 12, REGSP, sys.MIPS64, 0},
+	{AMOVF, C_LAUTO, C_NONE, C_FREG, 27, 12, REGSP, 0, 0},
+	{AMOVD, C_LAUTO, C_NONE, C_FREG, 27, 12, REGSP, 0, 0},
+	{AMOVW, C_LOREG, C_NONE, C_FREG, 27, 12, REGZERO, sys.MIPS64, 0},
+	{AMOVF, C_LOREG, C_NONE, C_FREG, 27, 12, REGZERO, 0, 0},
+	{AMOVD, C_LOREG, C_NONE, C_FREG, 27, 12, REGZERO, 0, 0},
+	{AMOVF, C_ADDR, C_NONE, C_FREG, 51, 8, 0, sys.MIPS, 0},
+	{AMOVF, C_ADDR, C_NONE, C_FREG, 51, 12, 0, sys.MIPS64, 0},
+	{AMOVD, C_ADDR, C_NONE, C_FREG, 51, 8, 0, sys.MIPS, 0},
+	{AMOVD, C_ADDR, C_NONE, C_FREG, 51, 12, 0, sys.MIPS64, 0},
+
+	{AMOVW, C_FREG, C_NONE, C_SEXT, 28, 4, REGSB, sys.MIPS64, 0},
+	{AMOVF, C_FREG, C_NONE, C_SEXT, 28, 4, REGSB, sys.MIPS64, 0},
+	{AMOVD, C_FREG, C_NONE, C_SEXT, 28, 4, REGSB, sys.MIPS64, 0},
+	{AMOVW, C_FREG, C_NONE, C_SAUTO, 28, 4, REGSP, sys.MIPS64, 0},
+	{AMOVF, C_FREG, C_NONE, C_SAUTO, 28, 4, REGSP, 0, 0},
+	{AMOVD, C_FREG, C_NONE, C_SAUTO, 28, 4, REGSP, 0, 0},
+	{AMOVW, C_FREG, C_NONE, C_SOREG, 28, 4, REGZERO, sys.MIPS64, 0},
+	{AMOVF, C_FREG, C_NONE, C_SOREG, 28, 4, REGZERO, 0, 0},
+	{AMOVD, C_FREG, C_NONE, C_SOREG, 28, 4, REGZERO, 0, 0},
+
+	{AMOVW, C_FREG, C_NONE, C_LEXT, 28, 12, REGSB, sys.MIPS64, 0},
+	{AMOVF, C_FREG, C_NONE, C_LEXT, 28, 12, REGSB, sys.MIPS64, 0},
+	{AMOVD, C_FREG, C_NONE, C_LEXT, 28, 12, REGSB, sys.MIPS64, 0},
+	{AMOVW, C_FREG, C_NONE, C_LAUTO, 28, 12, REGSP, sys.MIPS64, 0},
+	{AMOVF, C_FREG, C_NONE, C_LAUTO, 28, 12, REGSP, 0, 0},
+	{AMOVD, C_FREG, C_NONE, C_LAUTO, 28, 12, REGSP, 0, 0},
+	{AMOVW, C_FREG, C_NONE, C_LOREG, 28, 12, REGZERO, sys.MIPS64, 0},
+	{AMOVF, C_FREG, C_NONE, C_LOREG, 28, 12, REGZERO, 0, 0},
+	{AMOVD, C_FREG, C_NONE, C_LOREG, 28, 12, REGZERO, 0, 0},
+	{AMOVF, C_FREG, C_NONE, C_ADDR, 50, 8, 0, sys.MIPS, 0},
+	{AMOVF, C_FREG, C_NONE, C_ADDR, 50, 12, 0, sys.MIPS64, 0},
+	{AMOVD, C_FREG, C_NONE, C_ADDR, 50, 8, 0, sys.MIPS, 0},
+	{AMOVD, C_FREG, C_NONE, C_ADDR, 50, 12, 0, sys.MIPS64, 0},
+
+	{AMOVW, C_REG, C_NONE, C_FREG, 30, 4, 0, 0, 0},
+	{AMOVW, C_FREG, C_NONE, C_REG, 31, 4, 0, 0, 0},
+	{AMOVV, C_REG, C_NONE, C_FREG, 47, 4, 0, sys.MIPS64, 0},
+	{AMOVV, C_FREG, C_NONE, C_REG, 48, 4, 0, sys.MIPS64, 0},
+
+	{AMOVW, C_ADDCON, C_NONE, C_FREG, 34, 8, 0, sys.MIPS64, 0},
+	{AMOVW, C_ANDCON, C_NONE, C_FREG, 34, 8, 0, sys.MIPS64, 0},
+
+	{AMOVW, C_REG, C_NONE, C_MREG, 37, 4, 0, 0, 0},
+	{AMOVV, C_REG, C_NONE, C_MREG, 37, 4, 0, sys.MIPS64, 0},
+	{AMOVW, C_MREG, C_NONE, C_REG, 38, 4, 0, 0, 0},
+	{AMOVV, C_MREG, C_NONE, C_REG, 38, 4, 0, sys.MIPS64, 0},
+
+	{AWORD, C_LCON, C_NONE, C_NONE, 40, 4, 0, 0, 0},
+
+	{AMOVW, C_REG, C_NONE, C_FCREG, 41, 4, 0, 0, 0},
+	{AMOVV, C_REG, C_NONE, C_FCREG, 41, 4, 0, sys.MIPS64, 0},
+	{AMOVW, C_FCREG, C_NONE, C_REG, 42, 4, 0, 0, 0},
+	{AMOVV, C_FCREG, C_NONE, C_REG, 42, 4, 0, sys.MIPS64, 0},
+
+	{ATEQ, C_SCON, C_REG, C_REG, 15, 4, 0, 0, 0},
+	{ATEQ, C_SCON, C_NONE, C_REG, 15, 4, 0, 0, 0},
+	{ACMOVT, C_REG, C_NONE, C_REG, 17, 4, 0, 0, 0},
+
+	{AVMOVB, C_SCON, C_NONE, C_WREG, 56, 4, 0, sys.MIPS64, 0},
+	{AVMOVB, C_ADDCON, C_NONE, C_WREG, 56, 4, 0, sys.MIPS64, 0},
+	{AVMOVB, C_SOREG, C_NONE, C_WREG, 57, 4, 0, sys.MIPS64, 0},
+	{AVMOVB, C_WREG, C_NONE, C_SOREG, 58, 4, 0, sys.MIPS64, 0},
+
+	{ABREAK, C_REG, C_NONE, C_SEXT, 7, 4, REGSB, sys.MIPS64, 0}, /* really CACHE instruction */
+	{ABREAK, C_REG, C_NONE, C_SAUTO, 7, 4, REGSP, sys.MIPS64, 0},
+	{ABREAK, C_REG, C_NONE, C_SOREG, 7, 4, REGZERO, sys.MIPS64, 0},
+	{ABREAK, C_NONE, C_NONE, C_NONE, 5, 4, 0, 0, 0},
+
+	{obj.AUNDEF, C_NONE, C_NONE, C_NONE, 49, 4, 0, 0, 0},
+	{obj.APCDATA, C_LCON, C_NONE, C_LCON, 0, 0, 0, 0, 0},
+	{obj.AFUNCDATA, C_SCON, C_NONE, C_ADDR, 0, 0, 0, 0, 0},
+	{obj.ANOP, C_NONE, C_NONE, C_NONE, 0, 0, 0, 0, 0},
+	{obj.ANOP, C_LCON, C_NONE, C_NONE, 0, 0, 0, 0, 0}, // nop variants, see #40689
+	{obj.ANOP, C_REG, C_NONE, C_NONE, 0, 0, 0, 0, 0},
+	{obj.ANOP, C_FREG, C_NONE, C_NONE, 0, 0, 0, 0, 0},
+	{obj.ADUFFZERO, C_NONE, C_NONE, C_LBRA, 11, 4, 0, 0, 0}, // same as AJMP
+	{obj.ADUFFCOPY, C_NONE, C_NONE, C_LBRA, 11, 4, 0, 0, 0}, // same as AJMP
+
+	{obj.AXXX, C_NONE, C_NONE, C_NONE, 0, 4, 0, 0, 0},
+}
+
+var oprange [ALAST & obj.AMask][]Optab
+
+var xcmp [C_NCLASS][C_NCLASS]bool
+
+func span0(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
+	if ctxt.Retpoline {
+		ctxt.Diag("-spectre=ret not supported on mips")
+		ctxt.Retpoline = false // don't keep printing
+	}
+
+	p := cursym.Func.Text
+	if p == nil || p.Link == nil { // handle external functions and ELF section symbols
+		return
+	}
+
+	c := ctxt0{ctxt: ctxt, newprog: newprog, cursym: cursym, autosize: int32(p.To.Offset + ctxt.FixedFrameSize())}
+
+	if oprange[AOR&obj.AMask] == nil {
+		c.ctxt.Diag("mips ops not initialized, call mips.buildop first")
+	}
+
+	pc := int64(0)
+	p.Pc = pc
+
+	var m int
+	var o *Optab
+	for p = p.Link; p != nil; p = p.Link {
+		p.Pc = pc
+		o = c.oplook(p)
+		m = int(o.size)
+		if m == 0 {
+			if p.As != obj.ANOP && p.As != obj.AFUNCDATA && p.As != obj.APCDATA {
+				c.ctxt.Diag("zero-width instruction\n%v", p)
+			}
+			continue
+		}
+
+		pc += int64(m)
+	}
+
+	c.cursym.Size = pc
+
+	/*
+	 * if any procedure is large enough to
+	 * generate a large SBRA branch, then
+	 * generate extra passes putting branches
+	 * around jmps to fix. this is rare.
+	 */
+	bflag := 1
+
+	var otxt int64
+	var q *obj.Prog
+	for bflag != 0 {
+		bflag = 0
+		pc = 0
+		for p = c.cursym.Func.Text.Link; p != nil; p = p.Link {
+			p.Pc = pc
+			o = c.oplook(p)
+
+			// very large conditional branches
+			if o.type_ == 6 && p.To.Target() != nil {
+				otxt = p.To.Target().Pc - pc
+				if otxt < -(1<<17)+10 || otxt >= (1<<17)-10 {
+					q = c.newprog()
+					q.Link = p.Link
+					p.Link = q
+					q.As = AJMP
+					q.Pos = p.Pos
+					q.To.Type = obj.TYPE_BRANCH
+					q.To.SetTarget(p.To.Target())
+					p.To.SetTarget(q)
+					q = c.newprog()
+					q.Link = p.Link
+					p.Link = q
+					q.As = AJMP
+					q.Pos = p.Pos
+					q.To.Type = obj.TYPE_BRANCH
+					q.To.SetTarget(q.Link.Link)
+
+					c.addnop(p.Link)
+					c.addnop(p)
+					bflag = 1
+				}
+			}
+
+			m = int(o.size)
+			if m == 0 {
+				if p.As != obj.ANOP && p.As != obj.AFUNCDATA && p.As != obj.APCDATA {
+					c.ctxt.Diag("zero-width instruction\n%v", p)
+				}
+				continue
+			}
+
+			pc += int64(m)
+		}
+
+		c.cursym.Size = pc
+	}
+	if c.ctxt.Arch.Family == sys.MIPS64 {
+		pc += -pc & (mips64FuncAlign - 1)
+	}
+	c.cursym.Size = pc
+
+	/*
+	 * lay out the code, emitting code and data relocations.
+	 */
+
+	c.cursym.Grow(c.cursym.Size)
+
+	bp := c.cursym.P
+	var i int32
+	var out [4]uint32
+	for p := c.cursym.Func.Text.Link; p != nil; p = p.Link {
+		c.pc = p.Pc
+		o = c.oplook(p)
+		if int(o.size) > 4*len(out) {
+			log.Fatalf("out array in span0 is too small, need at least %d for %v", o.size/4, p)
+		}
+		c.asmout(p, o, out[:])
+		for i = 0; i < int32(o.size/4); i++ {
+			c.ctxt.Arch.ByteOrder.PutUint32(bp, out[i])
+			bp = bp[4:]
+		}
+	}
+
+	// Mark nonpreemptible instruction sequences.
+	// We use REGTMP as a scratch register during call injection,
+	// so instruction sequences that use REGTMP are unsafe to
+	// preempt asynchronously.
+	obj.MarkUnsafePoints(c.ctxt, c.cursym.Func.Text, c.newprog, c.isUnsafePoint, c.isRestartable)
+}
+
+// isUnsafePoint returns whether p is an unsafe point.
+func (c *ctxt0) isUnsafePoint(p *obj.Prog) bool {
+	// If p explicitly uses REGTMP, it's unsafe to preempt, because the
+	// preemption sequence clobbers REGTMP.
+	return p.From.Reg == REGTMP || p.To.Reg == REGTMP || p.Reg == REGTMP
+}
+
+// isRestartable returns whether p is a multi-instruction sequence that,
+// if preempted, can be restarted.
+func (c *ctxt0) isRestartable(p *obj.Prog) bool {
+	if c.isUnsafePoint(p) {
+		return false
+	}
+	// If p is a multi-instruction sequence with uses REGTMP inserted by
+	// the assembler in order to materialize a large constant/offset, we
+	// can restart p (at the start of the instruction sequence), recompute
+	// the content of REGTMP, upon async preemption. Currently, all cases
+	// of assembler-inserted REGTMP fall into this category.
+	// If p doesn't use REGTMP, it can be simply preempted, so we don't
+	// mark it.
+	o := c.oplook(p)
+	return o.size > 4 && o.flag&NOTUSETMP == 0
+}
+
+func isint32(v int64) bool {
+	return int64(int32(v)) == v
+}
+
+func isuint32(v uint64) bool {
+	return uint64(uint32(v)) == v
+}
+
+func (c *ctxt0) aclass(a *obj.Addr) int {
+	switch a.Type {
+	case obj.TYPE_NONE:
+		return C_NONE
+
+	case obj.TYPE_REG:
+		if REG_R0 <= a.Reg && a.Reg <= REG_R31 {
+			return C_REG
+		}
+		if REG_F0 <= a.Reg && a.Reg <= REG_F31 {
+			return C_FREG
+		}
+		if REG_M0 <= a.Reg && a.Reg <= REG_M31 {
+			return C_MREG
+		}
+		if REG_FCR0 <= a.Reg && a.Reg <= REG_FCR31 {
+			return C_FCREG
+		}
+		if REG_W0 <= a.Reg && a.Reg <= REG_W31 {
+			return C_WREG
+		}
+		if a.Reg == REG_LO {
+			return C_LO
+		}
+		if a.Reg == REG_HI {
+			return C_HI
+		}
+		return C_GOK
+
+	case obj.TYPE_MEM:
+		switch a.Name {
+		case obj.NAME_EXTERN,
+			obj.NAME_STATIC:
+			if a.Sym == nil {
+				break
+			}
+			c.instoffset = a.Offset
+			if a.Sym != nil { // use relocation
+				if a.Sym.Type == objabi.STLSBSS {
+					return C_TLS
+				}
+				return C_ADDR
+			}
+			return C_LEXT
+
+		case obj.NAME_AUTO:
+			if a.Reg == REGSP {
+				// unset base register for better printing, since
+				// a.Offset is still relative to pseudo-SP.
+				a.Reg = obj.REG_NONE
+			}
+			c.instoffset = int64(c.autosize) + a.Offset
+			if c.instoffset >= -BIG && c.instoffset < BIG {
+				return C_SAUTO
+			}
+			return C_LAUTO
+
+		case obj.NAME_PARAM:
+			if a.Reg == REGSP {
+				// unset base register for better printing, since
+				// a.Offset is still relative to pseudo-FP.
+				a.Reg = obj.REG_NONE
+			}
+			c.instoffset = int64(c.autosize) + a.Offset + c.ctxt.FixedFrameSize()
+			if c.instoffset >= -BIG && c.instoffset < BIG {
+				return C_SAUTO
+			}
+			return C_LAUTO
+
+		case obj.NAME_NONE:
+			c.instoffset = a.Offset
+			if c.instoffset == 0 {
+				return C_ZOREG
+			}
+			if c.instoffset >= -BIG && c.instoffset < BIG {
+				return C_SOREG
+			}
+			return C_LOREG
+		}
+
+		return C_GOK
+
+	case obj.TYPE_TEXTSIZE:
+		return C_TEXTSIZE
+
+	case obj.TYPE_CONST,
+		obj.TYPE_ADDR:
+		switch a.Name {
+		case obj.NAME_NONE:
+			c.instoffset = a.Offset
+			if a.Reg != 0 {
+				if -BIG <= c.instoffset && c.instoffset <= BIG {
+					return C_SACON
+				}
+				if isint32(c.instoffset) {
+					return C_LACON
+				}
+				return C_DACON
+			}
+
+		case obj.NAME_EXTERN,
+			obj.NAME_STATIC:
+			s := a.Sym
+			if s == nil {
+				return C_GOK
+			}
+
+			c.instoffset = a.Offset
+			if s.Type == objabi.STLSBSS {
+				return C_STCON // address of TLS variable
+			}
+			return C_LECON
+
+		case obj.NAME_AUTO:
+			if a.Reg == REGSP {
+				// unset base register for better printing, since
+				// a.Offset is still relative to pseudo-SP.
+				a.Reg = obj.REG_NONE
+			}
+			c.instoffset = int64(c.autosize) + a.Offset
+			if c.instoffset >= -BIG && c.instoffset < BIG {
+				return C_SACON
+			}
+			return C_LACON
+
+		case obj.NAME_PARAM:
+			if a.Reg == REGSP {
+				// unset base register for better printing, since
+				// a.Offset is still relative to pseudo-FP.
+				a.Reg = obj.REG_NONE
+			}
+			c.instoffset = int64(c.autosize) + a.Offset + c.ctxt.FixedFrameSize()
+			if c.instoffset >= -BIG && c.instoffset < BIG {
+				return C_SACON
+			}
+			return C_LACON
+
+		default:
+			return C_GOK
+		}
+
+		if c.instoffset >= 0 {
+			if c.instoffset == 0 {
+				return C_ZCON
+			}
+			if c.instoffset <= 0x7fff {
+				return C_SCON
+			}
+			if c.instoffset <= 0xffff {
+				return C_ANDCON
+			}
+			if c.instoffset&0xffff == 0 && isuint32(uint64(c.instoffset)) { /* && (instoffset & (1<<31)) == 0) */
+				return C_UCON
+			}
+			if isint32(c.instoffset) || isuint32(uint64(c.instoffset)) {
+				return C_LCON
+			}
+			return C_LCON // C_DCON
+		}
+
+		if c.instoffset >= -0x8000 {
+			return C_ADDCON
+		}
+		if c.instoffset&0xffff == 0 && isint32(c.instoffset) {
+			return C_UCON
+		}
+		if isint32(c.instoffset) {
+			return C_LCON
+		}
+		return C_LCON // C_DCON
+
+	case obj.TYPE_BRANCH:
+		return C_SBRA
+	}
+
+	return C_GOK
+}
+
+func prasm(p *obj.Prog) {
+	fmt.Printf("%v\n", p)
+}
+
+func (c *ctxt0) oplook(p *obj.Prog) *Optab {
+	if oprange[AOR&obj.AMask] == nil {
+		c.ctxt.Diag("mips ops not initialized, call mips.buildop first")
+	}
+
+	a1 := int(p.Optab)
+	if a1 != 0 {
+		return &optab[a1-1]
+	}
+	a1 = int(p.From.Class)
+	if a1 == 0 {
+		a1 = c.aclass(&p.From) + 1
+		p.From.Class = int8(a1)
+	}
+
+	a1--
+	a3 := int(p.To.Class)
+	if a3 == 0 {
+		a3 = c.aclass(&p.To) + 1
+		p.To.Class = int8(a3)
+	}
+
+	a3--
+	a2 := C_NONE
+	if p.Reg != 0 {
+		a2 = C_REG
+	}
+
+	ops := oprange[p.As&obj.AMask]
+	c1 := &xcmp[a1]
+	c3 := &xcmp[a3]
+	for i := range ops {
+		op := &ops[i]
+		if int(op.a2) == a2 && c1[op.a1] && c3[op.a3] && (op.family == 0 || c.ctxt.Arch.Family == op.family) {
+			p.Optab = uint16(cap(optab) - cap(ops) + i + 1)
+			return op
+		}
+	}
+
+	c.ctxt.Diag("illegal combination %v %v %v %v", p.As, DRconv(a1), DRconv(a2), DRconv(a3))
+	prasm(p)
+	// Turn illegal instruction into an UNDEF, avoid crashing in asmout.
+	return &Optab{obj.AUNDEF, C_NONE, C_NONE, C_NONE, 49, 4, 0, 0, 0}
+}
+
+func cmp(a int, b int) bool {
+	if a == b {
+		return true
+	}
+	switch a {
+	case C_LCON:
+		if b == C_ZCON || b == C_SCON || b == C_UCON || b == C_ADDCON || b == C_ANDCON {
+			return true
+		}
+
+	case C_ADD0CON:
+		if b == C_ADDCON {
+			return true
+		}
+		fallthrough
+
+	case C_ADDCON:
+		if b == C_ZCON || b == C_SCON {
+			return true
+		}
+
+	case C_AND0CON:
+		if b == C_ANDCON {
+			return true
+		}
+		fallthrough
+
+	case C_ANDCON:
+		if b == C_ZCON || b == C_SCON {
+			return true
+		}
+
+	case C_UCON:
+		if b == C_ZCON {
+			return true
+		}
+
+	case C_SCON:
+		if b == C_ZCON {
+			return true
+		}
+
+	case C_LACON:
+		if b == C_SACON {
+			return true
+		}
+
+	case C_LBRA:
+		if b == C_SBRA {
+			return true
+		}
+
+	case C_LEXT:
+		if b == C_SEXT {
+			return true
+		}
+
+	case C_LAUTO:
+		if b == C_SAUTO {
+			return true
+		}
+
+	case C_REG:
+		if b == C_ZCON {
+			return r0iszero != 0 /*TypeKind(100016)*/
+		}
+
+	case C_LOREG:
+		if b == C_ZOREG || b == C_SOREG {
+			return true
+		}
+
+	case C_SOREG:
+		if b == C_ZOREG {
+			return true
+		}
+	}
+
+	return false
+}
+
+type ocmp []Optab
+
+func (x ocmp) Len() int {
+	return len(x)
+}
+
+func (x ocmp) Swap(i, j int) {
+	x[i], x[j] = x[j], x[i]
+}
+
+func (x ocmp) Less(i, j int) bool {
+	p1 := &x[i]
+	p2 := &x[j]
+	n := int(p1.as) - int(p2.as)
+	if n != 0 {
+		return n < 0
+	}
+	n = int(p1.a1) - int(p2.a1)
+	if n != 0 {
+		return n < 0
+	}
+	n = int(p1.a2) - int(p2.a2)
+	if n != 0 {
+		return n < 0
+	}
+	n = int(p1.a3) - int(p2.a3)
+	if n != 0 {
+		return n < 0
+	}
+	return false
+}
+
+func opset(a, b0 obj.As) {
+	oprange[a&obj.AMask] = oprange[b0]
+}
+
+func buildop(ctxt *obj.Link) {
+	if oprange[AOR&obj.AMask] != nil {
+		// Already initialized; stop now.
+		// This happens in the cmd/asm tests,
+		// each of which re-initializes the arch.
+		return
+	}
+
+	var n int
+
+	for i := 0; i < C_NCLASS; i++ {
+		for n = 0; n < C_NCLASS; n++ {
+			if cmp(n, i) {
+				xcmp[i][n] = true
+			}
+		}
+	}
+	for n = 0; optab[n].as != obj.AXXX; n++ {
+	}
+	sort.Sort(ocmp(optab[:n]))
+	for i := 0; i < n; i++ {
+		r := optab[i].as
+		r0 := r & obj.AMask
+		start := i
+		for optab[i].as == r {
+			i++
+		}
+		oprange[r0] = optab[start:i]
+		i--
+
+		switch r {
+		default:
+			ctxt.Diag("unknown op in build: %v", r)
+			ctxt.DiagFlush()
+			log.Fatalf("bad code")
+
+		case AABSF:
+			opset(AMOVFD, r0)
+			opset(AMOVDF, r0)
+			opset(AMOVWF, r0)
+			opset(AMOVFW, r0)
+			opset(AMOVWD, r0)
+			opset(AMOVDW, r0)
+			opset(ANEGF, r0)
+			opset(ANEGD, r0)
+			opset(AABSD, r0)
+			opset(ATRUNCDW, r0)
+			opset(ATRUNCFW, r0)
+			opset(ASQRTF, r0)
+			opset(ASQRTD, r0)
+
+		case AMOVVF:
+			opset(AMOVVD, r0)
+			opset(AMOVFV, r0)
+			opset(AMOVDV, r0)
+			opset(ATRUNCDV, r0)
+			opset(ATRUNCFV, r0)
+
+		case AADD:
+			opset(ASGT, r0)
+			opset(ASGTU, r0)
+			opset(AADDU, r0)
+
+		case AADDV:
+			opset(AADDVU, r0)
+
+		case AADDF:
+			opset(ADIVF, r0)
+			opset(ADIVD, r0)
+			opset(AMULF, r0)
+			opset(AMULD, r0)
+			opset(ASUBF, r0)
+			opset(ASUBD, r0)
+			opset(AADDD, r0)
+
+		case AAND:
+			opset(AOR, r0)
+			opset(AXOR, r0)
+
+		case ABEQ:
+			opset(ABNE, r0)
+
+		case ABLEZ:
+			opset(ABGEZ, r0)
+			opset(ABGEZAL, r0)
+			opset(ABLTZ, r0)
+			opset(ABLTZAL, r0)
+			opset(ABGTZ, r0)
+
+		case AMOVB:
+			opset(AMOVH, r0)
+
+		case AMOVBU:
+			opset(AMOVHU, r0)
+
+		case AMUL:
+			opset(AREM, r0)
+			opset(AREMU, r0)
+			opset(ADIVU, r0)
+			opset(AMULU, r0)
+			opset(ADIV, r0)
+			opset(AMADD, r0)
+			opset(AMSUB, r0)
+
+		case AMULV:
+			opset(ADIVV, r0)
+			opset(ADIVVU, r0)
+			opset(AMULVU, r0)
+			opset(AREMV, r0)
+			opset(AREMVU, r0)
+
+		case ASLL:
+			opset(ASRL, r0)
+			opset(ASRA, r0)
+
+		case ASLLV:
+			opset(ASRAV, r0)
+			opset(ASRLV, r0)
+
+		case ASUB:
+			opset(ASUBU, r0)
+			opset(ANOR, r0)
+
+		case ASUBV:
+			opset(ASUBVU, r0)
+
+		case ASYSCALL:
+			opset(ASYNC, r0)
+			opset(ANOOP, r0)
+			opset(ATLBP, r0)
+			opset(ATLBR, r0)
+			opset(ATLBWI, r0)
+			opset(ATLBWR, r0)
+
+		case ACMPEQF:
+			opset(ACMPGTF, r0)
+			opset(ACMPGTD, r0)
+			opset(ACMPGEF, r0)
+			opset(ACMPGED, r0)
+			opset(ACMPEQD, r0)
+
+		case ABFPT:
+			opset(ABFPF, r0)
+
+		case AMOVWL:
+			opset(AMOVWR, r0)
+
+		case AMOVVL:
+			opset(AMOVVR, r0)
+
+		case AVMOVB:
+			opset(AVMOVH, r0)
+			opset(AVMOVW, r0)
+			opset(AVMOVD, r0)
+
+		case AMOVW,
+			AMOVD,
+			AMOVF,
+			AMOVV,
+			ABREAK,
+			ARFE,
+			AJAL,
+			AJMP,
+			AMOVWU,
+			ALL,
+			ALLV,
+			ASC,
+			ASCV,
+			ANEGW,
+			ANEGV,
+			AWORD,
+			obj.ANOP,
+			obj.ATEXT,
+			obj.AUNDEF,
+			obj.AFUNCDATA,
+			obj.APCDATA,
+			obj.ADUFFZERO,
+			obj.ADUFFCOPY:
+			break
+
+		case ACMOVN:
+			opset(ACMOVZ, r0)
+
+		case ACMOVT:
+			opset(ACMOVF, r0)
+
+		case ACLO:
+			opset(ACLZ, r0)
+
+		case ATEQ:
+			opset(ATNE, r0)
+		}
+	}
+}
+
+func OP(x uint32, y uint32) uint32 {
+	return x<<3 | y<<0
+}
+
+func SP(x uint32, y uint32) uint32 {
+	return x<<29 | y<<26
+}
+
+func BCOND(x uint32, y uint32) uint32 {
+	return x<<19 | y<<16
+}
+
+func MMU(x uint32, y uint32) uint32 {
+	return SP(2, 0) | 16<<21 | x<<3 | y<<0
+}
+
+func FPF(x uint32, y uint32) uint32 {
+	return SP(2, 1) | 16<<21 | x<<3 | y<<0
+}
+
+func FPD(x uint32, y uint32) uint32 {
+	return SP(2, 1) | 17<<21 | x<<3 | y<<0
+}
+
+func FPW(x uint32, y uint32) uint32 {
+	return SP(2, 1) | 20<<21 | x<<3 | y<<0
+}
+
+func FPV(x uint32, y uint32) uint32 {
+	return SP(2, 1) | 21<<21 | x<<3 | y<<0
+}
+
+func OP_RRR(op uint32, r1 uint32, r2 uint32, r3 uint32) uint32 {
+	return op | (r1&31)<<16 | (r2&31)<<21 | (r3&31)<<11
+}
+
+func OP_IRR(op uint32, i uint32, r2 uint32, r3 uint32) uint32 {
+	return op | i&0xFFFF | (r2&31)<<21 | (r3&31)<<16
+}
+
+func OP_SRR(op uint32, s uint32, r2 uint32, r3 uint32) uint32 {
+	return op | (s&31)<<6 | (r2&31)<<16 | (r3&31)<<11
+}
+
+func OP_FRRR(op uint32, r1 uint32, r2 uint32, r3 uint32) uint32 {
+	return op | (r1&31)<<16 | (r2&31)<<11 | (r3&31)<<6
+}
+
+func OP_JMP(op uint32, i uint32) uint32 {
+	return op | i&0x3FFFFFF
+}
+
+func OP_VI10(op uint32, df uint32, s10 int32, wd uint32, minor uint32) uint32 {
+	return 0x1e<<26 | (op&7)<<23 | (df&3)<<21 | uint32(s10&0x3FF)<<11 | (wd&31)<<6 | minor&0x3F
+}
+
+func OP_VMI10(s10 int32, rs uint32, wd uint32, minor uint32, df uint32) uint32 {
+	return 0x1e<<26 | uint32(s10&0x3FF)<<16 | (rs&31)<<11 | (wd&31)<<6 | (minor&15)<<2 | df&3
+}
+
+func (c *ctxt0) asmout(p *obj.Prog, o *Optab, out []uint32) {
+	o1 := uint32(0)
+	o2 := uint32(0)
+	o3 := uint32(0)
+	o4 := uint32(0)
+
+	add := AADDU
+
+	if c.ctxt.Arch.Family == sys.MIPS64 {
+		add = AADDVU
+	}
+	switch o.type_ {
+	default:
+		c.ctxt.Diag("unknown type %d %v", o.type_)
+		prasm(p)
+
+	case 0: /* pseudo ops */
+		break
+
+	case 1: /* mov r1,r2 ==> OR r1,r0,r2 */
+		a := AOR
+		if p.As == AMOVW && c.ctxt.Arch.Family == sys.MIPS64 {
+			// on MIPS64, most of the 32-bit instructions have unpredictable behavior,
+			// but SLL is special that the result is always sign-extended to 64-bit.
+			a = ASLL
+		}
+		o1 = OP_RRR(c.oprrr(a), uint32(p.From.Reg), uint32(REGZERO), uint32(p.To.Reg))
+
+	case 2: /* add/sub r1,[r2],r3 */
+		r := int(p.Reg)
+		if p.As == ANEGW || p.As == ANEGV {
+			r = REGZERO
+		}
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		o1 = OP_RRR(c.oprrr(p.As), uint32(p.From.Reg), uint32(r), uint32(p.To.Reg))
+
+	case 3: /* mov $soreg, r ==> or/add $i,o,r */
+		v := c.regoff(&p.From)
+
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		a := add
+		if o.a1 == C_ANDCON {
+			a = AOR
+		}
+
+		o1 = OP_IRR(c.opirr(a), uint32(v), uint32(r), uint32(p.To.Reg))
+
+	case 4: /* add $scon,[r1],r2 */
+		v := c.regoff(&p.From)
+
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+
+		o1 = OP_IRR(c.opirr(p.As), uint32(v), uint32(r), uint32(p.To.Reg))
+
+	case 5: /* syscall */
+		o1 = c.oprrr(p.As)
+
+	case 6: /* beq r1,[r2],sbra */
+		v := int32(0)
+		if p.To.Target() == nil {
+			v = int32(-4) >> 2
+		} else {
+			v = int32(p.To.Target().Pc-p.Pc-4) >> 2
+		}
+		if (v<<16)>>16 != v {
+			c.ctxt.Diag("short branch too far\n%v", p)
+		}
+		o1 = OP_IRR(c.opirr(p.As), uint32(v), uint32(p.From.Reg), uint32(p.Reg))
+		// for ABFPT and ABFPF only: always fill delay slot with 0
+		// see comments in func preprocess for details.
+		o2 = 0
+
+	case 7: /* mov r, soreg ==> sw o(r) */
+		r := int(p.To.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		v := c.regoff(&p.To)
+		o1 = OP_IRR(c.opirr(p.As), uint32(v), uint32(r), uint32(p.From.Reg))
+
+	case 8: /* mov soreg, r ==> lw o(r) */
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		v := c.regoff(&p.From)
+		o1 = OP_IRR(c.opirr(-p.As), uint32(v), uint32(r), uint32(p.To.Reg))
+
+	case 9: /* sll r1,[r2],r3 */
+		r := int(p.Reg)
+
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		o1 = OP_RRR(c.oprrr(p.As), uint32(r), uint32(p.From.Reg), uint32(p.To.Reg))
+
+	case 10: /* add $con,[r1],r2 ==> mov $con, t; add t,[r1],r2 */
+		v := c.regoff(&p.From)
+		a := AOR
+		if v < 0 {
+			a = AADDU
+		}
+		o1 = OP_IRR(c.opirr(a), uint32(v), uint32(0), uint32(REGTMP))
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		o2 = OP_RRR(c.oprrr(p.As), uint32(REGTMP), uint32(r), uint32(p.To.Reg))
+
+	case 11: /* jmp lbra */
+		v := int32(0)
+		if c.aclass(&p.To) == C_SBRA && p.To.Sym == nil && p.As == AJMP {
+			// use PC-relative branch for short branches
+			// BEQ	R0, R0, sbra
+			if p.To.Target() == nil {
+				v = int32(-4) >> 2
+			} else {
+				v = int32(p.To.Target().Pc-p.Pc-4) >> 2
+			}
+			if (v<<16)>>16 == v {
+				o1 = OP_IRR(c.opirr(ABEQ), uint32(v), uint32(REGZERO), uint32(REGZERO))
+				break
+			}
+		}
+		if p.To.Target() == nil {
+			v = int32(p.Pc) >> 2
+		} else {
+			v = int32(p.To.Target().Pc) >> 2
+		}
+		o1 = OP_JMP(c.opirr(p.As), uint32(v))
+		if p.To.Sym == nil {
+			p.To.Sym = c.cursym.Func.Text.From.Sym
+			p.To.Offset = p.To.Target().Pc
+		}
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 4
+		rel.Sym = p.To.Sym
+		rel.Add = p.To.Offset
+		if p.As == AJAL {
+			rel.Type = objabi.R_CALLMIPS
+		} else {
+			rel.Type = objabi.R_JMPMIPS
+		}
+
+	case 12: /* movbs r,r */
+		// NOTE: this case does not use REGTMP. If it ever does,
+		// remove the NOTUSETMP flag in optab.
+		v := 16
+		if p.As == AMOVB {
+			v = 24
+		}
+		o1 = OP_SRR(c.opirr(ASLL), uint32(v), uint32(p.From.Reg), uint32(p.To.Reg))
+		o2 = OP_SRR(c.opirr(ASRA), uint32(v), uint32(p.To.Reg), uint32(p.To.Reg))
+
+	case 13: /* movbu r,r */
+		if p.As == AMOVBU {
+			o1 = OP_IRR(c.opirr(AAND), uint32(0xff), uint32(p.From.Reg), uint32(p.To.Reg))
+		} else {
+			o1 = OP_IRR(c.opirr(AAND), uint32(0xffff), uint32(p.From.Reg), uint32(p.To.Reg))
+		}
+
+	case 14: /* movwu r,r */
+		// NOTE: this case does not use REGTMP. If it ever does,
+		// remove the NOTUSETMP flag in optab.
+		o1 = OP_SRR(c.opirr(-ASLLV), uint32(0), uint32(p.From.Reg), uint32(p.To.Reg))
+		o2 = OP_SRR(c.opirr(-ASRLV), uint32(0), uint32(p.To.Reg), uint32(p.To.Reg))
+
+	case 15: /* teq $c r,r */
+		v := c.regoff(&p.From)
+		r := int(p.Reg)
+		if r == 0 {
+			r = REGZERO
+		}
+		/* only use 10 bits of trap code */
+		o1 = OP_IRR(c.opirr(p.As), (uint32(v)&0x3FF)<<6, uint32(r), uint32(p.To.Reg))
+
+	case 16: /* sll $c,[r1],r2 */
+		v := c.regoff(&p.From)
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+
+		/* OP_SRR will use only the low 5 bits of the shift value */
+		if v >= 32 && vshift(p.As) {
+			o1 = OP_SRR(c.opirr(-p.As), uint32(v-32), uint32(r), uint32(p.To.Reg))
+		} else {
+			o1 = OP_SRR(c.opirr(p.As), uint32(v), uint32(r), uint32(p.To.Reg))
+		}
+
+	case 17:
+		o1 = OP_RRR(c.oprrr(p.As), uint32(REGZERO), uint32(p.From.Reg), uint32(p.To.Reg))
+
+	case 18: /* jmp [r1],0(r2) */
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o1 = OP_RRR(c.oprrr(p.As), uint32(0), uint32(p.To.Reg), uint32(r))
+		if p.As == obj.ACALL {
+			rel := obj.Addrel(c.cursym)
+			rel.Off = int32(c.pc)
+			rel.Siz = 0
+			rel.Type = objabi.R_CALLIND
+		}
+
+	case 19: /* mov $lcon,r ==> lu+or */
+		// NOTE: this case does not use REGTMP. If it ever does,
+		// remove the NOTUSETMP flag in optab.
+		v := c.regoff(&p.From)
+		o1 = OP_IRR(c.opirr(ALUI), uint32(v>>16), uint32(REGZERO), uint32(p.To.Reg))
+		o2 = OP_IRR(c.opirr(AOR), uint32(v), uint32(p.To.Reg), uint32(p.To.Reg))
+
+	case 20: /* mov lo/hi,r */
+		a := OP(2, 0) /* mfhi */
+		if p.From.Reg == REG_LO {
+			a = OP(2, 2) /* mflo */
+		}
+		o1 = OP_RRR(a, uint32(REGZERO), uint32(REGZERO), uint32(p.To.Reg))
+
+	case 21: /* mov r,lo/hi */
+		a := OP(2, 1) /* mthi */
+		if p.To.Reg == REG_LO {
+			a = OP(2, 3) /* mtlo */
+		}
+		o1 = OP_RRR(a, uint32(REGZERO), uint32(p.From.Reg), uint32(REGZERO))
+
+	case 22: /* mul r1,r2 [r3]*/
+		if p.To.Reg != 0 {
+			r := int(p.Reg)
+			if r == 0 {
+				r = int(p.To.Reg)
+			}
+			a := SP(3, 4) | 2 /* mul */
+			o1 = OP_RRR(a, uint32(p.From.Reg), uint32(r), uint32(p.To.Reg))
+		} else {
+			o1 = OP_RRR(c.oprrr(p.As), uint32(p.From.Reg), uint32(p.Reg), uint32(REGZERO))
+		}
+
+	case 23: /* add $lcon,r1,r2 ==> lu+or+add */
+		v := c.regoff(&p.From)
+		o1 = OP_IRR(c.opirr(ALUI), uint32(v>>16), uint32(REGZERO), uint32(REGTMP))
+		o2 = OP_IRR(c.opirr(AOR), uint32(v), uint32(REGTMP), uint32(REGTMP))
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		o3 = OP_RRR(c.oprrr(p.As), uint32(REGTMP), uint32(r), uint32(p.To.Reg))
+
+	case 24: /* mov $ucon,r ==> lu r */
+		v := c.regoff(&p.From)
+		o1 = OP_IRR(c.opirr(ALUI), uint32(v>>16), uint32(REGZERO), uint32(p.To.Reg))
+
+	case 25: /* add/and $ucon,[r1],r2 ==> lu $con,t; add t,[r1],r2 */
+		v := c.regoff(&p.From)
+		o1 = OP_IRR(c.opirr(ALUI), uint32(v>>16), uint32(REGZERO), uint32(REGTMP))
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		o2 = OP_RRR(c.oprrr(p.As), uint32(REGTMP), uint32(r), uint32(p.To.Reg))
+
+	case 26: /* mov $lsext/auto/oreg,r ==> lu+or+add */
+		v := c.regoff(&p.From)
+		o1 = OP_IRR(c.opirr(ALUI), uint32(v>>16), uint32(REGZERO), uint32(REGTMP))
+		o2 = OP_IRR(c.opirr(AOR), uint32(v), uint32(REGTMP), uint32(REGTMP))
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o3 = OP_RRR(c.oprrr(add), uint32(REGTMP), uint32(r), uint32(p.To.Reg))
+
+	case 27: /* mov [sl]ext/auto/oreg,fr ==> lwc1 o(r) */
+		v := c.regoff(&p.From)
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		a := -AMOVF
+		if p.As == AMOVD {
+			a = -AMOVD
+		}
+		switch o.size {
+		case 12:
+			o1 = OP_IRR(c.opirr(ALUI), uint32((v+1<<15)>>16), uint32(REGZERO), uint32(REGTMP))
+			o2 = OP_RRR(c.oprrr(add), uint32(r), uint32(REGTMP), uint32(REGTMP))
+			o3 = OP_IRR(c.opirr(a), uint32(v), uint32(REGTMP), uint32(p.To.Reg))
+
+		case 4:
+			o1 = OP_IRR(c.opirr(a), uint32(v), uint32(r), uint32(p.To.Reg))
+		}
+
+	case 28: /* mov fr,[sl]ext/auto/oreg ==> swc1 o(r) */
+		v := c.regoff(&p.To)
+		r := int(p.To.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		a := AMOVF
+		if p.As == AMOVD {
+			a = AMOVD
+		}
+		switch o.size {
+		case 12:
+			o1 = OP_IRR(c.opirr(ALUI), uint32((v+1<<15)>>16), uint32(REGZERO), uint32(REGTMP))
+			o2 = OP_RRR(c.oprrr(add), uint32(r), uint32(REGTMP), uint32(REGTMP))
+			o3 = OP_IRR(c.opirr(a), uint32(v), uint32(REGTMP), uint32(p.From.Reg))
+
+		case 4:
+			o1 = OP_IRR(c.opirr(a), uint32(v), uint32(r), uint32(p.From.Reg))
+		}
+
+	case 30: /* movw r,fr */
+		a := SP(2, 1) | (4 << 21) /* mtc1 */
+		o1 = OP_RRR(a, uint32(p.From.Reg), uint32(0), uint32(p.To.Reg))
+
+	case 31: /* movw fr,r */
+		a := SP(2, 1) | (0 << 21) /* mtc1 */
+		o1 = OP_RRR(a, uint32(p.To.Reg), uint32(0), uint32(p.From.Reg))
+
+	case 32: /* fadd fr1,[fr2],fr3 */
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		o1 = OP_FRRR(c.oprrr(p.As), uint32(p.From.Reg), uint32(r), uint32(p.To.Reg))
+
+	case 33: /* fabs fr1, fr3 */
+		o1 = OP_FRRR(c.oprrr(p.As), uint32(0), uint32(p.From.Reg), uint32(p.To.Reg))
+
+	case 34: /* mov $con,fr ==> or/add $i,t; mov t,fr */
+		v := c.regoff(&p.From)
+		a := AADDU
+		if o.a1 == C_ANDCON {
+			a = AOR
+		}
+		o1 = OP_IRR(c.opirr(a), uint32(v), uint32(0), uint32(REGTMP))
+		o2 = OP_RRR(SP(2, 1)|(4<<21), uint32(REGTMP), uint32(0), uint32(p.To.Reg)) /* mtc1 */
+
+	case 35: /* mov r,lext/auto/oreg ==> sw o(REGTMP) */
+		v := c.regoff(&p.To)
+		r := int(p.To.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o1 = OP_IRR(c.opirr(ALUI), uint32((v+1<<15)>>16), uint32(REGZERO), uint32(REGTMP))
+		o2 = OP_RRR(c.oprrr(add), uint32(r), uint32(REGTMP), uint32(REGTMP))
+		o3 = OP_IRR(c.opirr(p.As), uint32(v), uint32(REGTMP), uint32(p.From.Reg))
+
+	case 36: /* mov lext/auto/oreg,r ==> lw o(REGTMP) */
+		v := c.regoff(&p.From)
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o1 = OP_IRR(c.opirr(ALUI), uint32((v+1<<15)>>16), uint32(REGZERO), uint32(REGTMP))
+		o2 = OP_RRR(c.oprrr(add), uint32(r), uint32(REGTMP), uint32(REGTMP))
+		o3 = OP_IRR(c.opirr(-p.As), uint32(v), uint32(REGTMP), uint32(p.To.Reg))
+
+	case 37: /* movw r,mr */
+		a := SP(2, 0) | (4 << 21) /* mtc0 */
+		if p.As == AMOVV {
+			a = SP(2, 0) | (5 << 21) /* dmtc0 */
+		}
+		o1 = OP_RRR(a, uint32(p.From.Reg), uint32(0), uint32(p.To.Reg))
+
+	case 38: /* movw mr,r */
+		a := SP(2, 0) | (0 << 21) /* mfc0 */
+		if p.As == AMOVV {
+			a = SP(2, 0) | (1 << 21) /* dmfc0 */
+		}
+		o1 = OP_RRR(a, uint32(p.To.Reg), uint32(0), uint32(p.From.Reg))
+
+	case 40: /* word */
+		o1 = uint32(c.regoff(&p.From))
+
+	case 41: /* movw f,fcr */
+		o1 = OP_RRR(SP(2, 1)|(6<<21), uint32(p.From.Reg), uint32(0), uint32(p.To.Reg)) /* mtcc1 */
+
+	case 42: /* movw fcr,r */
+		o1 = OP_RRR(SP(2, 1)|(2<<21), uint32(p.To.Reg), uint32(0), uint32(p.From.Reg)) /* mfcc1 */
+
+	case 47: /* movv r,fr */
+		a := SP(2, 1) | (5 << 21) /* dmtc1 */
+		o1 = OP_RRR(a, uint32(p.From.Reg), uint32(0), uint32(p.To.Reg))
+
+	case 48: /* movv fr,r */
+		a := SP(2, 1) | (1 << 21) /* dmtc1 */
+		o1 = OP_RRR(a, uint32(p.To.Reg), uint32(0), uint32(p.From.Reg))
+
+	case 49: /* undef */
+		o1 = 52 /* trap -- teq r0, r0 */
+
+	/* relocation operations */
+	case 50: /* mov r,addr ==> lu + add REGSB, REGTMP + sw o(REGTMP) */
+		o1 = OP_IRR(c.opirr(ALUI), uint32(0), uint32(REGZERO), uint32(REGTMP))
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 4
+		rel.Sym = p.To.Sym
+		rel.Add = p.To.Offset
+		rel.Type = objabi.R_ADDRMIPSU
+		o2 = OP_IRR(c.opirr(p.As), uint32(0), uint32(REGTMP), uint32(p.From.Reg))
+		rel2 := obj.Addrel(c.cursym)
+		rel2.Off = int32(c.pc + 4)
+		rel2.Siz = 4
+		rel2.Sym = p.To.Sym
+		rel2.Add = p.To.Offset
+		rel2.Type = objabi.R_ADDRMIPS
+
+		if o.size == 12 {
+			o3 = o2
+			o2 = OP_RRR(c.oprrr(AADDVU), uint32(REGSB), uint32(REGTMP), uint32(REGTMP))
+			rel2.Off += 4
+		}
+
+	case 51: /* mov addr,r ==> lu + add REGSB, REGTMP + lw o(REGTMP) */
+		o1 = OP_IRR(c.opirr(ALUI), uint32(0), uint32(REGZERO), uint32(REGTMP))
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 4
+		rel.Sym = p.From.Sym
+		rel.Add = p.From.Offset
+		rel.Type = objabi.R_ADDRMIPSU
+		o2 = OP_IRR(c.opirr(-p.As), uint32(0), uint32(REGTMP), uint32(p.To.Reg))
+		rel2 := obj.Addrel(c.cursym)
+		rel2.Off = int32(c.pc + 4)
+		rel2.Siz = 4
+		rel2.Sym = p.From.Sym
+		rel2.Add = p.From.Offset
+		rel2.Type = objabi.R_ADDRMIPS
+
+		if o.size == 12 {
+			o3 = o2
+			o2 = OP_RRR(c.oprrr(AADDVU), uint32(REGSB), uint32(REGTMP), uint32(REGTMP))
+			rel2.Off += 4
+		}
+
+	case 52: /* mov $lext, r ==> lu + add REGSB, r + add */
+		// NOTE: this case does not use REGTMP. If it ever does,
+		// remove the NOTUSETMP flag in optab.
+		o1 = OP_IRR(c.opirr(ALUI), uint32(0), uint32(REGZERO), uint32(p.To.Reg))
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 4
+		rel.Sym = p.From.Sym
+		rel.Add = p.From.Offset
+		rel.Type = objabi.R_ADDRMIPSU
+		o2 = OP_IRR(c.opirr(add), uint32(0), uint32(p.To.Reg), uint32(p.To.Reg))
+		rel2 := obj.Addrel(c.cursym)
+		rel2.Off = int32(c.pc + 4)
+		rel2.Siz = 4
+		rel2.Sym = p.From.Sym
+		rel2.Add = p.From.Offset
+		rel2.Type = objabi.R_ADDRMIPS
+
+		if o.size == 12 {
+			o3 = o2
+			o2 = OP_RRR(c.oprrr(AADDVU), uint32(REGSB), uint32(p.To.Reg), uint32(p.To.Reg))
+			rel2.Off += 4
+		}
+
+	case 53: /* mov r, tlsvar ==> rdhwr + sw o(r3) */
+		// clobbers R3 !
+		// load thread pointer with RDHWR, R3 is used for fast kernel emulation on Linux
+		// NOTE: this case does not use REGTMP. If it ever does,
+		// remove the NOTUSETMP flag in optab.
+		o1 = (037<<26 + 073) | (29 << 11) | (3 << 16) // rdhwr $29, r3
+		o2 = OP_IRR(c.opirr(p.As), uint32(0), uint32(REG_R3), uint32(p.From.Reg))
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc + 4)
+		rel.Siz = 4
+		rel.Sym = p.To.Sym
+		rel.Add = p.To.Offset
+		rel.Type = objabi.R_ADDRMIPSTLS
+
+	case 54: /* mov tlsvar, r ==> rdhwr + lw o(r3) */
+		// clobbers R3 !
+		// NOTE: this case does not use REGTMP. If it ever does,
+		// remove the NOTUSETMP flag in optab.
+		o1 = (037<<26 + 073) | (29 << 11) | (3 << 16) // rdhwr $29, r3
+		o2 = OP_IRR(c.opirr(-p.As), uint32(0), uint32(REG_R3), uint32(p.To.Reg))
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc + 4)
+		rel.Siz = 4
+		rel.Sym = p.From.Sym
+		rel.Add = p.From.Offset
+		rel.Type = objabi.R_ADDRMIPSTLS
+
+	case 55: /* mov $tlsvar, r ==> rdhwr + add */
+		// clobbers R3 !
+		// NOTE: this case does not use REGTMP. If it ever does,
+		// remove the NOTUSETMP flag in optab.
+		o1 = (037<<26 + 073) | (29 << 11) | (3 << 16) // rdhwr $29, r3
+		o2 = OP_IRR(c.opirr(add), uint32(0), uint32(REG_R3), uint32(p.To.Reg))
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc + 4)
+		rel.Siz = 4
+		rel.Sym = p.From.Sym
+		rel.Add = p.From.Offset
+		rel.Type = objabi.R_ADDRMIPSTLS
+
+	case 56: /* vmov{b,h,w,d} $scon, wr */
+
+		v := c.regoff(&p.From)
+		o1 = OP_VI10(110, c.twobitdf(p.As), v, uint32(p.To.Reg), 7)
+
+	case 57: /* vld $soreg, wr */
+		v := c.lsoffset(p.As, c.regoff(&p.From))
+		o1 = OP_VMI10(v, uint32(p.From.Reg), uint32(p.To.Reg), 8, c.twobitdf(p.As))
+
+	case 58: /* vst wr, $soreg */
+		v := c.lsoffset(p.As, c.regoff(&p.To))
+		o1 = OP_VMI10(v, uint32(p.To.Reg), uint32(p.From.Reg), 9, c.twobitdf(p.As))
+	}
+
+	out[0] = o1
+	out[1] = o2
+	out[2] = o3
+	out[3] = o4
+}
+
+func (c *ctxt0) vregoff(a *obj.Addr) int64 {
+	c.instoffset = 0
+	c.aclass(a)
+	return c.instoffset
+}
+
+func (c *ctxt0) regoff(a *obj.Addr) int32 {
+	return int32(c.vregoff(a))
+}
+
+func (c *ctxt0) oprrr(a obj.As) uint32 {
+	switch a {
+	case AADD:
+		return OP(4, 0)
+	case AADDU:
+		return OP(4, 1)
+	case ASGT:
+		return OP(5, 2)
+	case ASGTU:
+		return OP(5, 3)
+	case AAND:
+		return OP(4, 4)
+	case AOR:
+		return OP(4, 5)
+	case AXOR:
+		return OP(4, 6)
+	case ASUB:
+		return OP(4, 2)
+	case ASUBU, ANEGW:
+		return OP(4, 3)
+	case ANOR:
+		return OP(4, 7)
+	case ASLL:
+		return OP(0, 4)
+	case ASRL:
+		return OP(0, 6)
+	case ASRA:
+		return OP(0, 7)
+	case ASLLV:
+		return OP(2, 4)
+	case ASRLV:
+		return OP(2, 6)
+	case ASRAV:
+		return OP(2, 7)
+	case AADDV:
+		return OP(5, 4)
+	case AADDVU:
+		return OP(5, 5)
+	case ASUBV:
+		return OP(5, 6)
+	case ASUBVU, ANEGV:
+		return OP(5, 7)
+	case AREM,
+		ADIV:
+		return OP(3, 2)
+	case AREMU,
+		ADIVU:
+		return OP(3, 3)
+	case AMUL:
+		return OP(3, 0)
+	case AMULU:
+		return OP(3, 1)
+	case AREMV,
+		ADIVV:
+		return OP(3, 6)
+	case AREMVU,
+		ADIVVU:
+		return OP(3, 7)
+	case AMULV:
+		return OP(3, 4)
+	case AMULVU:
+		return OP(3, 5)
+
+	case AJMP:
+		return OP(1, 0)
+	case AJAL:
+		return OP(1, 1)
+
+	case ABREAK:
+		return OP(1, 5)
+	case ASYSCALL:
+		return OP(1, 4)
+	case ATLBP:
+		return MMU(1, 0)
+	case ATLBR:
+		return MMU(0, 1)
+	case ATLBWI:
+		return MMU(0, 2)
+	case ATLBWR:
+		return MMU(0, 6)
+	case ARFE:
+		return MMU(2, 0)
+
+	case ADIVF:
+		return FPF(0, 3)
+	case ADIVD:
+		return FPD(0, 3)
+	case AMULF:
+		return FPF(0, 2)
+	case AMULD:
+		return FPD(0, 2)
+	case ASUBF:
+		return FPF(0, 1)
+	case ASUBD:
+		return FPD(0, 1)
+	case AADDF:
+		return FPF(0, 0)
+	case AADDD:
+		return FPD(0, 0)
+	case ATRUNCFV:
+		return FPF(1, 1)
+	case ATRUNCDV:
+		return FPD(1, 1)
+	case ATRUNCFW:
+		return FPF(1, 5)
+	case ATRUNCDW:
+		return FPD(1, 5)
+	case AMOVFV:
+		return FPF(4, 5)
+	case AMOVDV:
+		return FPD(4, 5)
+	case AMOVVF:
+		return FPV(4, 0)
+	case AMOVVD:
+		return FPV(4, 1)
+	case AMOVFW:
+		return FPF(4, 4)
+	case AMOVDW:
+		return FPD(4, 4)
+	case AMOVWF:
+		return FPW(4, 0)
+	case AMOVDF:
+		return FPD(4, 0)
+	case AMOVWD:
+		return FPW(4, 1)
+	case AMOVFD:
+		return FPF(4, 1)
+	case AABSF:
+		return FPF(0, 5)
+	case AABSD:
+		return FPD(0, 5)
+	case AMOVF:
+		return FPF(0, 6)
+	case AMOVD:
+		return FPD(0, 6)
+	case ANEGF:
+		return FPF(0, 7)
+	case ANEGD:
+		return FPD(0, 7)
+	case ACMPEQF:
+		return FPF(6, 2)
+	case ACMPEQD:
+		return FPD(6, 2)
+	case ACMPGTF:
+		return FPF(7, 4)
+	case ACMPGTD:
+		return FPD(7, 4)
+	case ACMPGEF:
+		return FPF(7, 6)
+	case ACMPGED:
+		return FPD(7, 6)
+
+	case ASQRTF:
+		return FPF(0, 4)
+	case ASQRTD:
+		return FPD(0, 4)
+
+	case ASYNC:
+		return OP(1, 7)
+	case ANOOP:
+		return 0
+
+	case ACMOVN:
+		return OP(1, 3)
+	case ACMOVZ:
+		return OP(1, 2)
+	case ACMOVT:
+		return OP(0, 1) | (1 << 16)
+	case ACMOVF:
+		return OP(0, 1) | (0 << 16)
+	case ACLO:
+		return SP(3, 4) | OP(4, 1)
+	case ACLZ:
+		return SP(3, 4) | OP(4, 0)
+	case AMADD:
+		return SP(3, 4) | OP(0, 0)
+	case AMSUB:
+		return SP(3, 4) | OP(0, 4)
+	}
+
+	if a < 0 {
+		c.ctxt.Diag("bad rrr opcode -%v", -a)
+	} else {
+		c.ctxt.Diag("bad rrr opcode %v", a)
+	}
+	return 0
+}
+
+func (c *ctxt0) opirr(a obj.As) uint32 {
+	switch a {
+	case AADD:
+		return SP(1, 0)
+	case AADDU:
+		return SP(1, 1)
+	case ASGT:
+		return SP(1, 2)
+	case ASGTU:
+		return SP(1, 3)
+	case AAND:
+		return SP(1, 4)
+	case AOR:
+		return SP(1, 5)
+	case AXOR:
+		return SP(1, 6)
+	case ALUI:
+		return SP(1, 7)
+	case ASLL:
+		return OP(0, 0)
+	case ASRL:
+		return OP(0, 2)
+	case ASRA:
+		return OP(0, 3)
+	case AADDV:
+		return SP(3, 0)
+	case AADDVU:
+		return SP(3, 1)
+
+	case AJMP:
+		return SP(0, 2)
+	case AJAL,
+		obj.ADUFFZERO,
+		obj.ADUFFCOPY:
+		return SP(0, 3)
+	case ABEQ:
+		return SP(0, 4)
+	case -ABEQ:
+		return SP(2, 4) /* likely */
+	case ABNE:
+		return SP(0, 5)
+	case -ABNE:
+		return SP(2, 5) /* likely */
+	case ABGEZ:
+		return SP(0, 1) | BCOND(0, 1)
+	case -ABGEZ:
+		return SP(0, 1) | BCOND(0, 3) /* likely */
+	case ABGEZAL:
+		return SP(0, 1) | BCOND(2, 1)
+	case -ABGEZAL:
+		return SP(0, 1) | BCOND(2, 3) /* likely */
+	case ABGTZ:
+		return SP(0, 7)
+	case -ABGTZ:
+		return SP(2, 7) /* likely */
+	case ABLEZ:
+		return SP(0, 6)
+	case -ABLEZ:
+		return SP(2, 6) /* likely */
+	case ABLTZ:
+		return SP(0, 1) | BCOND(0, 0)
+	case -ABLTZ:
+		return SP(0, 1) | BCOND(0, 2) /* likely */
+	case ABLTZAL:
+		return SP(0, 1) | BCOND(2, 0)
+	case -ABLTZAL:
+		return SP(0, 1) | BCOND(2, 2) /* likely */
+	case ABFPT:
+		return SP(2, 1) | (257 << 16)
+	case -ABFPT:
+		return SP(2, 1) | (259 << 16) /* likely */
+	case ABFPF:
+		return SP(2, 1) | (256 << 16)
+	case -ABFPF:
+		return SP(2, 1) | (258 << 16) /* likely */
+
+	case AMOVB,
+		AMOVBU:
+		return SP(5, 0)
+	case AMOVH,
+		AMOVHU:
+		return SP(5, 1)
+	case AMOVW,
+		AMOVWU:
+		return SP(5, 3)
+	case AMOVV:
+		return SP(7, 7)
+	case AMOVF:
+		return SP(7, 1)
+	case AMOVD:
+		return SP(7, 5)
+	case AMOVWL:
+		return SP(5, 2)
+	case AMOVWR:
+		return SP(5, 6)
+	case AMOVVL:
+		return SP(5, 4)
+	case AMOVVR:
+		return SP(5, 5)
+
+	case ABREAK:
+		return SP(5, 7)
+
+	case -AMOVWL:
+		return SP(4, 2)
+	case -AMOVWR:
+		return SP(4, 6)
+	case -AMOVVL:
+		return SP(3, 2)
+	case -AMOVVR:
+		return SP(3, 3)
+	case -AMOVB:
+		return SP(4, 0)
+	case -AMOVBU:
+		return SP(4, 4)
+	case -AMOVH:
+		return SP(4, 1)
+	case -AMOVHU:
+		return SP(4, 5)
+	case -AMOVW:
+		return SP(4, 3)
+	case -AMOVWU:
+		return SP(4, 7)
+	case -AMOVV:
+		return SP(6, 7)
+	case -AMOVF:
+		return SP(6, 1)
+	case -AMOVD:
+		return SP(6, 5)
+
+	case ASLLV:
+		return OP(7, 0)
+	case ASRLV:
+		return OP(7, 2)
+	case ASRAV:
+		return OP(7, 3)
+	case -ASLLV:
+		return OP(7, 4)
+	case -ASRLV:
+		return OP(7, 6)
+	case -ASRAV:
+		return OP(7, 7)
+
+	case ATEQ:
+		return OP(6, 4)
+	case ATNE:
+		return OP(6, 6)
+	case -ALL:
+		return SP(6, 0)
+	case -ALLV:
+		return SP(6, 4)
+	case ASC:
+		return SP(7, 0)
+	case ASCV:
+		return SP(7, 4)
+	}
+
+	if a < 0 {
+		c.ctxt.Diag("bad irr opcode -%v", -a)
+	} else {
+		c.ctxt.Diag("bad irr opcode %v", a)
+	}
+	return 0
+}
+
+func vshift(a obj.As) bool {
+	switch a {
+	case ASLLV,
+		ASRLV,
+		ASRAV:
+		return true
+	}
+	return false
+}
+
+// MSA Two-bit Data Format Field Encoding
+func (c *ctxt0) twobitdf(a obj.As) uint32 {
+	switch a {
+	case AVMOVB:
+		return 0
+	case AVMOVH:
+		return 1
+	case AVMOVW:
+		return 2
+	case AVMOVD:
+		return 3
+	default:
+		c.ctxt.Diag("unsupported data format %v", a)
+	}
+	return 0
+}
+
+// MSA Load/Store offset have to be multiple of size of data format
+func (c *ctxt0) lsoffset(a obj.As, o int32) int32 {
+	var mod int32
+	switch a {
+	case AVMOVB:
+		mod = 1
+	case AVMOVH:
+		mod = 2
+	case AVMOVW:
+		mod = 4
+	case AVMOVD:
+		mod = 8
+	default:
+		c.ctxt.Diag("unsupported instruction:%v", a)
+	}
+
+	if o%mod != 0 {
+		c.ctxt.Diag("invalid offset for %v: %d is not a multiple of %d", a, o, mod)
+	}
+
+	return o / mod
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/list0.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/list0.go
new file mode 100644
index 000000000..71232aab1
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/list0.go
@@ -0,0 +1,83 @@
+// cmd/9l/list.c from Vita Nuova.
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2008 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package mips
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"fmt"
+)
+
+func init() {
+	obj.RegisterRegister(obj.RBaseMIPS, REG_LAST+1, rconv)
+	obj.RegisterOpcode(obj.ABaseMIPS, Anames)
+}
+
+func rconv(r int) string {
+	if r == 0 {
+		return "NONE"
+	}
+	if r == REGG {
+		// Special case.
+		return "g"
+	}
+	if REG_R0 <= r && r <= REG_R31 {
+		return fmt.Sprintf("R%d", r-REG_R0)
+	}
+	if REG_F0 <= r && r <= REG_F31 {
+		return fmt.Sprintf("F%d", r-REG_F0)
+	}
+	if REG_M0 <= r && r <= REG_M31 {
+		return fmt.Sprintf("M%d", r-REG_M0)
+	}
+	if REG_FCR0 <= r && r <= REG_FCR31 {
+		return fmt.Sprintf("FCR%d", r-REG_FCR0)
+	}
+	if REG_W0 <= r && r <= REG_W31 {
+		return fmt.Sprintf("W%d", r-REG_W0)
+	}
+	if r == REG_HI {
+		return "HI"
+	}
+	if r == REG_LO {
+		return "LO"
+	}
+
+	return fmt.Sprintf("Rgok(%d)", r-obj.RBaseMIPS)
+}
+
+func DRconv(a int) string {
+	s := "C_??"
+	if a >= C_NONE && a <= C_NCLASS {
+		s = cnames0[a]
+	}
+	var fp string
+	fp += s
+	return fp
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/obj0.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/obj0.go
new file mode 100644
index 000000000..839db889f
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/mips/obj0.go
@@ -0,0 +1,1457 @@
+// cmd/9l/noop.c, cmd/9l/pass.c, cmd/9l/span.c from Vita Nuova.
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2008 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package mips
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"github.com/twitchyliquid64/golang-asm/sys"
+	"encoding/binary"
+	"fmt"
+	"math"
+)
+
+func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
+	c := ctxt0{ctxt: ctxt, newprog: newprog}
+
+	p.From.Class = 0
+	p.To.Class = 0
+
+	// Rewrite JMP/JAL to symbol as TYPE_BRANCH.
+	switch p.As {
+	case AJMP,
+		AJAL,
+		ARET,
+		obj.ADUFFZERO,
+		obj.ADUFFCOPY:
+		if p.To.Sym != nil {
+			p.To.Type = obj.TYPE_BRANCH
+		}
+	}
+
+	// Rewrite float constants to values stored in memory.
+	switch p.As {
+	case AMOVF:
+		if p.From.Type == obj.TYPE_FCONST {
+			f32 := float32(p.From.Val.(float64))
+			if math.Float32bits(f32) == 0 {
+				p.As = AMOVW
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REGZERO
+				break
+			}
+			p.From.Type = obj.TYPE_MEM
+			p.From.Sym = ctxt.Float32Sym(f32)
+			p.From.Name = obj.NAME_EXTERN
+			p.From.Offset = 0
+		}
+
+	case AMOVD:
+		if p.From.Type == obj.TYPE_FCONST {
+			f64 := p.From.Val.(float64)
+			if math.Float64bits(f64) == 0 && c.ctxt.Arch.Family == sys.MIPS64 {
+				p.As = AMOVV
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REGZERO
+				break
+			}
+			p.From.Type = obj.TYPE_MEM
+			p.From.Sym = ctxt.Float64Sym(f64)
+			p.From.Name = obj.NAME_EXTERN
+			p.From.Offset = 0
+		}
+
+		// Put >32-bit constants in memory and load them
+	case AMOVV:
+		if p.From.Type == obj.TYPE_CONST && p.From.Name == obj.NAME_NONE && p.From.Reg == 0 && int64(int32(p.From.Offset)) != p.From.Offset {
+			p.From.Type = obj.TYPE_MEM
+			p.From.Sym = ctxt.Int64Sym(p.From.Offset)
+			p.From.Name = obj.NAME_EXTERN
+			p.From.Offset = 0
+		}
+	}
+
+	// Rewrite SUB constants into ADD.
+	switch p.As {
+	case ASUB:
+		if p.From.Type == obj.TYPE_CONST {
+			p.From.Offset = -p.From.Offset
+			p.As = AADD
+		}
+
+	case ASUBU:
+		if p.From.Type == obj.TYPE_CONST {
+			p.From.Offset = -p.From.Offset
+			p.As = AADDU
+		}
+
+	case ASUBV:
+		if p.From.Type == obj.TYPE_CONST {
+			p.From.Offset = -p.From.Offset
+			p.As = AADDV
+		}
+
+	case ASUBVU:
+		if p.From.Type == obj.TYPE_CONST {
+			p.From.Offset = -p.From.Offset
+			p.As = AADDVU
+		}
+	}
+}
+
+func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
+	// TODO(minux): add morestack short-cuts with small fixed frame-size.
+	c := ctxt0{ctxt: ctxt, newprog: newprog, cursym: cursym}
+
+	// a switch for enabling/disabling instruction scheduling
+	nosched := true
+
+	if c.cursym.Func.Text == nil || c.cursym.Func.Text.Link == nil {
+		return
+	}
+
+	p := c.cursym.Func.Text
+	textstksiz := p.To.Offset
+	if textstksiz == -ctxt.FixedFrameSize() {
+		// Historical way to mark NOFRAME.
+		p.From.Sym.Set(obj.AttrNoFrame, true)
+		textstksiz = 0
+	}
+	if textstksiz < 0 {
+		c.ctxt.Diag("negative frame size %d - did you mean NOFRAME?", textstksiz)
+	}
+	if p.From.Sym.NoFrame() {
+		if textstksiz != 0 {
+			c.ctxt.Diag("NOFRAME functions must have a frame size of 0, not %d", textstksiz)
+		}
+	}
+
+	c.cursym.Func.Args = p.To.Val.(int32)
+	c.cursym.Func.Locals = int32(textstksiz)
+
+	/*
+	 * find leaf subroutines
+	 * expand RET
+	 * expand BECOME pseudo
+	 */
+
+	for p := c.cursym.Func.Text; p != nil; p = p.Link {
+		switch p.As {
+		/* too hard, just leave alone */
+		case obj.ATEXT:
+			p.Mark |= LABEL | LEAF | SYNC
+			if p.Link != nil {
+				p.Link.Mark |= LABEL
+			}
+
+		/* too hard, just leave alone */
+		case AMOVW,
+			AMOVV:
+			if p.To.Type == obj.TYPE_REG && p.To.Reg >= REG_SPECIAL {
+				p.Mark |= LABEL | SYNC
+				break
+			}
+			if p.From.Type == obj.TYPE_REG && p.From.Reg >= REG_SPECIAL {
+				p.Mark |= LABEL | SYNC
+			}
+
+		/* too hard, just leave alone */
+		case ASYSCALL,
+			AWORD,
+			ATLBWR,
+			ATLBWI,
+			ATLBP,
+			ATLBR:
+			p.Mark |= LABEL | SYNC
+
+		case ANOR:
+			if p.To.Type == obj.TYPE_REG {
+				if p.To.Reg == REGZERO {
+					p.Mark |= LABEL | SYNC
+				}
+			}
+
+		case ABGEZAL,
+			ABLTZAL,
+			AJAL,
+			obj.ADUFFZERO,
+			obj.ADUFFCOPY:
+			c.cursym.Func.Text.Mark &^= LEAF
+			fallthrough
+
+		case AJMP,
+			ABEQ,
+			ABGEZ,
+			ABGTZ,
+			ABLEZ,
+			ABLTZ,
+			ABNE,
+			ABFPT, ABFPF:
+			if p.As == ABFPT || p.As == ABFPF {
+				// We don't treat ABFPT and ABFPF as branches here,
+				// so that we will always fill nop (0x0) in their
+				// delay slot during assembly.
+				// This is to workaround a kernel FPU emulator bug
+				// where it uses the user stack to simulate the
+				// instruction in the delay slot if it's not 0x0,
+				// and somehow that leads to SIGSEGV when the kernel
+				// jump to the stack.
+				p.Mark |= SYNC
+			} else {
+				p.Mark |= BRANCH
+			}
+			q1 := p.To.Target()
+			if q1 != nil {
+				for q1.As == obj.ANOP {
+					q1 = q1.Link
+					p.To.SetTarget(q1)
+				}
+
+				if q1.Mark&LEAF == 0 {
+					q1.Mark |= LABEL
+				}
+			}
+			//else {
+			//	p.Mark |= LABEL
+			//}
+			q1 = p.Link
+			if q1 != nil {
+				q1.Mark |= LABEL
+			}
+
+		case ARET:
+			if p.Link != nil {
+				p.Link.Mark |= LABEL
+			}
+		}
+	}
+
+	var mov, add obj.As
+	if c.ctxt.Arch.Family == sys.MIPS64 {
+		add = AADDV
+		mov = AMOVV
+	} else {
+		add = AADDU
+		mov = AMOVW
+	}
+
+	var q *obj.Prog
+	var q1 *obj.Prog
+	autosize := int32(0)
+	var p1 *obj.Prog
+	var p2 *obj.Prog
+	for p := c.cursym.Func.Text; p != nil; p = p.Link {
+		o := p.As
+		switch o {
+		case obj.ATEXT:
+			autosize = int32(textstksiz)
+
+			if p.Mark&LEAF != 0 && autosize == 0 {
+				// A leaf function with no locals has no frame.
+				p.From.Sym.Set(obj.AttrNoFrame, true)
+			}
+
+			if !p.From.Sym.NoFrame() {
+				// If there is a stack frame at all, it includes
+				// space to save the LR.
+				autosize += int32(c.ctxt.FixedFrameSize())
+			}
+
+			if autosize&4 != 0 && c.ctxt.Arch.Family == sys.MIPS64 {
+				autosize += 4
+			}
+
+			if autosize == 0 && c.cursym.Func.Text.Mark&LEAF == 0 {
+				if c.cursym.Func.Text.From.Sym.NoSplit() {
+					if ctxt.Debugvlog {
+						ctxt.Logf("save suppressed in: %s\n", c.cursym.Name)
+					}
+
+					c.cursym.Func.Text.Mark |= LEAF
+				}
+			}
+
+			p.To.Offset = int64(autosize) - ctxt.FixedFrameSize()
+
+			if c.cursym.Func.Text.Mark&LEAF != 0 {
+				c.cursym.Set(obj.AttrLeaf, true)
+				if p.From.Sym.NoFrame() {
+					break
+				}
+			}
+
+			if !p.From.Sym.NoSplit() {
+				p = c.stacksplit(p, autosize) // emit split check
+			}
+
+			q = p
+
+			if autosize != 0 {
+				// Make sure to save link register for non-empty frame, even if
+				// it is a leaf function, so that traceback works.
+				// Store link register before decrement SP, so if a signal comes
+				// during the execution of the function prologue, the traceback
+				// code will not see a half-updated stack frame.
+				// This sequence is not async preemptible, as if we open a frame
+				// at the current SP, it will clobber the saved LR.
+				q = c.ctxt.StartUnsafePoint(q, c.newprog)
+
+				q = obj.Appendp(q, newprog)
+				q.As = mov
+				q.Pos = p.Pos
+				q.From.Type = obj.TYPE_REG
+				q.From.Reg = REGLINK
+				q.To.Type = obj.TYPE_MEM
+				q.To.Offset = int64(-autosize)
+				q.To.Reg = REGSP
+
+				q = obj.Appendp(q, newprog)
+				q.As = add
+				q.Pos = p.Pos
+				q.From.Type = obj.TYPE_CONST
+				q.From.Offset = int64(-autosize)
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REGSP
+				q.Spadj = +autosize
+
+				q = c.ctxt.EndUnsafePoint(q, c.newprog, -1)
+			}
+
+			if c.cursym.Func.Text.From.Sym.Wrapper() && c.cursym.Func.Text.Mark&LEAF == 0 {
+				// if(g->panic != nil && g->panic->argp == FP) g->panic->argp = bottom-of-frame
+				//
+				//	MOV	g_panic(g), R1
+				//	BEQ	R1, end
+				//	MOV	panic_argp(R1), R2
+				//	ADD	$(autosize+FIXED_FRAME), R29, R3
+				//	BNE	R2, R3, end
+				//	ADD	$FIXED_FRAME, R29, R2
+				//	MOV	R2, panic_argp(R1)
+				// end:
+				//	NOP
+				//
+				// The NOP is needed to give the jumps somewhere to land.
+				// It is a liblink NOP, not an mips NOP: it encodes to 0 instruction bytes.
+				//
+				// We don't generate this for leafs because that means the wrapped
+				// function was inlined into the wrapper.
+
+				q = obj.Appendp(q, newprog)
+
+				q.As = mov
+				q.From.Type = obj.TYPE_MEM
+				q.From.Reg = REGG
+				q.From.Offset = 4 * int64(c.ctxt.Arch.PtrSize) // G.panic
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R1
+
+				q = obj.Appendp(q, newprog)
+				q.As = ABEQ
+				q.From.Type = obj.TYPE_REG
+				q.From.Reg = REG_R1
+				q.To.Type = obj.TYPE_BRANCH
+				q.Mark |= BRANCH
+				p1 = q
+
+				q = obj.Appendp(q, newprog)
+				q.As = mov
+				q.From.Type = obj.TYPE_MEM
+				q.From.Reg = REG_R1
+				q.From.Offset = 0 // Panic.argp
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R2
+
+				q = obj.Appendp(q, newprog)
+				q.As = add
+				q.From.Type = obj.TYPE_CONST
+				q.From.Offset = int64(autosize) + ctxt.FixedFrameSize()
+				q.Reg = REGSP
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R3
+
+				q = obj.Appendp(q, newprog)
+				q.As = ABNE
+				q.From.Type = obj.TYPE_REG
+				q.From.Reg = REG_R2
+				q.Reg = REG_R3
+				q.To.Type = obj.TYPE_BRANCH
+				q.Mark |= BRANCH
+				p2 = q
+
+				q = obj.Appendp(q, newprog)
+				q.As = add
+				q.From.Type = obj.TYPE_CONST
+				q.From.Offset = ctxt.FixedFrameSize()
+				q.Reg = REGSP
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R2
+
+				q = obj.Appendp(q, newprog)
+				q.As = mov
+				q.From.Type = obj.TYPE_REG
+				q.From.Reg = REG_R2
+				q.To.Type = obj.TYPE_MEM
+				q.To.Reg = REG_R1
+				q.To.Offset = 0 // Panic.argp
+
+				q = obj.Appendp(q, newprog)
+
+				q.As = obj.ANOP
+				p1.To.SetTarget(q)
+				p2.To.SetTarget(q)
+			}
+
+		case ARET:
+			if p.From.Type == obj.TYPE_CONST {
+				ctxt.Diag("using BECOME (%v) is not supported!", p)
+				break
+			}
+
+			retSym := p.To.Sym
+			p.To.Name = obj.NAME_NONE // clear fields as we may modify p to other instruction
+			p.To.Sym = nil
+
+			if c.cursym.Func.Text.Mark&LEAF != 0 {
+				if autosize == 0 {
+					p.As = AJMP
+					p.From = obj.Addr{}
+					if retSym != nil { // retjmp
+						p.To.Type = obj.TYPE_BRANCH
+						p.To.Name = obj.NAME_EXTERN
+						p.To.Sym = retSym
+					} else {
+						p.To.Type = obj.TYPE_MEM
+						p.To.Reg = REGLINK
+						p.To.Offset = 0
+					}
+					p.Mark |= BRANCH
+					break
+				}
+
+				p.As = add
+				p.From.Type = obj.TYPE_CONST
+				p.From.Offset = int64(autosize)
+				p.To.Type = obj.TYPE_REG
+				p.To.Reg = REGSP
+				p.Spadj = -autosize
+
+				q = c.newprog()
+				q.As = AJMP
+				q.Pos = p.Pos
+				q.To.Type = obj.TYPE_MEM
+				q.To.Offset = 0
+				q.To.Reg = REGLINK
+				q.Mark |= BRANCH
+				q.Spadj = +autosize
+
+				q.Link = p.Link
+				p.Link = q
+				break
+			}
+
+			p.As = mov
+			p.From.Type = obj.TYPE_MEM
+			p.From.Offset = 0
+			p.From.Reg = REGSP
+			p.To.Type = obj.TYPE_REG
+			p.To.Reg = REGLINK
+
+			if autosize != 0 {
+				q = c.newprog()
+				q.As = add
+				q.Pos = p.Pos
+				q.From.Type = obj.TYPE_CONST
+				q.From.Offset = int64(autosize)
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REGSP
+				q.Spadj = -autosize
+
+				q.Link = p.Link
+				p.Link = q
+			}
+
+			q1 = c.newprog()
+			q1.As = AJMP
+			q1.Pos = p.Pos
+			if retSym != nil { // retjmp
+				q1.To.Type = obj.TYPE_BRANCH
+				q1.To.Name = obj.NAME_EXTERN
+				q1.To.Sym = retSym
+			} else {
+				q1.To.Type = obj.TYPE_MEM
+				q1.To.Offset = 0
+				q1.To.Reg = REGLINK
+			}
+			q1.Mark |= BRANCH
+			q1.Spadj = +autosize
+
+			q1.Link = q.Link
+			q.Link = q1
+
+		case AADD,
+			AADDU,
+			AADDV,
+			AADDVU:
+			if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.From.Type == obj.TYPE_CONST {
+				p.Spadj = int32(-p.From.Offset)
+			}
+
+		case obj.AGETCALLERPC:
+			if cursym.Leaf() {
+				/* MOV LR, Rd */
+				p.As = mov
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REGLINK
+			} else {
+				/* MOV (RSP), Rd */
+				p.As = mov
+				p.From.Type = obj.TYPE_MEM
+				p.From.Reg = REGSP
+			}
+		}
+	}
+
+	if c.ctxt.Arch.Family == sys.MIPS {
+		// rewrite MOVD into two MOVF in 32-bit mode to avoid unaligned memory access
+		for p = c.cursym.Func.Text; p != nil; p = p1 {
+			p1 = p.Link
+
+			if p.As != AMOVD {
+				continue
+			}
+			if p.From.Type != obj.TYPE_MEM && p.To.Type != obj.TYPE_MEM {
+				continue
+			}
+
+			p.As = AMOVF
+			q = c.newprog()
+			*q = *p
+			q.Link = p.Link
+			p.Link = q
+			p1 = q.Link
+
+			var addrOff int64
+			if c.ctxt.Arch.ByteOrder == binary.BigEndian {
+				addrOff = 4 // swap load/save order
+			}
+			if p.From.Type == obj.TYPE_MEM {
+				reg := REG_F0 + (p.To.Reg-REG_F0)&^1
+				p.To.Reg = reg
+				q.To.Reg = reg + 1
+				p.From.Offset += addrOff
+				q.From.Offset += 4 - addrOff
+			} else if p.To.Type == obj.TYPE_MEM {
+				reg := REG_F0 + (p.From.Reg-REG_F0)&^1
+				p.From.Reg = reg
+				q.From.Reg = reg + 1
+				p.To.Offset += addrOff
+				q.To.Offset += 4 - addrOff
+			}
+		}
+	}
+
+	if nosched {
+		// if we don't do instruction scheduling, simply add
+		// NOP after each branch instruction.
+		for p = c.cursym.Func.Text; p != nil; p = p.Link {
+			if p.Mark&BRANCH != 0 {
+				c.addnop(p)
+			}
+		}
+		return
+	}
+
+	// instruction scheduling
+	q = nil                 // p - 1
+	q1 = c.cursym.Func.Text // top of block
+	o := 0                  // count of instructions
+	for p = c.cursym.Func.Text; p != nil; p = p1 {
+		p1 = p.Link
+		o++
+		if p.Mark&NOSCHED != 0 {
+			if q1 != p {
+				c.sched(q1, q)
+			}
+			for ; p != nil; p = p.Link {
+				if p.Mark&NOSCHED == 0 {
+					break
+				}
+				q = p
+			}
+			p1 = p
+			q1 = p
+			o = 0
+			continue
+		}
+		if p.Mark&(LABEL|SYNC) != 0 {
+			if q1 != p {
+				c.sched(q1, q)
+			}
+			q1 = p
+			o = 1
+		}
+		if p.Mark&(BRANCH|SYNC) != 0 {
+			c.sched(q1, p)
+			q1 = p1
+			o = 0
+		}
+		if o >= NSCHED {
+			c.sched(q1, p)
+			q1 = p1
+			o = 0
+		}
+		q = p
+	}
+}
+
+func (c *ctxt0) stacksplit(p *obj.Prog, framesize int32) *obj.Prog {
+	var mov, add, sub obj.As
+
+	if c.ctxt.Arch.Family == sys.MIPS64 {
+		add = AADDV
+		mov = AMOVV
+		sub = ASUBVU
+	} else {
+		add = AADDU
+		mov = AMOVW
+		sub = ASUBU
+	}
+
+	// MOV	g_stackguard(g), R1
+	p = obj.Appendp(p, c.newprog)
+
+	p.As = mov
+	p.From.Type = obj.TYPE_MEM
+	p.From.Reg = REGG
+	p.From.Offset = 2 * int64(c.ctxt.Arch.PtrSize) // G.stackguard0
+	if c.cursym.CFunc() {
+		p.From.Offset = 3 * int64(c.ctxt.Arch.PtrSize) // G.stackguard1
+	}
+	p.To.Type = obj.TYPE_REG
+	p.To.Reg = REG_R1
+
+	// Mark the stack bound check and morestack call async nonpreemptible.
+	// If we get preempted here, when resumed the preemption request is
+	// cleared, but we'll still call morestack, which will double the stack
+	// unnecessarily. See issue #35470.
+	p = c.ctxt.StartUnsafePoint(p, c.newprog)
+
+	var q *obj.Prog
+	if framesize <= objabi.StackSmall {
+		// small stack: SP < stackguard
+		//	AGTU	SP, stackguard, R1
+		p = obj.Appendp(p, c.newprog)
+
+		p.As = ASGTU
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REGSP
+		p.Reg = REG_R1
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R1
+	} else if framesize <= objabi.StackBig {
+		// large stack: SP-framesize < stackguard-StackSmall
+		//	ADD	$-(framesize-StackSmall), SP, R2
+		//	SGTU	R2, stackguard, R1
+		p = obj.Appendp(p, c.newprog)
+
+		p.As = add
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = -(int64(framesize) - objabi.StackSmall)
+		p.Reg = REGSP
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R2
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = ASGTU
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R2
+		p.Reg = REG_R1
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R1
+	} else {
+		// Such a large stack we need to protect against wraparound.
+		// If SP is close to zero:
+		//	SP-stackguard+StackGuard <= framesize + (StackGuard-StackSmall)
+		// The +StackGuard on both sides is required to keep the left side positive:
+		// SP is allowed to be slightly below stackguard. See stack.h.
+		//
+		// Preemption sets stackguard to StackPreempt, a very large value.
+		// That breaks the math above, so we have to check for that explicitly.
+		//	// stackguard is R1
+		//	MOV	$StackPreempt, R2
+		//	BEQ	R1, R2, label-of-call-to-morestack
+		//	ADD	$StackGuard, SP, R2
+		//	SUB	R1, R2
+		//	MOV	$(framesize+(StackGuard-StackSmall)), R1
+		//	SGTU	R2, R1, R1
+		p = obj.Appendp(p, c.newprog)
+
+		p.As = mov
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = objabi.StackPreempt
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R2
+
+		p = obj.Appendp(p, c.newprog)
+		q = p
+		p.As = ABEQ
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R1
+		p.Reg = REG_R2
+		p.To.Type = obj.TYPE_BRANCH
+		p.Mark |= BRANCH
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = add
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = int64(objabi.StackGuard)
+		p.Reg = REGSP
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R2
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = sub
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R1
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R2
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = mov
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = int64(framesize) + int64(objabi.StackGuard) - objabi.StackSmall
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R1
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = ASGTU
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R2
+		p.Reg = REG_R1
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R1
+	}
+
+	// q1: BNE	R1, done
+	p = obj.Appendp(p, c.newprog)
+	q1 := p
+
+	p.As = ABNE
+	p.From.Type = obj.TYPE_REG
+	p.From.Reg = REG_R1
+	p.To.Type = obj.TYPE_BRANCH
+	p.Mark |= BRANCH
+
+	// MOV	LINK, R3
+	p = obj.Appendp(p, c.newprog)
+
+	p.As = mov
+	p.From.Type = obj.TYPE_REG
+	p.From.Reg = REGLINK
+	p.To.Type = obj.TYPE_REG
+	p.To.Reg = REG_R3
+	if q != nil {
+		q.To.SetTarget(p)
+		p.Mark |= LABEL
+	}
+
+	p = c.ctxt.EmitEntryStackMap(c.cursym, p, c.newprog)
+
+	// JAL	runtime.morestack(SB)
+	p = obj.Appendp(p, c.newprog)
+
+	p.As = AJAL
+	p.To.Type = obj.TYPE_BRANCH
+	if c.cursym.CFunc() {
+		p.To.Sym = c.ctxt.Lookup("runtime.morestackc")
+	} else if !c.cursym.Func.Text.From.Sym.NeedCtxt() {
+		p.To.Sym = c.ctxt.Lookup("runtime.morestack_noctxt")
+	} else {
+		p.To.Sym = c.ctxt.Lookup("runtime.morestack")
+	}
+	p.Mark |= BRANCH
+
+	p = c.ctxt.EndUnsafePoint(p, c.newprog, -1)
+
+	// JMP	start
+	p = obj.Appendp(p, c.newprog)
+
+	p.As = AJMP
+	p.To.Type = obj.TYPE_BRANCH
+	p.To.SetTarget(c.cursym.Func.Text.Link)
+	p.Mark |= BRANCH
+
+	// placeholder for q1's jump target
+	p = obj.Appendp(p, c.newprog)
+
+	p.As = obj.ANOP // zero-width place holder
+	q1.To.SetTarget(p)
+
+	return p
+}
+
+func (c *ctxt0) addnop(p *obj.Prog) {
+	q := c.newprog()
+	q.As = ANOOP
+	q.Pos = p.Pos
+	q.Link = p.Link
+	p.Link = q
+}
+
+const (
+	E_HILO  = 1 << 0
+	E_FCR   = 1 << 1
+	E_MCR   = 1 << 2
+	E_MEM   = 1 << 3
+	E_MEMSP = 1 << 4 /* uses offset and size */
+	E_MEMSB = 1 << 5 /* uses offset and size */
+	ANYMEM  = E_MEM | E_MEMSP | E_MEMSB
+	//DELAY = LOAD|BRANCH|FCMP
+	DELAY = BRANCH /* only schedule branch */
+)
+
+type Dep struct {
+	ireg uint32
+	freg uint32
+	cc   uint32
+}
+
+type Sch struct {
+	p       obj.Prog
+	set     Dep
+	used    Dep
+	soffset int32
+	size    uint8
+	nop     uint8
+	comp    bool
+}
+
+func (c *ctxt0) sched(p0, pe *obj.Prog) {
+	var sch [NSCHED]Sch
+
+	/*
+	 * build side structure
+	 */
+	s := sch[:]
+	for p := p0; ; p = p.Link {
+		s[0].p = *p
+		c.markregused(&s[0])
+		if p == pe {
+			break
+		}
+		s = s[1:]
+	}
+	se := s
+
+	for i := cap(sch) - cap(se); i >= 0; i-- {
+		s = sch[i:]
+		if s[0].p.Mark&DELAY == 0 {
+			continue
+		}
+		if -cap(s) < -cap(se) {
+			if !conflict(&s[0], &s[1]) {
+				continue
+			}
+		}
+
+		var t []Sch
+		var j int
+		for j = cap(sch) - cap(s) - 1; j >= 0; j-- {
+			t = sch[j:]
+			if t[0].comp {
+				if s[0].p.Mark&BRANCH != 0 {
+					continue
+				}
+			}
+			if t[0].p.Mark&DELAY != 0 {
+				if -cap(s) >= -cap(se) || conflict(&t[0], &s[1]) {
+					continue
+				}
+			}
+			for u := t[1:]; -cap(u) <= -cap(s); u = u[1:] {
+				if c.depend(&u[0], &t[0]) {
+					continue
+				}
+			}
+			goto out2
+		}
+
+		if s[0].p.Mark&BRANCH != 0 {
+			s[0].nop = 1
+		}
+		continue
+
+	out2:
+		// t[0] is the instruction being moved to fill the delay
+		stmp := t[0]
+		copy(t[:i-j], t[1:i-j+1])
+		s[0] = stmp
+
+		if t[i-j-1].p.Mark&BRANCH != 0 {
+			// t[i-j] is being put into a branch delay slot
+			// combine its Spadj with the branch instruction
+			t[i-j-1].p.Spadj += t[i-j].p.Spadj
+			t[i-j].p.Spadj = 0
+		}
+
+		i--
+	}
+
+	/*
+	 * put it all back
+	 */
+	var p *obj.Prog
+	var q *obj.Prog
+	for s, p = sch[:], p0; -cap(s) <= -cap(se); s, p = s[1:], q {
+		q = p.Link
+		if q != s[0].p.Link {
+			*p = s[0].p
+			p.Link = q
+		}
+		for s[0].nop != 0 {
+			s[0].nop--
+			c.addnop(p)
+		}
+	}
+}
+
+func (c *ctxt0) markregused(s *Sch) {
+	p := &s.p
+	s.comp = c.compound(p)
+	s.nop = 0
+	if s.comp {
+		s.set.ireg |= 1 << (REGTMP - REG_R0)
+		s.used.ireg |= 1 << (REGTMP - REG_R0)
+	}
+
+	ar := 0  /* dest is really reference */
+	ad := 0  /* source/dest is really address */
+	ld := 0  /* opcode is load instruction */
+	sz := 20 /* size of load/store for overlap computation */
+
+	/*
+	 * flags based on opcode
+	 */
+	switch p.As {
+	case obj.ATEXT:
+		c.autosize = int32(p.To.Offset + 8)
+		ad = 1
+
+	case AJAL:
+		r := p.Reg
+		if r == 0 {
+			r = REGLINK
+		}
+		s.set.ireg |= 1 << uint(r-REG_R0)
+		ar = 1
+		ad = 1
+
+	case ABGEZAL,
+		ABLTZAL:
+		s.set.ireg |= 1 << (REGLINK - REG_R0)
+		fallthrough
+	case ABEQ,
+		ABGEZ,
+		ABGTZ,
+		ABLEZ,
+		ABLTZ,
+		ABNE:
+		ar = 1
+		ad = 1
+
+	case ABFPT,
+		ABFPF:
+		ad = 1
+		s.used.cc |= E_FCR
+
+	case ACMPEQD,
+		ACMPEQF,
+		ACMPGED,
+		ACMPGEF,
+		ACMPGTD,
+		ACMPGTF:
+		ar = 1
+		s.set.cc |= E_FCR
+		p.Mark |= FCMP
+
+	case AJMP:
+		ar = 1
+		ad = 1
+
+	case AMOVB,
+		AMOVBU:
+		sz = 1
+		ld = 1
+
+	case AMOVH,
+		AMOVHU:
+		sz = 2
+		ld = 1
+
+	case AMOVF,
+		AMOVW,
+		AMOVWL,
+		AMOVWR:
+		sz = 4
+		ld = 1
+
+	case AMOVD,
+		AMOVV,
+		AMOVVL,
+		AMOVVR:
+		sz = 8
+		ld = 1
+
+	case ADIV,
+		ADIVU,
+		AMUL,
+		AMULU,
+		AREM,
+		AREMU,
+		ADIVV,
+		ADIVVU,
+		AMULV,
+		AMULVU,
+		AREMV,
+		AREMVU:
+		s.set.cc = E_HILO
+		fallthrough
+	case AADD,
+		AADDU,
+		AADDV,
+		AADDVU,
+		AAND,
+		ANOR,
+		AOR,
+		ASGT,
+		ASGTU,
+		ASLL,
+		ASRA,
+		ASRL,
+		ASLLV,
+		ASRAV,
+		ASRLV,
+		ASUB,
+		ASUBU,
+		ASUBV,
+		ASUBVU,
+		AXOR,
+
+		AADDD,
+		AADDF,
+		AADDW,
+		ASUBD,
+		ASUBF,
+		ASUBW,
+		AMULF,
+		AMULD,
+		AMULW,
+		ADIVF,
+		ADIVD,
+		ADIVW:
+		if p.Reg == 0 {
+			if p.To.Type == obj.TYPE_REG {
+				p.Reg = p.To.Reg
+			}
+			//if(p->reg == NREG)
+			//	print("botch %P\n", p);
+		}
+	}
+
+	/*
+	 * flags based on 'to' field
+	 */
+	cls := int(p.To.Class)
+	if cls == 0 {
+		cls = c.aclass(&p.To) + 1
+		p.To.Class = int8(cls)
+	}
+	cls--
+	switch cls {
+	default:
+		fmt.Printf("unknown class %d %v\n", cls, p)
+
+	case C_ZCON,
+		C_SCON,
+		C_ADD0CON,
+		C_AND0CON,
+		C_ADDCON,
+		C_ANDCON,
+		C_UCON,
+		C_LCON,
+		C_NONE,
+		C_SBRA,
+		C_LBRA,
+		C_ADDR,
+		C_TEXTSIZE:
+		break
+
+	case C_HI,
+		C_LO:
+		s.set.cc |= E_HILO
+
+	case C_FCREG:
+		s.set.cc |= E_FCR
+
+	case C_MREG:
+		s.set.cc |= E_MCR
+
+	case C_ZOREG,
+		C_SOREG,
+		C_LOREG:
+		cls = int(p.To.Reg)
+		s.used.ireg |= 1 << uint(cls-REG_R0)
+		if ad != 0 {
+			break
+		}
+		s.size = uint8(sz)
+		s.soffset = c.regoff(&p.To)
+
+		m := uint32(ANYMEM)
+		if cls == REGSB {
+			m = E_MEMSB
+		}
+		if cls == REGSP {
+			m = E_MEMSP
+		}
+
+		if ar != 0 {
+			s.used.cc |= m
+		} else {
+			s.set.cc |= m
+		}
+
+	case C_SACON,
+		C_LACON:
+		s.used.ireg |= 1 << (REGSP - REG_R0)
+
+	case C_SECON,
+		C_LECON:
+		s.used.ireg |= 1 << (REGSB - REG_R0)
+
+	case C_REG:
+		if ar != 0 {
+			s.used.ireg |= 1 << uint(p.To.Reg-REG_R0)
+		} else {
+			s.set.ireg |= 1 << uint(p.To.Reg-REG_R0)
+		}
+
+	case C_FREG:
+		if ar != 0 {
+			s.used.freg |= 1 << uint(p.To.Reg-REG_F0)
+		} else {
+			s.set.freg |= 1 << uint(p.To.Reg-REG_F0)
+		}
+		if ld != 0 && p.From.Type == obj.TYPE_REG {
+			p.Mark |= LOAD
+		}
+
+	case C_SAUTO,
+		C_LAUTO:
+		s.used.ireg |= 1 << (REGSP - REG_R0)
+		if ad != 0 {
+			break
+		}
+		s.size = uint8(sz)
+		s.soffset = c.regoff(&p.To)
+
+		if ar != 0 {
+			s.used.cc |= E_MEMSP
+		} else {
+			s.set.cc |= E_MEMSP
+		}
+
+	case C_SEXT,
+		C_LEXT:
+		s.used.ireg |= 1 << (REGSB - REG_R0)
+		if ad != 0 {
+			break
+		}
+		s.size = uint8(sz)
+		s.soffset = c.regoff(&p.To)
+
+		if ar != 0 {
+			s.used.cc |= E_MEMSB
+		} else {
+			s.set.cc |= E_MEMSB
+		}
+	}
+
+	/*
+	 * flags based on 'from' field
+	 */
+	cls = int(p.From.Class)
+	if cls == 0 {
+		cls = c.aclass(&p.From) + 1
+		p.From.Class = int8(cls)
+	}
+	cls--
+	switch cls {
+	default:
+		fmt.Printf("unknown class %d %v\n", cls, p)
+
+	case C_ZCON,
+		C_SCON,
+		C_ADD0CON,
+		C_AND0CON,
+		C_ADDCON,
+		C_ANDCON,
+		C_UCON,
+		C_LCON,
+		C_NONE,
+		C_SBRA,
+		C_LBRA,
+		C_ADDR,
+		C_TEXTSIZE:
+		break
+
+	case C_HI,
+		C_LO:
+		s.used.cc |= E_HILO
+
+	case C_FCREG:
+		s.used.cc |= E_FCR
+
+	case C_MREG:
+		s.used.cc |= E_MCR
+
+	case C_ZOREG,
+		C_SOREG,
+		C_LOREG:
+		cls = int(p.From.Reg)
+		s.used.ireg |= 1 << uint(cls-REG_R0)
+		if ld != 0 {
+			p.Mark |= LOAD
+		}
+		s.size = uint8(sz)
+		s.soffset = c.regoff(&p.From)
+
+		m := uint32(ANYMEM)
+		if cls == REGSB {
+			m = E_MEMSB
+		}
+		if cls == REGSP {
+			m = E_MEMSP
+		}
+
+		s.used.cc |= m
+
+	case C_SACON,
+		C_LACON:
+		cls = int(p.From.Reg)
+		if cls == 0 {
+			cls = REGSP
+		}
+		s.used.ireg |= 1 << uint(cls-REG_R0)
+
+	case C_SECON,
+		C_LECON:
+		s.used.ireg |= 1 << (REGSB - REG_R0)
+
+	case C_REG:
+		s.used.ireg |= 1 << uint(p.From.Reg-REG_R0)
+
+	case C_FREG:
+		s.used.freg |= 1 << uint(p.From.Reg-REG_F0)
+		if ld != 0 && p.To.Type == obj.TYPE_REG {
+			p.Mark |= LOAD
+		}
+
+	case C_SAUTO,
+		C_LAUTO:
+		s.used.ireg |= 1 << (REGSP - REG_R0)
+		if ld != 0 {
+			p.Mark |= LOAD
+		}
+		if ad != 0 {
+			break
+		}
+		s.size = uint8(sz)
+		s.soffset = c.regoff(&p.From)
+
+		s.used.cc |= E_MEMSP
+
+	case C_SEXT:
+	case C_LEXT:
+		s.used.ireg |= 1 << (REGSB - REG_R0)
+		if ld != 0 {
+			p.Mark |= LOAD
+		}
+		if ad != 0 {
+			break
+		}
+		s.size = uint8(sz)
+		s.soffset = c.regoff(&p.From)
+
+		s.used.cc |= E_MEMSB
+	}
+
+	cls = int(p.Reg)
+	if cls != 0 {
+		if REG_F0 <= cls && cls <= REG_F31 {
+			s.used.freg |= 1 << uint(cls-REG_F0)
+		} else {
+			s.used.ireg |= 1 << uint(cls-REG_R0)
+		}
+	}
+	s.set.ireg &^= (1 << (REGZERO - REG_R0)) /* R0 can't be set */
+}
+
+/*
+ * test to see if two instructions can be
+ * interchanged without changing semantics
+ */
+func (c *ctxt0) depend(sa, sb *Sch) bool {
+	if sa.set.ireg&(sb.set.ireg|sb.used.ireg) != 0 {
+		return true
+	}
+	if sb.set.ireg&sa.used.ireg != 0 {
+		return true
+	}
+
+	if sa.set.freg&(sb.set.freg|sb.used.freg) != 0 {
+		return true
+	}
+	if sb.set.freg&sa.used.freg != 0 {
+		return true
+	}
+
+	/*
+	 * special case.
+	 * loads from same address cannot pass.
+	 * this is for hardware fifo's and the like
+	 */
+	if sa.used.cc&sb.used.cc&E_MEM != 0 {
+		if sa.p.Reg == sb.p.Reg {
+			if c.regoff(&sa.p.From) == c.regoff(&sb.p.From) {
+				return true
+			}
+		}
+	}
+
+	x := (sa.set.cc & (sb.set.cc | sb.used.cc)) | (sb.set.cc & sa.used.cc)
+	if x != 0 {
+		/*
+		 * allow SB and SP to pass each other.
+		 * allow SB to pass SB iff doffsets are ok
+		 * anything else conflicts
+		 */
+		if x != E_MEMSP && x != E_MEMSB {
+			return true
+		}
+		x = sa.set.cc | sb.set.cc | sa.used.cc | sb.used.cc
+		if x&E_MEM != 0 {
+			return true
+		}
+		if offoverlap(sa, sb) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func offoverlap(sa, sb *Sch) bool {
+	if sa.soffset < sb.soffset {
+		if sa.soffset+int32(sa.size) > sb.soffset {
+			return true
+		}
+		return false
+	}
+	if sb.soffset+int32(sb.size) > sa.soffset {
+		return true
+	}
+	return false
+}
+
+/*
+ * test 2 adjacent instructions
+ * and find out if inserted instructions
+ * are desired to prevent stalls.
+ */
+func conflict(sa, sb *Sch) bool {
+	if sa.set.ireg&sb.used.ireg != 0 {
+		return true
+	}
+	if sa.set.freg&sb.used.freg != 0 {
+		return true
+	}
+	if sa.set.cc&sb.used.cc != 0 {
+		return true
+	}
+	return false
+}
+
+func (c *ctxt0) compound(p *obj.Prog) bool {
+	o := c.oplook(p)
+	if o.size != 4 {
+		return true
+	}
+	if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSB {
+		return true
+	}
+	return false
+}
+
+var Linkmips64 = obj.LinkArch{
+	Arch:           sys.ArchMIPS64,
+	Init:           buildop,
+	Preprocess:     preprocess,
+	Assemble:       span0,
+	Progedit:       progedit,
+	DWARFRegisters: MIPSDWARFRegisters,
+}
+
+var Linkmips64le = obj.LinkArch{
+	Arch:           sys.ArchMIPS64LE,
+	Init:           buildop,
+	Preprocess:     preprocess,
+	Assemble:       span0,
+	Progedit:       progedit,
+	DWARFRegisters: MIPSDWARFRegisters,
+}
+
+var Linkmips = obj.LinkArch{
+	Arch:           sys.ArchMIPS,
+	Init:           buildop,
+	Preprocess:     preprocess,
+	Assemble:       span0,
+	Progedit:       progedit,
+	DWARFRegisters: MIPSDWARFRegisters,
+}
+
+var Linkmipsle = obj.LinkArch{
+	Arch:           sys.ArchMIPSLE,
+	Init:           buildop,
+	Preprocess:     preprocess,
+	Assemble:       span0,
+	Progedit:       progedit,
+	DWARFRegisters: MIPSDWARFRegisters,
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/objfile.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/objfile.go
new file mode 100644
index 000000000..dd2ba4b0e
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/objfile.go
@@ -0,0 +1,755 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Writing Go object files.
+
+package obj
+
+import (
+	"bytes"
+	"github.com/twitchyliquid64/golang-asm/bio"
+	"github.com/twitchyliquid64/golang-asm/goobj"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"github.com/twitchyliquid64/golang-asm/sys"
+	"crypto/sha1"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+// Entry point of writing new object file.
+func WriteObjFile(ctxt *Link, b *bio.Writer) {
+
+	debugAsmEmit(ctxt)
+
+	genFuncInfoSyms(ctxt)
+
+	w := writer{
+		Writer:  goobj.NewWriter(b),
+		ctxt:    ctxt,
+		pkgpath: objabi.PathToPrefix(ctxt.Pkgpath),
+	}
+
+	start := b.Offset()
+	w.init()
+
+	// Header
+	// We just reserve the space. We'll fill in the offsets later.
+	flags := uint32(0)
+	if ctxt.Flag_shared {
+		flags |= goobj.ObjFlagShared
+	}
+	if w.pkgpath == "" {
+		flags |= goobj.ObjFlagNeedNameExpansion
+	}
+	if ctxt.IsAsm {
+		flags |= goobj.ObjFlagFromAssembly
+	}
+	h := goobj.Header{
+		Magic:       goobj.Magic,
+		Fingerprint: ctxt.Fingerprint,
+		Flags:       flags,
+	}
+	h.Write(w.Writer)
+
+	// String table
+	w.StringTable()
+
+	// Autolib
+	h.Offsets[goobj.BlkAutolib] = w.Offset()
+	for i := range ctxt.Imports {
+		ctxt.Imports[i].Write(w.Writer)
+	}
+
+	// Package references
+	h.Offsets[goobj.BlkPkgIdx] = w.Offset()
+	for _, pkg := range w.pkglist {
+		w.StringRef(pkg)
+	}
+
+	// File table (for DWARF and pcln generation).
+	h.Offsets[goobj.BlkFile] = w.Offset()
+	for _, f := range ctxt.PosTable.FileTable() {
+		w.StringRef(filepath.ToSlash(f))
+	}
+
+	// Symbol definitions
+	h.Offsets[goobj.BlkSymdef] = w.Offset()
+	for _, s := range ctxt.defs {
+		w.Sym(s)
+	}
+
+	// Short hashed symbol definitions
+	h.Offsets[goobj.BlkHashed64def] = w.Offset()
+	for _, s := range ctxt.hashed64defs {
+		w.Sym(s)
+	}
+
+	// Hashed symbol definitions
+	h.Offsets[goobj.BlkHasheddef] = w.Offset()
+	for _, s := range ctxt.hasheddefs {
+		w.Sym(s)
+	}
+
+	// Non-pkg symbol definitions
+	h.Offsets[goobj.BlkNonpkgdef] = w.Offset()
+	for _, s := range ctxt.nonpkgdefs {
+		w.Sym(s)
+	}
+
+	// Non-pkg symbol references
+	h.Offsets[goobj.BlkNonpkgref] = w.Offset()
+	for _, s := range ctxt.nonpkgrefs {
+		w.Sym(s)
+	}
+
+	// Referenced package symbol flags
+	h.Offsets[goobj.BlkRefFlags] = w.Offset()
+	w.refFlags()
+
+	// Hashes
+	h.Offsets[goobj.BlkHash64] = w.Offset()
+	for _, s := range ctxt.hashed64defs {
+		w.Hash64(s)
+	}
+	h.Offsets[goobj.BlkHash] = w.Offset()
+	for _, s := range ctxt.hasheddefs {
+		w.Hash(s)
+	}
+	// TODO: hashedrefs unused/unsupported for now
+
+	// Reloc indexes
+	h.Offsets[goobj.BlkRelocIdx] = w.Offset()
+	nreloc := uint32(0)
+	lists := [][]*LSym{ctxt.defs, ctxt.hashed64defs, ctxt.hasheddefs, ctxt.nonpkgdefs}
+	for _, list := range lists {
+		for _, s := range list {
+			w.Uint32(nreloc)
+			nreloc += uint32(len(s.R))
+		}
+	}
+	w.Uint32(nreloc)
+
+	// Symbol Info indexes
+	h.Offsets[goobj.BlkAuxIdx] = w.Offset()
+	naux := uint32(0)
+	for _, list := range lists {
+		for _, s := range list {
+			w.Uint32(naux)
+			naux += uint32(nAuxSym(s))
+		}
+	}
+	w.Uint32(naux)
+
+	// Data indexes
+	h.Offsets[goobj.BlkDataIdx] = w.Offset()
+	dataOff := uint32(0)
+	for _, list := range lists {
+		for _, s := range list {
+			w.Uint32(dataOff)
+			dataOff += uint32(len(s.P))
+		}
+	}
+	w.Uint32(dataOff)
+
+	// Relocs
+	h.Offsets[goobj.BlkReloc] = w.Offset()
+	for _, list := range lists {
+		for _, s := range list {
+			for i := range s.R {
+				w.Reloc(&s.R[i])
+			}
+		}
+	}
+
+	// Aux symbol info
+	h.Offsets[goobj.BlkAux] = w.Offset()
+	for _, list := range lists {
+		for _, s := range list {
+			w.Aux(s)
+		}
+	}
+
+	// Data
+	h.Offsets[goobj.BlkData] = w.Offset()
+	for _, list := range lists {
+		for _, s := range list {
+			w.Bytes(s.P)
+		}
+	}
+
+	// Pcdata
+	h.Offsets[goobj.BlkPcdata] = w.Offset()
+	for _, s := range ctxt.Text { // iteration order must match genFuncInfoSyms
+		if s.Func != nil {
+			pc := &s.Func.Pcln
+			w.Bytes(pc.Pcsp.P)
+			w.Bytes(pc.Pcfile.P)
+			w.Bytes(pc.Pcline.P)
+			w.Bytes(pc.Pcinline.P)
+			for i := range pc.Pcdata {
+				w.Bytes(pc.Pcdata[i].P)
+			}
+		}
+	}
+
+	// Blocks used only by tools (objdump, nm).
+
+	// Referenced symbol names from other packages
+	h.Offsets[goobj.BlkRefName] = w.Offset()
+	w.refNames()
+
+	h.Offsets[goobj.BlkEnd] = w.Offset()
+
+	// Fix up block offsets in the header
+	end := start + int64(w.Offset())
+	b.MustSeek(start, 0)
+	h.Write(w.Writer)
+	b.MustSeek(end, 0)
+}
+
+type writer struct {
+	*goobj.Writer
+	ctxt    *Link
+	pkgpath string   // the package import path (escaped), "" if unknown
+	pkglist []string // list of packages referenced, indexed by ctxt.pkgIdx
+}
+
+// prepare package index list
+func (w *writer) init() {
+	w.pkglist = make([]string, len(w.ctxt.pkgIdx)+1)
+	w.pkglist[0] = "" // dummy invalid package for index 0
+	for pkg, i := range w.ctxt.pkgIdx {
+		w.pkglist[i] = pkg
+	}
+}
+
+func (w *writer) StringTable() {
+	w.AddString("")
+	for _, p := range w.ctxt.Imports {
+		w.AddString(p.Pkg)
+	}
+	for _, pkg := range w.pkglist {
+		w.AddString(pkg)
+	}
+	w.ctxt.traverseSyms(traverseAll, func(s *LSym) {
+		// TODO: this includes references of indexed symbols from other packages,
+		// for which the linker doesn't need the name. Consider moving them to
+		// a separate block (for tools only).
+		if w.pkgpath != "" {
+			s.Name = strings.Replace(s.Name, "\"\".", w.pkgpath+".", -1)
+		}
+		// Don't put names of builtins into the string table (to save
+		// space).
+		if s.PkgIdx == goobj.PkgIdxBuiltin {
+			return
+		}
+		w.AddString(s.Name)
+	})
+
+	// All filenames are in the postable.
+	for _, f := range w.ctxt.PosTable.FileTable() {
+		w.AddString(filepath.ToSlash(f))
+	}
+}
+
+func (w *writer) Sym(s *LSym) {
+	abi := uint16(s.ABI())
+	if s.Static() {
+		abi = goobj.SymABIstatic
+	}
+	flag := uint8(0)
+	if s.DuplicateOK() {
+		flag |= goobj.SymFlagDupok
+	}
+	if s.Local() {
+		flag |= goobj.SymFlagLocal
+	}
+	if s.MakeTypelink() {
+		flag |= goobj.SymFlagTypelink
+	}
+	if s.Leaf() {
+		flag |= goobj.SymFlagLeaf
+	}
+	if s.NoSplit() {
+		flag |= goobj.SymFlagNoSplit
+	}
+	if s.ReflectMethod() {
+		flag |= goobj.SymFlagReflectMethod
+	}
+	if s.TopFrame() {
+		flag |= goobj.SymFlagTopFrame
+	}
+	if strings.HasPrefix(s.Name, "type.") && s.Name[5] != '.' && s.Type == objabi.SRODATA {
+		flag |= goobj.SymFlagGoType
+	}
+	flag2 := uint8(0)
+	if s.UsedInIface() {
+		flag2 |= goobj.SymFlagUsedInIface
+	}
+	if strings.HasPrefix(s.Name, "go.itab.") && s.Type == objabi.SRODATA {
+		flag2 |= goobj.SymFlagItab
+	}
+	name := s.Name
+	if strings.HasPrefix(name, "gofile..") {
+		name = filepath.ToSlash(name)
+	}
+	var align uint32
+	if s.Func != nil {
+		align = uint32(s.Func.Align)
+	}
+	if s.ContentAddressable() {
+		// We generally assume data symbols are natually aligned,
+		// except for strings. If we dedup a string symbol and a
+		// non-string symbol with the same content, we should keep
+		// the largest alignment.
+		// TODO: maybe the compiler could set the alignment for all
+		// data symbols more carefully.
+		if s.Size != 0 && !strings.HasPrefix(s.Name, "go.string.") {
+			switch {
+			case w.ctxt.Arch.PtrSize == 8 && s.Size%8 == 0:
+				align = 8
+			case s.Size%4 == 0:
+				align = 4
+			case s.Size%2 == 0:
+				align = 2
+			}
+			// don't bother setting align to 1.
+		}
+	}
+	var o goobj.Sym
+	o.SetName(name, w.Writer)
+	o.SetABI(abi)
+	o.SetType(uint8(s.Type))
+	o.SetFlag(flag)
+	o.SetFlag2(flag2)
+	o.SetSiz(uint32(s.Size))
+	o.SetAlign(align)
+	o.Write(w.Writer)
+}
+
+func (w *writer) Hash64(s *LSym) {
+	if !s.ContentAddressable() || len(s.R) != 0 {
+		panic("Hash of non-content-addresable symbol")
+	}
+	b := contentHash64(s)
+	w.Bytes(b[:])
+}
+
+func (w *writer) Hash(s *LSym) {
+	if !s.ContentAddressable() {
+		panic("Hash of non-content-addresable symbol")
+	}
+	b := w.contentHash(s)
+	w.Bytes(b[:])
+}
+
+func contentHash64(s *LSym) goobj.Hash64Type {
+	var b goobj.Hash64Type
+	copy(b[:], s.P)
+	return b
+}
+
+// Compute the content hash for a content-addressable symbol.
+// We build a content hash based on its content and relocations.
+// Depending on the category of the referenced symbol, we choose
+// different hash algorithms such that the hash is globally
+// consistent.
+// - For referenced content-addressable symbol, its content hash
+//   is globally consistent.
+// - For package symbol and builtin symbol, its local index is
+//   globally consistent.
+// - For non-package symbol, its fully-expanded name is globally
+//   consistent. For now, we require we know the current package
+//   path so we can always expand symbol names. (Otherwise,
+//   symbols with relocations are not considered hashable.)
+//
+// For now, we assume there is no circular dependencies among
+// hashed symbols.
+func (w *writer) contentHash(s *LSym) goobj.HashType {
+	h := sha1.New()
+	// The compiler trims trailing zeros _sometimes_. We just do
+	// it always.
+	h.Write(bytes.TrimRight(s.P, "\x00"))
+	var tmp [14]byte
+	for i := range s.R {
+		r := &s.R[i]
+		binary.LittleEndian.PutUint32(tmp[:4], uint32(r.Off))
+		tmp[4] = r.Siz
+		tmp[5] = uint8(r.Type)
+		binary.LittleEndian.PutUint64(tmp[6:14], uint64(r.Add))
+		h.Write(tmp[:])
+		rs := r.Sym
+		switch rs.PkgIdx {
+		case goobj.PkgIdxHashed64:
+			h.Write([]byte{0})
+			t := contentHash64(rs)
+			h.Write(t[:])
+		case goobj.PkgIdxHashed:
+			h.Write([]byte{1})
+			t := w.contentHash(rs)
+			h.Write(t[:])
+		case goobj.PkgIdxNone:
+			h.Write([]byte{2})
+			io.WriteString(h, rs.Name) // name is already expanded at this point
+		case goobj.PkgIdxBuiltin:
+			h.Write([]byte{3})
+			binary.LittleEndian.PutUint32(tmp[:4], uint32(rs.SymIdx))
+			h.Write(tmp[:4])
+		case goobj.PkgIdxSelf:
+			io.WriteString(h, w.pkgpath)
+			binary.LittleEndian.PutUint32(tmp[:4], uint32(rs.SymIdx))
+			h.Write(tmp[:4])
+		default:
+			io.WriteString(h, rs.Pkg)
+			binary.LittleEndian.PutUint32(tmp[:4], uint32(rs.SymIdx))
+			h.Write(tmp[:4])
+		}
+	}
+	var b goobj.HashType
+	copy(b[:], h.Sum(nil))
+	return b
+}
+
+func makeSymRef(s *LSym) goobj.SymRef {
+	if s == nil {
+		return goobj.SymRef{}
+	}
+	if s.PkgIdx == 0 || !s.Indexed() {
+		fmt.Printf("unindexed symbol reference: %v\n", s)
+		panic("unindexed symbol reference")
+	}
+	return goobj.SymRef{PkgIdx: uint32(s.PkgIdx), SymIdx: uint32(s.SymIdx)}
+}
+
+func (w *writer) Reloc(r *Reloc) {
+	var o goobj.Reloc
+	o.SetOff(r.Off)
+	o.SetSiz(r.Siz)
+	o.SetType(uint8(r.Type))
+	o.SetAdd(r.Add)
+	o.SetSym(makeSymRef(r.Sym))
+	o.Write(w.Writer)
+}
+
+func (w *writer) aux1(typ uint8, rs *LSym) {
+	var o goobj.Aux
+	o.SetType(typ)
+	o.SetSym(makeSymRef(rs))
+	o.Write(w.Writer)
+}
+
+func (w *writer) Aux(s *LSym) {
+	if s.Gotype != nil {
+		w.aux1(goobj.AuxGotype, s.Gotype)
+	}
+	if s.Func != nil {
+		w.aux1(goobj.AuxFuncInfo, s.Func.FuncInfoSym)
+
+		for _, d := range s.Func.Pcln.Funcdata {
+			w.aux1(goobj.AuxFuncdata, d)
+		}
+
+		if s.Func.dwarfInfoSym != nil && s.Func.dwarfInfoSym.Size != 0 {
+			w.aux1(goobj.AuxDwarfInfo, s.Func.dwarfInfoSym)
+		}
+		if s.Func.dwarfLocSym != nil && s.Func.dwarfLocSym.Size != 0 {
+			w.aux1(goobj.AuxDwarfLoc, s.Func.dwarfLocSym)
+		}
+		if s.Func.dwarfRangesSym != nil && s.Func.dwarfRangesSym.Size != 0 {
+			w.aux1(goobj.AuxDwarfRanges, s.Func.dwarfRangesSym)
+		}
+		if s.Func.dwarfDebugLinesSym != nil && s.Func.dwarfDebugLinesSym.Size != 0 {
+			w.aux1(goobj.AuxDwarfLines, s.Func.dwarfDebugLinesSym)
+		}
+	}
+}
+
+// Emits flags of referenced indexed symbols.
+func (w *writer) refFlags() {
+	seen := make(map[*LSym]bool)
+	w.ctxt.traverseSyms(traverseRefs, func(rs *LSym) { // only traverse refs, not auxs, as tools don't need auxs
+		switch rs.PkgIdx {
+		case goobj.PkgIdxNone, goobj.PkgIdxHashed64, goobj.PkgIdxHashed, goobj.PkgIdxBuiltin, goobj.PkgIdxSelf: // not an external indexed reference
+			return
+		case goobj.PkgIdxInvalid:
+			panic("unindexed symbol reference")
+		}
+		if seen[rs] {
+			return
+		}
+		seen[rs] = true
+		symref := makeSymRef(rs)
+		flag2 := uint8(0)
+		if rs.UsedInIface() {
+			flag2 |= goobj.SymFlagUsedInIface
+		}
+		if flag2 == 0 {
+			return // no need to write zero flags
+		}
+		var o goobj.RefFlags
+		o.SetSym(symref)
+		o.SetFlag2(flag2)
+		o.Write(w.Writer)
+	})
+}
+
+// Emits names of referenced indexed symbols, used by tools (objdump, nm)
+// only.
+func (w *writer) refNames() {
+	seen := make(map[*LSym]bool)
+	w.ctxt.traverseSyms(traverseRefs, func(rs *LSym) { // only traverse refs, not auxs, as tools don't need auxs
+		switch rs.PkgIdx {
+		case goobj.PkgIdxNone, goobj.PkgIdxHashed64, goobj.PkgIdxHashed, goobj.PkgIdxBuiltin, goobj.PkgIdxSelf: // not an external indexed reference
+			return
+		case goobj.PkgIdxInvalid:
+			panic("unindexed symbol reference")
+		}
+		if seen[rs] {
+			return
+		}
+		seen[rs] = true
+		symref := makeSymRef(rs)
+		var o goobj.RefName
+		o.SetSym(symref)
+		o.SetName(rs.Name, w.Writer)
+		o.Write(w.Writer)
+	})
+	// TODO: output in sorted order?
+	// Currently tools (cmd/internal/goobj package) doesn't use mmap,
+	// and it just read it into a map in memory upfront. If it uses
+	// mmap, if the output is sorted, it probably could avoid reading
+	// into memory and just do lookups in the mmap'd object file.
+}
+
+// return the number of aux symbols s have.
+func nAuxSym(s *LSym) int {
+	n := 0
+	if s.Gotype != nil {
+		n++
+	}
+	if s.Func != nil {
+		// FuncInfo is an aux symbol, each Funcdata is an aux symbol
+		n += 1 + len(s.Func.Pcln.Funcdata)
+		if s.Func.dwarfInfoSym != nil && s.Func.dwarfInfoSym.Size != 0 {
+			n++
+		}
+		if s.Func.dwarfLocSym != nil && s.Func.dwarfLocSym.Size != 0 {
+			n++
+		}
+		if s.Func.dwarfRangesSym != nil && s.Func.dwarfRangesSym.Size != 0 {
+			n++
+		}
+		if s.Func.dwarfDebugLinesSym != nil && s.Func.dwarfDebugLinesSym.Size != 0 {
+			n++
+		}
+	}
+	return n
+}
+
+// generate symbols for FuncInfo.
+func genFuncInfoSyms(ctxt *Link) {
+	infosyms := make([]*LSym, 0, len(ctxt.Text))
+	var pcdataoff uint32
+	var b bytes.Buffer
+	symidx := int32(len(ctxt.defs))
+	for _, s := range ctxt.Text {
+		if s.Func == nil {
+			continue
+		}
+		o := goobj.FuncInfo{
+			Args:   uint32(s.Func.Args),
+			Locals: uint32(s.Func.Locals),
+			FuncID: objabi.FuncID(s.Func.FuncID),
+		}
+		pc := &s.Func.Pcln
+		o.Pcsp = pcdataoff
+		pcdataoff += uint32(len(pc.Pcsp.P))
+		o.Pcfile = pcdataoff
+		pcdataoff += uint32(len(pc.Pcfile.P))
+		o.Pcline = pcdataoff
+		pcdataoff += uint32(len(pc.Pcline.P))
+		o.Pcinline = pcdataoff
+		pcdataoff += uint32(len(pc.Pcinline.P))
+		o.Pcdata = make([]uint32, len(pc.Pcdata))
+		for i, pcd := range pc.Pcdata {
+			o.Pcdata[i] = pcdataoff
+			pcdataoff += uint32(len(pcd.P))
+		}
+		o.PcdataEnd = pcdataoff
+		o.Funcdataoff = make([]uint32, len(pc.Funcdataoff))
+		for i, x := range pc.Funcdataoff {
+			o.Funcdataoff[i] = uint32(x)
+		}
+		i := 0
+		o.File = make([]goobj.CUFileIndex, len(pc.UsedFiles))
+		for f := range pc.UsedFiles {
+			o.File[i] = f
+			i++
+		}
+		sort.Slice(o.File, func(i, j int) bool { return o.File[i] < o.File[j] })
+		o.InlTree = make([]goobj.InlTreeNode, len(pc.InlTree.nodes))
+		for i, inl := range pc.InlTree.nodes {
+			f, l := getFileIndexAndLine(ctxt, inl.Pos)
+			o.InlTree[i] = goobj.InlTreeNode{
+				Parent:   int32(inl.Parent),
+				File:     goobj.CUFileIndex(f),
+				Line:     l,
+				Func:     makeSymRef(inl.Func),
+				ParentPC: inl.ParentPC,
+			}
+		}
+
+		o.Write(&b)
+		isym := &LSym{
+			Type:   objabi.SDATA, // for now, I don't think it matters
+			PkgIdx: goobj.PkgIdxSelf,
+			SymIdx: symidx,
+			P:      append([]byte(nil), b.Bytes()...),
+		}
+		isym.Set(AttrIndexed, true)
+		symidx++
+		infosyms = append(infosyms, isym)
+		s.Func.FuncInfoSym = isym
+		b.Reset()
+
+		dwsyms := []*LSym{s.Func.dwarfRangesSym, s.Func.dwarfLocSym, s.Func.dwarfDebugLinesSym, s.Func.dwarfInfoSym}
+		for _, s := range dwsyms {
+			if s == nil || s.Size == 0 {
+				continue
+			}
+			s.PkgIdx = goobj.PkgIdxSelf
+			s.SymIdx = symidx
+			s.Set(AttrIndexed, true)
+			symidx++
+			infosyms = append(infosyms, s)
+		}
+	}
+	ctxt.defs = append(ctxt.defs, infosyms...)
+}
+
+// debugDumpAux is a dumper for selected aux symbols.
+func writeAuxSymDebug(ctxt *Link, par *LSym, aux *LSym) {
+	// Most aux symbols (ex: funcdata) are not interesting--
+	// pick out just the DWARF ones for now.
+	if aux.Type != objabi.SDWARFLOC &&
+		aux.Type != objabi.SDWARFFCN &&
+		aux.Type != objabi.SDWARFABSFCN &&
+		aux.Type != objabi.SDWARFLINES &&
+		aux.Type != objabi.SDWARFRANGE {
+		return
+	}
+	ctxt.writeSymDebugNamed(aux, "aux for "+par.Name)
+}
+
+func debugAsmEmit(ctxt *Link) {
+	if ctxt.Debugasm > 0 {
+		ctxt.traverseSyms(traverseDefs, ctxt.writeSymDebug)
+		if ctxt.Debugasm > 1 {
+			fn := func(par *LSym, aux *LSym) {
+				writeAuxSymDebug(ctxt, par, aux)
+			}
+			ctxt.traverseAuxSyms(traverseAux, fn)
+		}
+	}
+}
+
+func (ctxt *Link) writeSymDebug(s *LSym) {
+	ctxt.writeSymDebugNamed(s, s.Name)
+}
+
+func (ctxt *Link) writeSymDebugNamed(s *LSym, name string) {
+	ver := ""
+	if ctxt.Debugasm > 1 {
+		ver = fmt.Sprintf("<%d>", s.ABI())
+	}
+	fmt.Fprintf(ctxt.Bso, "%s%s ", name, ver)
+	if s.Type != 0 {
+		fmt.Fprintf(ctxt.Bso, "%v ", s.Type)
+	}
+	if s.Static() {
+		fmt.Fprint(ctxt.Bso, "static ")
+	}
+	if s.DuplicateOK() {
+		fmt.Fprintf(ctxt.Bso, "dupok ")
+	}
+	if s.CFunc() {
+		fmt.Fprintf(ctxt.Bso, "cfunc ")
+	}
+	if s.NoSplit() {
+		fmt.Fprintf(ctxt.Bso, "nosplit ")
+	}
+	if s.TopFrame() {
+		fmt.Fprintf(ctxt.Bso, "topframe ")
+	}
+	fmt.Fprintf(ctxt.Bso, "size=%d", s.Size)
+	if s.Type == objabi.STEXT {
+		fmt.Fprintf(ctxt.Bso, " args=%#x locals=%#x funcid=%#x", uint64(s.Func.Args), uint64(s.Func.Locals), uint64(s.Func.FuncID))
+		if s.Leaf() {
+			fmt.Fprintf(ctxt.Bso, " leaf")
+		}
+	}
+	fmt.Fprintf(ctxt.Bso, "\n")
+	if s.Type == objabi.STEXT {
+		for p := s.Func.Text; p != nil; p = p.Link {
+			fmt.Fprintf(ctxt.Bso, "\t%#04x ", uint(int(p.Pc)))
+			if ctxt.Debugasm > 1 {
+				io.WriteString(ctxt.Bso, p.String())
+			} else {
+				p.InnermostString(ctxt.Bso)
+			}
+			fmt.Fprintln(ctxt.Bso)
+		}
+	}
+	for i := 0; i < len(s.P); i += 16 {
+		fmt.Fprintf(ctxt.Bso, "\t%#04x", uint(i))
+		j := i
+		for ; j < i+16 && j < len(s.P); j++ {
+			fmt.Fprintf(ctxt.Bso, " %02x", s.P[j])
+		}
+		for ; j < i+16; j++ {
+			fmt.Fprintf(ctxt.Bso, "   ")
+		}
+		fmt.Fprintf(ctxt.Bso, "  ")
+		for j = i; j < i+16 && j < len(s.P); j++ {
+			c := int(s.P[j])
+			b := byte('.')
+			if ' ' <= c && c <= 0x7e {
+				b = byte(c)
+			}
+			ctxt.Bso.WriteByte(b)
+		}
+
+		fmt.Fprintf(ctxt.Bso, "\n")
+	}
+
+	sort.Sort(relocByOff(s.R)) // generate stable output
+	for _, r := range s.R {
+		name := ""
+		ver := ""
+		if r.Sym != nil {
+			name = r.Sym.Name
+			if ctxt.Debugasm > 1 {
+				ver = fmt.Sprintf("<%d>", s.ABI())
+			}
+		} else if r.Type == objabi.R_TLS_LE {
+			name = "TLS"
+		}
+		if ctxt.Arch.InFamily(sys.ARM, sys.PPC64) {
+			fmt.Fprintf(ctxt.Bso, "\trel %d+%d t=%d %s%s+%x\n", int(r.Off), r.Siz, r.Type, name, ver, uint64(r.Add))
+		} else {
+			fmt.Fprintf(ctxt.Bso, "\trel %d+%d t=%d %s%s+%d\n", int(r.Off), r.Siz, r.Type, name, ver, r.Add)
+		}
+	}
+}
+
+// relocByOff sorts relocations by their offsets.
+type relocByOff []Reloc
+
+func (x relocByOff) Len() int           { return len(x) }
+func (x relocByOff) Less(i, j int) bool { return x[i].Off < x[j].Off }
+func (x relocByOff) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/pass.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/pass.go
new file mode 100644
index 000000000..09d520b4e
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/pass.go
@@ -0,0 +1,176 @@
+// Inferno utils/6l/pass.c
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/pass.c
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package obj
+
+// Code and data passes.
+
+// brloop returns the ultimate destination of the series of unconditional jumps beginning at p.
+// In the case of an infinite loop, brloop returns nil.
+func brloop(p *Prog) *Prog {
+	c := 0
+	for q := p; q != nil; q = q.To.Target() {
+		if q.As != AJMP || q.To.Target() == nil {
+			return q
+		}
+		c++
+		if c >= 5000 {
+			// infinite loop
+			return nil
+		}
+	}
+	panic("unreachable")
+}
+
+// checkaddr checks that a has an expected encoding, especially TYPE_CONST vs TYPE_ADDR.
+func checkaddr(ctxt *Link, p *Prog, a *Addr) {
+	switch a.Type {
+	case TYPE_NONE, TYPE_REGREG2, TYPE_REGLIST:
+		return
+
+	case TYPE_BRANCH, TYPE_TEXTSIZE:
+		if a.Reg != 0 || a.Index != 0 || a.Scale != 0 || a.Name != 0 {
+			break
+		}
+		return
+
+	case TYPE_MEM:
+		return
+
+	case TYPE_CONST:
+		// TODO(rsc): After fixing SHRQ, check a.Index != 0 too.
+		if a.Name != 0 || a.Sym != nil || a.Reg != 0 {
+			ctxt.Diag("argument is TYPE_CONST, should be TYPE_ADDR, in %v", p)
+			return
+		}
+
+		if a.Reg != 0 || a.Scale != 0 || a.Name != 0 || a.Sym != nil || a.Val != nil {
+			break
+		}
+		return
+
+	case TYPE_FCONST, TYPE_SCONST:
+		if a.Reg != 0 || a.Index != 0 || a.Scale != 0 || a.Name != 0 || a.Offset != 0 || a.Sym != nil {
+			break
+		}
+		return
+
+	case TYPE_REG:
+		// TODO(rsc): After fixing PINSRQ, check a.Offset != 0 too.
+		// TODO(rsc): After fixing SHRQ, check a.Index != 0 too.
+		if a.Scale != 0 || a.Name != 0 || a.Sym != nil {
+			break
+		}
+		return
+
+	case TYPE_ADDR:
+		if a.Val != nil {
+			break
+		}
+		if a.Reg == 0 && a.Index == 0 && a.Scale == 0 && a.Name == 0 && a.Sym == nil {
+			ctxt.Diag("argument is TYPE_ADDR, should be TYPE_CONST, in %v", p)
+		}
+		return
+
+	case TYPE_SHIFT, TYPE_REGREG:
+		if a.Index != 0 || a.Scale != 0 || a.Name != 0 || a.Sym != nil || a.Val != nil {
+			break
+		}
+		return
+
+	case TYPE_INDIR:
+		// Expect sym and name to be set, nothing else.
+		// Technically more is allowed, but this is only used for *name(SB).
+		if a.Reg != 0 || a.Index != 0 || a.Scale != 0 || a.Name == 0 || a.Offset != 0 || a.Sym == nil || a.Val != nil {
+			break
+		}
+		return
+	}
+
+	ctxt.Diag("invalid encoding for argument %v", p)
+}
+
+func linkpatch(ctxt *Link, sym *LSym, newprog ProgAlloc) {
+	for p := sym.Func.Text; p != nil; p = p.Link {
+		checkaddr(ctxt, p, &p.From)
+		if p.GetFrom3() != nil {
+			checkaddr(ctxt, p, p.GetFrom3())
+		}
+		checkaddr(ctxt, p, &p.To)
+
+		if ctxt.Arch.Progedit != nil {
+			ctxt.Arch.Progedit(ctxt, p, newprog)
+		}
+		if p.To.Type != TYPE_BRANCH {
+			continue
+		}
+		if p.To.Val != nil {
+			continue
+		}
+
+		if p.To.Sym != nil {
+			continue
+		}
+		q := sym.Func.Text
+		for q != nil && p.To.Offset != q.Pc {
+			if q.Forwd != nil && p.To.Offset >= q.Forwd.Pc {
+				q = q.Forwd
+			} else {
+				q = q.Link
+			}
+		}
+
+		if q == nil {
+			name := "<nil>"
+			if p.To.Sym != nil {
+				name = p.To.Sym.Name
+			}
+			ctxt.Diag("branch out of range (%#x)\n%v [%s]", uint32(p.To.Offset), p, name)
+			p.To.Type = TYPE_NONE
+		}
+
+		p.To.SetTarget(q)
+	}
+
+	if !ctxt.Flag_optimize {
+		return
+	}
+
+	// Collapse series of jumps to jumps.
+	for p := sym.Func.Text; p != nil; p = p.Link {
+		if p.To.Target() == nil {
+			continue
+		}
+		p.To.SetTarget(brloop(p.To.Target()))
+		if p.To.Target() != nil && p.To.Type == TYPE_BRANCH {
+			p.To.Offset = p.To.Target().Pc
+		}
+	}
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/pcln.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/pcln.go
new file mode 100644
index 000000000..d9a33577e
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/pcln.go
@@ -0,0 +1,413 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package obj
+
+import (
+	"github.com/twitchyliquid64/golang-asm/goobj"
+	"encoding/binary"
+	"log"
+)
+
+// funcpctab writes to dst a pc-value table mapping the code in func to the values
+// returned by valfunc parameterized by arg. The invocation of valfunc to update the
+// current value is, for each p,
+//
+//	val = valfunc(func, val, p, 0, arg);
+//	record val as value at p->pc;
+//	val = valfunc(func, val, p, 1, arg);
+//
+// where func is the function, val is the current value, p is the instruction being
+// considered, and arg can be used to further parameterize valfunc.
+func funcpctab(ctxt *Link, dst *Pcdata, func_ *LSym, desc string, valfunc func(*Link, *LSym, int32, *Prog, int32, interface{}) int32, arg interface{}) {
+	dbg := desc == ctxt.Debugpcln
+
+	dst.P = dst.P[:0]
+
+	if dbg {
+		ctxt.Logf("funcpctab %s [valfunc=%s]\n", func_.Name, desc)
+	}
+
+	val := int32(-1)
+	oldval := val
+	if func_.Func.Text == nil {
+		return
+	}
+
+	pc := func_.Func.Text.Pc
+
+	if dbg {
+		ctxt.Logf("%6x %6d %v\n", uint64(pc), val, func_.Func.Text)
+	}
+
+	buf := make([]byte, binary.MaxVarintLen32)
+	started := false
+	for p := func_.Func.Text; p != nil; p = p.Link {
+		// Update val. If it's not changing, keep going.
+		val = valfunc(ctxt, func_, val, p, 0, arg)
+
+		if val == oldval && started {
+			val = valfunc(ctxt, func_, val, p, 1, arg)
+			if dbg {
+				ctxt.Logf("%6x %6s %v\n", uint64(p.Pc), "", p)
+			}
+			continue
+		}
+
+		// If the pc of the next instruction is the same as the
+		// pc of this instruction, this instruction is not a real
+		// instruction. Keep going, so that we only emit a delta
+		// for a true instruction boundary in the program.
+		if p.Link != nil && p.Link.Pc == p.Pc {
+			val = valfunc(ctxt, func_, val, p, 1, arg)
+			if dbg {
+				ctxt.Logf("%6x %6s %v\n", uint64(p.Pc), "", p)
+			}
+			continue
+		}
+
+		// The table is a sequence of (value, pc) pairs, where each
+		// pair states that the given value is in effect from the current position
+		// up to the given pc, which becomes the new current position.
+		// To generate the table as we scan over the program instructions,
+		// we emit a "(value" when pc == func->value, and then
+		// each time we observe a change in value we emit ", pc) (value".
+		// When the scan is over, we emit the closing ", pc)".
+		//
+		// The table is delta-encoded. The value deltas are signed and
+		// transmitted in zig-zag form, where a complement bit is placed in bit 0,
+		// and the pc deltas are unsigned. Both kinds of deltas are sent
+		// as variable-length little-endian base-128 integers,
+		// where the 0x80 bit indicates that the integer continues.
+
+		if dbg {
+			ctxt.Logf("%6x %6d %v\n", uint64(p.Pc), val, p)
+		}
+
+		if started {
+			pcdelta := (p.Pc - pc) / int64(ctxt.Arch.MinLC)
+			n := binary.PutUvarint(buf, uint64(pcdelta))
+			dst.P = append(dst.P, buf[:n]...)
+			pc = p.Pc
+		}
+
+		delta := val - oldval
+		n := binary.PutVarint(buf, int64(delta))
+		dst.P = append(dst.P, buf[:n]...)
+		oldval = val
+		started = true
+		val = valfunc(ctxt, func_, val, p, 1, arg)
+	}
+
+	if started {
+		if dbg {
+			ctxt.Logf("%6x done\n", uint64(func_.Func.Text.Pc+func_.Size))
+		}
+		v := (func_.Size - pc) / int64(ctxt.Arch.MinLC)
+		if v < 0 {
+			ctxt.Diag("negative pc offset: %v", v)
+		}
+		n := binary.PutUvarint(buf, uint64(v))
+		dst.P = append(dst.P, buf[:n]...)
+		// add terminating varint-encoded 0, which is just 0
+		dst.P = append(dst.P, 0)
+	}
+
+	if dbg {
+		ctxt.Logf("wrote %d bytes to %p\n", len(dst.P), dst)
+		for _, p := range dst.P {
+			ctxt.Logf(" %02x", p)
+		}
+		ctxt.Logf("\n")
+	}
+}
+
+// pctofileline computes either the file number (arg == 0)
+// or the line number (arg == 1) to use at p.
+// Because p.Pos applies to p, phase == 0 (before p)
+// takes care of the update.
+func pctofileline(ctxt *Link, sym *LSym, oldval int32, p *Prog, phase int32, arg interface{}) int32 {
+	if p.As == ATEXT || p.As == ANOP || p.Pos.Line() == 0 || phase == 1 {
+		return oldval
+	}
+	f, l := getFileIndexAndLine(ctxt, p.Pos)
+	if arg == nil {
+		return l
+	}
+	pcln := arg.(*Pcln)
+	pcln.UsedFiles[goobj.CUFileIndex(f)] = struct{}{}
+	return int32(f)
+}
+
+// pcinlineState holds the state used to create a function's inlining
+// tree and the PC-value table that maps PCs to nodes in that tree.
+type pcinlineState struct {
+	globalToLocal map[int]int
+	localTree     InlTree
+}
+
+// addBranch adds a branch from the global inlining tree in ctxt to
+// the function's local inlining tree, returning the index in the local tree.
+func (s *pcinlineState) addBranch(ctxt *Link, globalIndex int) int {
+	if globalIndex < 0 {
+		return -1
+	}
+
+	localIndex, ok := s.globalToLocal[globalIndex]
+	if ok {
+		return localIndex
+	}
+
+	// Since tracebacks don't include column information, we could
+	// use one node for multiple calls of the same function on the
+	// same line (e.g., f(x) + f(y)). For now, we use one node for
+	// each inlined call.
+	call := ctxt.InlTree.nodes[globalIndex]
+	call.Parent = s.addBranch(ctxt, call.Parent)
+	localIndex = len(s.localTree.nodes)
+	s.localTree.nodes = append(s.localTree.nodes, call)
+	s.globalToLocal[globalIndex] = localIndex
+	return localIndex
+}
+
+func (s *pcinlineState) setParentPC(ctxt *Link, globalIndex int, pc int32) {
+	localIndex, ok := s.globalToLocal[globalIndex]
+	if !ok {
+		// We know where to unwind to when we need to unwind a body identified
+		// by globalIndex. But there may be no instructions generated by that
+		// body (it's empty, or its instructions were CSEd with other things, etc.).
+		// In that case, we don't need an unwind entry.
+		// TODO: is this really right? Seems to happen a whole lot...
+		return
+	}
+	s.localTree.setParentPC(localIndex, pc)
+}
+
+// pctoinline computes the index into the local inlining tree to use at p.
+// If p is not the result of inlining, pctoinline returns -1. Because p.Pos
+// applies to p, phase == 0 (before p) takes care of the update.
+func (s *pcinlineState) pctoinline(ctxt *Link, sym *LSym, oldval int32, p *Prog, phase int32, arg interface{}) int32 {
+	if phase == 1 {
+		return oldval
+	}
+
+	posBase := ctxt.PosTable.Pos(p.Pos).Base()
+	if posBase == nil {
+		return -1
+	}
+
+	globalIndex := posBase.InliningIndex()
+	if globalIndex < 0 {
+		return -1
+	}
+
+	if s.globalToLocal == nil {
+		s.globalToLocal = make(map[int]int)
+	}
+
+	return int32(s.addBranch(ctxt, globalIndex))
+}
+
+// pctospadj computes the sp adjustment in effect.
+// It is oldval plus any adjustment made by p itself.
+// The adjustment by p takes effect only after p, so we
+// apply the change during phase == 1.
+func pctospadj(ctxt *Link, sym *LSym, oldval int32, p *Prog, phase int32, arg interface{}) int32 {
+	if oldval == -1 { // starting
+		oldval = 0
+	}
+	if phase == 0 {
+		return oldval
+	}
+	if oldval+p.Spadj < -10000 || oldval+p.Spadj > 1100000000 {
+		ctxt.Diag("overflow in spadj: %d + %d = %d", oldval, p.Spadj, oldval+p.Spadj)
+		ctxt.DiagFlush()
+		log.Fatalf("bad code")
+	}
+
+	return oldval + p.Spadj
+}
+
+// pctopcdata computes the pcdata value in effect at p.
+// A PCDATA instruction sets the value in effect at future
+// non-PCDATA instructions.
+// Since PCDATA instructions have no width in the final code,
+// it does not matter which phase we use for the update.
+func pctopcdata(ctxt *Link, sym *LSym, oldval int32, p *Prog, phase int32, arg interface{}) int32 {
+	if phase == 0 || p.As != APCDATA || p.From.Offset != int64(arg.(uint32)) {
+		return oldval
+	}
+	if int64(int32(p.To.Offset)) != p.To.Offset {
+		ctxt.Diag("overflow in PCDATA instruction: %v", p)
+		ctxt.DiagFlush()
+		log.Fatalf("bad code")
+	}
+
+	return int32(p.To.Offset)
+}
+
+func linkpcln(ctxt *Link, cursym *LSym) {
+	pcln := &cursym.Func.Pcln
+	pcln.UsedFiles = make(map[goobj.CUFileIndex]struct{})
+
+	npcdata := 0
+	nfuncdata := 0
+	for p := cursym.Func.Text; p != nil; p = p.Link {
+		// Find the highest ID of any used PCDATA table. This ignores PCDATA table
+		// that consist entirely of "-1", since that's the assumed default value.
+		//   From.Offset is table ID
+		//   To.Offset is data
+		if p.As == APCDATA && p.From.Offset >= int64(npcdata) && p.To.Offset != -1 { // ignore -1 as we start at -1, if we only see -1, nothing changed
+			npcdata = int(p.From.Offset + 1)
+		}
+		// Find the highest ID of any FUNCDATA table.
+		//   From.Offset is table ID
+		if p.As == AFUNCDATA && p.From.Offset >= int64(nfuncdata) {
+			nfuncdata = int(p.From.Offset + 1)
+		}
+	}
+
+	pcln.Pcdata = make([]Pcdata, npcdata)
+	pcln.Pcdata = pcln.Pcdata[:npcdata]
+	pcln.Funcdata = make([]*LSym, nfuncdata)
+	pcln.Funcdataoff = make([]int64, nfuncdata)
+	pcln.Funcdataoff = pcln.Funcdataoff[:nfuncdata]
+
+	funcpctab(ctxt, &pcln.Pcsp, cursym, "pctospadj", pctospadj, nil)
+	funcpctab(ctxt, &pcln.Pcfile, cursym, "pctofile", pctofileline, pcln)
+	funcpctab(ctxt, &pcln.Pcline, cursym, "pctoline", pctofileline, nil)
+
+	// Check that all the Progs used as inline markers are still reachable.
+	// See issue #40473.
+	inlMarkProgs := make(map[*Prog]struct{}, len(cursym.Func.InlMarks))
+	for _, inlMark := range cursym.Func.InlMarks {
+		inlMarkProgs[inlMark.p] = struct{}{}
+	}
+	for p := cursym.Func.Text; p != nil; p = p.Link {
+		if _, ok := inlMarkProgs[p]; ok {
+			delete(inlMarkProgs, p)
+		}
+	}
+	if len(inlMarkProgs) > 0 {
+		ctxt.Diag("one or more instructions used as inline markers are no longer reachable")
+	}
+
+	pcinlineState := new(pcinlineState)
+	funcpctab(ctxt, &pcln.Pcinline, cursym, "pctoinline", pcinlineState.pctoinline, nil)
+	for _, inlMark := range cursym.Func.InlMarks {
+		pcinlineState.setParentPC(ctxt, int(inlMark.id), int32(inlMark.p.Pc))
+	}
+	pcln.InlTree = pcinlineState.localTree
+	if ctxt.Debugpcln == "pctoinline" && len(pcln.InlTree.nodes) > 0 {
+		ctxt.Logf("-- inlining tree for %s:\n", cursym)
+		dumpInlTree(ctxt, pcln.InlTree)
+		ctxt.Logf("--\n")
+	}
+
+	// tabulate which pc and func data we have.
+	havepc := make([]uint32, (npcdata+31)/32)
+	havefunc := make([]uint32, (nfuncdata+31)/32)
+	for p := cursym.Func.Text; p != nil; p = p.Link {
+		if p.As == AFUNCDATA {
+			if (havefunc[p.From.Offset/32]>>uint64(p.From.Offset%32))&1 != 0 {
+				ctxt.Diag("multiple definitions for FUNCDATA $%d", p.From.Offset)
+			}
+			havefunc[p.From.Offset/32] |= 1 << uint64(p.From.Offset%32)
+		}
+
+		if p.As == APCDATA && p.To.Offset != -1 {
+			havepc[p.From.Offset/32] |= 1 << uint64(p.From.Offset%32)
+		}
+	}
+
+	// pcdata.
+	for i := 0; i < npcdata; i++ {
+		if (havepc[i/32]>>uint(i%32))&1 == 0 {
+			continue
+		}
+		funcpctab(ctxt, &pcln.Pcdata[i], cursym, "pctopcdata", pctopcdata, interface{}(uint32(i)))
+	}
+
+	// funcdata
+	if nfuncdata > 0 {
+		for p := cursym.Func.Text; p != nil; p = p.Link {
+			if p.As != AFUNCDATA {
+				continue
+			}
+			i := int(p.From.Offset)
+			pcln.Funcdataoff[i] = p.To.Offset
+			if p.To.Type != TYPE_CONST {
+				// TODO: Dedup.
+				//funcdata_bytes += p->to.sym->size;
+				pcln.Funcdata[i] = p.To.Sym
+			}
+		}
+	}
+}
+
+// PCIter iterates over encoded pcdata tables.
+type PCIter struct {
+	p       []byte
+	PC      uint32
+	NextPC  uint32
+	PCScale uint32
+	Value   int32
+	start   bool
+	Done    bool
+}
+
+// newPCIter creates a PCIter with a scale factor for the PC step size.
+func NewPCIter(pcScale uint32) *PCIter {
+	it := new(PCIter)
+	it.PCScale = pcScale
+	return it
+}
+
+// Next advances it to the Next pc.
+func (it *PCIter) Next() {
+	it.PC = it.NextPC
+	if it.Done {
+		return
+	}
+	if len(it.p) == 0 {
+		it.Done = true
+		return
+	}
+
+	// Value delta
+	val, n := binary.Varint(it.p)
+	if n <= 0 {
+		log.Fatalf("bad Value varint in pciterNext: read %v", n)
+	}
+	it.p = it.p[n:]
+
+	if val == 0 && !it.start {
+		it.Done = true
+		return
+	}
+
+	it.start = false
+	it.Value += int32(val)
+
+	// pc delta
+	pc, n := binary.Uvarint(it.p)
+	if n <= 0 {
+		log.Fatalf("bad pc varint in pciterNext: read %v", n)
+	}
+	it.p = it.p[n:]
+
+	it.NextPC = it.PC + uint32(pc)*it.PCScale
+}
+
+// init prepares it to iterate over p,
+// and advances it to the first pc.
+func (it *PCIter) Init(p []byte) {
+	it.p = p
+	it.PC = 0
+	it.NextPC = 0
+	it.Value = -1
+	it.start = true
+	it.Done = false
+	it.Next()
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/plist.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/plist.go
new file mode 100644
index 000000000..85074a202
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/plist.go
@@ -0,0 +1,314 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package obj
+
+import (
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"fmt"
+	"strings"
+)
+
+type Plist struct {
+	Firstpc *Prog
+	Curfn   interface{} // holds a *gc.Node, if non-nil
+}
+
+// ProgAlloc is a function that allocates Progs.
+// It is used to provide access to cached/bulk-allocated Progs to the assemblers.
+type ProgAlloc func() *Prog
+
+func Flushplist(ctxt *Link, plist *Plist, newprog ProgAlloc, myimportpath string) {
+	// Build list of symbols, and assign instructions to lists.
+	var curtext *LSym
+	var etext *Prog
+	var text []*LSym
+
+	var plink *Prog
+	for p := plist.Firstpc; p != nil; p = plink {
+		if ctxt.Debugasm > 0 && ctxt.Debugvlog {
+			fmt.Printf("obj: %v\n", p)
+		}
+		plink = p.Link
+		p.Link = nil
+
+		switch p.As {
+		case AEND:
+			continue
+
+		case ATEXT:
+			s := p.From.Sym
+			if s == nil {
+				// func _() { }
+				curtext = nil
+				continue
+			}
+			text = append(text, s)
+			etext = p
+			curtext = s
+			continue
+
+		case AFUNCDATA:
+			// Rewrite reference to go_args_stackmap(SB) to the Go-provided declaration information.
+			if curtext == nil { // func _() {}
+				continue
+			}
+			if p.To.Sym.Name == "go_args_stackmap" {
+				if p.From.Type != TYPE_CONST || p.From.Offset != objabi.FUNCDATA_ArgsPointerMaps {
+					ctxt.Diag("FUNCDATA use of go_args_stackmap(SB) without FUNCDATA_ArgsPointerMaps")
+				}
+				p.To.Sym = ctxt.LookupDerived(curtext, curtext.Name+".args_stackmap")
+			}
+
+		}
+
+		if curtext == nil {
+			etext = nil
+			continue
+		}
+		etext.Link = p
+		etext = p
+	}
+
+	if newprog == nil {
+		newprog = ctxt.NewProg
+	}
+
+	// Add reference to Go arguments for C or assembly functions without them.
+	for _, s := range text {
+		if !strings.HasPrefix(s.Name, "\"\".") {
+			continue
+		}
+		found := false
+		for p := s.Func.Text; p != nil; p = p.Link {
+			if p.As == AFUNCDATA && p.From.Type == TYPE_CONST && p.From.Offset == objabi.FUNCDATA_ArgsPointerMaps {
+				found = true
+				break
+			}
+		}
+
+		if !found {
+			p := Appendp(s.Func.Text, newprog)
+			p.As = AFUNCDATA
+			p.From.Type = TYPE_CONST
+			p.From.Offset = objabi.FUNCDATA_ArgsPointerMaps
+			p.To.Type = TYPE_MEM
+			p.To.Name = NAME_EXTERN
+			p.To.Sym = ctxt.LookupDerived(s, s.Name+".args_stackmap")
+		}
+	}
+
+	// Turn functions into machine code images.
+	for _, s := range text {
+		mkfwd(s)
+		linkpatch(ctxt, s, newprog)
+		ctxt.Arch.Preprocess(ctxt, s, newprog)
+		ctxt.Arch.Assemble(ctxt, s, newprog)
+		if ctxt.Errors > 0 {
+			continue
+		}
+		linkpcln(ctxt, s)
+		if myimportpath != "" {
+			ctxt.populateDWARF(plist.Curfn, s, myimportpath)
+		}
+	}
+}
+
+func (ctxt *Link) InitTextSym(s *LSym, flag int) {
+	if s == nil {
+		// func _() { }
+		return
+	}
+	if s.Func != nil {
+		ctxt.Diag("InitTextSym double init for %s", s.Name)
+	}
+	s.Func = new(FuncInfo)
+	if s.OnList() {
+		ctxt.Diag("symbol %s listed multiple times", s.Name)
+	}
+	name := strings.Replace(s.Name, "\"\"", ctxt.Pkgpath, -1)
+	s.Func.FuncID = objabi.GetFuncID(name, flag&WRAPPER != 0)
+	s.Set(AttrOnList, true)
+	s.Set(AttrDuplicateOK, flag&DUPOK != 0)
+	s.Set(AttrNoSplit, flag&NOSPLIT != 0)
+	s.Set(AttrReflectMethod, flag&REFLECTMETHOD != 0)
+	s.Set(AttrWrapper, flag&WRAPPER != 0)
+	s.Set(AttrNeedCtxt, flag&NEEDCTXT != 0)
+	s.Set(AttrNoFrame, flag&NOFRAME != 0)
+	s.Set(AttrTopFrame, flag&TOPFRAME != 0)
+	s.Type = objabi.STEXT
+	ctxt.Text = append(ctxt.Text, s)
+
+	// Set up DWARF entries for s
+	ctxt.dwarfSym(s)
+}
+
+func (ctxt *Link) Globl(s *LSym, size int64, flag int) {
+	if s.OnList() {
+		ctxt.Diag("symbol %s listed multiple times", s.Name)
+	}
+	s.Set(AttrOnList, true)
+	ctxt.Data = append(ctxt.Data, s)
+	s.Size = size
+	if s.Type == 0 {
+		s.Type = objabi.SBSS
+	}
+	if flag&DUPOK != 0 {
+		s.Set(AttrDuplicateOK, true)
+	}
+	if flag&RODATA != 0 {
+		s.Type = objabi.SRODATA
+	} else if flag&NOPTR != 0 {
+		if s.Type == objabi.SDATA {
+			s.Type = objabi.SNOPTRDATA
+		} else {
+			s.Type = objabi.SNOPTRBSS
+		}
+	} else if flag&TLSBSS != 0 {
+		s.Type = objabi.STLSBSS
+	}
+	if strings.HasPrefix(s.Name, "\"\"."+StaticNamePref) {
+		s.Set(AttrStatic, true)
+	}
+}
+
+// EmitEntryLiveness generates PCDATA Progs after p to switch to the
+// liveness map active at the entry of function s. It returns the last
+// Prog generated.
+func (ctxt *Link) EmitEntryLiveness(s *LSym, p *Prog, newprog ProgAlloc) *Prog {
+	pcdata := ctxt.EmitEntryStackMap(s, p, newprog)
+	pcdata = ctxt.EmitEntryRegMap(s, pcdata, newprog)
+	return pcdata
+}
+
+// Similar to EmitEntryLiveness, but just emit stack map.
+func (ctxt *Link) EmitEntryStackMap(s *LSym, p *Prog, newprog ProgAlloc) *Prog {
+	pcdata := Appendp(p, newprog)
+	pcdata.Pos = s.Func.Text.Pos
+	pcdata.As = APCDATA
+	pcdata.From.Type = TYPE_CONST
+	pcdata.From.Offset = objabi.PCDATA_StackMapIndex
+	pcdata.To.Type = TYPE_CONST
+	pcdata.To.Offset = -1 // pcdata starts at -1 at function entry
+
+	return pcdata
+}
+
+// Similar to EmitEntryLiveness, but just emit register map.
+func (ctxt *Link) EmitEntryRegMap(s *LSym, p *Prog, newprog ProgAlloc) *Prog {
+	pcdata := Appendp(p, newprog)
+	pcdata.Pos = s.Func.Text.Pos
+	pcdata.As = APCDATA
+	pcdata.From.Type = TYPE_CONST
+	pcdata.From.Offset = objabi.PCDATA_RegMapIndex
+	pcdata.To.Type = TYPE_CONST
+	pcdata.To.Offset = -1
+
+	return pcdata
+}
+
+// StartUnsafePoint generates PCDATA Progs after p to mark the
+// beginning of an unsafe point. The unsafe point starts immediately
+// after p.
+// It returns the last Prog generated.
+func (ctxt *Link) StartUnsafePoint(p *Prog, newprog ProgAlloc) *Prog {
+	pcdata := Appendp(p, newprog)
+	pcdata.As = APCDATA
+	pcdata.From.Type = TYPE_CONST
+	pcdata.From.Offset = objabi.PCDATA_RegMapIndex
+	pcdata.To.Type = TYPE_CONST
+	pcdata.To.Offset = objabi.PCDATA_RegMapUnsafe
+
+	return pcdata
+}
+
+// EndUnsafePoint generates PCDATA Progs after p to mark the end of an
+// unsafe point, restoring the register map index to oldval.
+// The unsafe point ends right after p.
+// It returns the last Prog generated.
+func (ctxt *Link) EndUnsafePoint(p *Prog, newprog ProgAlloc, oldval int64) *Prog {
+	pcdata := Appendp(p, newprog)
+	pcdata.As = APCDATA
+	pcdata.From.Type = TYPE_CONST
+	pcdata.From.Offset = objabi.PCDATA_RegMapIndex
+	pcdata.To.Type = TYPE_CONST
+	pcdata.To.Offset = oldval
+
+	return pcdata
+}
+
+// MarkUnsafePoints inserts PCDATAs to mark nonpreemptible and restartable
+// instruction sequences, based on isUnsafePoint and isRestartable predicate.
+// p0 is the start of the instruction stream.
+// isUnsafePoint(p) returns true if p is not safe for async preemption.
+// isRestartable(p) returns true if we can restart at the start of p (this Prog)
+// upon async preemption. (Currently multi-Prog restartable sequence is not
+// supported.)
+// isRestartable can be nil. In this case it is treated as always returning false.
+// If isUnsafePoint(p) and isRestartable(p) are both true, it is treated as
+// an unsafe point.
+func MarkUnsafePoints(ctxt *Link, p0 *Prog, newprog ProgAlloc, isUnsafePoint, isRestartable func(*Prog) bool) {
+	if isRestartable == nil {
+		// Default implementation: nothing is restartable.
+		isRestartable = func(*Prog) bool { return false }
+	}
+	prev := p0
+	prevPcdata := int64(-1) // entry PC data value
+	prevRestart := int64(0)
+	for p := prev.Link; p != nil; p, prev = p.Link, p {
+		if p.As == APCDATA && p.From.Offset == objabi.PCDATA_RegMapIndex {
+			prevPcdata = p.To.Offset
+			continue
+		}
+		if prevPcdata == objabi.PCDATA_RegMapUnsafe {
+			continue // already unsafe
+		}
+		if isUnsafePoint(p) {
+			q := ctxt.StartUnsafePoint(prev, newprog)
+			q.Pc = p.Pc
+			q.Link = p
+			// Advance to the end of unsafe point.
+			for p.Link != nil && isUnsafePoint(p.Link) {
+				p = p.Link
+			}
+			if p.Link == nil {
+				break // Reached the end, don't bother marking the end
+			}
+			p = ctxt.EndUnsafePoint(p, newprog, prevPcdata)
+			p.Pc = p.Link.Pc
+			continue
+		}
+		if isRestartable(p) {
+			val := int64(objabi.PCDATA_Restart1)
+			if val == prevRestart {
+				val = objabi.PCDATA_Restart2
+			}
+			prevRestart = val
+			q := Appendp(prev, newprog)
+			q.As = APCDATA
+			q.From.Type = TYPE_CONST
+			q.From.Offset = objabi.PCDATA_RegMapIndex
+			q.To.Type = TYPE_CONST
+			q.To.Offset = val
+			q.Pc = p.Pc
+			q.Link = p
+
+			if p.Link == nil {
+				break // Reached the end, don't bother marking the end
+			}
+			if isRestartable(p.Link) {
+				// Next Prog is also restartable. No need to mark the end
+				// of this sequence. We'll just go ahead mark the next one.
+				continue
+			}
+			p = Appendp(p, newprog)
+			p.As = APCDATA
+			p.From.Type = TYPE_CONST
+			p.From.Offset = objabi.PCDATA_RegMapIndex
+			p.To.Type = TYPE_CONST
+			p.To.Offset = prevPcdata
+			p.Pc = p.Link.Pc
+		}
+	}
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/a.out.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/a.out.go
new file mode 100644
index 000000000..ae02aa6e8
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/a.out.go
@@ -0,0 +1,1032 @@
+// cmd/9c/9.out.h from Vita Nuova.
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2008 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package ppc64
+
+import "github.com/twitchyliquid64/golang-asm/obj"
+
+//go:generate go run ../stringer.go -i $GOFILE -o anames.go -p ppc64
+
+/*
+ * powerpc 64
+ */
+const (
+	NSNAME = 8
+	NSYM   = 50
+	NREG   = 32 /* number of general registers */
+	NFREG  = 32 /* number of floating point registers */
+)
+
+const (
+	/* RBasePPC64 = 4096 */
+	/* R0=4096 ... R31=4127 */
+	REG_R0 = obj.RBasePPC64 + iota
+	REG_R1
+	REG_R2
+	REG_R3
+	REG_R4
+	REG_R5
+	REG_R6
+	REG_R7
+	REG_R8
+	REG_R9
+	REG_R10
+	REG_R11
+	REG_R12
+	REG_R13
+	REG_R14
+	REG_R15
+	REG_R16
+	REG_R17
+	REG_R18
+	REG_R19
+	REG_R20
+	REG_R21
+	REG_R22
+	REG_R23
+	REG_R24
+	REG_R25
+	REG_R26
+	REG_R27
+	REG_R28
+	REG_R29
+	REG_R30
+	REG_R31
+
+	/* F0=4128 ... F31=4159 */
+	REG_F0
+	REG_F1
+	REG_F2
+	REG_F3
+	REG_F4
+	REG_F5
+	REG_F6
+	REG_F7
+	REG_F8
+	REG_F9
+	REG_F10
+	REG_F11
+	REG_F12
+	REG_F13
+	REG_F14
+	REG_F15
+	REG_F16
+	REG_F17
+	REG_F18
+	REG_F19
+	REG_F20
+	REG_F21
+	REG_F22
+	REG_F23
+	REG_F24
+	REG_F25
+	REG_F26
+	REG_F27
+	REG_F28
+	REG_F29
+	REG_F30
+	REG_F31
+
+	/* V0=4160 ... V31=4191 */
+	REG_V0
+	REG_V1
+	REG_V2
+	REG_V3
+	REG_V4
+	REG_V5
+	REG_V6
+	REG_V7
+	REG_V8
+	REG_V9
+	REG_V10
+	REG_V11
+	REG_V12
+	REG_V13
+	REG_V14
+	REG_V15
+	REG_V16
+	REG_V17
+	REG_V18
+	REG_V19
+	REG_V20
+	REG_V21
+	REG_V22
+	REG_V23
+	REG_V24
+	REG_V25
+	REG_V26
+	REG_V27
+	REG_V28
+	REG_V29
+	REG_V30
+	REG_V31
+
+	/* VS0=4192 ... VS63=4255 */
+	REG_VS0
+	REG_VS1
+	REG_VS2
+	REG_VS3
+	REG_VS4
+	REG_VS5
+	REG_VS6
+	REG_VS7
+	REG_VS8
+	REG_VS9
+	REG_VS10
+	REG_VS11
+	REG_VS12
+	REG_VS13
+	REG_VS14
+	REG_VS15
+	REG_VS16
+	REG_VS17
+	REG_VS18
+	REG_VS19
+	REG_VS20
+	REG_VS21
+	REG_VS22
+	REG_VS23
+	REG_VS24
+	REG_VS25
+	REG_VS26
+	REG_VS27
+	REG_VS28
+	REG_VS29
+	REG_VS30
+	REG_VS31
+	REG_VS32
+	REG_VS33
+	REG_VS34
+	REG_VS35
+	REG_VS36
+	REG_VS37
+	REG_VS38
+	REG_VS39
+	REG_VS40
+	REG_VS41
+	REG_VS42
+	REG_VS43
+	REG_VS44
+	REG_VS45
+	REG_VS46
+	REG_VS47
+	REG_VS48
+	REG_VS49
+	REG_VS50
+	REG_VS51
+	REG_VS52
+	REG_VS53
+	REG_VS54
+	REG_VS55
+	REG_VS56
+	REG_VS57
+	REG_VS58
+	REG_VS59
+	REG_VS60
+	REG_VS61
+	REG_VS62
+	REG_VS63
+
+	REG_CR0
+	REG_CR1
+	REG_CR2
+	REG_CR3
+	REG_CR4
+	REG_CR5
+	REG_CR6
+	REG_CR7
+
+	REG_MSR
+	REG_FPSCR
+	REG_CR
+
+	REG_SPECIAL = REG_CR0
+
+	REG_SPR0 = obj.RBasePPC64 + 1024 // first of 1024 registers
+	REG_DCR0 = obj.RBasePPC64 + 2048 // first of 1024 registers
+
+	REG_XER = REG_SPR0 + 1
+	REG_LR  = REG_SPR0 + 8
+	REG_CTR = REG_SPR0 + 9
+
+	REGZERO = REG_R0 /* set to zero */
+	REGSP   = REG_R1
+	REGSB   = REG_R2
+	REGRET  = REG_R3
+	REGARG  = -1      /* -1 disables passing the first argument in register */
+	REGRT1  = REG_R3  /* reserved for runtime, duffzero and duffcopy */
+	REGRT2  = REG_R4  /* reserved for runtime, duffcopy */
+	REGMIN  = REG_R7  /* register variables allocated from here to REGMAX */
+	REGCTXT = REG_R11 /* context for closures */
+	REGTLS  = REG_R13 /* C ABI TLS base pointer */
+	REGMAX  = REG_R27
+	REGEXT  = REG_R30 /* external registers allocated from here down */
+	REGG    = REG_R30 /* G */
+	REGTMP  = REG_R31 /* used by the linker */
+	FREGRET = REG_F0
+	FREGMIN = REG_F17 /* first register variable */
+	FREGMAX = REG_F26 /* last register variable for 9g only */
+	FREGEXT = REG_F26 /* first external register */
+)
+
+// OpenPOWER ABI for Linux Supplement Power Architecture 64-Bit ELF V2 ABI
+// https://openpowerfoundation.org/?resource_lib=64-bit-elf-v2-abi-specification-power-architecture
+var PPC64DWARFRegisters = map[int16]int16{}
+
+func init() {
+	// f assigns dwarfregister[from:to] = (base):(to-from+base)
+	f := func(from, to, base int16) {
+		for r := int16(from); r <= to; r++ {
+			PPC64DWARFRegisters[r] = r - from + base
+		}
+	}
+	f(REG_R0, REG_R31, 0)
+	f(REG_F0, REG_F31, 32)
+	f(REG_V0, REG_V31, 77)
+	f(REG_CR0, REG_CR7, 68)
+
+	f(REG_VS0, REG_VS31, 32)  // overlaps F0-F31
+	f(REG_VS32, REG_VS63, 77) // overlaps V0-V31
+	PPC64DWARFRegisters[REG_LR] = 65
+	PPC64DWARFRegisters[REG_CTR] = 66
+	PPC64DWARFRegisters[REG_XER] = 76
+}
+
+/*
+ * GENERAL:
+ *
+ * compiler allocates R3 up as temps
+ * compiler allocates register variables R7-R27
+ * compiler allocates external registers R30 down
+ *
+ * compiler allocates register variables F17-F26
+ * compiler allocates external registers F26 down
+ */
+const (
+	BIG = 32768 - 8
+)
+
+const (
+	/* mark flags */
+	LABEL   = 1 << 0
+	LEAF    = 1 << 1
+	FLOAT   = 1 << 2
+	BRANCH  = 1 << 3
+	LOAD    = 1 << 4
+	FCMP    = 1 << 5
+	SYNC    = 1 << 6
+	LIST    = 1 << 7
+	FOLL    = 1 << 8
+	NOSCHED = 1 << 9
+)
+
+// Values for use in branch instruction BC
+// BC B0,BI,label
+// BO is type of branch + likely bits described below
+// BI is CR value + branch type
+// ex: BEQ CR2,label is BC 12,10,label
+//   12 = BO_BCR
+//   10 = BI_CR2 + BI_EQ
+
+const (
+	BI_CR0 = 0
+	BI_CR1 = 4
+	BI_CR2 = 8
+	BI_CR3 = 12
+	BI_CR4 = 16
+	BI_CR5 = 20
+	BI_CR6 = 24
+	BI_CR7 = 28
+	BI_LT  = 0
+	BI_GT  = 1
+	BI_EQ  = 2
+	BI_OVF = 3
+)
+
+// Values for the BO field.  Add the branch type to
+// the likely bits, if a likely setting is known.
+// If branch likely or unlikely is not known, don't set it.
+// e.g. branch on cr+likely = 15
+
+const (
+	BO_BCTR     = 16 // branch on ctr value
+	BO_BCR      = 12 // branch on cr value
+	BO_BCRBCTR  = 8  // branch on ctr and cr value
+	BO_NOTBCR   = 4  // branch on not cr value
+	BO_UNLIKELY = 2  // value for unlikely
+	BO_LIKELY   = 3  // value for likely
+)
+
+// Bit settings from the CR
+
+const (
+	C_COND_LT = iota // 0 result is negative
+	C_COND_GT        // 1 result is positive
+	C_COND_EQ        // 2 result is zero
+	C_COND_SO        // 3 summary overflow or FP compare w/ NaN
+)
+
+const (
+	C_NONE = iota
+	C_REG
+	C_FREG
+	C_VREG
+	C_VSREG
+	C_CREG
+	C_SPR /* special processor register */
+	C_ZCON
+	C_SCON   /* 16 bit signed */
+	C_UCON   /* 32 bit signed, low 16 bits 0 */
+	C_ADDCON /* -0x8000 <= v < 0 */
+	C_ANDCON /* 0 < v <= 0xFFFF */
+	C_LCON   /* other 32 */
+	C_DCON   /* other 64 (could subdivide further) */
+	C_SACON  /* $n(REG) where n <= int16 */
+	C_SECON
+	C_LACON /* $n(REG) where int16 < n <= int32 */
+	C_LECON
+	C_DACON /* $n(REG) where int32 < n */
+	C_SBRA
+	C_LBRA
+	C_LBRAPIC
+	C_SAUTO
+	C_LAUTO
+	C_SEXT
+	C_LEXT
+	C_ZOREG // conjecture: either (1) register + zeroed offset, or (2) "R0" implies zero or C_REG
+	C_SOREG // register + signed offset
+	C_LOREG
+	C_FPSCR
+	C_MSR
+	C_XER
+	C_LR
+	C_CTR
+	C_ANY
+	C_GOK
+	C_ADDR
+	C_GOTADDR
+	C_TOCADDR
+	C_TLS_LE
+	C_TLS_IE
+	C_TEXTSIZE
+
+	C_NCLASS /* must be the last */
+)
+
+const (
+	AADD = obj.ABasePPC64 + obj.A_ARCHSPECIFIC + iota
+	AADDCC
+	AADDIS
+	AADDV
+	AADDVCC
+	AADDC
+	AADDCCC
+	AADDCV
+	AADDCVCC
+	AADDME
+	AADDMECC
+	AADDMEVCC
+	AADDMEV
+	AADDE
+	AADDECC
+	AADDEVCC
+	AADDEV
+	AADDZE
+	AADDZECC
+	AADDZEVCC
+	AADDZEV
+	AADDEX
+	AAND
+	AANDCC
+	AANDN
+	AANDNCC
+	AANDISCC
+	ABC
+	ABCL
+	ABEQ
+	ABGE // not LT = G/E/U
+	ABGT
+	ABLE // not GT = L/E/U
+	ABLT
+	ABNE // not EQ = L/G/U
+	ABVC // Unordered-clear
+	ABVS // Unordered-set
+	ACMP
+	ACMPU
+	ACMPEQB
+	ACNTLZW
+	ACNTLZWCC
+	ACRAND
+	ACRANDN
+	ACREQV
+	ACRNAND
+	ACRNOR
+	ACROR
+	ACRORN
+	ACRXOR
+	ADIVW
+	ADIVWCC
+	ADIVWVCC
+	ADIVWV
+	ADIVWU
+	ADIVWUCC
+	ADIVWUVCC
+	ADIVWUV
+	AMODUD
+	AMODUW
+	AMODSD
+	AMODSW
+	AEQV
+	AEQVCC
+	AEXTSB
+	AEXTSBCC
+	AEXTSH
+	AEXTSHCC
+	AFABS
+	AFABSCC
+	AFADD
+	AFADDCC
+	AFADDS
+	AFADDSCC
+	AFCMPO
+	AFCMPU
+	AFCTIW
+	AFCTIWCC
+	AFCTIWZ
+	AFCTIWZCC
+	AFDIV
+	AFDIVCC
+	AFDIVS
+	AFDIVSCC
+	AFMADD
+	AFMADDCC
+	AFMADDS
+	AFMADDSCC
+	AFMOVD
+	AFMOVDCC
+	AFMOVDU
+	AFMOVS
+	AFMOVSU
+	AFMOVSX
+	AFMOVSZ
+	AFMSUB
+	AFMSUBCC
+	AFMSUBS
+	AFMSUBSCC
+	AFMUL
+	AFMULCC
+	AFMULS
+	AFMULSCC
+	AFNABS
+	AFNABSCC
+	AFNEG
+	AFNEGCC
+	AFNMADD
+	AFNMADDCC
+	AFNMADDS
+	AFNMADDSCC
+	AFNMSUB
+	AFNMSUBCC
+	AFNMSUBS
+	AFNMSUBSCC
+	AFRSP
+	AFRSPCC
+	AFSUB
+	AFSUBCC
+	AFSUBS
+	AFSUBSCC
+	AISEL
+	AMOVMW
+	ALBAR
+	ALHAR
+	ALSW
+	ALWAR
+	ALWSYNC
+	AMOVDBR
+	AMOVWBR
+	AMOVB
+	AMOVBU
+	AMOVBZ
+	AMOVBZU
+	AMOVH
+	AMOVHBR
+	AMOVHU
+	AMOVHZ
+	AMOVHZU
+	AMOVW
+	AMOVWU
+	AMOVFL
+	AMOVCRFS
+	AMTFSB0
+	AMTFSB0CC
+	AMTFSB1
+	AMTFSB1CC
+	AMULHW
+	AMULHWCC
+	AMULHWU
+	AMULHWUCC
+	AMULLW
+	AMULLWCC
+	AMULLWVCC
+	AMULLWV
+	ANAND
+	ANANDCC
+	ANEG
+	ANEGCC
+	ANEGVCC
+	ANEGV
+	ANOR
+	ANORCC
+	AOR
+	AORCC
+	AORN
+	AORNCC
+	AORIS
+	AREM
+	AREMU
+	ARFI
+	ARLWMI
+	ARLWMICC
+	ARLWNM
+	ARLWNMCC
+	ACLRLSLWI
+	ASLW
+	ASLWCC
+	ASRW
+	ASRAW
+	ASRAWCC
+	ASRWCC
+	ASTBCCC
+	ASTHCCC
+	ASTSW
+	ASTWCCC
+	ASUB
+	ASUBCC
+	ASUBVCC
+	ASUBC
+	ASUBCCC
+	ASUBCV
+	ASUBCVCC
+	ASUBME
+	ASUBMECC
+	ASUBMEVCC
+	ASUBMEV
+	ASUBV
+	ASUBE
+	ASUBECC
+	ASUBEV
+	ASUBEVCC
+	ASUBZE
+	ASUBZECC
+	ASUBZEVCC
+	ASUBZEV
+	ASYNC
+	AXOR
+	AXORCC
+	AXORIS
+
+	ADCBF
+	ADCBI
+	ADCBST
+	ADCBT
+	ADCBTST
+	ADCBZ
+	AECIWX
+	AECOWX
+	AEIEIO
+	AICBI
+	AISYNC
+	APTESYNC
+	ATLBIE
+	ATLBIEL
+	ATLBSYNC
+	ATW
+
+	ASYSCALL
+	AWORD
+
+	ARFCI
+
+	AFCPSGN
+	AFCPSGNCC
+	/* optional on 32-bit */
+	AFRES
+	AFRESCC
+	AFRIM
+	AFRIMCC
+	AFRIP
+	AFRIPCC
+	AFRIZ
+	AFRIZCC
+	AFRIN
+	AFRINCC
+	AFRSQRTE
+	AFRSQRTECC
+	AFSEL
+	AFSELCC
+	AFSQRT
+	AFSQRTCC
+	AFSQRTS
+	AFSQRTSCC
+
+	/* 64-bit */
+
+	ACNTLZD
+	ACNTLZDCC
+	ACMPW /* CMP with L=0 */
+	ACMPWU
+	ACMPB
+	AFTDIV
+	AFTSQRT
+	ADIVD
+	ADIVDCC
+	ADIVDE
+	ADIVDECC
+	ADIVDEU
+	ADIVDEUCC
+	ADIVDVCC
+	ADIVDV
+	ADIVDU
+	ADIVDUCC
+	ADIVDUVCC
+	ADIVDUV
+	AEXTSW
+	AEXTSWCC
+	/* AFCFIW; AFCFIWCC */
+	AFCFID
+	AFCFIDCC
+	AFCFIDU
+	AFCFIDUCC
+	AFCFIDS
+	AFCFIDSCC
+	AFCTID
+	AFCTIDCC
+	AFCTIDZ
+	AFCTIDZCC
+	ALDAR
+	AMOVD
+	AMOVDU
+	AMOVWZ
+	AMOVWZU
+	AMULHD
+	AMULHDCC
+	AMULHDU
+	AMULHDUCC
+	AMULLD
+	AMULLDCC
+	AMULLDVCC
+	AMULLDV
+	ARFID
+	ARLDMI
+	ARLDMICC
+	ARLDIMI
+	ARLDIMICC
+	ARLDC
+	ARLDCCC
+	ARLDCR
+	ARLDCRCC
+	ARLDICR
+	ARLDICRCC
+	ARLDCL
+	ARLDCLCC
+	ARLDICL
+	ARLDICLCC
+	ARLDIC
+	ARLDICCC
+	ACLRLSLDI
+	AROTL
+	AROTLW
+	ASLBIA
+	ASLBIE
+	ASLBMFEE
+	ASLBMFEV
+	ASLBMTE
+	ASLD
+	ASLDCC
+	ASRD
+	ASRAD
+	ASRADCC
+	ASRDCC
+	ASTDCCC
+	ATD
+
+	/* 64-bit pseudo operation */
+	ADWORD
+	AREMD
+	AREMDU
+
+	/* more 64-bit operations */
+	AHRFID
+	APOPCNTD
+	APOPCNTW
+	APOPCNTB
+	ACNTTZW
+	ACNTTZWCC
+	ACNTTZD
+	ACNTTZDCC
+	ACOPY
+	APASTECC
+	ADARN
+	ALDMX
+	AMADDHD
+	AMADDHDU
+	AMADDLD
+
+	/* Vector */
+	ALV
+	ALVEBX
+	ALVEHX
+	ALVEWX
+	ALVX
+	ALVXL
+	ALVSL
+	ALVSR
+	ASTV
+	ASTVEBX
+	ASTVEHX
+	ASTVEWX
+	ASTVX
+	ASTVXL
+	AVAND
+	AVANDC
+	AVNAND
+	AVOR
+	AVORC
+	AVNOR
+	AVXOR
+	AVEQV
+	AVADDUM
+	AVADDUBM
+	AVADDUHM
+	AVADDUWM
+	AVADDUDM
+	AVADDUQM
+	AVADDCU
+	AVADDCUQ
+	AVADDCUW
+	AVADDUS
+	AVADDUBS
+	AVADDUHS
+	AVADDUWS
+	AVADDSS
+	AVADDSBS
+	AVADDSHS
+	AVADDSWS
+	AVADDE
+	AVADDEUQM
+	AVADDECUQ
+	AVSUBUM
+	AVSUBUBM
+	AVSUBUHM
+	AVSUBUWM
+	AVSUBUDM
+	AVSUBUQM
+	AVSUBCU
+	AVSUBCUQ
+	AVSUBCUW
+	AVSUBUS
+	AVSUBUBS
+	AVSUBUHS
+	AVSUBUWS
+	AVSUBSS
+	AVSUBSBS
+	AVSUBSHS
+	AVSUBSWS
+	AVSUBE
+	AVSUBEUQM
+	AVSUBECUQ
+	AVMULESB
+	AVMULOSB
+	AVMULEUB
+	AVMULOUB
+	AVMULESH
+	AVMULOSH
+	AVMULEUH
+	AVMULOUH
+	AVMULESW
+	AVMULOSW
+	AVMULEUW
+	AVMULOUW
+	AVMULUWM
+	AVPMSUM
+	AVPMSUMB
+	AVPMSUMH
+	AVPMSUMW
+	AVPMSUMD
+	AVMSUMUDM
+	AVR
+	AVRLB
+	AVRLH
+	AVRLW
+	AVRLD
+	AVS
+	AVSLB
+	AVSLH
+	AVSLW
+	AVSL
+	AVSLO
+	AVSRB
+	AVSRH
+	AVSRW
+	AVSR
+	AVSRO
+	AVSLD
+	AVSRD
+	AVSA
+	AVSRAB
+	AVSRAH
+	AVSRAW
+	AVSRAD
+	AVSOI
+	AVSLDOI
+	AVCLZ
+	AVCLZB
+	AVCLZH
+	AVCLZW
+	AVCLZD
+	AVPOPCNT
+	AVPOPCNTB
+	AVPOPCNTH
+	AVPOPCNTW
+	AVPOPCNTD
+	AVCMPEQ
+	AVCMPEQUB
+	AVCMPEQUBCC
+	AVCMPEQUH
+	AVCMPEQUHCC
+	AVCMPEQUW
+	AVCMPEQUWCC
+	AVCMPEQUD
+	AVCMPEQUDCC
+	AVCMPGT
+	AVCMPGTUB
+	AVCMPGTUBCC
+	AVCMPGTUH
+	AVCMPGTUHCC
+	AVCMPGTUW
+	AVCMPGTUWCC
+	AVCMPGTUD
+	AVCMPGTUDCC
+	AVCMPGTSB
+	AVCMPGTSBCC
+	AVCMPGTSH
+	AVCMPGTSHCC
+	AVCMPGTSW
+	AVCMPGTSWCC
+	AVCMPGTSD
+	AVCMPGTSDCC
+	AVCMPNEZB
+	AVCMPNEZBCC
+	AVCMPNEB
+	AVCMPNEBCC
+	AVCMPNEH
+	AVCMPNEHCC
+	AVCMPNEW
+	AVCMPNEWCC
+	AVPERM
+	AVPERMXOR
+	AVPERMR
+	AVBPERMQ
+	AVBPERMD
+	AVSEL
+	AVSPLT
+	AVSPLTB
+	AVSPLTH
+	AVSPLTW
+	AVSPLTI
+	AVSPLTISB
+	AVSPLTISH
+	AVSPLTISW
+	AVCIPH
+	AVCIPHER
+	AVCIPHERLAST
+	AVNCIPH
+	AVNCIPHER
+	AVNCIPHERLAST
+	AVSBOX
+	AVSHASIGMA
+	AVSHASIGMAW
+	AVSHASIGMAD
+	AVMRGEW
+	AVMRGOW
+
+	/* VSX */
+	ALXV
+	ALXVL
+	ALXVLL
+	ALXVD2X
+	ALXVW4X
+	ALXVH8X
+	ALXVB16X
+	ALXVX
+	ALXVDSX
+	ASTXV
+	ASTXVL
+	ASTXVLL
+	ASTXVD2X
+	ASTXVW4X
+	ASTXVH8X
+	ASTXVB16X
+	ASTXVX
+	ALXSDX
+	ASTXSDX
+	ALXSIWAX
+	ALXSIWZX
+	ASTXSIWX
+	AMFVSRD
+	AMFFPRD
+	AMFVRD
+	AMFVSRWZ
+	AMFVSRLD
+	AMTVSRD
+	AMTFPRD
+	AMTVRD
+	AMTVSRWA
+	AMTVSRWZ
+	AMTVSRDD
+	AMTVSRWS
+	AXXLAND
+	AXXLANDC
+	AXXLEQV
+	AXXLNAND
+	AXXLOR
+	AXXLORC
+	AXXLNOR
+	AXXLORQ
+	AXXLXOR
+	AXXSEL
+	AXXMRGHW
+	AXXMRGLW
+	AXXSPLT
+	AXXSPLTW
+	AXXSPLTIB
+	AXXPERM
+	AXXPERMDI
+	AXXSLDWI
+	AXXBRQ
+	AXXBRD
+	AXXBRW
+	AXXBRH
+	AXSCVDPSP
+	AXSCVSPDP
+	AXSCVDPSPN
+	AXSCVSPDPN
+	AXVCVDPSP
+	AXVCVSPDP
+	AXSCVDPSXDS
+	AXSCVDPSXWS
+	AXSCVDPUXDS
+	AXSCVDPUXWS
+	AXSCVSXDDP
+	AXSCVUXDDP
+	AXSCVSXDSP
+	AXSCVUXDSP
+	AXVCVDPSXDS
+	AXVCVDPSXWS
+	AXVCVDPUXDS
+	AXVCVDPUXWS
+	AXVCVSPSXDS
+	AXVCVSPSXWS
+	AXVCVSPUXDS
+	AXVCVSPUXWS
+	AXVCVSXDDP
+	AXVCVSXWDP
+	AXVCVUXDDP
+	AXVCVUXWDP
+	AXVCVSXDSP
+	AXVCVSXWSP
+	AXVCVUXDSP
+	AXVCVUXWSP
+
+	ALAST
+
+	// aliases
+	ABR = obj.AJMP
+	ABL = obj.ACALL
+)
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/anames.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/anames.go
new file mode 100644
index 000000000..582e70d40
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/anames.go
@@ -0,0 +1,615 @@
+// Code generated by stringer -i a.out.go -o anames.go -p ppc64; DO NOT EDIT.
+
+package ppc64
+
+import "github.com/twitchyliquid64/golang-asm/obj"
+
+var Anames = []string{
+	obj.A_ARCHSPECIFIC: "ADD",
+	"ADDCC",
+	"ADDIS",
+	"ADDV",
+	"ADDVCC",
+	"ADDC",
+	"ADDCCC",
+	"ADDCV",
+	"ADDCVCC",
+	"ADDME",
+	"ADDMECC",
+	"ADDMEVCC",
+	"ADDMEV",
+	"ADDE",
+	"ADDECC",
+	"ADDEVCC",
+	"ADDEV",
+	"ADDZE",
+	"ADDZECC",
+	"ADDZEVCC",
+	"ADDZEV",
+	"ADDEX",
+	"AND",
+	"ANDCC",
+	"ANDN",
+	"ANDNCC",
+	"ANDISCC",
+	"BC",
+	"BCL",
+	"BEQ",
+	"BGE",
+	"BGT",
+	"BLE",
+	"BLT",
+	"BNE",
+	"BVC",
+	"BVS",
+	"CMP",
+	"CMPU",
+	"CMPEQB",
+	"CNTLZW",
+	"CNTLZWCC",
+	"CRAND",
+	"CRANDN",
+	"CREQV",
+	"CRNAND",
+	"CRNOR",
+	"CROR",
+	"CRORN",
+	"CRXOR",
+	"DIVW",
+	"DIVWCC",
+	"DIVWVCC",
+	"DIVWV",
+	"DIVWU",
+	"DIVWUCC",
+	"DIVWUVCC",
+	"DIVWUV",
+	"MODUD",
+	"MODUW",
+	"MODSD",
+	"MODSW",
+	"EQV",
+	"EQVCC",
+	"EXTSB",
+	"EXTSBCC",
+	"EXTSH",
+	"EXTSHCC",
+	"FABS",
+	"FABSCC",
+	"FADD",
+	"FADDCC",
+	"FADDS",
+	"FADDSCC",
+	"FCMPO",
+	"FCMPU",
+	"FCTIW",
+	"FCTIWCC",
+	"FCTIWZ",
+	"FCTIWZCC",
+	"FDIV",
+	"FDIVCC",
+	"FDIVS",
+	"FDIVSCC",
+	"FMADD",
+	"FMADDCC",
+	"FMADDS",
+	"FMADDSCC",
+	"FMOVD",
+	"FMOVDCC",
+	"FMOVDU",
+	"FMOVS",
+	"FMOVSU",
+	"FMOVSX",
+	"FMOVSZ",
+	"FMSUB",
+	"FMSUBCC",
+	"FMSUBS",
+	"FMSUBSCC",
+	"FMUL",
+	"FMULCC",
+	"FMULS",
+	"FMULSCC",
+	"FNABS",
+	"FNABSCC",
+	"FNEG",
+	"FNEGCC",
+	"FNMADD",
+	"FNMADDCC",
+	"FNMADDS",
+	"FNMADDSCC",
+	"FNMSUB",
+	"FNMSUBCC",
+	"FNMSUBS",
+	"FNMSUBSCC",
+	"FRSP",
+	"FRSPCC",
+	"FSUB",
+	"FSUBCC",
+	"FSUBS",
+	"FSUBSCC",
+	"ISEL",
+	"MOVMW",
+	"LBAR",
+	"LHAR",
+	"LSW",
+	"LWAR",
+	"LWSYNC",
+	"MOVDBR",
+	"MOVWBR",
+	"MOVB",
+	"MOVBU",
+	"MOVBZ",
+	"MOVBZU",
+	"MOVH",
+	"MOVHBR",
+	"MOVHU",
+	"MOVHZ",
+	"MOVHZU",
+	"MOVW",
+	"MOVWU",
+	"MOVFL",
+	"MOVCRFS",
+	"MTFSB0",
+	"MTFSB0CC",
+	"MTFSB1",
+	"MTFSB1CC",
+	"MULHW",
+	"MULHWCC",
+	"MULHWU",
+	"MULHWUCC",
+	"MULLW",
+	"MULLWCC",
+	"MULLWVCC",
+	"MULLWV",
+	"NAND",
+	"NANDCC",
+	"NEG",
+	"NEGCC",
+	"NEGVCC",
+	"NEGV",
+	"NOR",
+	"NORCC",
+	"OR",
+	"ORCC",
+	"ORN",
+	"ORNCC",
+	"ORIS",
+	"REM",
+	"REMU",
+	"RFI",
+	"RLWMI",
+	"RLWMICC",
+	"RLWNM",
+	"RLWNMCC",
+	"CLRLSLWI",
+	"SLW",
+	"SLWCC",
+	"SRW",
+	"SRAW",
+	"SRAWCC",
+	"SRWCC",
+	"STBCCC",
+	"STHCCC",
+	"STSW",
+	"STWCCC",
+	"SUB",
+	"SUBCC",
+	"SUBVCC",
+	"SUBC",
+	"SUBCCC",
+	"SUBCV",
+	"SUBCVCC",
+	"SUBME",
+	"SUBMECC",
+	"SUBMEVCC",
+	"SUBMEV",
+	"SUBV",
+	"SUBE",
+	"SUBECC",
+	"SUBEV",
+	"SUBEVCC",
+	"SUBZE",
+	"SUBZECC",
+	"SUBZEVCC",
+	"SUBZEV",
+	"SYNC",
+	"XOR",
+	"XORCC",
+	"XORIS",
+	"DCBF",
+	"DCBI",
+	"DCBST",
+	"DCBT",
+	"DCBTST",
+	"DCBZ",
+	"ECIWX",
+	"ECOWX",
+	"EIEIO",
+	"ICBI",
+	"ISYNC",
+	"PTESYNC",
+	"TLBIE",
+	"TLBIEL",
+	"TLBSYNC",
+	"TW",
+	"SYSCALL",
+	"WORD",
+	"RFCI",
+	"FCPSGN",
+	"FCPSGNCC",
+	"FRES",
+	"FRESCC",
+	"FRIM",
+	"FRIMCC",
+	"FRIP",
+	"FRIPCC",
+	"FRIZ",
+	"FRIZCC",
+	"FRIN",
+	"FRINCC",
+	"FRSQRTE",
+	"FRSQRTECC",
+	"FSEL",
+	"FSELCC",
+	"FSQRT",
+	"FSQRTCC",
+	"FSQRTS",
+	"FSQRTSCC",
+	"CNTLZD",
+	"CNTLZDCC",
+	"CMPW",
+	"CMPWU",
+	"CMPB",
+	"FTDIV",
+	"FTSQRT",
+	"DIVD",
+	"DIVDCC",
+	"DIVDE",
+	"DIVDECC",
+	"DIVDEU",
+	"DIVDEUCC",
+	"DIVDVCC",
+	"DIVDV",
+	"DIVDU",
+	"DIVDUCC",
+	"DIVDUVCC",
+	"DIVDUV",
+	"EXTSW",
+	"EXTSWCC",
+	"FCFID",
+	"FCFIDCC",
+	"FCFIDU",
+	"FCFIDUCC",
+	"FCFIDS",
+	"FCFIDSCC",
+	"FCTID",
+	"FCTIDCC",
+	"FCTIDZ",
+	"FCTIDZCC",
+	"LDAR",
+	"MOVD",
+	"MOVDU",
+	"MOVWZ",
+	"MOVWZU",
+	"MULHD",
+	"MULHDCC",
+	"MULHDU",
+	"MULHDUCC",
+	"MULLD",
+	"MULLDCC",
+	"MULLDVCC",
+	"MULLDV",
+	"RFID",
+	"RLDMI",
+	"RLDMICC",
+	"RLDIMI",
+	"RLDIMICC",
+	"RLDC",
+	"RLDCCC",
+	"RLDCR",
+	"RLDCRCC",
+	"RLDICR",
+	"RLDICRCC",
+	"RLDCL",
+	"RLDCLCC",
+	"RLDICL",
+	"RLDICLCC",
+	"RLDIC",
+	"RLDICCC",
+	"CLRLSLDI",
+	"ROTL",
+	"ROTLW",
+	"SLBIA",
+	"SLBIE",
+	"SLBMFEE",
+	"SLBMFEV",
+	"SLBMTE",
+	"SLD",
+	"SLDCC",
+	"SRD",
+	"SRAD",
+	"SRADCC",
+	"SRDCC",
+	"STDCCC",
+	"TD",
+	"DWORD",
+	"REMD",
+	"REMDU",
+	"HRFID",
+	"POPCNTD",
+	"POPCNTW",
+	"POPCNTB",
+	"CNTTZW",
+	"CNTTZWCC",
+	"CNTTZD",
+	"CNTTZDCC",
+	"COPY",
+	"PASTECC",
+	"DARN",
+	"LDMX",
+	"MADDHD",
+	"MADDHDU",
+	"MADDLD",
+	"LV",
+	"LVEBX",
+	"LVEHX",
+	"LVEWX",
+	"LVX",
+	"LVXL",
+	"LVSL",
+	"LVSR",
+	"STV",
+	"STVEBX",
+	"STVEHX",
+	"STVEWX",
+	"STVX",
+	"STVXL",
+	"VAND",
+	"VANDC",
+	"VNAND",
+	"VOR",
+	"VORC",
+	"VNOR",
+	"VXOR",
+	"VEQV",
+	"VADDUM",
+	"VADDUBM",
+	"VADDUHM",
+	"VADDUWM",
+	"VADDUDM",
+	"VADDUQM",
+	"VADDCU",
+	"VADDCUQ",
+	"VADDCUW",
+	"VADDUS",
+	"VADDUBS",
+	"VADDUHS",
+	"VADDUWS",
+	"VADDSS",
+	"VADDSBS",
+	"VADDSHS",
+	"VADDSWS",
+	"VADDE",
+	"VADDEUQM",
+	"VADDECUQ",
+	"VSUBUM",
+	"VSUBUBM",
+	"VSUBUHM",
+	"VSUBUWM",
+	"VSUBUDM",
+	"VSUBUQM",
+	"VSUBCU",
+	"VSUBCUQ",
+	"VSUBCUW",
+	"VSUBUS",
+	"VSUBUBS",
+	"VSUBUHS",
+	"VSUBUWS",
+	"VSUBSS",
+	"VSUBSBS",
+	"VSUBSHS",
+	"VSUBSWS",
+	"VSUBE",
+	"VSUBEUQM",
+	"VSUBECUQ",
+	"VMULESB",
+	"VMULOSB",
+	"VMULEUB",
+	"VMULOUB",
+	"VMULESH",
+	"VMULOSH",
+	"VMULEUH",
+	"VMULOUH",
+	"VMULESW",
+	"VMULOSW",
+	"VMULEUW",
+	"VMULOUW",
+	"VMULUWM",
+	"VPMSUM",
+	"VPMSUMB",
+	"VPMSUMH",
+	"VPMSUMW",
+	"VPMSUMD",
+	"VMSUMUDM",
+	"VR",
+	"VRLB",
+	"VRLH",
+	"VRLW",
+	"VRLD",
+	"VS",
+	"VSLB",
+	"VSLH",
+	"VSLW",
+	"VSL",
+	"VSLO",
+	"VSRB",
+	"VSRH",
+	"VSRW",
+	"VSR",
+	"VSRO",
+	"VSLD",
+	"VSRD",
+	"VSA",
+	"VSRAB",
+	"VSRAH",
+	"VSRAW",
+	"VSRAD",
+	"VSOI",
+	"VSLDOI",
+	"VCLZ",
+	"VCLZB",
+	"VCLZH",
+	"VCLZW",
+	"VCLZD",
+	"VPOPCNT",
+	"VPOPCNTB",
+	"VPOPCNTH",
+	"VPOPCNTW",
+	"VPOPCNTD",
+	"VCMPEQ",
+	"VCMPEQUB",
+	"VCMPEQUBCC",
+	"VCMPEQUH",
+	"VCMPEQUHCC",
+	"VCMPEQUW",
+	"VCMPEQUWCC",
+	"VCMPEQUD",
+	"VCMPEQUDCC",
+	"VCMPGT",
+	"VCMPGTUB",
+	"VCMPGTUBCC",
+	"VCMPGTUH",
+	"VCMPGTUHCC",
+	"VCMPGTUW",
+	"VCMPGTUWCC",
+	"VCMPGTUD",
+	"VCMPGTUDCC",
+	"VCMPGTSB",
+	"VCMPGTSBCC",
+	"VCMPGTSH",
+	"VCMPGTSHCC",
+	"VCMPGTSW",
+	"VCMPGTSWCC",
+	"VCMPGTSD",
+	"VCMPGTSDCC",
+	"VCMPNEZB",
+	"VCMPNEZBCC",
+	"VCMPNEB",
+	"VCMPNEBCC",
+	"VCMPNEH",
+	"VCMPNEHCC",
+	"VCMPNEW",
+	"VCMPNEWCC",
+	"VPERM",
+	"VPERMXOR",
+	"VPERMR",
+	"VBPERMQ",
+	"VBPERMD",
+	"VSEL",
+	"VSPLT",
+	"VSPLTB",
+	"VSPLTH",
+	"VSPLTW",
+	"VSPLTI",
+	"VSPLTISB",
+	"VSPLTISH",
+	"VSPLTISW",
+	"VCIPH",
+	"VCIPHER",
+	"VCIPHERLAST",
+	"VNCIPH",
+	"VNCIPHER",
+	"VNCIPHERLAST",
+	"VSBOX",
+	"VSHASIGMA",
+	"VSHASIGMAW",
+	"VSHASIGMAD",
+	"VMRGEW",
+	"VMRGOW",
+	"LXV",
+	"LXVL",
+	"LXVLL",
+	"LXVD2X",
+	"LXVW4X",
+	"LXVH8X",
+	"LXVB16X",
+	"LXVX",
+	"LXVDSX",
+	"STXV",
+	"STXVL",
+	"STXVLL",
+	"STXVD2X",
+	"STXVW4X",
+	"STXVH8X",
+	"STXVB16X",
+	"STXVX",
+	"LXSDX",
+	"STXSDX",
+	"LXSIWAX",
+	"LXSIWZX",
+	"STXSIWX",
+	"MFVSRD",
+	"MFFPRD",
+	"MFVRD",
+	"MFVSRWZ",
+	"MFVSRLD",
+	"MTVSRD",
+	"MTFPRD",
+	"MTVRD",
+	"MTVSRWA",
+	"MTVSRWZ",
+	"MTVSRDD",
+	"MTVSRWS",
+	"XXLAND",
+	"XXLANDC",
+	"XXLEQV",
+	"XXLNAND",
+	"XXLOR",
+	"XXLORC",
+	"XXLNOR",
+	"XXLORQ",
+	"XXLXOR",
+	"XXSEL",
+	"XXMRGHW",
+	"XXMRGLW",
+	"XXSPLT",
+	"XXSPLTW",
+	"XXSPLTIB",
+	"XXPERM",
+	"XXPERMDI",
+	"XXSLDWI",
+	"XXBRQ",
+	"XXBRD",
+	"XXBRW",
+	"XXBRH",
+	"XSCVDPSP",
+	"XSCVSPDP",
+	"XSCVDPSPN",
+	"XSCVSPDPN",
+	"XVCVDPSP",
+	"XVCVSPDP",
+	"XSCVDPSXDS",
+	"XSCVDPSXWS",
+	"XSCVDPUXDS",
+	"XSCVDPUXWS",
+	"XSCVSXDDP",
+	"XSCVUXDDP",
+	"XSCVSXDSP",
+	"XSCVUXDSP",
+	"XVCVDPSXDS",
+	"XVCVDPSXWS",
+	"XVCVDPUXDS",
+	"XVCVDPUXWS",
+	"XVCVSPSXDS",
+	"XVCVSPSXWS",
+	"XVCVSPUXDS",
+	"XVCVSPUXWS",
+	"XVCVSXDDP",
+	"XVCVSXWDP",
+	"XVCVUXDDP",
+	"XVCVUXWDP",
+	"XVCVSXDSP",
+	"XVCVSXWSP",
+	"XVCVUXDSP",
+	"XVCVUXWSP",
+	"LAST",
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/anames9.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/anames9.go
new file mode 100644
index 000000000..4699a15d3
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/anames9.go
@@ -0,0 +1,51 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ppc64
+
+var cnames9 = []string{
+	"NONE",
+	"REG",
+	"FREG",
+	"VREG",
+	"VSREG",
+	"CREG",
+	"SPR",
+	"ZCON",
+	"SCON",
+	"UCON",
+	"ADDCON",
+	"ANDCON",
+	"LCON",
+	"DCON",
+	"SACON",
+	"SECON",
+	"LACON",
+	"LECON",
+	"DACON",
+	"SBRA",
+	"LBRA",
+	"LBRAPIC",
+	"SAUTO",
+	"LAUTO",
+	"SEXT",
+	"LEXT",
+	"ZOREG",
+	"SOREG",
+	"LOREG",
+	"FPSCR",
+	"MSR",
+	"XER",
+	"LR",
+	"CTR",
+	"ANY",
+	"GOK",
+	"ADDR",
+	"GOTADDR",
+	"TOCADDR",
+	"TLS_LE",
+	"TLS_IE",
+	"TEXTSIZE",
+	"NCLASS",
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/asm9.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/asm9.go
new file mode 100644
index 000000000..f56d87b12
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/asm9.go
@@ -0,0 +1,5367 @@
+// cmd/9l/optab.c, cmd/9l/asmout.c from Vita Nuova.
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2008 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package ppc64
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"encoding/binary"
+	"fmt"
+	"log"
+	"math"
+	"sort"
+)
+
+// ctxt9 holds state while assembling a single function.
+// Each function gets a fresh ctxt9.
+// This allows for multiple functions to be safely concurrently assembled.
+type ctxt9 struct {
+	ctxt       *obj.Link
+	newprog    obj.ProgAlloc
+	cursym     *obj.LSym
+	autosize   int32
+	instoffset int64
+	pc         int64
+}
+
+// Instruction layout.
+
+const (
+	funcAlign     = 16
+	funcAlignMask = funcAlign - 1
+)
+
+const (
+	r0iszero = 1
+)
+
+type Optab struct {
+	as    obj.As // Opcode
+	a1    uint8
+	a2    uint8
+	a3    uint8
+	a4    uint8
+	type_ int8 // cases in asmout below. E.g., 44 = st r,(ra+rb); 45 = ld (ra+rb), r
+	size  int8
+	param int16
+}
+
+// This optab contains a list of opcodes with the operand
+// combinations that are implemented. Not all opcodes are in this
+// table, but are added later in buildop by calling opset for those
+// opcodes which allow the same operand combinations as an opcode
+// already in the table.
+//
+// The type field in the Optabl identifies the case in asmout where
+// the instruction word is assembled.
+var optab = []Optab{
+	{obj.ATEXT, C_LEXT, C_NONE, C_NONE, C_TEXTSIZE, 0, 0, 0},
+	{obj.ATEXT, C_LEXT, C_NONE, C_LCON, C_TEXTSIZE, 0, 0, 0},
+	{obj.ATEXT, C_ADDR, C_NONE, C_NONE, C_TEXTSIZE, 0, 0, 0},
+	{obj.ATEXT, C_ADDR, C_NONE, C_LCON, C_TEXTSIZE, 0, 0, 0},
+	/* move register */
+	{AMOVD, C_REG, C_NONE, C_NONE, C_REG, 1, 4, 0},
+	{AMOVB, C_REG, C_NONE, C_NONE, C_REG, 12, 4, 0},
+	{AMOVBZ, C_REG, C_NONE, C_NONE, C_REG, 13, 4, 0},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_REG, 12, 4, 0},
+	{AMOVWZ, C_REG, C_NONE, C_NONE, C_REG, 13, 4, 0},
+	{AADD, C_REG, C_REG, C_NONE, C_REG, 2, 4, 0},
+	{AADD, C_REG, C_NONE, C_NONE, C_REG, 2, 4, 0},
+	{AADD, C_SCON, C_REG, C_NONE, C_REG, 4, 4, 0},
+	{AADD, C_SCON, C_NONE, C_NONE, C_REG, 4, 4, 0},
+	{AADD, C_ADDCON, C_REG, C_NONE, C_REG, 4, 4, 0},
+	{AADD, C_ADDCON, C_NONE, C_NONE, C_REG, 4, 4, 0},
+	{AADD, C_UCON, C_REG, C_NONE, C_REG, 20, 4, 0},
+	{AADD, C_UCON, C_NONE, C_NONE, C_REG, 20, 4, 0},
+	{AADD, C_ANDCON, C_REG, C_NONE, C_REG, 22, 8, 0},
+	{AADD, C_ANDCON, C_NONE, C_NONE, C_REG, 22, 8, 0},
+	{AADD, C_LCON, C_REG, C_NONE, C_REG, 22, 12, 0},
+	{AADD, C_LCON, C_NONE, C_NONE, C_REG, 22, 12, 0},
+	{AADDIS, C_ADDCON, C_REG, C_NONE, C_REG, 20, 4, 0},
+	{AADDIS, C_ADDCON, C_NONE, C_NONE, C_REG, 20, 4, 0},
+	{AADDC, C_REG, C_REG, C_NONE, C_REG, 2, 4, 0},
+	{AADDC, C_REG, C_NONE, C_NONE, C_REG, 2, 4, 0},
+	{AADDC, C_ADDCON, C_REG, C_NONE, C_REG, 4, 4, 0},
+	{AADDC, C_ADDCON, C_NONE, C_NONE, C_REG, 4, 4, 0},
+	{AADDC, C_LCON, C_REG, C_NONE, C_REG, 22, 12, 0},
+	{AADDC, C_LCON, C_NONE, C_NONE, C_REG, 22, 12, 0},
+	{AAND, C_REG, C_REG, C_NONE, C_REG, 6, 4, 0}, /* logical, no literal */
+	{AAND, C_REG, C_NONE, C_NONE, C_REG, 6, 4, 0},
+	{AANDCC, C_REG, C_REG, C_NONE, C_REG, 6, 4, 0},
+	{AANDCC, C_REG, C_NONE, C_NONE, C_REG, 6, 4, 0},
+	{AANDCC, C_ANDCON, C_NONE, C_NONE, C_REG, 58, 4, 0},
+	{AANDCC, C_ANDCON, C_REG, C_NONE, C_REG, 58, 4, 0},
+	{AANDCC, C_UCON, C_NONE, C_NONE, C_REG, 59, 4, 0},
+	{AANDCC, C_UCON, C_REG, C_NONE, C_REG, 59, 4, 0},
+	{AANDCC, C_ADDCON, C_NONE, C_NONE, C_REG, 23, 8, 0},
+	{AANDCC, C_ADDCON, C_REG, C_NONE, C_REG, 23, 8, 0},
+	{AANDCC, C_LCON, C_NONE, C_NONE, C_REG, 23, 12, 0},
+	{AANDCC, C_LCON, C_REG, C_NONE, C_REG, 23, 12, 0},
+	{AANDISCC, C_ANDCON, C_NONE, C_NONE, C_REG, 59, 4, 0},
+	{AANDISCC, C_ANDCON, C_REG, C_NONE, C_REG, 59, 4, 0},
+	{AMULLW, C_REG, C_REG, C_NONE, C_REG, 2, 4, 0},
+	{AMULLW, C_REG, C_NONE, C_NONE, C_REG, 2, 4, 0},
+	{AMULLW, C_ADDCON, C_REG, C_NONE, C_REG, 4, 4, 0},
+	{AMULLW, C_ADDCON, C_NONE, C_NONE, C_REG, 4, 4, 0},
+	{AMULLW, C_ANDCON, C_REG, C_NONE, C_REG, 4, 4, 0},
+	{AMULLW, C_ANDCON, C_NONE, C_NONE, C_REG, 4, 4, 0},
+	{AMULLW, C_LCON, C_REG, C_NONE, C_REG, 22, 12, 0},
+	{AMULLW, C_LCON, C_NONE, C_NONE, C_REG, 22, 12, 0},
+	{ASUBC, C_REG, C_REG, C_NONE, C_REG, 10, 4, 0},
+	{ASUBC, C_REG, C_NONE, C_NONE, C_REG, 10, 4, 0},
+	{ASUBC, C_REG, C_NONE, C_ADDCON, C_REG, 27, 4, 0},
+	{ASUBC, C_REG, C_NONE, C_LCON, C_REG, 28, 12, 0},
+	{AOR, C_REG, C_REG, C_NONE, C_REG, 6, 4, 0}, /* logical, literal not cc (or/xor) */
+	{AOR, C_REG, C_NONE, C_NONE, C_REG, 6, 4, 0},
+	{AOR, C_ANDCON, C_NONE, C_NONE, C_REG, 58, 4, 0},
+	{AOR, C_ANDCON, C_REG, C_NONE, C_REG, 58, 4, 0},
+	{AOR, C_UCON, C_NONE, C_NONE, C_REG, 59, 4, 0},
+	{AOR, C_UCON, C_REG, C_NONE, C_REG, 59, 4, 0},
+	{AOR, C_ADDCON, C_NONE, C_NONE, C_REG, 23, 8, 0},
+	{AOR, C_ADDCON, C_REG, C_NONE, C_REG, 23, 8, 0},
+	{AOR, C_LCON, C_NONE, C_NONE, C_REG, 23, 12, 0},
+	{AOR, C_LCON, C_REG, C_NONE, C_REG, 23, 12, 0},
+	{AORIS, C_ANDCON, C_NONE, C_NONE, C_REG, 59, 4, 0},
+	{AORIS, C_ANDCON, C_REG, C_NONE, C_REG, 59, 4, 0},
+	{ADIVW, C_REG, C_REG, C_NONE, C_REG, 2, 4, 0}, /* op r1[,r2],r3 */
+	{ADIVW, C_REG, C_NONE, C_NONE, C_REG, 2, 4, 0},
+	{ASUB, C_REG, C_REG, C_NONE, C_REG, 10, 4, 0}, /* op r2[,r1],r3 */
+	{ASUB, C_REG, C_NONE, C_NONE, C_REG, 10, 4, 0},
+	{ASLW, C_REG, C_NONE, C_NONE, C_REG, 6, 4, 0},
+	{ASLW, C_REG, C_REG, C_NONE, C_REG, 6, 4, 0},
+	{ASLD, C_REG, C_NONE, C_NONE, C_REG, 6, 4, 0},
+	{ASLD, C_REG, C_REG, C_NONE, C_REG, 6, 4, 0},
+	{ASLD, C_SCON, C_REG, C_NONE, C_REG, 25, 4, 0},
+	{ASLD, C_SCON, C_NONE, C_NONE, C_REG, 25, 4, 0},
+	{ASLW, C_SCON, C_REG, C_NONE, C_REG, 57, 4, 0},
+	{ASLW, C_SCON, C_NONE, C_NONE, C_REG, 57, 4, 0},
+	{ASRAW, C_REG, C_NONE, C_NONE, C_REG, 6, 4, 0},
+	{ASRAW, C_REG, C_REG, C_NONE, C_REG, 6, 4, 0},
+	{ASRAW, C_SCON, C_REG, C_NONE, C_REG, 56, 4, 0},
+	{ASRAW, C_SCON, C_NONE, C_NONE, C_REG, 56, 4, 0},
+	{ASRAD, C_REG, C_NONE, C_NONE, C_REG, 6, 4, 0},
+	{ASRAD, C_REG, C_REG, C_NONE, C_REG, 6, 4, 0},
+	{ASRAD, C_SCON, C_REG, C_NONE, C_REG, 56, 4, 0},
+	{ASRAD, C_SCON, C_NONE, C_NONE, C_REG, 56, 4, 0},
+	{ARLWMI, C_SCON, C_REG, C_LCON, C_REG, 62, 4, 0},
+	{ARLWMI, C_REG, C_REG, C_LCON, C_REG, 63, 4, 0},
+	{ARLDMI, C_SCON, C_REG, C_LCON, C_REG, 30, 4, 0},
+	{ARLDC, C_SCON, C_REG, C_LCON, C_REG, 29, 4, 0},
+	{ARLDCL, C_SCON, C_REG, C_LCON, C_REG, 29, 4, 0},
+	{ARLDCL, C_REG, C_REG, C_LCON, C_REG, 14, 4, 0},
+	{ARLDICL, C_REG, C_REG, C_LCON, C_REG, 14, 4, 0},
+	{ARLDICL, C_SCON, C_REG, C_LCON, C_REG, 14, 4, 0},
+	{ARLDCL, C_REG, C_NONE, C_LCON, C_REG, 14, 4, 0},
+	{AFADD, C_FREG, C_NONE, C_NONE, C_FREG, 2, 4, 0},
+	{AFADD, C_FREG, C_FREG, C_NONE, C_FREG, 2, 4, 0},
+	{AFABS, C_FREG, C_NONE, C_NONE, C_FREG, 33, 4, 0},
+	{AFABS, C_NONE, C_NONE, C_NONE, C_FREG, 33, 4, 0},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_FREG, 33, 4, 0},
+	{AFMADD, C_FREG, C_FREG, C_FREG, C_FREG, 34, 4, 0},
+	{AFMUL, C_FREG, C_NONE, C_NONE, C_FREG, 32, 4, 0},
+	{AFMUL, C_FREG, C_FREG, C_NONE, C_FREG, 32, 4, 0},
+
+	/* store, short offset */
+	{AMOVD, C_REG, C_REG, C_NONE, C_ZOREG, 7, 4, REGZERO},
+	{AMOVW, C_REG, C_REG, C_NONE, C_ZOREG, 7, 4, REGZERO},
+	{AMOVWZ, C_REG, C_REG, C_NONE, C_ZOREG, 7, 4, REGZERO},
+	{AMOVBZ, C_REG, C_REG, C_NONE, C_ZOREG, 7, 4, REGZERO},
+	{AMOVBZU, C_REG, C_REG, C_NONE, C_ZOREG, 7, 4, REGZERO},
+	{AMOVB, C_REG, C_REG, C_NONE, C_ZOREG, 7, 4, REGZERO},
+	{AMOVBU, C_REG, C_REG, C_NONE, C_ZOREG, 7, 4, REGZERO},
+	{AMOVD, C_REG, C_NONE, C_NONE, C_SEXT, 7, 4, REGSB},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_SEXT, 7, 4, REGSB},
+	{AMOVWZ, C_REG, C_NONE, C_NONE, C_SEXT, 7, 4, REGSB},
+	{AMOVBZ, C_REG, C_NONE, C_NONE, C_SEXT, 7, 4, REGSB},
+	{AMOVB, C_REG, C_NONE, C_NONE, C_SEXT, 7, 4, REGSB},
+	{AMOVD, C_REG, C_NONE, C_NONE, C_SAUTO, 7, 4, REGSP},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_SAUTO, 7, 4, REGSP},
+	{AMOVWZ, C_REG, C_NONE, C_NONE, C_SAUTO, 7, 4, REGSP},
+	{AMOVBZ, C_REG, C_NONE, C_NONE, C_SAUTO, 7, 4, REGSP},
+	{AMOVB, C_REG, C_NONE, C_NONE, C_SAUTO, 7, 4, REGSP},
+	{AMOVD, C_REG, C_NONE, C_NONE, C_SOREG, 7, 4, REGZERO},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_SOREG, 7, 4, REGZERO},
+	{AMOVWZ, C_REG, C_NONE, C_NONE, C_SOREG, 7, 4, REGZERO},
+	{AMOVBZ, C_REG, C_NONE, C_NONE, C_SOREG, 7, 4, REGZERO},
+	{AMOVBZU, C_REG, C_NONE, C_NONE, C_SOREG, 7, 4, REGZERO},
+	{AMOVB, C_REG, C_NONE, C_NONE, C_SOREG, 7, 4, REGZERO},
+	{AMOVBU, C_REG, C_NONE, C_NONE, C_SOREG, 7, 4, REGZERO},
+
+	/* load, short offset */
+	{AMOVD, C_ZOREG, C_REG, C_NONE, C_REG, 8, 4, REGZERO},
+	{AMOVW, C_ZOREG, C_REG, C_NONE, C_REG, 8, 4, REGZERO},
+	{AMOVWZ, C_ZOREG, C_REG, C_NONE, C_REG, 8, 4, REGZERO},
+	{AMOVBZ, C_ZOREG, C_REG, C_NONE, C_REG, 8, 4, REGZERO},
+	{AMOVBZU, C_ZOREG, C_REG, C_NONE, C_REG, 8, 4, REGZERO},
+	{AMOVB, C_ZOREG, C_REG, C_NONE, C_REG, 9, 8, REGZERO},
+	{AMOVBU, C_ZOREG, C_REG, C_NONE, C_REG, 9, 8, REGZERO},
+	{AMOVD, C_SEXT, C_NONE, C_NONE, C_REG, 8, 4, REGSB},
+	{AMOVW, C_SEXT, C_NONE, C_NONE, C_REG, 8, 4, REGSB},
+	{AMOVWZ, C_SEXT, C_NONE, C_NONE, C_REG, 8, 4, REGSB},
+	{AMOVBZ, C_SEXT, C_NONE, C_NONE, C_REG, 8, 4, REGSB},
+	{AMOVB, C_SEXT, C_NONE, C_NONE, C_REG, 9, 8, REGSB},
+	{AMOVD, C_SAUTO, C_NONE, C_NONE, C_REG, 8, 4, REGSP},
+	{AMOVW, C_SAUTO, C_NONE, C_NONE, C_REG, 8, 4, REGSP},
+	{AMOVWZ, C_SAUTO, C_NONE, C_NONE, C_REG, 8, 4, REGSP},
+	{AMOVBZ, C_SAUTO, C_NONE, C_NONE, C_REG, 8, 4, REGSP},
+	{AMOVB, C_SAUTO, C_NONE, C_NONE, C_REG, 9, 8, REGSP},
+	{AMOVD, C_SOREG, C_NONE, C_NONE, C_REG, 8, 4, REGZERO},
+	{AMOVW, C_SOREG, C_NONE, C_NONE, C_REG, 8, 4, REGZERO},
+	{AMOVWZ, C_SOREG, C_NONE, C_NONE, C_REG, 8, 4, REGZERO},
+	{AMOVBZ, C_SOREG, C_NONE, C_NONE, C_REG, 8, 4, REGZERO},
+	{AMOVBZU, C_SOREG, C_NONE, C_NONE, C_REG, 8, 4, REGZERO},
+	{AMOVB, C_SOREG, C_NONE, C_NONE, C_REG, 9, 8, REGZERO},
+	{AMOVBU, C_SOREG, C_NONE, C_NONE, C_REG, 9, 8, REGZERO},
+
+	/* store, long offset */
+	{AMOVD, C_REG, C_NONE, C_NONE, C_LEXT, 35, 8, REGSB},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_LEXT, 35, 8, REGSB},
+	{AMOVWZ, C_REG, C_NONE, C_NONE, C_LEXT, 35, 8, REGSB},
+	{AMOVBZ, C_REG, C_NONE, C_NONE, C_LEXT, 35, 8, REGSB},
+	{AMOVB, C_REG, C_NONE, C_NONE, C_LEXT, 35, 8, REGSB},
+	{AMOVD, C_REG, C_NONE, C_NONE, C_LAUTO, 35, 8, REGSP},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_LAUTO, 35, 8, REGSP},
+	{AMOVWZ, C_REG, C_NONE, C_NONE, C_LAUTO, 35, 8, REGSP},
+	{AMOVBZ, C_REG, C_NONE, C_NONE, C_LAUTO, 35, 8, REGSP},
+	{AMOVB, C_REG, C_NONE, C_NONE, C_LAUTO, 35, 8, REGSP},
+	{AMOVD, C_REG, C_NONE, C_NONE, C_LOREG, 35, 8, REGZERO},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_LOREG, 35, 8, REGZERO},
+	{AMOVWZ, C_REG, C_NONE, C_NONE, C_LOREG, 35, 8, REGZERO},
+	{AMOVBZ, C_REG, C_NONE, C_NONE, C_LOREG, 35, 8, REGZERO},
+	{AMOVB, C_REG, C_NONE, C_NONE, C_LOREG, 35, 8, REGZERO},
+	{AMOVD, C_REG, C_NONE, C_NONE, C_ADDR, 74, 8, 0},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_ADDR, 74, 8, 0},
+	{AMOVWZ, C_REG, C_NONE, C_NONE, C_ADDR, 74, 8, 0},
+	{AMOVBZ, C_REG, C_NONE, C_NONE, C_ADDR, 74, 8, 0},
+	{AMOVB, C_REG, C_NONE, C_NONE, C_ADDR, 74, 8, 0},
+
+	/* load, long offset */
+	{AMOVD, C_LEXT, C_NONE, C_NONE, C_REG, 36, 8, REGSB},
+	{AMOVW, C_LEXT, C_NONE, C_NONE, C_REG, 36, 8, REGSB},
+	{AMOVWZ, C_LEXT, C_NONE, C_NONE, C_REG, 36, 8, REGSB},
+	{AMOVBZ, C_LEXT, C_NONE, C_NONE, C_REG, 36, 8, REGSB},
+	{AMOVB, C_LEXT, C_NONE, C_NONE, C_REG, 37, 12, REGSB},
+	{AMOVD, C_LAUTO, C_NONE, C_NONE, C_REG, 36, 8, REGSP},
+	{AMOVW, C_LAUTO, C_NONE, C_NONE, C_REG, 36, 8, REGSP},
+	{AMOVWZ, C_LAUTO, C_NONE, C_NONE, C_REG, 36, 8, REGSP},
+	{AMOVBZ, C_LAUTO, C_NONE, C_NONE, C_REG, 36, 8, REGSP},
+	{AMOVB, C_LAUTO, C_NONE, C_NONE, C_REG, 37, 12, REGSP},
+	{AMOVD, C_LOREG, C_NONE, C_NONE, C_REG, 36, 8, REGZERO},
+	{AMOVW, C_LOREG, C_NONE, C_NONE, C_REG, 36, 8, REGZERO},
+	{AMOVWZ, C_LOREG, C_NONE, C_NONE, C_REG, 36, 8, REGZERO},
+	{AMOVBZ, C_LOREG, C_NONE, C_NONE, C_REG, 36, 8, REGZERO},
+	{AMOVB, C_LOREG, C_NONE, C_NONE, C_REG, 37, 12, REGZERO},
+	{AMOVD, C_ADDR, C_NONE, C_NONE, C_REG, 75, 8, 0},
+	{AMOVW, C_ADDR, C_NONE, C_NONE, C_REG, 75, 8, 0},
+	{AMOVWZ, C_ADDR, C_NONE, C_NONE, C_REG, 75, 8, 0},
+	{AMOVBZ, C_ADDR, C_NONE, C_NONE, C_REG, 75, 8, 0},
+	{AMOVB, C_ADDR, C_NONE, C_NONE, C_REG, 76, 12, 0},
+
+	{AMOVD, C_TLS_LE, C_NONE, C_NONE, C_REG, 79, 4, 0},
+	{AMOVD, C_TLS_IE, C_NONE, C_NONE, C_REG, 80, 8, 0},
+
+	{AMOVD, C_GOTADDR, C_NONE, C_NONE, C_REG, 81, 8, 0},
+	{AMOVD, C_TOCADDR, C_NONE, C_NONE, C_REG, 95, 8, 0},
+
+	/* load constant */
+	{AMOVD, C_SECON, C_NONE, C_NONE, C_REG, 3, 4, REGSB},
+	{AMOVD, C_SACON, C_NONE, C_NONE, C_REG, 3, 4, REGSP},
+	{AMOVD, C_LECON, C_NONE, C_NONE, C_REG, 26, 8, REGSB},
+	{AMOVD, C_LACON, C_NONE, C_NONE, C_REG, 26, 8, REGSP},
+	{AMOVD, C_ADDCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
+	{AMOVD, C_ANDCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
+	{AMOVW, C_SECON, C_NONE, C_NONE, C_REG, 3, 4, REGSB}, /* TO DO: check */
+	{AMOVW, C_SACON, C_NONE, C_NONE, C_REG, 3, 4, REGSP},
+	{AMOVW, C_LECON, C_NONE, C_NONE, C_REG, 26, 8, REGSB},
+	{AMOVW, C_LACON, C_NONE, C_NONE, C_REG, 26, 8, REGSP},
+	{AMOVW, C_ADDCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
+	{AMOVW, C_ANDCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
+	{AMOVWZ, C_SECON, C_NONE, C_NONE, C_REG, 3, 4, REGSB}, /* TO DO: check */
+	{AMOVWZ, C_SACON, C_NONE, C_NONE, C_REG, 3, 4, REGSP},
+	{AMOVWZ, C_LECON, C_NONE, C_NONE, C_REG, 26, 8, REGSB},
+	{AMOVWZ, C_LACON, C_NONE, C_NONE, C_REG, 26, 8, REGSP},
+	{AMOVWZ, C_ADDCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
+	{AMOVWZ, C_ANDCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
+
+	/* load unsigned/long constants (TO DO: check) */
+	{AMOVD, C_UCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
+	{AMOVD, C_LCON, C_NONE, C_NONE, C_REG, 19, 8, 0},
+	{AMOVW, C_UCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
+	{AMOVW, C_LCON, C_NONE, C_NONE, C_REG, 19, 8, 0},
+	{AMOVWZ, C_UCON, C_NONE, C_NONE, C_REG, 3, 4, REGZERO},
+	{AMOVWZ, C_LCON, C_NONE, C_NONE, C_REG, 19, 8, 0},
+	{AMOVHBR, C_ZOREG, C_REG, C_NONE, C_REG, 45, 4, 0},
+	{AMOVHBR, C_ZOREG, C_NONE, C_NONE, C_REG, 45, 4, 0},
+	{AMOVHBR, C_REG, C_REG, C_NONE, C_ZOREG, 44, 4, 0},
+	{AMOVHBR, C_REG, C_NONE, C_NONE, C_ZOREG, 44, 4, 0},
+	{ASYSCALL, C_NONE, C_NONE, C_NONE, C_NONE, 5, 4, 0},
+	{ASYSCALL, C_REG, C_NONE, C_NONE, C_NONE, 77, 12, 0},
+	{ASYSCALL, C_SCON, C_NONE, C_NONE, C_NONE, 77, 12, 0},
+	{ABEQ, C_NONE, C_NONE, C_NONE, C_SBRA, 16, 4, 0},
+	{ABEQ, C_CREG, C_NONE, C_NONE, C_SBRA, 16, 4, 0},
+	{ABR, C_NONE, C_NONE, C_NONE, C_LBRA, 11, 4, 0},
+	{ABR, C_NONE, C_NONE, C_NONE, C_LBRAPIC, 11, 8, 0},
+	{ABC, C_SCON, C_REG, C_NONE, C_SBRA, 16, 4, 0},
+	{ABC, C_SCON, C_REG, C_NONE, C_LBRA, 17, 4, 0},
+	{ABR, C_NONE, C_NONE, C_NONE, C_LR, 18, 4, 0},
+	{ABR, C_NONE, C_NONE, C_NONE, C_CTR, 18, 4, 0},
+	{ABR, C_REG, C_NONE, C_NONE, C_CTR, 18, 4, 0},
+	{ABR, C_NONE, C_NONE, C_NONE, C_ZOREG, 15, 8, 0},
+	{ABC, C_NONE, C_REG, C_NONE, C_LR, 18, 4, 0},
+	{ABC, C_NONE, C_REG, C_NONE, C_CTR, 18, 4, 0},
+	{ABC, C_SCON, C_REG, C_NONE, C_LR, 18, 4, 0},
+	{ABC, C_SCON, C_REG, C_NONE, C_CTR, 18, 4, 0},
+	{ABC, C_NONE, C_NONE, C_NONE, C_ZOREG, 15, 8, 0},
+	{AFMOVD, C_SEXT, C_NONE, C_NONE, C_FREG, 8, 4, REGSB},
+	{AFMOVD, C_SAUTO, C_NONE, C_NONE, C_FREG, 8, 4, REGSP},
+	{AFMOVD, C_SOREG, C_NONE, C_NONE, C_FREG, 8, 4, REGZERO},
+	{AFMOVD, C_LEXT, C_NONE, C_NONE, C_FREG, 36, 8, REGSB},
+	{AFMOVD, C_LAUTO, C_NONE, C_NONE, C_FREG, 36, 8, REGSP},
+	{AFMOVD, C_LOREG, C_NONE, C_NONE, C_FREG, 36, 8, REGZERO},
+	{AFMOVD, C_ZCON, C_NONE, C_NONE, C_FREG, 24, 4, 0},
+	{AFMOVD, C_ADDCON, C_NONE, C_NONE, C_FREG, 24, 8, 0},
+	{AFMOVD, C_ADDR, C_NONE, C_NONE, C_FREG, 75, 8, 0},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_SEXT, 7, 4, REGSB},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_SAUTO, 7, 4, REGSP},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_SOREG, 7, 4, REGZERO},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_LEXT, 35, 8, REGSB},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_LAUTO, 35, 8, REGSP},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_LOREG, 35, 8, REGZERO},
+	{AFMOVD, C_FREG, C_NONE, C_NONE, C_ADDR, 74, 8, 0},
+	{AFMOVSX, C_ZOREG, C_REG, C_NONE, C_FREG, 45, 4, 0},
+	{AFMOVSX, C_ZOREG, C_NONE, C_NONE, C_FREG, 45, 4, 0},
+	{AFMOVSX, C_FREG, C_REG, C_NONE, C_ZOREG, 44, 4, 0},
+	{AFMOVSX, C_FREG, C_NONE, C_NONE, C_ZOREG, 44, 4, 0},
+	{AFMOVSZ, C_ZOREG, C_REG, C_NONE, C_FREG, 45, 4, 0},
+	{AFMOVSZ, C_ZOREG, C_NONE, C_NONE, C_FREG, 45, 4, 0},
+	{ASYNC, C_NONE, C_NONE, C_NONE, C_NONE, 46, 4, 0},
+	{AWORD, C_LCON, C_NONE, C_NONE, C_NONE, 40, 4, 0},
+	{ADWORD, C_LCON, C_NONE, C_NONE, C_NONE, 31, 8, 0},
+	{ADWORD, C_DCON, C_NONE, C_NONE, C_NONE, 31, 8, 0},
+	{AADDME, C_REG, C_NONE, C_NONE, C_REG, 47, 4, 0},
+	{AEXTSB, C_REG, C_NONE, C_NONE, C_REG, 48, 4, 0},
+	{AEXTSB, C_NONE, C_NONE, C_NONE, C_REG, 48, 4, 0},
+	{AISEL, C_LCON, C_REG, C_REG, C_REG, 84, 4, 0},
+	{AISEL, C_ZCON, C_REG, C_REG, C_REG, 84, 4, 0},
+	{ANEG, C_REG, C_NONE, C_NONE, C_REG, 47, 4, 0},
+	{ANEG, C_NONE, C_NONE, C_NONE, C_REG, 47, 4, 0},
+	{AREM, C_REG, C_NONE, C_NONE, C_REG, 50, 12, 0},
+	{AREM, C_REG, C_REG, C_NONE, C_REG, 50, 12, 0},
+	{AREMU, C_REG, C_NONE, C_NONE, C_REG, 50, 16, 0},
+	{AREMU, C_REG, C_REG, C_NONE, C_REG, 50, 16, 0},
+	{AREMD, C_REG, C_NONE, C_NONE, C_REG, 51, 12, 0},
+	{AREMD, C_REG, C_REG, C_NONE, C_REG, 51, 12, 0},
+	{AMTFSB0, C_SCON, C_NONE, C_NONE, C_NONE, 52, 4, 0},
+	{AMOVFL, C_FPSCR, C_NONE, C_NONE, C_FREG, 53, 4, 0},
+	{AMOVFL, C_FREG, C_NONE, C_NONE, C_FPSCR, 64, 4, 0},
+	{AMOVFL, C_FREG, C_NONE, C_LCON, C_FPSCR, 64, 4, 0},
+	{AMOVFL, C_LCON, C_NONE, C_NONE, C_FPSCR, 65, 4, 0},
+	{AMOVD, C_MSR, C_NONE, C_NONE, C_REG, 54, 4, 0},  /* mfmsr */
+	{AMOVD, C_REG, C_NONE, C_NONE, C_MSR, 54, 4, 0},  /* mtmsrd */
+	{AMOVWZ, C_REG, C_NONE, C_NONE, C_MSR, 54, 4, 0}, /* mtmsr */
+
+	/* Other ISA 2.05+ instructions */
+	{APOPCNTD, C_REG, C_NONE, C_NONE, C_REG, 93, 4, 0}, /* population count, x-form */
+	{ACMPB, C_REG, C_REG, C_NONE, C_REG, 92, 4, 0},     /* compare byte, x-form */
+	{ACMPEQB, C_REG, C_REG, C_NONE, C_CREG, 92, 4, 0},  /* compare equal byte, x-form, ISA 3.0 */
+	{ACMPEQB, C_REG, C_NONE, C_NONE, C_REG, 70, 4, 0},
+	{AFTDIV, C_FREG, C_FREG, C_NONE, C_SCON, 92, 4, 0},  /* floating test for sw divide, x-form */
+	{AFTSQRT, C_FREG, C_NONE, C_NONE, C_SCON, 93, 4, 0}, /* floating test for sw square root, x-form */
+	{ACOPY, C_REG, C_NONE, C_NONE, C_REG, 92, 4, 0},     /* copy/paste facility, x-form */
+	{ADARN, C_SCON, C_NONE, C_NONE, C_REG, 92, 4, 0},    /* deliver random number, x-form */
+	{ALDMX, C_SOREG, C_NONE, C_NONE, C_REG, 45, 4, 0},   /* load doubleword monitored, x-form */
+	{AMADDHD, C_REG, C_REG, C_REG, C_REG, 83, 4, 0},     /* multiply-add high/low doubleword, va-form */
+	{AADDEX, C_REG, C_REG, C_SCON, C_REG, 94, 4, 0},     /* add extended using alternate carry, z23-form */
+	{ACRAND, C_CREG, C_NONE, C_NONE, C_CREG, 2, 4, 0},   /* logical ops for condition registers xl-form */
+
+	/* Vector instructions */
+
+	/* Vector load */
+	{ALV, C_SOREG, C_NONE, C_NONE, C_VREG, 45, 4, 0}, /* vector load, x-form */
+
+	/* Vector store */
+	{ASTV, C_VREG, C_NONE, C_NONE, C_SOREG, 44, 4, 0}, /* vector store, x-form */
+
+	/* Vector logical */
+	{AVAND, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector and, vx-form */
+	{AVOR, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0},  /* vector or, vx-form */
+
+	/* Vector add */
+	{AVADDUM, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector add unsigned modulo, vx-form */
+	{AVADDCU, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector add & write carry unsigned, vx-form */
+	{AVADDUS, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector add unsigned saturate, vx-form */
+	{AVADDSS, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector add signed saturate, vx-form */
+	{AVADDE, C_VREG, C_VREG, C_VREG, C_VREG, 83, 4, 0},  /* vector add extended, va-form */
+
+	/* Vector subtract */
+	{AVSUBUM, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector subtract unsigned modulo, vx-form */
+	{AVSUBCU, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector subtract & write carry unsigned, vx-form */
+	{AVSUBUS, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector subtract unsigned saturate, vx-form */
+	{AVSUBSS, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector subtract signed saturate, vx-form */
+	{AVSUBE, C_VREG, C_VREG, C_VREG, C_VREG, 83, 4, 0},  /* vector subtract extended, va-form */
+
+	/* Vector multiply */
+	{AVMULESB, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 9},  /* vector multiply, vx-form */
+	{AVPMSUM, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0},   /* vector polynomial multiply & sum, vx-form */
+	{AVMSUMUDM, C_VREG, C_VREG, C_VREG, C_VREG, 83, 4, 0}, /* vector multiply-sum, va-form */
+
+	/* Vector rotate */
+	{AVR, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector rotate, vx-form */
+
+	/* Vector shift */
+	{AVS, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0},     /* vector shift, vx-form */
+	{AVSA, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0},    /* vector shift algebraic, vx-form */
+	{AVSOI, C_ANDCON, C_VREG, C_VREG, C_VREG, 83, 4, 0}, /* vector shift by octet immediate, va-form */
+
+	/* Vector count */
+	{AVCLZ, C_VREG, C_NONE, C_NONE, C_VREG, 85, 4, 0},    /* vector count leading zeros, vx-form */
+	{AVPOPCNT, C_VREG, C_NONE, C_NONE, C_VREG, 85, 4, 0}, /* vector population count, vx-form */
+
+	/* Vector compare */
+	{AVCMPEQ, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0},   /* vector compare equal, vc-form */
+	{AVCMPGT, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0},   /* vector compare greater than, vc-form */
+	{AVCMPNEZB, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector compare not equal, vx-form */
+
+	/* Vector merge */
+	{AVMRGOW, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector merge odd word, vx-form */
+
+	/* Vector permute */
+	{AVPERM, C_VREG, C_VREG, C_VREG, C_VREG, 83, 4, 0}, /* vector permute, va-form */
+
+	/* Vector bit permute */
+	{AVBPERMQ, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector bit permute, vx-form */
+
+	/* Vector select */
+	{AVSEL, C_VREG, C_VREG, C_VREG, C_VREG, 83, 4, 0}, /* vector select, va-form */
+
+	/* Vector splat */
+	{AVSPLTB, C_SCON, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector splat, vx-form */
+	{AVSPLTB, C_ADDCON, C_VREG, C_NONE, C_VREG, 82, 4, 0},
+	{AVSPLTISB, C_SCON, C_NONE, C_NONE, C_VREG, 82, 4, 0}, /* vector splat immediate, vx-form */
+	{AVSPLTISB, C_ADDCON, C_NONE, C_NONE, C_VREG, 82, 4, 0},
+
+	/* Vector AES */
+	{AVCIPH, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0},  /* vector AES cipher, vx-form */
+	{AVNCIPH, C_VREG, C_VREG, C_NONE, C_VREG, 82, 4, 0}, /* vector AES inverse cipher, vx-form */
+	{AVSBOX, C_VREG, C_NONE, C_NONE, C_VREG, 82, 4, 0},  /* vector AES subbytes, vx-form */
+
+	/* Vector SHA */
+	{AVSHASIGMA, C_ANDCON, C_VREG, C_ANDCON, C_VREG, 82, 4, 0}, /* vector SHA sigma, vx-form */
+
+	/* VSX vector load */
+	{ALXVD2X, C_SOREG, C_NONE, C_NONE, C_VSREG, 87, 4, 0}, /* vsx vector load, xx1-form */
+	{ALXV, C_SOREG, C_NONE, C_NONE, C_VSREG, 96, 4, 0},    /* vsx vector load, dq-form */
+	{ALXVL, C_REG, C_REG, C_NONE, C_VSREG, 98, 4, 0},      /* vsx vector load length */
+
+	/* VSX vector store */
+	{ASTXVD2X, C_VSREG, C_NONE, C_NONE, C_SOREG, 86, 4, 0}, /* vsx vector store, xx1-form */
+	{ASTXV, C_VSREG, C_NONE, C_NONE, C_SOREG, 97, 4, 0},    /* vsx vector store, dq-form */
+	{ASTXVL, C_VSREG, C_REG, C_NONE, C_REG, 99, 4, 0},      /* vsx vector store with length x-form */
+
+	/* VSX scalar load */
+	{ALXSDX, C_SOREG, C_NONE, C_NONE, C_VSREG, 87, 4, 0}, /* vsx scalar load, xx1-form */
+
+	/* VSX scalar store */
+	{ASTXSDX, C_VSREG, C_NONE, C_NONE, C_SOREG, 86, 4, 0}, /* vsx scalar store, xx1-form */
+
+	/* VSX scalar as integer load */
+	{ALXSIWAX, C_SOREG, C_NONE, C_NONE, C_VSREG, 87, 4, 0}, /* vsx scalar as integer load, xx1-form */
+
+	/* VSX scalar store as integer */
+	{ASTXSIWX, C_VSREG, C_NONE, C_NONE, C_SOREG, 86, 4, 0}, /* vsx scalar as integer store, xx1-form */
+
+	/* VSX move from VSR */
+	{AMFVSRD, C_VSREG, C_NONE, C_NONE, C_REG, 88, 4, 0}, /* vsx move from vsr, xx1-form */
+	{AMFVSRD, C_FREG, C_NONE, C_NONE, C_REG, 88, 4, 0},
+	{AMFVSRD, C_VREG, C_NONE, C_NONE, C_REG, 88, 4, 0},
+
+	/* VSX move to VSR */
+	{AMTVSRD, C_REG, C_NONE, C_NONE, C_VSREG, 88, 4, 0}, /* vsx move to vsr, xx1-form */
+	{AMTVSRD, C_REG, C_REG, C_NONE, C_VSREG, 88, 4, 0},
+	{AMTVSRD, C_REG, C_NONE, C_NONE, C_FREG, 88, 4, 0},
+	{AMTVSRD, C_REG, C_NONE, C_NONE, C_VREG, 88, 4, 0},
+
+	/* VSX logical */
+	{AXXLAND, C_VSREG, C_VSREG, C_NONE, C_VSREG, 90, 4, 0}, /* vsx and, xx3-form */
+	{AXXLOR, C_VSREG, C_VSREG, C_NONE, C_VSREG, 90, 4, 0},  /* vsx or, xx3-form */
+
+	/* VSX select */
+	{AXXSEL, C_VSREG, C_VSREG, C_VSREG, C_VSREG, 91, 4, 0}, /* vsx select, xx4-form */
+
+	/* VSX merge */
+	{AXXMRGHW, C_VSREG, C_VSREG, C_NONE, C_VSREG, 90, 4, 0}, /* vsx merge, xx3-form */
+
+	/* VSX splat */
+	{AXXSPLTW, C_VSREG, C_NONE, C_SCON, C_VSREG, 89, 4, 0},  /* vsx splat, xx2-form */
+	{AXXSPLTIB, C_SCON, C_NONE, C_NONE, C_VSREG, 100, 4, 0}, /* vsx splat, xx2-form */
+
+	/* VSX permute */
+	{AXXPERM, C_VSREG, C_VSREG, C_NONE, C_VSREG, 90, 4, 0}, /* vsx permute, xx3-form */
+
+	/* VSX shift */
+	{AXXSLDWI, C_VSREG, C_VSREG, C_SCON, C_VSREG, 90, 4, 0}, /* vsx shift immediate, xx3-form */
+
+	/* VSX reverse bytes */
+	{AXXBRQ, C_VSREG, C_NONE, C_NONE, C_VSREG, 101, 4, 0}, /* vsx reverse bytes */
+
+	/* VSX scalar FP-FP conversion */
+	{AXSCVDPSP, C_VSREG, C_NONE, C_NONE, C_VSREG, 89, 4, 0}, /* vsx scalar fp-fp conversion, xx2-form */
+
+	/* VSX vector FP-FP conversion */
+	{AXVCVDPSP, C_VSREG, C_NONE, C_NONE, C_VSREG, 89, 4, 0}, /* vsx vector fp-fp conversion, xx2-form */
+
+	/* VSX scalar FP-integer conversion */
+	{AXSCVDPSXDS, C_VSREG, C_NONE, C_NONE, C_VSREG, 89, 4, 0}, /* vsx scalar fp-integer conversion, xx2-form */
+
+	/* VSX scalar integer-FP conversion */
+	{AXSCVSXDDP, C_VSREG, C_NONE, C_NONE, C_VSREG, 89, 4, 0}, /* vsx scalar integer-fp conversion, xx2-form */
+
+	/* VSX vector FP-integer conversion */
+	{AXVCVDPSXDS, C_VSREG, C_NONE, C_NONE, C_VSREG, 89, 4, 0}, /* vsx vector fp-integer conversion, xx2-form */
+
+	/* VSX vector integer-FP conversion */
+	{AXVCVSXDDP, C_VSREG, C_NONE, C_NONE, C_VSREG, 89, 4, 0}, /* vsx vector integer-fp conversion, xx2-form */
+
+	/* 64-bit special registers */
+	{AMOVD, C_REG, C_NONE, C_NONE, C_SPR, 66, 4, 0},
+	{AMOVD, C_REG, C_NONE, C_NONE, C_LR, 66, 4, 0},
+	{AMOVD, C_REG, C_NONE, C_NONE, C_CTR, 66, 4, 0},
+	{AMOVD, C_REG, C_NONE, C_NONE, C_XER, 66, 4, 0},
+	{AMOVD, C_SPR, C_NONE, C_NONE, C_REG, 66, 4, 0},
+	{AMOVD, C_LR, C_NONE, C_NONE, C_REG, 66, 4, 0},
+	{AMOVD, C_CTR, C_NONE, C_NONE, C_REG, 66, 4, 0},
+	{AMOVD, C_XER, C_NONE, C_NONE, C_REG, 66, 4, 0},
+
+	/* 32-bit special registers (gloss over sign-extension or not?) */
+	{AMOVW, C_REG, C_NONE, C_NONE, C_SPR, 66, 4, 0},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_CTR, 66, 4, 0},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_XER, 66, 4, 0},
+	{AMOVW, C_SPR, C_NONE, C_NONE, C_REG, 66, 4, 0},
+	{AMOVW, C_XER, C_NONE, C_NONE, C_REG, 66, 4, 0},
+	{AMOVWZ, C_REG, C_NONE, C_NONE, C_SPR, 66, 4, 0},
+	{AMOVWZ, C_REG, C_NONE, C_NONE, C_CTR, 66, 4, 0},
+	{AMOVWZ, C_REG, C_NONE, C_NONE, C_XER, 66, 4, 0},
+	{AMOVWZ, C_SPR, C_NONE, C_NONE, C_REG, 66, 4, 0},
+	{AMOVWZ, C_XER, C_NONE, C_NONE, C_REG, 66, 4, 0},
+	{AMOVFL, C_FPSCR, C_NONE, C_NONE, C_CREG, 73, 4, 0},
+	{AMOVFL, C_CREG, C_NONE, C_NONE, C_CREG, 67, 4, 0},
+	{AMOVW, C_CREG, C_NONE, C_NONE, C_REG, 68, 4, 0},
+	{AMOVWZ, C_CREG, C_NONE, C_NONE, C_REG, 68, 4, 0},
+	{AMOVFL, C_REG, C_NONE, C_NONE, C_LCON, 69, 4, 0},
+	{AMOVFL, C_REG, C_NONE, C_NONE, C_CREG, 69, 4, 0},
+	{AMOVW, C_REG, C_NONE, C_NONE, C_CREG, 69, 4, 0},
+	{AMOVWZ, C_REG, C_NONE, C_NONE, C_CREG, 69, 4, 0},
+	{ACMP, C_REG, C_NONE, C_NONE, C_REG, 70, 4, 0},
+	{ACMP, C_REG, C_REG, C_NONE, C_REG, 70, 4, 0},
+	{ACMP, C_REG, C_NONE, C_NONE, C_ADDCON, 71, 4, 0},
+	{ACMP, C_REG, C_REG, C_NONE, C_ADDCON, 71, 4, 0},
+	{ACMPU, C_REG, C_NONE, C_NONE, C_REG, 70, 4, 0},
+	{ACMPU, C_REG, C_REG, C_NONE, C_REG, 70, 4, 0},
+	{ACMPU, C_REG, C_NONE, C_NONE, C_ANDCON, 71, 4, 0},
+	{ACMPU, C_REG, C_REG, C_NONE, C_ANDCON, 71, 4, 0},
+	{AFCMPO, C_FREG, C_NONE, C_NONE, C_FREG, 70, 4, 0},
+	{AFCMPO, C_FREG, C_REG, C_NONE, C_FREG, 70, 4, 0},
+	{ATW, C_LCON, C_REG, C_NONE, C_REG, 60, 4, 0},
+	{ATW, C_LCON, C_REG, C_NONE, C_ADDCON, 61, 4, 0},
+	{ADCBF, C_ZOREG, C_NONE, C_NONE, C_NONE, 43, 4, 0},
+	{ADCBF, C_SOREG, C_NONE, C_NONE, C_NONE, 43, 4, 0},
+	{ADCBF, C_ZOREG, C_REG, C_NONE, C_SCON, 43, 4, 0},
+	{ADCBF, C_SOREG, C_NONE, C_NONE, C_SCON, 43, 4, 0},
+	{AECOWX, C_REG, C_REG, C_NONE, C_ZOREG, 44, 4, 0},
+	{AECIWX, C_ZOREG, C_REG, C_NONE, C_REG, 45, 4, 0},
+	{AECOWX, C_REG, C_NONE, C_NONE, C_ZOREG, 44, 4, 0},
+	{AECIWX, C_ZOREG, C_NONE, C_NONE, C_REG, 45, 4, 0},
+	{ALDAR, C_ZOREG, C_NONE, C_NONE, C_REG, 45, 4, 0},
+	{ALDAR, C_ZOREG, C_NONE, C_ANDCON, C_REG, 45, 4, 0},
+	{AEIEIO, C_NONE, C_NONE, C_NONE, C_NONE, 46, 4, 0},
+	{ATLBIE, C_REG, C_NONE, C_NONE, C_NONE, 49, 4, 0},
+	{ATLBIE, C_SCON, C_NONE, C_NONE, C_REG, 49, 4, 0},
+	{ASLBMFEE, C_REG, C_NONE, C_NONE, C_REG, 55, 4, 0},
+	{ASLBMTE, C_REG, C_NONE, C_NONE, C_REG, 55, 4, 0},
+	{ASTSW, C_REG, C_NONE, C_NONE, C_ZOREG, 44, 4, 0},
+	{ASTSW, C_REG, C_NONE, C_LCON, C_ZOREG, 41, 4, 0},
+	{ALSW, C_ZOREG, C_NONE, C_NONE, C_REG, 45, 4, 0},
+	{ALSW, C_ZOREG, C_NONE, C_LCON, C_REG, 42, 4, 0},
+	{obj.AUNDEF, C_NONE, C_NONE, C_NONE, C_NONE, 78, 4, 0},
+	{obj.APCDATA, C_LCON, C_NONE, C_NONE, C_LCON, 0, 0, 0},
+	{obj.AFUNCDATA, C_SCON, C_NONE, C_NONE, C_ADDR, 0, 0, 0},
+	{obj.ANOP, C_NONE, C_NONE, C_NONE, C_NONE, 0, 0, 0},
+	{obj.ANOP, C_LCON, C_NONE, C_NONE, C_NONE, 0, 0, 0}, // NOP operand variations added for #40689
+	{obj.ANOP, C_REG, C_NONE, C_NONE, C_NONE, 0, 0, 0},  // to preserve previous behavior
+	{obj.ANOP, C_FREG, C_NONE, C_NONE, C_NONE, 0, 0, 0},
+	{obj.ADUFFZERO, C_NONE, C_NONE, C_NONE, C_LBRA, 11, 4, 0}, // same as ABR/ABL
+	{obj.ADUFFCOPY, C_NONE, C_NONE, C_NONE, C_LBRA, 11, 4, 0}, // same as ABR/ABL
+	{obj.APCALIGN, C_LCON, C_NONE, C_NONE, C_NONE, 0, 0, 0},   // align code
+
+	{obj.AXXX, C_NONE, C_NONE, C_NONE, C_NONE, 0, 4, 0},
+}
+
+var oprange [ALAST & obj.AMask][]Optab
+
+var xcmp [C_NCLASS][C_NCLASS]bool
+
+// padding bytes to add to align code as requested
+func addpad(pc, a int64, ctxt *obj.Link, cursym *obj.LSym) int {
+	// For 16 and 32 byte alignment, there is a tradeoff
+	// between aligning the code and adding too many NOPs.
+	switch a {
+	case 8:
+		if pc&7 != 0 {
+			return 4
+		}
+	case 16:
+		// Align to 16 bytes if possible but add at
+		// most 2 NOPs.
+		switch pc & 15 {
+		case 4, 12:
+			return 4
+		case 8:
+			return 8
+		}
+	case 32:
+		// Align to 32 bytes if possible but add at
+		// most 3 NOPs.
+		switch pc & 31 {
+		case 4, 20:
+			return 12
+		case 8, 24:
+			return 8
+		case 12, 28:
+			return 4
+		}
+		// When 32 byte alignment is requested on Linux,
+		// promote the function's alignment to 32. On AIX
+		// the function alignment is not changed which might
+		// result in 16 byte alignment but that is still fine.
+		// TODO: alignment on AIX
+		if ctxt.Headtype != objabi.Haix && cursym.Func.Align < 32 {
+			cursym.Func.Align = 32
+		}
+	default:
+		ctxt.Diag("Unexpected alignment: %d for PCALIGN directive\n", a)
+	}
+	return 0
+}
+
+func span9(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
+	p := cursym.Func.Text
+	if p == nil || p.Link == nil { // handle external functions and ELF section symbols
+		return
+	}
+
+	if oprange[AANDN&obj.AMask] == nil {
+		ctxt.Diag("ppc64 ops not initialized, call ppc64.buildop first")
+	}
+
+	c := ctxt9{ctxt: ctxt, newprog: newprog, cursym: cursym, autosize: int32(p.To.Offset)}
+
+	pc := int64(0)
+	p.Pc = pc
+
+	var m int
+	var o *Optab
+	for p = p.Link; p != nil; p = p.Link {
+		p.Pc = pc
+		o = c.oplook(p)
+		m = int(o.size)
+		if m == 0 {
+			if p.As == obj.APCALIGN {
+				a := c.vregoff(&p.From)
+				m = addpad(pc, a, ctxt, cursym)
+			} else {
+				if p.As != obj.ANOP && p.As != obj.AFUNCDATA && p.As != obj.APCDATA {
+					ctxt.Diag("zero-width instruction\n%v", p)
+				}
+				continue
+			}
+		}
+		pc += int64(m)
+	}
+
+	c.cursym.Size = pc
+
+	/*
+	 * if any procedure is large enough to
+	 * generate a large SBRA branch, then
+	 * generate extra passes putting branches
+	 * around jmps to fix. this is rare.
+	 */
+	bflag := 1
+
+	var otxt int64
+	var q *obj.Prog
+	for bflag != 0 {
+		bflag = 0
+		pc = 0
+		for p = c.cursym.Func.Text.Link; p != nil; p = p.Link {
+			p.Pc = pc
+			o = c.oplook(p)
+
+			// very large conditional branches
+			if (o.type_ == 16 || o.type_ == 17) && p.To.Target() != nil {
+				otxt = p.To.Target().Pc - pc
+				if otxt < -(1<<15)+10 || otxt >= (1<<15)-10 {
+					q = c.newprog()
+					q.Link = p.Link
+					p.Link = q
+					q.As = ABR
+					q.To.Type = obj.TYPE_BRANCH
+					q.To.SetTarget(p.To.Target())
+					p.To.SetTarget(q)
+					q = c.newprog()
+					q.Link = p.Link
+					p.Link = q
+					q.As = ABR
+					q.To.Type = obj.TYPE_BRANCH
+					q.To.SetTarget(q.Link.Link)
+
+					//addnop(p->link);
+					//addnop(p);
+					bflag = 1
+				}
+			}
+
+			m = int(o.size)
+			if m == 0 {
+				if p.As == obj.APCALIGN {
+					a := c.vregoff(&p.From)
+					m = addpad(pc, a, ctxt, cursym)
+				} else {
+					if p.As != obj.ANOP && p.As != obj.AFUNCDATA && p.As != obj.APCDATA {
+						ctxt.Diag("zero-width instruction\n%v", p)
+					}
+					continue
+				}
+			}
+
+			pc += int64(m)
+		}
+
+		c.cursym.Size = pc
+	}
+
+	if r := pc & funcAlignMask; r != 0 {
+		pc += funcAlign - r
+	}
+
+	c.cursym.Size = pc
+
+	/*
+	 * lay out the code, emitting code and data relocations.
+	 */
+
+	c.cursym.Grow(c.cursym.Size)
+
+	bp := c.cursym.P
+	var i int32
+	var out [6]uint32
+	for p := c.cursym.Func.Text.Link; p != nil; p = p.Link {
+		c.pc = p.Pc
+		o = c.oplook(p)
+		if int(o.size) > 4*len(out) {
+			log.Fatalf("out array in span9 is too small, need at least %d for %v", o.size/4, p)
+		}
+		// asmout is not set up to add large amounts of padding
+		if o.type_ == 0 && p.As == obj.APCALIGN {
+			pad := LOP_RRR(OP_OR, REGZERO, REGZERO, REGZERO)
+			aln := c.vregoff(&p.From)
+			v := addpad(p.Pc, aln, c.ctxt, c.cursym)
+			if v > 0 {
+				// Same padding instruction for all
+				for i = 0; i < int32(v/4); i++ {
+					c.ctxt.Arch.ByteOrder.PutUint32(bp, pad)
+					bp = bp[4:]
+				}
+			}
+		} else {
+			c.asmout(p, o, out[:])
+			for i = 0; i < int32(o.size/4); i++ {
+				c.ctxt.Arch.ByteOrder.PutUint32(bp, out[i])
+				bp = bp[4:]
+			}
+		}
+	}
+}
+
+func isint32(v int64) bool {
+	return int64(int32(v)) == v
+}
+
+func isuint32(v uint64) bool {
+	return uint64(uint32(v)) == v
+}
+
+func (c *ctxt9) aclass(a *obj.Addr) int {
+	switch a.Type {
+	case obj.TYPE_NONE:
+		return C_NONE
+
+	case obj.TYPE_REG:
+		if REG_R0 <= a.Reg && a.Reg <= REG_R31 {
+			return C_REG
+		}
+		if REG_F0 <= a.Reg && a.Reg <= REG_F31 {
+			return C_FREG
+		}
+		if REG_V0 <= a.Reg && a.Reg <= REG_V31 {
+			return C_VREG
+		}
+		if REG_VS0 <= a.Reg && a.Reg <= REG_VS63 {
+			return C_VSREG
+		}
+		if REG_CR0 <= a.Reg && a.Reg <= REG_CR7 || a.Reg == REG_CR {
+			return C_CREG
+		}
+		if REG_SPR0 <= a.Reg && a.Reg <= REG_SPR0+1023 {
+			switch a.Reg {
+			case REG_LR:
+				return C_LR
+
+			case REG_XER:
+				return C_XER
+
+			case REG_CTR:
+				return C_CTR
+			}
+
+			return C_SPR
+		}
+
+		if REG_DCR0 <= a.Reg && a.Reg <= REG_DCR0+1023 {
+			return C_SPR
+		}
+		if a.Reg == REG_FPSCR {
+			return C_FPSCR
+		}
+		if a.Reg == REG_MSR {
+			return C_MSR
+		}
+		return C_GOK
+
+	case obj.TYPE_MEM:
+		switch a.Name {
+		case obj.NAME_EXTERN,
+			obj.NAME_STATIC:
+			if a.Sym == nil {
+				break
+			}
+			c.instoffset = a.Offset
+			if a.Sym != nil { // use relocation
+				if a.Sym.Type == objabi.STLSBSS {
+					if c.ctxt.Flag_shared {
+						return C_TLS_IE
+					} else {
+						return C_TLS_LE
+					}
+				}
+				return C_ADDR
+			}
+			return C_LEXT
+
+		case obj.NAME_GOTREF:
+			return C_GOTADDR
+
+		case obj.NAME_TOCREF:
+			return C_TOCADDR
+
+		case obj.NAME_AUTO:
+			c.instoffset = int64(c.autosize) + a.Offset
+			if c.instoffset >= -BIG && c.instoffset < BIG {
+				return C_SAUTO
+			}
+			return C_LAUTO
+
+		case obj.NAME_PARAM:
+			c.instoffset = int64(c.autosize) + a.Offset + c.ctxt.FixedFrameSize()
+			if c.instoffset >= -BIG && c.instoffset < BIG {
+				return C_SAUTO
+			}
+			return C_LAUTO
+
+		case obj.NAME_NONE:
+			c.instoffset = a.Offset
+			if c.instoffset == 0 {
+				return C_ZOREG
+			}
+			if c.instoffset >= -BIG && c.instoffset < BIG {
+				return C_SOREG
+			}
+			return C_LOREG
+		}
+
+		return C_GOK
+
+	case obj.TYPE_TEXTSIZE:
+		return C_TEXTSIZE
+
+	case obj.TYPE_FCONST:
+		// The only cases where FCONST will occur are with float64 +/- 0.
+		// All other float constants are generated in memory.
+		f64 := a.Val.(float64)
+		if f64 == 0 {
+			if math.Signbit(f64) {
+				return C_ADDCON
+			}
+			return C_ZCON
+		}
+		log.Fatalf("Unexpected nonzero FCONST operand %v", a)
+
+	case obj.TYPE_CONST,
+		obj.TYPE_ADDR:
+		switch a.Name {
+		case obj.NAME_NONE:
+			c.instoffset = a.Offset
+			if a.Reg != 0 {
+				if -BIG <= c.instoffset && c.instoffset <= BIG {
+					return C_SACON
+				}
+				if isint32(c.instoffset) {
+					return C_LACON
+				}
+				return C_DACON
+			}
+
+		case obj.NAME_EXTERN,
+			obj.NAME_STATIC:
+			s := a.Sym
+			if s == nil {
+				return C_GOK
+			}
+
+			c.instoffset = a.Offset
+
+			/* not sure why this barfs */
+			return C_LCON
+
+		case obj.NAME_AUTO:
+			c.instoffset = int64(c.autosize) + a.Offset
+			if c.instoffset >= -BIG && c.instoffset < BIG {
+				return C_SACON
+			}
+			return C_LACON
+
+		case obj.NAME_PARAM:
+			c.instoffset = int64(c.autosize) + a.Offset + c.ctxt.FixedFrameSize()
+			if c.instoffset >= -BIG && c.instoffset < BIG {
+				return C_SACON
+			}
+			return C_LACON
+
+		default:
+			return C_GOK
+		}
+
+		if c.instoffset >= 0 {
+			if c.instoffset == 0 {
+				return C_ZCON
+			}
+			if c.instoffset <= 0x7fff {
+				return C_SCON
+			}
+			if c.instoffset <= 0xffff {
+				return C_ANDCON
+			}
+			if c.instoffset&0xffff == 0 && isuint32(uint64(c.instoffset)) { /* && (instoffset & (1<<31)) == 0) */
+				return C_UCON
+			}
+			if isint32(c.instoffset) || isuint32(uint64(c.instoffset)) {
+				return C_LCON
+			}
+			return C_DCON
+		}
+
+		if c.instoffset >= -0x8000 {
+			return C_ADDCON
+		}
+		if c.instoffset&0xffff == 0 && isint32(c.instoffset) {
+			return C_UCON
+		}
+		if isint32(c.instoffset) {
+			return C_LCON
+		}
+		return C_DCON
+
+	case obj.TYPE_BRANCH:
+		if a.Sym != nil && c.ctxt.Flag_dynlink {
+			return C_LBRAPIC
+		}
+		return C_SBRA
+	}
+
+	return C_GOK
+}
+
+func prasm(p *obj.Prog) {
+	fmt.Printf("%v\n", p)
+}
+
+func (c *ctxt9) oplook(p *obj.Prog) *Optab {
+	a1 := int(p.Optab)
+	if a1 != 0 {
+		return &optab[a1-1]
+	}
+	a1 = int(p.From.Class)
+	if a1 == 0 {
+		a1 = c.aclass(&p.From) + 1
+		p.From.Class = int8(a1)
+	}
+
+	a1--
+	a3 := C_NONE + 1
+	if p.GetFrom3() != nil {
+		a3 = int(p.GetFrom3().Class)
+		if a3 == 0 {
+			a3 = c.aclass(p.GetFrom3()) + 1
+			p.GetFrom3().Class = int8(a3)
+		}
+	}
+
+	a3--
+	a4 := int(p.To.Class)
+	if a4 == 0 {
+		a4 = c.aclass(&p.To) + 1
+		p.To.Class = int8(a4)
+	}
+
+	a4--
+	a2 := C_NONE
+	if p.Reg != 0 {
+		if REG_R0 <= p.Reg && p.Reg <= REG_R31 {
+			a2 = C_REG
+		} else if REG_V0 <= p.Reg && p.Reg <= REG_V31 {
+			a2 = C_VREG
+		} else if REG_VS0 <= p.Reg && p.Reg <= REG_VS63 {
+			a2 = C_VSREG
+		} else if REG_F0 <= p.Reg && p.Reg <= REG_F31 {
+			a2 = C_FREG
+		}
+	}
+
+	// c.ctxt.Logf("oplook %v %d %d %d %d\n", p, a1, a2, a3, a4)
+	ops := oprange[p.As&obj.AMask]
+	c1 := &xcmp[a1]
+	c3 := &xcmp[a3]
+	c4 := &xcmp[a4]
+	for i := range ops {
+		op := &ops[i]
+		if int(op.a2) == a2 && c1[op.a1] && c3[op.a3] && c4[op.a4] {
+			p.Optab = uint16(cap(optab) - cap(ops) + i + 1)
+			return op
+		}
+	}
+
+	c.ctxt.Diag("illegal combination %v %v %v %v %v", p.As, DRconv(a1), DRconv(a2), DRconv(a3), DRconv(a4))
+	prasm(p)
+	if ops == nil {
+		ops = optab
+	}
+	return &ops[0]
+}
+
+func cmp(a int, b int) bool {
+	if a == b {
+		return true
+	}
+	switch a {
+	case C_LCON:
+		if b == C_ZCON || b == C_SCON || b == C_UCON || b == C_ADDCON || b == C_ANDCON {
+			return true
+		}
+
+	case C_ADDCON:
+		if b == C_ZCON || b == C_SCON {
+			return true
+		}
+
+	case C_ANDCON:
+		if b == C_ZCON || b == C_SCON {
+			return true
+		}
+
+	case C_SPR:
+		if b == C_LR || b == C_XER || b == C_CTR {
+			return true
+		}
+
+	case C_UCON:
+		if b == C_ZCON {
+			return true
+		}
+
+	case C_SCON:
+		if b == C_ZCON {
+			return true
+		}
+
+	case C_LACON:
+		if b == C_SACON {
+			return true
+		}
+
+	case C_LBRA:
+		if b == C_SBRA {
+			return true
+		}
+
+	case C_LEXT:
+		if b == C_SEXT {
+			return true
+		}
+
+	case C_LAUTO:
+		if b == C_SAUTO {
+			return true
+		}
+
+	case C_REG:
+		if b == C_ZCON {
+			return r0iszero != 0 /*TypeKind(100016)*/
+		}
+
+	case C_LOREG:
+		if b == C_ZOREG || b == C_SOREG {
+			return true
+		}
+
+	case C_SOREG:
+		if b == C_ZOREG {
+			return true
+		}
+
+	case C_ANY:
+		return true
+	}
+
+	return false
+}
+
+type ocmp []Optab
+
+func (x ocmp) Len() int {
+	return len(x)
+}
+
+func (x ocmp) Swap(i, j int) {
+	x[i], x[j] = x[j], x[i]
+}
+
+// Used when sorting the optab. Sorting is
+// done in a way so that the best choice of
+// opcode/operand combination is considered first.
+func (x ocmp) Less(i, j int) bool {
+	p1 := &x[i]
+	p2 := &x[j]
+	n := int(p1.as) - int(p2.as)
+	// same opcode
+	if n != 0 {
+		return n < 0
+	}
+	// Consider those that generate fewer
+	// instructions first.
+	n = int(p1.size) - int(p2.size)
+	if n != 0 {
+		return n < 0
+	}
+	// operand order should match
+	// better choices first
+	n = int(p1.a1) - int(p2.a1)
+	if n != 0 {
+		return n < 0
+	}
+	n = int(p1.a2) - int(p2.a2)
+	if n != 0 {
+		return n < 0
+	}
+	n = int(p1.a3) - int(p2.a3)
+	if n != 0 {
+		return n < 0
+	}
+	n = int(p1.a4) - int(p2.a4)
+	if n != 0 {
+		return n < 0
+	}
+	return false
+}
+
+// Add an entry to the opcode table for
+// a new opcode b0 with the same operand combinations
+// as opcode a.
+func opset(a, b0 obj.As) {
+	oprange[a&obj.AMask] = oprange[b0]
+}
+
+// Build the opcode table
+func buildop(ctxt *obj.Link) {
+	if oprange[AANDN&obj.AMask] != nil {
+		// Already initialized; stop now.
+		// This happens in the cmd/asm tests,
+		// each of which re-initializes the arch.
+		return
+	}
+
+	var n int
+
+	for i := 0; i < C_NCLASS; i++ {
+		for n = 0; n < C_NCLASS; n++ {
+			if cmp(n, i) {
+				xcmp[i][n] = true
+			}
+		}
+	}
+	for n = 0; optab[n].as != obj.AXXX; n++ {
+	}
+	sort.Sort(ocmp(optab[:n]))
+	for i := 0; i < n; i++ {
+		r := optab[i].as
+		r0 := r & obj.AMask
+		start := i
+		for optab[i].as == r {
+			i++
+		}
+		oprange[r0] = optab[start:i]
+		i--
+
+		switch r {
+		default:
+			ctxt.Diag("unknown op in build: %v", r)
+			log.Fatalf("instruction missing from switch in asm9.go:buildop: %v", r)
+
+		case ADCBF: /* unary indexed: op (b+a); op (b) */
+			opset(ADCBI, r0)
+
+			opset(ADCBST, r0)
+			opset(ADCBT, r0)
+			opset(ADCBTST, r0)
+			opset(ADCBZ, r0)
+			opset(AICBI, r0)
+
+		case AECOWX: /* indexed store: op s,(b+a); op s,(b) */
+			opset(ASTWCCC, r0)
+			opset(ASTHCCC, r0)
+			opset(ASTBCCC, r0)
+			opset(ASTDCCC, r0)
+
+		case AREM: /* macro */
+			opset(AREM, r0)
+
+		case AREMU:
+			opset(AREMU, r0)
+
+		case AREMD:
+			opset(AREMDU, r0)
+
+		case ADIVW: /* op Rb[,Ra],Rd */
+			opset(AMULHW, r0)
+
+			opset(AMULHWCC, r0)
+			opset(AMULHWU, r0)
+			opset(AMULHWUCC, r0)
+			opset(AMULLWCC, r0)
+			opset(AMULLWVCC, r0)
+			opset(AMULLWV, r0)
+			opset(ADIVWCC, r0)
+			opset(ADIVWV, r0)
+			opset(ADIVWVCC, r0)
+			opset(ADIVWU, r0)
+			opset(ADIVWUCC, r0)
+			opset(ADIVWUV, r0)
+			opset(ADIVWUVCC, r0)
+			opset(AMODUD, r0)
+			opset(AMODUW, r0)
+			opset(AMODSD, r0)
+			opset(AMODSW, r0)
+			opset(AADDCC, r0)
+			opset(AADDCV, r0)
+			opset(AADDCVCC, r0)
+			opset(AADDV, r0)
+			opset(AADDVCC, r0)
+			opset(AADDE, r0)
+			opset(AADDECC, r0)
+			opset(AADDEV, r0)
+			opset(AADDEVCC, r0)
+			opset(AMULHD, r0)
+			opset(AMULHDCC, r0)
+			opset(AMULHDU, r0)
+			opset(AMULHDUCC, r0)
+			opset(AMULLD, r0)
+			opset(AMULLDCC, r0)
+			opset(AMULLDVCC, r0)
+			opset(AMULLDV, r0)
+			opset(ADIVD, r0)
+			opset(ADIVDCC, r0)
+			opset(ADIVDE, r0)
+			opset(ADIVDEU, r0)
+			opset(ADIVDECC, r0)
+			opset(ADIVDEUCC, r0)
+			opset(ADIVDVCC, r0)
+			opset(ADIVDV, r0)
+			opset(ADIVDU, r0)
+			opset(ADIVDUV, r0)
+			opset(ADIVDUVCC, r0)
+			opset(ADIVDUCC, r0)
+
+		case ACRAND:
+			opset(ACRANDN, r0)
+			opset(ACREQV, r0)
+			opset(ACRNAND, r0)
+			opset(ACRNOR, r0)
+			opset(ACROR, r0)
+			opset(ACRORN, r0)
+			opset(ACRXOR, r0)
+
+		case APOPCNTD: /* popcntd, popcntw, popcntb, cnttzw, cnttzd */
+			opset(APOPCNTW, r0)
+			opset(APOPCNTB, r0)
+			opset(ACNTTZW, r0)
+			opset(ACNTTZWCC, r0)
+			opset(ACNTTZD, r0)
+			opset(ACNTTZDCC, r0)
+
+		case ACOPY: /* copy, paste. */
+			opset(APASTECC, r0)
+
+		case AMADDHD: /* maddhd, maddhdu, maddld */
+			opset(AMADDHDU, r0)
+			opset(AMADDLD, r0)
+
+		case AMOVBZ: /* lbz, stz, rlwm(r/r), lhz, lha, stz, and x variants */
+			opset(AMOVH, r0)
+			opset(AMOVHZ, r0)
+
+		case AMOVBZU: /* lbz[x]u, stb[x]u, lhz[x]u, lha[x]u, sth[u]x, ld[x]u, std[u]x */
+			opset(AMOVHU, r0)
+
+			opset(AMOVHZU, r0)
+			opset(AMOVWU, r0)
+			opset(AMOVWZU, r0)
+			opset(AMOVDU, r0)
+			opset(AMOVMW, r0)
+
+		case ALV: /* lvebx, lvehx, lvewx, lvx, lvxl, lvsl, lvsr */
+			opset(ALVEBX, r0)
+			opset(ALVEHX, r0)
+			opset(ALVEWX, r0)
+			opset(ALVX, r0)
+			opset(ALVXL, r0)
+			opset(ALVSL, r0)
+			opset(ALVSR, r0)
+
+		case ASTV: /* stvebx, stvehx, stvewx, stvx, stvxl */
+			opset(ASTVEBX, r0)
+			opset(ASTVEHX, r0)
+			opset(ASTVEWX, r0)
+			opset(ASTVX, r0)
+			opset(ASTVXL, r0)
+
+		case AVAND: /* vand, vandc, vnand */
+			opset(AVAND, r0)
+			opset(AVANDC, r0)
+			opset(AVNAND, r0)
+
+		case AVMRGOW: /* vmrgew, vmrgow */
+			opset(AVMRGEW, r0)
+
+		case AVOR: /* vor, vorc, vxor, vnor, veqv */
+			opset(AVOR, r0)
+			opset(AVORC, r0)
+			opset(AVXOR, r0)
+			opset(AVNOR, r0)
+			opset(AVEQV, r0)
+
+		case AVADDUM: /* vaddubm, vadduhm, vadduwm, vaddudm, vadduqm */
+			opset(AVADDUBM, r0)
+			opset(AVADDUHM, r0)
+			opset(AVADDUWM, r0)
+			opset(AVADDUDM, r0)
+			opset(AVADDUQM, r0)
+
+		case AVADDCU: /* vaddcuq, vaddcuw */
+			opset(AVADDCUQ, r0)
+			opset(AVADDCUW, r0)
+
+		case AVADDUS: /* vaddubs, vadduhs, vadduws */
+			opset(AVADDUBS, r0)
+			opset(AVADDUHS, r0)
+			opset(AVADDUWS, r0)
+
+		case AVADDSS: /* vaddsbs, vaddshs, vaddsws */
+			opset(AVADDSBS, r0)
+			opset(AVADDSHS, r0)
+			opset(AVADDSWS, r0)
+
+		case AVADDE: /* vaddeuqm, vaddecuq */
+			opset(AVADDEUQM, r0)
+			opset(AVADDECUQ, r0)
+
+		case AVSUBUM: /* vsububm, vsubuhm, vsubuwm, vsubudm, vsubuqm */
+			opset(AVSUBUBM, r0)
+			opset(AVSUBUHM, r0)
+			opset(AVSUBUWM, r0)
+			opset(AVSUBUDM, r0)
+			opset(AVSUBUQM, r0)
+
+		case AVSUBCU: /* vsubcuq, vsubcuw */
+			opset(AVSUBCUQ, r0)
+			opset(AVSUBCUW, r0)
+
+		case AVSUBUS: /* vsububs, vsubuhs, vsubuws */
+			opset(AVSUBUBS, r0)
+			opset(AVSUBUHS, r0)
+			opset(AVSUBUWS, r0)
+
+		case AVSUBSS: /* vsubsbs, vsubshs, vsubsws */
+			opset(AVSUBSBS, r0)
+			opset(AVSUBSHS, r0)
+			opset(AVSUBSWS, r0)
+
+		case AVSUBE: /* vsubeuqm, vsubecuq */
+			opset(AVSUBEUQM, r0)
+			opset(AVSUBECUQ, r0)
+
+		case AVMULESB: /* vmulesb, vmulosb, vmuleub, vmuloub, vmulosh, vmulouh, vmulesw, vmulosw, vmuleuw, vmulouw, vmuluwm */
+			opset(AVMULOSB, r0)
+			opset(AVMULEUB, r0)
+			opset(AVMULOUB, r0)
+			opset(AVMULESH, r0)
+			opset(AVMULOSH, r0)
+			opset(AVMULEUH, r0)
+			opset(AVMULOUH, r0)
+			opset(AVMULESW, r0)
+			opset(AVMULOSW, r0)
+			opset(AVMULEUW, r0)
+			opset(AVMULOUW, r0)
+			opset(AVMULUWM, r0)
+		case AVPMSUM: /* vpmsumb, vpmsumh, vpmsumw, vpmsumd */
+			opset(AVPMSUMB, r0)
+			opset(AVPMSUMH, r0)
+			opset(AVPMSUMW, r0)
+			opset(AVPMSUMD, r0)
+
+		case AVR: /* vrlb, vrlh, vrlw, vrld */
+			opset(AVRLB, r0)
+			opset(AVRLH, r0)
+			opset(AVRLW, r0)
+			opset(AVRLD, r0)
+
+		case AVS: /* vs[l,r], vs[l,r]o, vs[l,r]b, vs[l,r]h, vs[l,r]w, vs[l,r]d */
+			opset(AVSLB, r0)
+			opset(AVSLH, r0)
+			opset(AVSLW, r0)
+			opset(AVSL, r0)
+			opset(AVSLO, r0)
+			opset(AVSRB, r0)
+			opset(AVSRH, r0)
+			opset(AVSRW, r0)
+			opset(AVSR, r0)
+			opset(AVSRO, r0)
+			opset(AVSLD, r0)
+			opset(AVSRD, r0)
+
+		case AVSA: /* vsrab, vsrah, vsraw, vsrad */
+			opset(AVSRAB, r0)
+			opset(AVSRAH, r0)
+			opset(AVSRAW, r0)
+			opset(AVSRAD, r0)
+
+		case AVSOI: /* vsldoi */
+			opset(AVSLDOI, r0)
+
+		case AVCLZ: /* vclzb, vclzh, vclzw, vclzd */
+			opset(AVCLZB, r0)
+			opset(AVCLZH, r0)
+			opset(AVCLZW, r0)
+			opset(AVCLZD, r0)
+
+		case AVPOPCNT: /* vpopcntb, vpopcnth, vpopcntw, vpopcntd */
+			opset(AVPOPCNTB, r0)
+			opset(AVPOPCNTH, r0)
+			opset(AVPOPCNTW, r0)
+			opset(AVPOPCNTD, r0)
+
+		case AVCMPEQ: /* vcmpequb[.], vcmpequh[.], vcmpequw[.], vcmpequd[.] */
+			opset(AVCMPEQUB, r0)
+			opset(AVCMPEQUBCC, r0)
+			opset(AVCMPEQUH, r0)
+			opset(AVCMPEQUHCC, r0)
+			opset(AVCMPEQUW, r0)
+			opset(AVCMPEQUWCC, r0)
+			opset(AVCMPEQUD, r0)
+			opset(AVCMPEQUDCC, r0)
+
+		case AVCMPGT: /* vcmpgt[u,s]b[.], vcmpgt[u,s]h[.], vcmpgt[u,s]w[.], vcmpgt[u,s]d[.] */
+			opset(AVCMPGTUB, r0)
+			opset(AVCMPGTUBCC, r0)
+			opset(AVCMPGTUH, r0)
+			opset(AVCMPGTUHCC, r0)
+			opset(AVCMPGTUW, r0)
+			opset(AVCMPGTUWCC, r0)
+			opset(AVCMPGTUD, r0)
+			opset(AVCMPGTUDCC, r0)
+			opset(AVCMPGTSB, r0)
+			opset(AVCMPGTSBCC, r0)
+			opset(AVCMPGTSH, r0)
+			opset(AVCMPGTSHCC, r0)
+			opset(AVCMPGTSW, r0)
+			opset(AVCMPGTSWCC, r0)
+			opset(AVCMPGTSD, r0)
+			opset(AVCMPGTSDCC, r0)
+
+		case AVCMPNEZB: /* vcmpnezb[.] */
+			opset(AVCMPNEZBCC, r0)
+			opset(AVCMPNEB, r0)
+			opset(AVCMPNEBCC, r0)
+			opset(AVCMPNEH, r0)
+			opset(AVCMPNEHCC, r0)
+			opset(AVCMPNEW, r0)
+			opset(AVCMPNEWCC, r0)
+
+		case AVPERM: /* vperm */
+			opset(AVPERMXOR, r0)
+			opset(AVPERMR, r0)
+
+		case AVBPERMQ: /* vbpermq, vbpermd */
+			opset(AVBPERMD, r0)
+
+		case AVSEL: /* vsel */
+			opset(AVSEL, r0)
+
+		case AVSPLTB: /* vspltb, vsplth, vspltw */
+			opset(AVSPLTH, r0)
+			opset(AVSPLTW, r0)
+
+		case AVSPLTISB: /* vspltisb, vspltish, vspltisw */
+			opset(AVSPLTISH, r0)
+			opset(AVSPLTISW, r0)
+
+		case AVCIPH: /* vcipher, vcipherlast */
+			opset(AVCIPHER, r0)
+			opset(AVCIPHERLAST, r0)
+
+		case AVNCIPH: /* vncipher, vncipherlast */
+			opset(AVNCIPHER, r0)
+			opset(AVNCIPHERLAST, r0)
+
+		case AVSBOX: /* vsbox */
+			opset(AVSBOX, r0)
+
+		case AVSHASIGMA: /* vshasigmaw, vshasigmad */
+			opset(AVSHASIGMAW, r0)
+			opset(AVSHASIGMAD, r0)
+
+		case ALXVD2X: /* lxvd2x, lxvdsx, lxvw4x, lxvh8x, lxvb16x */
+			opset(ALXVDSX, r0)
+			opset(ALXVW4X, r0)
+			opset(ALXVH8X, r0)
+			opset(ALXVB16X, r0)
+
+		case ALXV: /* lxv */
+			opset(ALXV, r0)
+
+		case ALXVL: /* lxvl, lxvll, lxvx */
+			opset(ALXVLL, r0)
+			opset(ALXVX, r0)
+
+		case ASTXVD2X: /* stxvd2x, stxvdsx, stxvw4x, stxvh8x, stxvb16x */
+			opset(ASTXVW4X, r0)
+			opset(ASTXVH8X, r0)
+			opset(ASTXVB16X, r0)
+
+		case ASTXV: /* stxv */
+			opset(ASTXV, r0)
+
+		case ASTXVL: /* stxvl, stxvll, stvx */
+			opset(ASTXVLL, r0)
+			opset(ASTXVX, r0)
+
+		case ALXSDX: /* lxsdx  */
+			opset(ALXSDX, r0)
+
+		case ASTXSDX: /* stxsdx */
+			opset(ASTXSDX, r0)
+
+		case ALXSIWAX: /* lxsiwax, lxsiwzx  */
+			opset(ALXSIWZX, r0)
+
+		case ASTXSIWX: /* stxsiwx */
+			opset(ASTXSIWX, r0)
+
+		case AMFVSRD: /* mfvsrd, mfvsrwz (and extended mnemonics), mfvsrld */
+			opset(AMFFPRD, r0)
+			opset(AMFVRD, r0)
+			opset(AMFVSRWZ, r0)
+			opset(AMFVSRLD, r0)
+
+		case AMTVSRD: /* mtvsrd, mtvsrwa, mtvsrwz (and extended mnemonics), mtvsrdd, mtvsrws */
+			opset(AMTFPRD, r0)
+			opset(AMTVRD, r0)
+			opset(AMTVSRWA, r0)
+			opset(AMTVSRWZ, r0)
+			opset(AMTVSRDD, r0)
+			opset(AMTVSRWS, r0)
+
+		case AXXLAND: /* xxland, xxlandc, xxleqv, xxlnand */
+			opset(AXXLANDC, r0)
+			opset(AXXLEQV, r0)
+			opset(AXXLNAND, r0)
+
+		case AXXLOR: /* xxlorc, xxlnor, xxlor, xxlxor */
+			opset(AXXLORC, r0)
+			opset(AXXLNOR, r0)
+			opset(AXXLORQ, r0)
+			opset(AXXLXOR, r0)
+
+		case AXXSEL: /* xxsel */
+			opset(AXXSEL, r0)
+
+		case AXXMRGHW: /* xxmrghw, xxmrglw */
+			opset(AXXMRGLW, r0)
+
+		case AXXSPLTW: /* xxspltw */
+			opset(AXXSPLTW, r0)
+
+		case AXXSPLTIB: /* xxspltib */
+			opset(AXXSPLTIB, r0)
+
+		case AXXPERM: /* xxpermdi */
+			opset(AXXPERM, r0)
+
+		case AXXSLDWI: /* xxsldwi */
+			opset(AXXPERMDI, r0)
+			opset(AXXSLDWI, r0)
+
+		case AXXBRQ: /* xxbrq, xxbrd, xxbrw, xxbrh */
+			opset(AXXBRD, r0)
+			opset(AXXBRW, r0)
+			opset(AXXBRH, r0)
+
+		case AXSCVDPSP: /* xscvdpsp, xscvspdp, xscvdpspn, xscvspdpn */
+			opset(AXSCVSPDP, r0)
+			opset(AXSCVDPSPN, r0)
+			opset(AXSCVSPDPN, r0)
+
+		case AXVCVDPSP: /* xvcvdpsp, xvcvspdp */
+			opset(AXVCVSPDP, r0)
+
+		case AXSCVDPSXDS: /* xscvdpsxds, xscvdpsxws, xscvdpuxds, xscvdpuxws */
+			opset(AXSCVDPSXWS, r0)
+			opset(AXSCVDPUXDS, r0)
+			opset(AXSCVDPUXWS, r0)
+
+		case AXSCVSXDDP: /* xscvsxddp, xscvuxddp, xscvsxdsp, xscvuxdsp */
+			opset(AXSCVUXDDP, r0)
+			opset(AXSCVSXDSP, r0)
+			opset(AXSCVUXDSP, r0)
+
+		case AXVCVDPSXDS: /* xvcvdpsxds, xvcvdpsxws, xvcvdpuxds, xvcvdpuxws, xvcvspsxds, xvcvspsxws, xvcvspuxds, xvcvspuxws */
+			opset(AXVCVDPSXDS, r0)
+			opset(AXVCVDPSXWS, r0)
+			opset(AXVCVDPUXDS, r0)
+			opset(AXVCVDPUXWS, r0)
+			opset(AXVCVSPSXDS, r0)
+			opset(AXVCVSPSXWS, r0)
+			opset(AXVCVSPUXDS, r0)
+			opset(AXVCVSPUXWS, r0)
+
+		case AXVCVSXDDP: /* xvcvsxddp, xvcvsxwdp, xvcvuxddp, xvcvuxwdp, xvcvsxdsp, xvcvsxwsp, xvcvuxdsp, xvcvuxwsp */
+			opset(AXVCVSXWDP, r0)
+			opset(AXVCVUXDDP, r0)
+			opset(AXVCVUXWDP, r0)
+			opset(AXVCVSXDSP, r0)
+			opset(AXVCVSXWSP, r0)
+			opset(AXVCVUXDSP, r0)
+			opset(AXVCVUXWSP, r0)
+
+		case AAND: /* logical op Rb,Rs,Ra; no literal */
+			opset(AANDN, r0)
+			opset(AANDNCC, r0)
+			opset(AEQV, r0)
+			opset(AEQVCC, r0)
+			opset(ANAND, r0)
+			opset(ANANDCC, r0)
+			opset(ANOR, r0)
+			opset(ANORCC, r0)
+			opset(AORCC, r0)
+			opset(AORN, r0)
+			opset(AORNCC, r0)
+			opset(AXORCC, r0)
+
+		case AADDME: /* op Ra, Rd */
+			opset(AADDMECC, r0)
+
+			opset(AADDMEV, r0)
+			opset(AADDMEVCC, r0)
+			opset(AADDZE, r0)
+			opset(AADDZECC, r0)
+			opset(AADDZEV, r0)
+			opset(AADDZEVCC, r0)
+			opset(ASUBME, r0)
+			opset(ASUBMECC, r0)
+			opset(ASUBMEV, r0)
+			opset(ASUBMEVCC, r0)
+			opset(ASUBZE, r0)
+			opset(ASUBZECC, r0)
+			opset(ASUBZEV, r0)
+			opset(ASUBZEVCC, r0)
+
+		case AADDC:
+			opset(AADDCCC, r0)
+
+		case ABEQ:
+			opset(ABGE, r0)
+			opset(ABGT, r0)
+			opset(ABLE, r0)
+			opset(ABLT, r0)
+			opset(ABNE, r0)
+			opset(ABVC, r0)
+			opset(ABVS, r0)
+
+		case ABR:
+			opset(ABL, r0)
+
+		case ABC:
+			opset(ABCL, r0)
+
+		case AEXTSB: /* op Rs, Ra */
+			opset(AEXTSBCC, r0)
+
+			opset(AEXTSH, r0)
+			opset(AEXTSHCC, r0)
+			opset(ACNTLZW, r0)
+			opset(ACNTLZWCC, r0)
+			opset(ACNTLZD, r0)
+			opset(AEXTSW, r0)
+			opset(AEXTSWCC, r0)
+			opset(ACNTLZDCC, r0)
+
+		case AFABS: /* fop [s,]d */
+			opset(AFABSCC, r0)
+
+			opset(AFNABS, r0)
+			opset(AFNABSCC, r0)
+			opset(AFNEG, r0)
+			opset(AFNEGCC, r0)
+			opset(AFRSP, r0)
+			opset(AFRSPCC, r0)
+			opset(AFCTIW, r0)
+			opset(AFCTIWCC, r0)
+			opset(AFCTIWZ, r0)
+			opset(AFCTIWZCC, r0)
+			opset(AFCTID, r0)
+			opset(AFCTIDCC, r0)
+			opset(AFCTIDZ, r0)
+			opset(AFCTIDZCC, r0)
+			opset(AFCFID, r0)
+			opset(AFCFIDCC, r0)
+			opset(AFCFIDU, r0)
+			opset(AFCFIDUCC, r0)
+			opset(AFCFIDS, r0)
+			opset(AFCFIDSCC, r0)
+			opset(AFRES, r0)
+			opset(AFRESCC, r0)
+			opset(AFRIM, r0)
+			opset(AFRIMCC, r0)
+			opset(AFRIP, r0)
+			opset(AFRIPCC, r0)
+			opset(AFRIZ, r0)
+			opset(AFRIZCC, r0)
+			opset(AFRIN, r0)
+			opset(AFRINCC, r0)
+			opset(AFRSQRTE, r0)
+			opset(AFRSQRTECC, r0)
+			opset(AFSQRT, r0)
+			opset(AFSQRTCC, r0)
+			opset(AFSQRTS, r0)
+			opset(AFSQRTSCC, r0)
+
+		case AFADD:
+			opset(AFADDS, r0)
+			opset(AFADDCC, r0)
+			opset(AFADDSCC, r0)
+			opset(AFCPSGN, r0)
+			opset(AFCPSGNCC, r0)
+			opset(AFDIV, r0)
+			opset(AFDIVS, r0)
+			opset(AFDIVCC, r0)
+			opset(AFDIVSCC, r0)
+			opset(AFSUB, r0)
+			opset(AFSUBS, r0)
+			opset(AFSUBCC, r0)
+			opset(AFSUBSCC, r0)
+
+		case AFMADD:
+			opset(AFMADDCC, r0)
+			opset(AFMADDS, r0)
+			opset(AFMADDSCC, r0)
+			opset(AFMSUB, r0)
+			opset(AFMSUBCC, r0)
+			opset(AFMSUBS, r0)
+			opset(AFMSUBSCC, r0)
+			opset(AFNMADD, r0)
+			opset(AFNMADDCC, r0)
+			opset(AFNMADDS, r0)
+			opset(AFNMADDSCC, r0)
+			opset(AFNMSUB, r0)
+			opset(AFNMSUBCC, r0)
+			opset(AFNMSUBS, r0)
+			opset(AFNMSUBSCC, r0)
+			opset(AFSEL, r0)
+			opset(AFSELCC, r0)
+
+		case AFMUL:
+			opset(AFMULS, r0)
+			opset(AFMULCC, r0)
+			opset(AFMULSCC, r0)
+
+		case AFCMPO:
+			opset(AFCMPU, r0)
+
+		case AISEL:
+			opset(AISEL, r0)
+
+		case AMTFSB0:
+			opset(AMTFSB0CC, r0)
+			opset(AMTFSB1, r0)
+			opset(AMTFSB1CC, r0)
+
+		case ANEG: /* op [Ra,] Rd */
+			opset(ANEGCC, r0)
+
+			opset(ANEGV, r0)
+			opset(ANEGVCC, r0)
+
+		case AOR: /* or/xor Rb,Rs,Ra; ori/xori $uimm,Rs,R */
+			opset(AXOR, r0)
+
+		case AORIS: /* oris/xoris $uimm,Rs,Ra */
+			opset(AXORIS, r0)
+
+		case ASLW:
+			opset(ASLWCC, r0)
+			opset(ASRW, r0)
+			opset(ASRWCC, r0)
+			opset(AROTLW, r0)
+
+		case ASLD:
+			opset(ASLDCC, r0)
+			opset(ASRD, r0)
+			opset(ASRDCC, r0)
+			opset(AROTL, r0)
+
+		case ASRAW: /* sraw Rb,Rs,Ra; srawi sh,Rs,Ra */
+			opset(ASRAWCC, r0)
+
+		case ASRAD: /* sraw Rb,Rs,Ra; srawi sh,Rs,Ra */
+			opset(ASRADCC, r0)
+
+		case ASUB: /* SUB Ra,Rb,Rd => subf Rd,ra,rb */
+			opset(ASUB, r0)
+
+			opset(ASUBCC, r0)
+			opset(ASUBV, r0)
+			opset(ASUBVCC, r0)
+			opset(ASUBCCC, r0)
+			opset(ASUBCV, r0)
+			opset(ASUBCVCC, r0)
+			opset(ASUBE, r0)
+			opset(ASUBECC, r0)
+			opset(ASUBEV, r0)
+			opset(ASUBEVCC, r0)
+
+		case ASYNC:
+			opset(AISYNC, r0)
+			opset(ALWSYNC, r0)
+			opset(APTESYNC, r0)
+			opset(ATLBSYNC, r0)
+
+		case ARLWMI:
+			opset(ARLWMICC, r0)
+			opset(ARLWNM, r0)
+			opset(ARLWNMCC, r0)
+			opset(ACLRLSLWI, r0)
+
+		case ARLDMI:
+			opset(ARLDMICC, r0)
+			opset(ARLDIMI, r0)
+			opset(ARLDIMICC, r0)
+
+		case ARLDC:
+			opset(ARLDCCC, r0)
+
+		case ARLDCL:
+			opset(ARLDCR, r0)
+			opset(ARLDCLCC, r0)
+			opset(ARLDCRCC, r0)
+
+		case ARLDICL:
+			opset(ARLDICLCC, r0)
+			opset(ARLDICR, r0)
+			opset(ARLDICRCC, r0)
+			opset(ARLDIC, r0)
+			opset(ARLDICCC, r0)
+			opset(ACLRLSLDI, r0)
+
+		case AFMOVD:
+			opset(AFMOVDCC, r0)
+			opset(AFMOVDU, r0)
+			opset(AFMOVS, r0)
+			opset(AFMOVSU, r0)
+
+		case ALDAR:
+			opset(ALBAR, r0)
+			opset(ALHAR, r0)
+			opset(ALWAR, r0)
+
+		case ASYSCALL: /* just the op; flow of control */
+			opset(ARFI, r0)
+
+			opset(ARFCI, r0)
+			opset(ARFID, r0)
+			opset(AHRFID, r0)
+
+		case AMOVHBR:
+			opset(AMOVWBR, r0)
+			opset(AMOVDBR, r0)
+
+		case ASLBMFEE:
+			opset(ASLBMFEV, r0)
+
+		case ATW:
+			opset(ATD, r0)
+
+		case ATLBIE:
+			opset(ASLBIE, r0)
+			opset(ATLBIEL, r0)
+
+		case AEIEIO:
+			opset(ASLBIA, r0)
+
+		case ACMP:
+			opset(ACMPW, r0)
+
+		case ACMPU:
+			opset(ACMPWU, r0)
+
+		case ACMPB:
+			opset(ACMPB, r0)
+
+		case AFTDIV:
+			opset(AFTDIV, r0)
+
+		case AFTSQRT:
+			opset(AFTSQRT, r0)
+
+		case AADD,
+			AADDIS,
+			AANDCC, /* and. Rb,Rs,Ra; andi. $uimm,Rs,Ra */
+			AANDISCC,
+			AFMOVSX,
+			AFMOVSZ,
+			ALSW,
+			AMOVW,
+			/* load/store/move word with sign extension; special 32-bit move; move 32-bit literals */
+			AMOVWZ, /* load/store/move word with zero extension; move 32-bit literals  */
+			AMOVD,  /* load/store/move 64-bit values, including 32-bit literals with/without sign-extension */
+			AMOVB,  /* macro: move byte with sign extension */
+			AMOVBU, /* macro: move byte with sign extension & update */
+			AMOVFL,
+			AMULLW,
+			/* op $s[,r2],r3; op r1[,r2],r3; no cc/v */
+			ASUBC, /* op r1,$s,r3; op r1[,r2],r3 */
+			ASTSW,
+			ASLBMTE,
+			AWORD,
+			ADWORD,
+			ADARN,
+			ALDMX,
+			AVMSUMUDM,
+			AADDEX,
+			ACMPEQB,
+			AECIWX,
+			obj.ANOP,
+			obj.ATEXT,
+			obj.AUNDEF,
+			obj.AFUNCDATA,
+			obj.APCALIGN,
+			obj.APCDATA,
+			obj.ADUFFZERO,
+			obj.ADUFFCOPY:
+			break
+		}
+	}
+}
+
+func OPVXX1(o uint32, xo uint32, oe uint32) uint32 {
+	return o<<26 | xo<<1 | oe<<11
+}
+
+func OPVXX2(o uint32, xo uint32, oe uint32) uint32 {
+	return o<<26 | xo<<2 | oe<<11
+}
+
+func OPVXX2VA(o uint32, xo uint32, oe uint32) uint32 {
+	return o<<26 | xo<<2 | oe<<16
+}
+
+func OPVXX3(o uint32, xo uint32, oe uint32) uint32 {
+	return o<<26 | xo<<3 | oe<<11
+}
+
+func OPVXX4(o uint32, xo uint32, oe uint32) uint32 {
+	return o<<26 | xo<<4 | oe<<11
+}
+
+func OPDQ(o uint32, xo uint32, oe uint32) uint32 {
+	return o<<26 | xo | oe<<4
+}
+
+func OPVX(o uint32, xo uint32, oe uint32, rc uint32) uint32 {
+	return o<<26 | xo | oe<<11 | rc&1
+}
+
+func OPVC(o uint32, xo uint32, oe uint32, rc uint32) uint32 {
+	return o<<26 | xo | oe<<11 | (rc&1)<<10
+}
+
+func OPVCC(o uint32, xo uint32, oe uint32, rc uint32) uint32 {
+	return o<<26 | xo<<1 | oe<<10 | rc&1
+}
+
+func OPCC(o uint32, xo uint32, rc uint32) uint32 {
+	return OPVCC(o, xo, 0, rc)
+}
+
+/* the order is dest, a/s, b/imm for both arithmetic and logical operations */
+func AOP_RRR(op uint32, d uint32, a uint32, b uint32) uint32 {
+	return op | (d&31)<<21 | (a&31)<<16 | (b&31)<<11
+}
+
+/* VX-form 2-register operands, r/none/r */
+func AOP_RR(op uint32, d uint32, a uint32) uint32 {
+	return op | (d&31)<<21 | (a&31)<<11
+}
+
+/* VA-form 4-register operands */
+func AOP_RRRR(op uint32, d uint32, a uint32, b uint32, c uint32) uint32 {
+	return op | (d&31)<<21 | (a&31)<<16 | (b&31)<<11 | (c&31)<<6
+}
+
+func AOP_IRR(op uint32, d uint32, a uint32, simm uint32) uint32 {
+	return op | (d&31)<<21 | (a&31)<<16 | simm&0xFFFF
+}
+
+/* VX-form 2-register + UIM operands */
+func AOP_VIRR(op uint32, d uint32, a uint32, simm uint32) uint32 {
+	return op | (d&31)<<21 | (simm&0xFFFF)<<16 | (a&31)<<11
+}
+
+/* VX-form 2-register + ST + SIX operands */
+func AOP_IIRR(op uint32, d uint32, a uint32, sbit uint32, simm uint32) uint32 {
+	return op | (d&31)<<21 | (a&31)<<16 | (sbit&1)<<15 | (simm&0xF)<<11
+}
+
+/* VA-form 3-register + SHB operands */
+func AOP_IRRR(op uint32, d uint32, a uint32, b uint32, simm uint32) uint32 {
+	return op | (d&31)<<21 | (a&31)<<16 | (b&31)<<11 | (simm&0xF)<<6
+}
+
+/* VX-form 1-register + SIM operands */
+func AOP_IR(op uint32, d uint32, simm uint32) uint32 {
+	return op | (d&31)<<21 | (simm&31)<<16
+}
+
+/* XX1-form 3-register operands, 1 VSR operand */
+func AOP_XX1(op uint32, d uint32, a uint32, b uint32) uint32 {
+	/* For the XX-form encodings, we need the VSX register number to be exactly */
+	/* between 0-63, so we can properly set the rightmost bits. */
+	r := d - REG_VS0
+	return op | (r&31)<<21 | (a&31)<<16 | (b&31)<<11 | (r&32)>>5
+}
+
+/* XX2-form 3-register operands, 2 VSR operands */
+func AOP_XX2(op uint32, d uint32, a uint32, b uint32) uint32 {
+	xt := d - REG_VS0
+	xb := b - REG_VS0
+	return op | (xt&31)<<21 | (a&3)<<16 | (xb&31)<<11 | (xb&32)>>4 | (xt&32)>>5
+}
+
+/* XX3-form 3 VSR operands */
+func AOP_XX3(op uint32, d uint32, a uint32, b uint32) uint32 {
+	xt := d - REG_VS0
+	xa := a - REG_VS0
+	xb := b - REG_VS0
+	return op | (xt&31)<<21 | (xa&31)<<16 | (xb&31)<<11 | (xa&32)>>3 | (xb&32)>>4 | (xt&32)>>5
+}
+
+/* XX3-form 3 VSR operands + immediate */
+func AOP_XX3I(op uint32, d uint32, a uint32, b uint32, c uint32) uint32 {
+	xt := d - REG_VS0
+	xa := a - REG_VS0
+	xb := b - REG_VS0
+	return op | (xt&31)<<21 | (xa&31)<<16 | (xb&31)<<11 | (c&3)<<8 | (xa&32)>>3 | (xb&32)>>4 | (xt&32)>>5
+}
+
+/* XX4-form, 4 VSR operands */
+func AOP_XX4(op uint32, d uint32, a uint32, b uint32, c uint32) uint32 {
+	xt := d - REG_VS0
+	xa := a - REG_VS0
+	xb := b - REG_VS0
+	xc := c - REG_VS0
+	return op | (xt&31)<<21 | (xa&31)<<16 | (xb&31)<<11 | (xc&31)<<6 | (xc&32)>>2 | (xa&32)>>3 | (xb&32)>>4 | (xt&32)>>5
+}
+
+/* DQ-form, VSR register, register + offset operands */
+func AOP_DQ(op uint32, d uint32, a uint32, b uint32) uint32 {
+	/* For the DQ-form encodings, we need the VSX register number to be exactly */
+	/* between 0-63, so we can properly set the SX bit. */
+	r := d - REG_VS0
+	/* The EA for this instruction form is (RA) + DQ << 4, where DQ is a 12-bit signed integer. */
+	/* In order to match the output of the GNU objdump (and make the usage in Go asm easier), the */
+	/* instruction is called using the sign extended value (i.e. a valid offset would be -32752 or 32752, */
+	/* not -2047 or 2047), so 'b' needs to be adjusted to the expected 12-bit DQ value. Bear in mind that */
+	/* bits 0 to 3 in 'dq' need to be zero, otherwise this will generate an illegal instruction. */
+	/* If in doubt how this instruction form is encoded, refer to ISA 3.0b, pages 492 and 507. */
+	dq := b >> 4
+	return op | (r&31)<<21 | (a&31)<<16 | (dq&4095)<<4 | (r&32)>>2
+}
+
+/* Z23-form, 3-register operands + CY field */
+func AOP_Z23I(op uint32, d uint32, a uint32, b uint32, c uint32) uint32 {
+	return op | (d&31)<<21 | (a&31)<<16 | (b&31)<<11 | (c&3)<<7
+}
+
+/* X-form, 3-register operands + EH field */
+func AOP_RRRI(op uint32, d uint32, a uint32, b uint32, c uint32) uint32 {
+	return op | (d&31)<<21 | (a&31)<<16 | (b&31)<<11 | (c & 1)
+}
+
+func LOP_RRR(op uint32, a uint32, s uint32, b uint32) uint32 {
+	return op | (s&31)<<21 | (a&31)<<16 | (b&31)<<11
+}
+
+func LOP_IRR(op uint32, a uint32, s uint32, uimm uint32) uint32 {
+	return op | (s&31)<<21 | (a&31)<<16 | uimm&0xFFFF
+}
+
+func OP_BR(op uint32, li uint32, aa uint32) uint32 {
+	return op | li&0x03FFFFFC | aa<<1
+}
+
+func OP_BC(op uint32, bo uint32, bi uint32, bd uint32, aa uint32) uint32 {
+	return op | (bo&0x1F)<<21 | (bi&0x1F)<<16 | bd&0xFFFC | aa<<1
+}
+
+func OP_BCR(op uint32, bo uint32, bi uint32) uint32 {
+	return op | (bo&0x1F)<<21 | (bi&0x1F)<<16
+}
+
+func OP_RLW(op uint32, a uint32, s uint32, sh uint32, mb uint32, me uint32) uint32 {
+	return op | (s&31)<<21 | (a&31)<<16 | (sh&31)<<11 | (mb&31)<<6 | (me&31)<<1
+}
+
+func AOP_RLDIC(op uint32, a uint32, s uint32, sh uint32, m uint32) uint32 {
+	return op | (s&31)<<21 | (a&31)<<16 | (sh&31)<<11 | ((sh&32)>>5)<<1 | (m&31)<<6 | ((m&32)>>5)<<5
+}
+
+func AOP_ISEL(op uint32, t uint32, a uint32, b uint32, bc uint32) uint32 {
+	return op | (t&31)<<21 | (a&31)<<16 | (b&31)<<11 | (bc&0x1F)<<6
+}
+
+const (
+	/* each rhs is OPVCC(_, _, _, _) */
+	OP_ADD    = 31<<26 | 266<<1 | 0<<10 | 0
+	OP_ADDI   = 14<<26 | 0<<1 | 0<<10 | 0
+	OP_ADDIS  = 15<<26 | 0<<1 | 0<<10 | 0
+	OP_ANDI   = 28<<26 | 0<<1 | 0<<10 | 0
+	OP_EXTSB  = 31<<26 | 954<<1 | 0<<10 | 0
+	OP_EXTSH  = 31<<26 | 922<<1 | 0<<10 | 0
+	OP_EXTSW  = 31<<26 | 986<<1 | 0<<10 | 0
+	OP_ISEL   = 31<<26 | 15<<1 | 0<<10 | 0
+	OP_MCRF   = 19<<26 | 0<<1 | 0<<10 | 0
+	OP_MCRFS  = 63<<26 | 64<<1 | 0<<10 | 0
+	OP_MCRXR  = 31<<26 | 512<<1 | 0<<10 | 0
+	OP_MFCR   = 31<<26 | 19<<1 | 0<<10 | 0
+	OP_MFFS   = 63<<26 | 583<<1 | 0<<10 | 0
+	OP_MFMSR  = 31<<26 | 83<<1 | 0<<10 | 0
+	OP_MFSPR  = 31<<26 | 339<<1 | 0<<10 | 0
+	OP_MFSR   = 31<<26 | 595<<1 | 0<<10 | 0
+	OP_MFSRIN = 31<<26 | 659<<1 | 0<<10 | 0
+	OP_MTCRF  = 31<<26 | 144<<1 | 0<<10 | 0
+	OP_MTFSF  = 63<<26 | 711<<1 | 0<<10 | 0
+	OP_MTFSFI = 63<<26 | 134<<1 | 0<<10 | 0
+	OP_MTMSR  = 31<<26 | 146<<1 | 0<<10 | 0
+	OP_MTMSRD = 31<<26 | 178<<1 | 0<<10 | 0
+	OP_MTSPR  = 31<<26 | 467<<1 | 0<<10 | 0
+	OP_MTSR   = 31<<26 | 210<<1 | 0<<10 | 0
+	OP_MTSRIN = 31<<26 | 242<<1 | 0<<10 | 0
+	OP_MULLW  = 31<<26 | 235<<1 | 0<<10 | 0
+	OP_MULLD  = 31<<26 | 233<<1 | 0<<10 | 0
+	OP_OR     = 31<<26 | 444<<1 | 0<<10 | 0
+	OP_ORI    = 24<<26 | 0<<1 | 0<<10 | 0
+	OP_ORIS   = 25<<26 | 0<<1 | 0<<10 | 0
+	OP_RLWINM = 21<<26 | 0<<1 | 0<<10 | 0
+	OP_RLWNM  = 23<<26 | 0<<1 | 0<<10 | 0
+	OP_SUBF   = 31<<26 | 40<<1 | 0<<10 | 0
+	OP_RLDIC  = 30<<26 | 4<<1 | 0<<10 | 0
+	OP_RLDICR = 30<<26 | 2<<1 | 0<<10 | 0
+	OP_RLDICL = 30<<26 | 0<<1 | 0<<10 | 0
+	OP_RLDCL  = 30<<26 | 8<<1 | 0<<10 | 0
+)
+
+func oclass(a *obj.Addr) int {
+	return int(a.Class) - 1
+}
+
+const (
+	D_FORM = iota
+	DS_FORM
+)
+
+// This function determines when a non-indexed load or store is D or
+// DS form for use in finding the size of the offset field in the instruction.
+// The size is needed when setting the offset value in the instruction
+// and when generating relocation for that field.
+// DS form instructions include: ld, ldu, lwa, std, stdu.  All other
+// loads and stores with an offset field are D form.  This function should
+// only be called with the same opcodes as are handled by opstore and opload.
+func (c *ctxt9) opform(insn uint32) int {
+	switch insn {
+	default:
+		c.ctxt.Diag("bad insn in loadform: %x", insn)
+	case OPVCC(58, 0, 0, 0), // ld
+		OPVCC(58, 0, 0, 1),        // ldu
+		OPVCC(58, 0, 0, 0) | 1<<1, // lwa
+		OPVCC(62, 0, 0, 0),        // std
+		OPVCC(62, 0, 0, 1):        //stdu
+		return DS_FORM
+	case OP_ADDI, // add
+		OPVCC(32, 0, 0, 0), // lwz
+		OPVCC(33, 0, 0, 0), // lwzu
+		OPVCC(34, 0, 0, 0), // lbz
+		OPVCC(35, 0, 0, 0), // lbzu
+		OPVCC(40, 0, 0, 0), // lhz
+		OPVCC(41, 0, 0, 0), // lhzu
+		OPVCC(42, 0, 0, 0), // lha
+		OPVCC(43, 0, 0, 0), // lhau
+		OPVCC(46, 0, 0, 0), // lmw
+		OPVCC(48, 0, 0, 0), // lfs
+		OPVCC(49, 0, 0, 0), // lfsu
+		OPVCC(50, 0, 0, 0), // lfd
+		OPVCC(51, 0, 0, 0), // lfdu
+		OPVCC(36, 0, 0, 0), // stw
+		OPVCC(37, 0, 0, 0), // stwu
+		OPVCC(38, 0, 0, 0), // stb
+		OPVCC(39, 0, 0, 0), // stbu
+		OPVCC(44, 0, 0, 0), // sth
+		OPVCC(45, 0, 0, 0), // sthu
+		OPVCC(47, 0, 0, 0), // stmw
+		OPVCC(52, 0, 0, 0), // stfs
+		OPVCC(53, 0, 0, 0), // stfsu
+		OPVCC(54, 0, 0, 0), // stfd
+		OPVCC(55, 0, 0, 0): // stfdu
+		return D_FORM
+	}
+	return 0
+}
+
+// Encode instructions and create relocation for accessing s+d according to the
+// instruction op with source or destination (as appropriate) register reg.
+func (c *ctxt9) symbolAccess(s *obj.LSym, d int64, reg int16, op uint32) (o1, o2 uint32) {
+	if c.ctxt.Headtype == objabi.Haix {
+		// Every symbol access must be made via a TOC anchor.
+		c.ctxt.Diag("symbolAccess called for %s", s.Name)
+	}
+	var base uint32
+	form := c.opform(op)
+	if c.ctxt.Flag_shared {
+		base = REG_R2
+	} else {
+		base = REG_R0
+	}
+	o1 = AOP_IRR(OP_ADDIS, REGTMP, base, 0)
+	o2 = AOP_IRR(op, uint32(reg), REGTMP, 0)
+	rel := obj.Addrel(c.cursym)
+	rel.Off = int32(c.pc)
+	rel.Siz = 8
+	rel.Sym = s
+	rel.Add = d
+	if c.ctxt.Flag_shared {
+		switch form {
+		case D_FORM:
+			rel.Type = objabi.R_ADDRPOWER_TOCREL
+		case DS_FORM:
+			rel.Type = objabi.R_ADDRPOWER_TOCREL_DS
+		}
+
+	} else {
+		switch form {
+		case D_FORM:
+			rel.Type = objabi.R_ADDRPOWER
+		case DS_FORM:
+			rel.Type = objabi.R_ADDRPOWER_DS
+		}
+	}
+	return
+}
+
+/*
+ * 32-bit masks
+ */
+func getmask(m []byte, v uint32) bool {
+	m[1] = 0
+	m[0] = m[1]
+	if v != ^uint32(0) && v&(1<<31) != 0 && v&1 != 0 { /* MB > ME */
+		if getmask(m, ^v) {
+			i := int(m[0])
+			m[0] = m[1] + 1
+			m[1] = byte(i - 1)
+			return true
+		}
+
+		return false
+	}
+
+	for i := 0; i < 32; i++ {
+		if v&(1<<uint(31-i)) != 0 {
+			m[0] = byte(i)
+			for {
+				m[1] = byte(i)
+				i++
+				if i >= 32 || v&(1<<uint(31-i)) == 0 {
+					break
+				}
+			}
+
+			for ; i < 32; i++ {
+				if v&(1<<uint(31-i)) != 0 {
+					return false
+				}
+			}
+			return true
+		}
+	}
+
+	return false
+}
+
+func (c *ctxt9) maskgen(p *obj.Prog, m []byte, v uint32) {
+	if !getmask(m, v) {
+		c.ctxt.Diag("cannot generate mask #%x\n%v", v, p)
+	}
+}
+
+/*
+ * 64-bit masks (rldic etc)
+ */
+func getmask64(m []byte, v uint64) bool {
+	m[1] = 0
+	m[0] = m[1]
+	for i := 0; i < 64; i++ {
+		if v&(uint64(1)<<uint(63-i)) != 0 {
+			m[0] = byte(i)
+			for {
+				m[1] = byte(i)
+				i++
+				if i >= 64 || v&(uint64(1)<<uint(63-i)) == 0 {
+					break
+				}
+			}
+
+			for ; i < 64; i++ {
+				if v&(uint64(1)<<uint(63-i)) != 0 {
+					return false
+				}
+			}
+			return true
+		}
+	}
+
+	return false
+}
+
+func (c *ctxt9) maskgen64(p *obj.Prog, m []byte, v uint64) {
+	if !getmask64(m, v) {
+		c.ctxt.Diag("cannot generate mask #%x\n%v", v, p)
+	}
+}
+
+func loadu32(r int, d int64) uint32 {
+	v := int32(d >> 16)
+	if isuint32(uint64(d)) {
+		return LOP_IRR(OP_ORIS, uint32(r), REGZERO, uint32(v))
+	}
+	return AOP_IRR(OP_ADDIS, uint32(r), REGZERO, uint32(v))
+}
+
+func high16adjusted(d int32) uint16 {
+	if d&0x8000 != 0 {
+		return uint16((d >> 16) + 1)
+	}
+	return uint16(d >> 16)
+}
+
+func (c *ctxt9) asmout(p *obj.Prog, o *Optab, out []uint32) {
+	o1 := uint32(0)
+	o2 := uint32(0)
+	o3 := uint32(0)
+	o4 := uint32(0)
+	o5 := uint32(0)
+
+	//print("%v => case %d\n", p, o->type);
+	switch o.type_ {
+	default:
+		c.ctxt.Diag("unknown type %d", o.type_)
+		prasm(p)
+
+	case 0: /* pseudo ops */
+		break
+
+	case 1: /* mov r1,r2 ==> OR Rs,Rs,Ra */
+		if p.To.Reg == REGZERO && p.From.Type == obj.TYPE_CONST {
+			v := c.regoff(&p.From)
+			if r0iszero != 0 /*TypeKind(100016)*/ && v != 0 {
+				//nerrors--;
+				c.ctxt.Diag("literal operation on R0\n%v", p)
+			}
+
+			o1 = LOP_IRR(OP_ADDI, REGZERO, REGZERO, uint32(v))
+			break
+		}
+
+		o1 = LOP_RRR(OP_OR, uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.From.Reg))
+
+	case 2: /* int/cr/fp op Rb,[Ra],Rd */
+		r := int(p.Reg)
+
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), uint32(p.From.Reg))
+
+	case 3: /* mov $soreg/addcon/andcon/ucon, r ==> addis/oris/addi/ori $i,reg',r */
+		d := c.vregoff(&p.From)
+
+		v := int32(d)
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		if r0iszero != 0 /*TypeKind(100016)*/ && p.To.Reg == 0 && (r != 0 || v != 0) {
+			c.ctxt.Diag("literal operation on R0\n%v", p)
+		}
+		a := OP_ADDI
+		if o.a1 == C_UCON {
+			if d&0xffff != 0 {
+				log.Fatalf("invalid handling of %v", p)
+			}
+			// For UCON operands the value is right shifted 16, using ADDIS if the
+			// value should be signed, ORIS if unsigned.
+			v >>= 16
+			if r == REGZERO && isuint32(uint64(d)) {
+				o1 = LOP_IRR(OP_ORIS, uint32(p.To.Reg), REGZERO, uint32(v))
+				break
+			}
+
+			a = OP_ADDIS
+		} else if int64(int16(d)) != d {
+			// Operand is 16 bit value with sign bit set
+			if o.a1 == C_ANDCON {
+				// Needs unsigned 16 bit so use ORI
+				if r == 0 || r == REGZERO {
+					o1 = LOP_IRR(uint32(OP_ORI), uint32(p.To.Reg), uint32(0), uint32(v))
+					break
+				}
+				// With ADDCON, needs signed 16 bit value, fall through to use ADDI
+			} else if o.a1 != C_ADDCON {
+				log.Fatalf("invalid handling of %v", p)
+			}
+		}
+
+		o1 = AOP_IRR(uint32(a), uint32(p.To.Reg), uint32(r), uint32(v))
+
+	case 4: /* add/mul $scon,[r1],r2 */
+		v := c.regoff(&p.From)
+
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		if r0iszero != 0 /*TypeKind(100016)*/ && p.To.Reg == 0 {
+			c.ctxt.Diag("literal operation on R0\n%v", p)
+		}
+		if int32(int16(v)) != v {
+			log.Fatalf("mishandled instruction %v", p)
+		}
+		o1 = AOP_IRR(c.opirr(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
+
+	case 5: /* syscall */
+		o1 = c.oprrr(p.As)
+
+	case 6: /* logical op Rb,[Rs,]Ra; no literal */
+		r := int(p.Reg)
+
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		// AROTL and AROTLW are extended mnemonics, which map to RLDCL and RLWNM.
+		switch p.As {
+		case AROTL:
+			o1 = AOP_RLDIC(OP_RLDCL, uint32(p.To.Reg), uint32(r), uint32(p.From.Reg), uint32(0))
+		case AROTLW:
+			o1 = OP_RLW(OP_RLWNM, uint32(p.To.Reg), uint32(r), uint32(p.From.Reg), 0, 31)
+		default:
+			o1 = LOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), uint32(p.From.Reg))
+		}
+
+	case 7: /* mov r, soreg ==> stw o(r) */
+		r := int(p.To.Reg)
+
+		if r == 0 {
+			r = int(o.param)
+		}
+		v := c.regoff(&p.To)
+		if p.To.Type == obj.TYPE_MEM && p.To.Index != 0 {
+			if v != 0 {
+				c.ctxt.Diag("illegal indexed instruction\n%v", p)
+			}
+			if c.ctxt.Flag_shared && r == REG_R13 {
+				rel := obj.Addrel(c.cursym)
+				rel.Off = int32(c.pc)
+				rel.Siz = 4
+				// This (and the matching part in the load case
+				// below) are the only places in the ppc64 toolchain
+				// that knows the name of the tls variable. Possibly
+				// we could add some assembly syntax so that the name
+				// of the variable does not have to be assumed.
+				rel.Sym = c.ctxt.Lookup("runtime.tls_g")
+				rel.Type = objabi.R_POWER_TLS
+			}
+			o1 = AOP_RRR(c.opstorex(p.As), uint32(p.From.Reg), uint32(p.To.Index), uint32(r))
+		} else {
+			if int32(int16(v)) != v {
+				log.Fatalf("mishandled instruction %v", p)
+			}
+			// Offsets in DS form stores must be a multiple of 4
+			inst := c.opstore(p.As)
+			if c.opform(inst) == DS_FORM && v&0x3 != 0 {
+				log.Fatalf("invalid offset for DS form load/store %v", p)
+			}
+			o1 = AOP_IRR(inst, uint32(p.From.Reg), uint32(r), uint32(v))
+		}
+
+	case 8: /* mov soreg, r ==> lbz/lhz/lwz o(r) */
+		r := int(p.From.Reg)
+
+		if r == 0 {
+			r = int(o.param)
+		}
+		v := c.regoff(&p.From)
+		if p.From.Type == obj.TYPE_MEM && p.From.Index != 0 {
+			if v != 0 {
+				c.ctxt.Diag("illegal indexed instruction\n%v", p)
+			}
+			if c.ctxt.Flag_shared && r == REG_R13 {
+				rel := obj.Addrel(c.cursym)
+				rel.Off = int32(c.pc)
+				rel.Siz = 4
+				rel.Sym = c.ctxt.Lookup("runtime.tls_g")
+				rel.Type = objabi.R_POWER_TLS
+			}
+			o1 = AOP_RRR(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(r))
+		} else {
+			if int32(int16(v)) != v {
+				log.Fatalf("mishandled instruction %v", p)
+			}
+			// Offsets in DS form loads must be a multiple of 4
+			inst := c.opload(p.As)
+			if c.opform(inst) == DS_FORM && v&0x3 != 0 {
+				log.Fatalf("invalid offset for DS form load/store %v", p)
+			}
+			o1 = AOP_IRR(inst, uint32(p.To.Reg), uint32(r), uint32(v))
+		}
+
+	case 9: /* movb soreg, r ==> lbz o(r),r2; extsb r2,r2 */
+		r := int(p.From.Reg)
+
+		if r == 0 {
+			r = int(o.param)
+		}
+		v := c.regoff(&p.From)
+		if p.From.Type == obj.TYPE_MEM && p.From.Index != 0 {
+			if v != 0 {
+				c.ctxt.Diag("illegal indexed instruction\n%v", p)
+			}
+			o1 = AOP_RRR(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(r))
+		} else {
+			o1 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
+		}
+		o2 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.To.Reg), 0)
+
+	case 10: /* sub Ra,[Rb],Rd => subf Rd,Ra,Rb */
+		r := int(p.Reg)
+
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(r))
+
+	case 11: /* br/bl lbra */
+		v := int32(0)
+
+		if p.To.Target() != nil {
+			v = int32(p.To.Target().Pc - p.Pc)
+			if v&03 != 0 {
+				c.ctxt.Diag("odd branch target address\n%v", p)
+				v &^= 03
+			}
+
+			if v < -(1<<25) || v >= 1<<24 {
+				c.ctxt.Diag("branch too far\n%v", p)
+			}
+		}
+
+		o1 = OP_BR(c.opirr(p.As), uint32(v), 0)
+		if p.To.Sym != nil {
+			rel := obj.Addrel(c.cursym)
+			rel.Off = int32(c.pc)
+			rel.Siz = 4
+			rel.Sym = p.To.Sym
+			v += int32(p.To.Offset)
+			if v&03 != 0 {
+				c.ctxt.Diag("odd branch target address\n%v", p)
+				v &^= 03
+			}
+
+			rel.Add = int64(v)
+			rel.Type = objabi.R_CALLPOWER
+		}
+		o2 = 0x60000000 // nop, sometimes overwritten by ld r2, 24(r1) when dynamic linking
+
+	case 12: /* movb r,r (extsb); movw r,r (extsw) */
+		if p.To.Reg == REGZERO && p.From.Type == obj.TYPE_CONST {
+			v := c.regoff(&p.From)
+			if r0iszero != 0 /*TypeKind(100016)*/ && v != 0 {
+				c.ctxt.Diag("literal operation on R0\n%v", p)
+			}
+
+			o1 = LOP_IRR(OP_ADDI, REGZERO, REGZERO, uint32(v))
+			break
+		}
+
+		if p.As == AMOVW {
+			o1 = LOP_RRR(OP_EXTSW, uint32(p.To.Reg), uint32(p.From.Reg), 0)
+		} else {
+			o1 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.From.Reg), 0)
+		}
+
+	case 13: /* mov[bhw]z r,r; uses rlwinm not andi. to avoid changing CC */
+		if p.As == AMOVBZ {
+			o1 = OP_RLW(OP_RLWINM, uint32(p.To.Reg), uint32(p.From.Reg), 0, 24, 31)
+		} else if p.As == AMOVH {
+			o1 = LOP_RRR(OP_EXTSH, uint32(p.To.Reg), uint32(p.From.Reg), 0)
+		} else if p.As == AMOVHZ {
+			o1 = OP_RLW(OP_RLWINM, uint32(p.To.Reg), uint32(p.From.Reg), 0, 16, 31)
+		} else if p.As == AMOVWZ {
+			o1 = OP_RLW(OP_RLDIC, uint32(p.To.Reg), uint32(p.From.Reg), 0, 0, 0) | 1<<5 /* MB=32 */
+		} else {
+			c.ctxt.Diag("internal: bad mov[bhw]z\n%v", p)
+		}
+
+	case 14: /* rldc[lr] Rb,Rs,$mask,Ra -- left, right give different masks */
+		r := int(p.Reg)
+
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		d := c.vregoff(p.GetFrom3())
+		var a int
+		switch p.As {
+
+		// These opcodes expect a mask operand that has to be converted into the
+		// appropriate operand.  The way these were defined, not all valid masks are possible.
+		// Left here for compatibility in case they were used or generated.
+		case ARLDCL, ARLDCLCC:
+			var mask [2]uint8
+			c.maskgen64(p, mask[:], uint64(d))
+
+			a = int(mask[0]) /* MB */
+			if mask[1] != 63 {
+				c.ctxt.Diag("invalid mask for rotate: %x (end != bit 63)\n%v", uint64(d), p)
+			}
+			o1 = LOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), uint32(p.From.Reg))
+			o1 |= (uint32(a) & 31) << 6
+			if a&0x20 != 0 {
+				o1 |= 1 << 5 /* mb[5] is top bit */
+			}
+
+		case ARLDCR, ARLDCRCC:
+			var mask [2]uint8
+			c.maskgen64(p, mask[:], uint64(d))
+
+			a = int(mask[1]) /* ME */
+			if mask[0] != 0 {
+				c.ctxt.Diag("invalid mask for rotate: %x %x (start != 0)\n%v", uint64(d), mask[0], p)
+			}
+			o1 = LOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), uint32(p.From.Reg))
+			o1 |= (uint32(a) & 31) << 6
+			if a&0x20 != 0 {
+				o1 |= 1 << 5 /* mb[5] is top bit */
+			}
+
+		// These opcodes use a shift count like the ppc64 asm, no mask conversion done
+		case ARLDICR, ARLDICRCC:
+			me := int(d)
+			sh := c.regoff(&p.From)
+			if me < 0 || me > 63 || sh > 63 {
+				c.ctxt.Diag("Invalid me or sh for RLDICR: %x %x\n%v", int(d), sh)
+			}
+			o1 = AOP_RLDIC(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), uint32(sh), uint32(me))
+
+		case ARLDICL, ARLDICLCC, ARLDIC, ARLDICCC:
+			mb := int(d)
+			sh := c.regoff(&p.From)
+			if mb < 0 || mb > 63 || sh > 63 {
+				c.ctxt.Diag("Invalid mb or sh for RLDIC, RLDICL: %x %x\n%v", mb, sh)
+			}
+			o1 = AOP_RLDIC(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), uint32(sh), uint32(mb))
+
+		case ACLRLSLDI:
+			// This is an extended mnemonic defined in the ISA section C.8.1
+			// clrlsldi ra,rs,n,b --> rldic ra,rs,n,b-n
+			// It maps onto RLDIC so is directly generated here based on the operands from
+			// the clrlsldi.
+			b := int(d)
+			n := c.regoff(&p.From)
+			if n > int32(b) || b > 63 {
+				c.ctxt.Diag("Invalid n or b for CLRLSLDI: %x %x\n%v", n, b)
+			}
+			o1 = AOP_RLDIC(OP_RLDIC, uint32(p.To.Reg), uint32(r), uint32(n), uint32(b)-uint32(n))
+
+		default:
+			c.ctxt.Diag("unexpected op in rldc case\n%v", p)
+			a = 0
+		}
+
+	case 17, /* bc bo,bi,lbra (same for now) */
+		16: /* bc bo,bi,sbra */
+		a := 0
+
+		r := int(p.Reg)
+
+		if p.From.Type == obj.TYPE_CONST {
+			a = int(c.regoff(&p.From))
+		} else if p.From.Type == obj.TYPE_REG {
+			if r != 0 {
+				c.ctxt.Diag("unexpected register setting for branch with CR: %d\n", r)
+			}
+			// BI values for the CR
+			switch p.From.Reg {
+			case REG_CR0:
+				r = BI_CR0
+			case REG_CR1:
+				r = BI_CR1
+			case REG_CR2:
+				r = BI_CR2
+			case REG_CR3:
+				r = BI_CR3
+			case REG_CR4:
+				r = BI_CR4
+			case REG_CR5:
+				r = BI_CR5
+			case REG_CR6:
+				r = BI_CR6
+			case REG_CR7:
+				r = BI_CR7
+			default:
+				c.ctxt.Diag("unrecognized register: expecting CR\n")
+			}
+		}
+		v := int32(0)
+		if p.To.Target() != nil {
+			v = int32(p.To.Target().Pc - p.Pc)
+		}
+		if v&03 != 0 {
+			c.ctxt.Diag("odd branch target address\n%v", p)
+			v &^= 03
+		}
+
+		if v < -(1<<16) || v >= 1<<15 {
+			c.ctxt.Diag("branch too far\n%v", p)
+		}
+		o1 = OP_BC(c.opirr(p.As), uint32(a), uint32(r), uint32(v), 0)
+
+	case 15: /* br/bl (r) => mov r,lr; br/bl (lr) */
+		var v int32
+		if p.As == ABC || p.As == ABCL {
+			v = c.regoff(&p.To) & 31
+		} else {
+			v = 20 /* unconditional */
+		}
+		o1 = AOP_RRR(OP_MTSPR, uint32(p.To.Reg), 0, 0) | (REG_LR&0x1f)<<16 | ((REG_LR>>5)&0x1f)<<11
+		o2 = OPVCC(19, 16, 0, 0)
+		if p.As == ABL || p.As == ABCL {
+			o2 |= 1
+		}
+		o2 = OP_BCR(o2, uint32(v), uint32(p.To.Index))
+
+	case 18: /* br/bl (lr/ctr); bc/bcl bo,bi,(lr/ctr) */
+		var v int32
+		if p.As == ABC || p.As == ABCL {
+			v = c.regoff(&p.From) & 31
+		} else {
+			v = 20 /* unconditional */
+		}
+		r := int(p.Reg)
+		if r == 0 {
+			r = 0
+		}
+		switch oclass(&p.To) {
+		case C_CTR:
+			o1 = OPVCC(19, 528, 0, 0)
+
+		case C_LR:
+			o1 = OPVCC(19, 16, 0, 0)
+
+		default:
+			c.ctxt.Diag("bad optab entry (18): %d\n%v", p.To.Class, p)
+			v = 0
+		}
+
+		if p.As == ABL || p.As == ABCL {
+			o1 |= 1
+		}
+		o1 = OP_BCR(o1, uint32(v), uint32(r))
+
+	case 19: /* mov $lcon,r ==> cau+or */
+		d := c.vregoff(&p.From)
+
+		if p.From.Sym == nil {
+			o1 = loadu32(int(p.To.Reg), d)
+			o2 = LOP_IRR(OP_ORI, uint32(p.To.Reg), uint32(p.To.Reg), uint32(int32(d)))
+		} else {
+			o1, o2 = c.symbolAccess(p.From.Sym, d, p.To.Reg, OP_ADDI)
+		}
+
+	case 20: /* add $ucon,,r | addis $addcon,r,r */
+		v := c.regoff(&p.From)
+
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		if p.As == AADD && (r0iszero == 0 /*TypeKind(100016)*/ && p.Reg == 0 || r0iszero != 0 /*TypeKind(100016)*/ && p.To.Reg == 0) {
+			c.ctxt.Diag("literal operation on R0\n%v", p)
+		}
+		if p.As == AADDIS {
+			o1 = AOP_IRR(c.opirr(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
+		} else {
+			o1 = AOP_IRR(c.opirr(AADDIS), uint32(p.To.Reg), uint32(r), uint32(v)>>16)
+		}
+
+	case 22: /* add $lcon/$andcon,r1,r2 ==> oris+ori+add/ori+add */
+		if p.To.Reg == REGTMP || p.Reg == REGTMP {
+			c.ctxt.Diag("can't synthesize large constant\n%v", p)
+		}
+		d := c.vregoff(&p.From)
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		if p.From.Sym != nil {
+			c.ctxt.Diag("%v is not supported", p)
+		}
+		// If operand is ANDCON, generate 2 instructions using
+		// ORI for unsigned value; with LCON 3 instructions.
+		if o.size == 8 {
+			o1 = LOP_IRR(OP_ORI, REGTMP, REGZERO, uint32(int32(d)))
+			o2 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), REGTMP, uint32(r))
+		} else {
+			o1 = loadu32(REGTMP, d)
+			o2 = LOP_IRR(OP_ORI, REGTMP, REGTMP, uint32(int32(d)))
+			o3 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), REGTMP, uint32(r))
+		}
+
+	case 23: /* and $lcon/$addcon,r1,r2 ==> oris+ori+and/addi+and */
+		if p.To.Reg == REGTMP || p.Reg == REGTMP {
+			c.ctxt.Diag("can't synthesize large constant\n%v", p)
+		}
+		d := c.vregoff(&p.From)
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+
+		// With ADDCON operand, generate 2 instructions using ADDI for signed value,
+		// with LCON operand generate 3 instructions.
+		if o.size == 8 {
+			o1 = LOP_IRR(OP_ADDI, REGZERO, REGTMP, uint32(int32(d)))
+			o2 = LOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), REGTMP, uint32(r))
+		} else {
+			o1 = loadu32(REGTMP, d)
+			o2 = LOP_IRR(OP_ORI, REGTMP, REGTMP, uint32(int32(d)))
+			o3 = LOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), REGTMP, uint32(r))
+		}
+		if p.From.Sym != nil {
+			c.ctxt.Diag("%v is not supported", p)
+		}
+
+	case 24: /* lfd fA,float64(0) -> xxlxor xsA,xsaA,xsaA + fneg for -0 */
+		o1 = AOP_XX3I(c.oprrr(AXXLXOR), uint32(p.To.Reg), uint32(p.To.Reg), uint32(p.To.Reg), uint32(0))
+		// This is needed for -0.
+		if o.size == 8 {
+			o2 = AOP_RRR(c.oprrr(AFNEG), uint32(p.To.Reg), 0, uint32(p.To.Reg))
+		}
+
+	case 25:
+		/* sld[.] $sh,rS,rA -> rldicr[.] $sh,rS,mask(0,63-sh),rA; srd[.] -> rldicl */
+		v := c.regoff(&p.From)
+
+		if v < 0 {
+			v = 0
+		} else if v > 63 {
+			v = 63
+		}
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		var a int
+		op := uint32(0)
+		switch p.As {
+		case ASLD, ASLDCC:
+			a = int(63 - v)
+			op = OP_RLDICR
+
+		case ASRD, ASRDCC:
+			a = int(v)
+			v = 64 - v
+			op = OP_RLDICL
+		case AROTL:
+			a = int(0)
+			op = OP_RLDICL
+		default:
+			c.ctxt.Diag("unexpected op in sldi case\n%v", p)
+			a = 0
+			o1 = 0
+		}
+
+		o1 = AOP_RLDIC(op, uint32(p.To.Reg), uint32(r), uint32(v), uint32(a))
+		if p.As == ASLDCC || p.As == ASRDCC {
+			o1 |= 1 // Set the condition code bit
+		}
+
+	case 26: /* mov $lsext/auto/oreg,,r2 ==> addis+addi */
+		if p.To.Reg == REGTMP {
+			c.ctxt.Diag("can't synthesize large constant\n%v", p)
+		}
+		v := c.regoff(&p.From)
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
+		o2 = AOP_IRR(OP_ADDI, uint32(p.To.Reg), REGTMP, uint32(v))
+
+	case 27: /* subc ra,$simm,rd => subfic rd,ra,$simm */
+		v := c.regoff(p.GetFrom3())
+
+		r := int(p.From.Reg)
+		o1 = AOP_IRR(c.opirr(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
+
+	case 28: /* subc r1,$lcon,r2 ==> cau+or+subfc */
+		if p.To.Reg == REGTMP || p.From.Reg == REGTMP {
+			c.ctxt.Diag("can't synthesize large constant\n%v", p)
+		}
+		v := c.regoff(p.GetFrom3())
+		o1 = AOP_IRR(OP_ADDIS, REGTMP, REGZERO, uint32(v)>>16)
+		o2 = LOP_IRR(OP_ORI, REGTMP, REGTMP, uint32(v))
+		o3 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), REGTMP)
+		if p.From.Sym != nil {
+			c.ctxt.Diag("%v is not supported", p)
+		}
+
+	case 29: /* rldic[lr]? $sh,s,$mask,a -- left, right, plain give different masks */
+		v := c.regoff(&p.From)
+
+		d := c.vregoff(p.GetFrom3())
+		var mask [2]uint8
+		c.maskgen64(p, mask[:], uint64(d))
+		var a int
+		switch p.As {
+		case ARLDC, ARLDCCC:
+			a = int(mask[0]) /* MB */
+			if int32(mask[1]) != (63 - v) {
+				c.ctxt.Diag("invalid mask for shift: %x %x (shift %d)\n%v", uint64(d), mask[1], v, p)
+			}
+
+		case ARLDCL, ARLDCLCC:
+			a = int(mask[0]) /* MB */
+			if mask[1] != 63 {
+				c.ctxt.Diag("invalid mask for shift: %x %s (shift %d)\n%v", uint64(d), mask[1], v, p)
+			}
+
+		case ARLDCR, ARLDCRCC:
+			a = int(mask[1]) /* ME */
+			if mask[0] != 0 {
+				c.ctxt.Diag("invalid mask for shift: %x %x (shift %d)\n%v", uint64(d), mask[0], v, p)
+			}
+
+		default:
+			c.ctxt.Diag("unexpected op in rldic case\n%v", p)
+			a = 0
+		}
+
+		o1 = AOP_RRR(c.opirr(p.As), uint32(p.Reg), uint32(p.To.Reg), (uint32(v) & 0x1F))
+		o1 |= (uint32(a) & 31) << 6
+		if v&0x20 != 0 {
+			o1 |= 1 << 1
+		}
+		if a&0x20 != 0 {
+			o1 |= 1 << 5 /* mb[5] is top bit */
+		}
+
+	case 30: /* rldimi $sh,s,$mask,a */
+		v := c.regoff(&p.From)
+
+		d := c.vregoff(p.GetFrom3())
+
+		// Original opcodes had mask operands which had to be converted to a shift count as expected by
+		// the ppc64 asm.
+		switch p.As {
+		case ARLDMI, ARLDMICC:
+			var mask [2]uint8
+			c.maskgen64(p, mask[:], uint64(d))
+			if int32(mask[1]) != (63 - v) {
+				c.ctxt.Diag("invalid mask for shift: %x %x (shift %d)\n%v", uint64(d), mask[1], v, p)
+			}
+			o1 = AOP_RRR(c.opirr(p.As), uint32(p.Reg), uint32(p.To.Reg), (uint32(v) & 0x1F))
+			o1 |= (uint32(mask[0]) & 31) << 6
+			if v&0x20 != 0 {
+				o1 |= 1 << 1
+			}
+			if mask[0]&0x20 != 0 {
+				o1 |= 1 << 5 /* mb[5] is top bit */
+			}
+
+		// Opcodes with shift count operands.
+		case ARLDIMI, ARLDIMICC:
+			o1 = AOP_RRR(c.opirr(p.As), uint32(p.Reg), uint32(p.To.Reg), (uint32(v) & 0x1F))
+			o1 |= (uint32(d) & 31) << 6
+			if d&0x20 != 0 {
+				o1 |= 1 << 5
+			}
+			if v&0x20 != 0 {
+				o1 |= 1 << 1
+			}
+		}
+
+	case 31: /* dword */
+		d := c.vregoff(&p.From)
+
+		if c.ctxt.Arch.ByteOrder == binary.BigEndian {
+			o1 = uint32(d >> 32)
+			o2 = uint32(d)
+		} else {
+			o1 = uint32(d)
+			o2 = uint32(d >> 32)
+		}
+
+		if p.From.Sym != nil {
+			rel := obj.Addrel(c.cursym)
+			rel.Off = int32(c.pc)
+			rel.Siz = 8
+			rel.Sym = p.From.Sym
+			rel.Add = p.From.Offset
+			rel.Type = objabi.R_ADDR
+			o2 = 0
+			o1 = o2
+		}
+
+	case 32: /* fmul frc,fra,frd */
+		r := int(p.Reg)
+
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), 0) | (uint32(p.From.Reg)&31)<<6
+
+	case 33: /* fabs [frb,]frd; fmr. frb,frd */
+		r := int(p.From.Reg)
+
+		if oclass(&p.From) == C_NONE {
+			r = int(p.To.Reg)
+		}
+		o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), 0, uint32(r))
+
+	case 34: /* FMADDx fra,frb,frc,frt (t=a*c±b) */
+		o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg)) | (uint32(p.GetFrom3().Reg)&31)<<6
+
+	case 35: /* mov r,lext/lauto/loreg ==> cau $(v>>16),sb,r'; store o(r') */
+		v := c.regoff(&p.To)
+
+		r := int(p.To.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		// Offsets in DS form stores must be a multiple of 4
+		inst := c.opstore(p.As)
+		if c.opform(inst) == DS_FORM && v&0x3 != 0 {
+			log.Fatalf("invalid offset for DS form load/store %v", p)
+		}
+		o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
+		o2 = AOP_IRR(inst, uint32(p.From.Reg), REGTMP, uint32(v))
+
+	case 36: /* mov bz/h/hz lext/lauto/lreg,r ==> lbz/lha/lhz etc */
+		v := c.regoff(&p.From)
+
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
+		o2 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), REGTMP, uint32(v))
+
+	case 37: /* movb lext/lauto/lreg,r ==> lbz o(reg),r; extsb r */
+		v := c.regoff(&p.From)
+
+		r := int(p.From.Reg)
+		if r == 0 {
+			r = int(o.param)
+		}
+		o1 = AOP_IRR(OP_ADDIS, REGTMP, uint32(r), uint32(high16adjusted(v)))
+		o2 = AOP_IRR(c.opload(p.As), uint32(p.To.Reg), REGTMP, uint32(v))
+		o3 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.To.Reg), 0)
+
+	case 40: /* word */
+		o1 = uint32(c.regoff(&p.From))
+
+	case 41: /* stswi */
+		o1 = AOP_RRR(c.opirr(p.As), uint32(p.From.Reg), uint32(p.To.Reg), 0) | (uint32(c.regoff(p.GetFrom3()))&0x7F)<<11
+
+	case 42: /* lswi */
+		o1 = AOP_RRR(c.opirr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), 0) | (uint32(c.regoff(p.GetFrom3()))&0x7F)<<11
+
+	case 43: /* data cache instructions: op (Ra+[Rb]), [th|l] */
+		/* TH field for dcbt/dcbtst: */
+		/* 0 = Block access - program will soon access EA. */
+		/* 8-15 = Stream access - sequence of access (data stream). See section 4.3.2 of the ISA for details. */
+		/* 16 = Block access - program will soon make a transient access to EA. */
+		/* 17 = Block access - program will not access EA for a long time. */
+
+		/* L field for dcbf: */
+		/* 0 = invalidates the block containing EA in all processors. */
+		/* 1 = same as 0, but with limited scope (i.e. block in the current processor will not be reused soon). */
+		/* 3 = same as 1, but with even more limited scope (i.e. block in the current processor primary cache will not be reused soon). */
+		if p.To.Type == obj.TYPE_NONE {
+			o1 = AOP_RRR(c.oprrr(p.As), 0, uint32(p.From.Index), uint32(p.From.Reg))
+		} else {
+			th := c.regoff(&p.To)
+			o1 = AOP_RRR(c.oprrr(p.As), uint32(th), uint32(p.From.Index), uint32(p.From.Reg))
+		}
+
+	case 44: /* indexed store */
+		o1 = AOP_RRR(c.opstorex(p.As), uint32(p.From.Reg), uint32(p.To.Index), uint32(p.To.Reg))
+
+	case 45: /* indexed load */
+		switch p.As {
+		/* The assembler accepts a 4-operand l*arx instruction. The fourth operand is an Exclusive Access Hint (EH) */
+		/* The EH field can be used as a lock acquire/release hint as follows: */
+		/* 0 = Atomic Update (fetch-and-operate or similar algorithm) */
+		/* 1 = Exclusive Access (lock acquire and release) */
+		case ALBAR, ALHAR, ALWAR, ALDAR:
+			if p.From3Type() != obj.TYPE_NONE {
+				eh := int(c.regoff(p.GetFrom3()))
+				if eh > 1 {
+					c.ctxt.Diag("illegal EH field\n%v", p)
+				}
+				o1 = AOP_RRRI(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(p.From.Reg), uint32(eh))
+			} else {
+				o1 = AOP_RRR(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(p.From.Reg))
+			}
+		default:
+			o1 = AOP_RRR(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(p.From.Reg))
+		}
+	case 46: /* plain op */
+		o1 = c.oprrr(p.As)
+
+	case 47: /* op Ra, Rd; also op [Ra,] Rd */
+		r := int(p.From.Reg)
+
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), 0)
+
+	case 48: /* op Rs, Ra */
+		r := int(p.From.Reg)
+
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		o1 = LOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(r), 0)
+
+	case 49: /* op Rb; op $n, Rb */
+		if p.From.Type != obj.TYPE_REG { /* tlbie $L, rB */
+			v := c.regoff(&p.From) & 1
+			o1 = AOP_RRR(c.oprrr(p.As), 0, 0, uint32(p.To.Reg)) | uint32(v)<<21
+		} else {
+			o1 = AOP_RRR(c.oprrr(p.As), 0, 0, uint32(p.From.Reg))
+		}
+
+	case 50: /* rem[u] r1[,r2],r3 */
+		r := int(p.Reg)
+
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		v := c.oprrr(p.As)
+		t := v & (1<<10 | 1) /* OE|Rc */
+		o1 = AOP_RRR(v&^t, REGTMP, uint32(r), uint32(p.From.Reg))
+		o2 = AOP_RRR(OP_MULLW, REGTMP, REGTMP, uint32(p.From.Reg))
+		o3 = AOP_RRR(OP_SUBF|t, uint32(p.To.Reg), REGTMP, uint32(r))
+		if p.As == AREMU {
+			o4 = o3
+
+			/* Clear top 32 bits */
+			o3 = OP_RLW(OP_RLDIC, REGTMP, REGTMP, 0, 0, 0) | 1<<5
+		}
+
+	case 51: /* remd[u] r1[,r2],r3 */
+		r := int(p.Reg)
+
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		v := c.oprrr(p.As)
+		t := v & (1<<10 | 1) /* OE|Rc */
+		o1 = AOP_RRR(v&^t, REGTMP, uint32(r), uint32(p.From.Reg))
+		o2 = AOP_RRR(OP_MULLD, REGTMP, REGTMP, uint32(p.From.Reg))
+		o3 = AOP_RRR(OP_SUBF|t, uint32(p.To.Reg), REGTMP, uint32(r))
+		/* cases 50,51: removed; can be reused. */
+
+		/* cases 50,51: removed; can be reused. */
+
+	case 52: /* mtfsbNx cr(n) */
+		v := c.regoff(&p.From) & 31
+
+		o1 = AOP_RRR(c.oprrr(p.As), uint32(v), 0, 0)
+
+	case 53: /* mffsX ,fr1 */
+		o1 = AOP_RRR(OP_MFFS, uint32(p.To.Reg), 0, 0)
+
+	case 54: /* mov msr,r1; mov r1, msr*/
+		if oclass(&p.From) == C_REG {
+			if p.As == AMOVD {
+				o1 = AOP_RRR(OP_MTMSRD, uint32(p.From.Reg), 0, 0)
+			} else {
+				o1 = AOP_RRR(OP_MTMSR, uint32(p.From.Reg), 0, 0)
+			}
+		} else {
+			o1 = AOP_RRR(OP_MFMSR, uint32(p.To.Reg), 0, 0)
+		}
+
+	case 55: /* op Rb, Rd */
+		o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), 0, uint32(p.From.Reg))
+
+	case 56: /* sra $sh,[s,]a; srd $sh,[s,]a */
+		v := c.regoff(&p.From)
+
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		o1 = AOP_RRR(c.opirr(p.As), uint32(r), uint32(p.To.Reg), uint32(v)&31)
+		if (p.As == ASRAD || p.As == ASRADCC) && (v&0x20 != 0) {
+			o1 |= 1 << 1 /* mb[5] */
+		}
+
+	case 57: /* slw $sh,[s,]a -> rlwinm ... */
+		v := c.regoff(&p.From)
+
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+
+		/*
+			 * Let user (gs) shoot himself in the foot.
+			 * qc has already complained.
+			 *
+			if(v < 0 || v > 31)
+				ctxt->diag("illegal shift %ld\n%v", v, p);
+		*/
+		if v < 0 {
+			v = 0
+		} else if v > 32 {
+			v = 32
+		}
+		var mask [2]uint8
+		switch p.As {
+		case AROTLW:
+			mask[0], mask[1] = 0, 31
+		case ASRW, ASRWCC:
+			mask[0], mask[1] = uint8(v), 31
+			v = 32 - v
+		default:
+			mask[0], mask[1] = 0, uint8(31-v)
+		}
+		o1 = OP_RLW(OP_RLWINM, uint32(p.To.Reg), uint32(r), uint32(v), uint32(mask[0]), uint32(mask[1]))
+		if p.As == ASLWCC || p.As == ASRWCC {
+			o1 |= 1 // set the condition code
+		}
+
+	case 58: /* logical $andcon,[s],a */
+		v := c.regoff(&p.From)
+
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		o1 = LOP_IRR(c.opirr(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
+
+	case 59: /* or/xor/and $ucon,,r | oris/xoris/andis $addcon,r,r */
+		v := c.regoff(&p.From)
+
+		r := int(p.Reg)
+		if r == 0 {
+			r = int(p.To.Reg)
+		}
+		switch p.As {
+		case AOR:
+			o1 = LOP_IRR(c.opirr(AORIS), uint32(p.To.Reg), uint32(r), uint32(v)>>16) /* oris, xoris, andis. */
+		case AXOR:
+			o1 = LOP_IRR(c.opirr(AXORIS), uint32(p.To.Reg), uint32(r), uint32(v)>>16)
+		case AANDCC:
+			o1 = LOP_IRR(c.opirr(AANDISCC), uint32(p.To.Reg), uint32(r), uint32(v)>>16)
+		default:
+			o1 = LOP_IRR(c.opirr(p.As), uint32(p.To.Reg), uint32(r), uint32(v))
+		}
+
+	case 60: /* tw to,a,b */
+		r := int(c.regoff(&p.From) & 31)
+
+		o1 = AOP_RRR(c.oprrr(p.As), uint32(r), uint32(p.Reg), uint32(p.To.Reg))
+
+	case 61: /* tw to,a,$simm */
+		r := int(c.regoff(&p.From) & 31)
+
+		v := c.regoff(&p.To)
+		o1 = AOP_IRR(c.opirr(p.As), uint32(r), uint32(p.Reg), uint32(v))
+
+	case 62: /* rlwmi $sh,s,$mask,a */
+		v := c.regoff(&p.From)
+		switch p.As {
+		case ACLRLSLWI:
+			b := c.regoff(p.GetFrom3())
+			// This is an extended mnemonic described in the ISA C.8.2
+			// clrlslwi ra,rs,n,b -> rlwinm ra,rs,n,b-n,31-n
+			// It maps onto rlwinm which is directly generated here.
+			if v < 0 || v > 32 || b > 32 {
+				c.ctxt.Diag("Invalid n or b for CLRLSLWI: %x %x\n%v", v, b)
+			}
+			o1 = OP_RLW(OP_RLWINM, uint32(p.To.Reg), uint32(p.Reg), uint32(v), uint32(b-v), uint32(31-v))
+		default:
+			var mask [2]uint8
+			c.maskgen(p, mask[:], uint32(c.regoff(p.GetFrom3())))
+			o1 = AOP_RRR(c.opirr(p.As), uint32(p.Reg), uint32(p.To.Reg), uint32(v))
+			o1 |= (uint32(mask[0])&31)<<6 | (uint32(mask[1])&31)<<1
+		}
+
+	case 63: /* rlwmi b,s,$mask,a */
+		v := c.regoff(&p.From)
+		switch p.As {
+		case ACLRLSLWI:
+			b := c.regoff(p.GetFrom3())
+			if v > b || b > 32 {
+				// Message will match operands from the ISA even though in the
+				// code it uses 'v'
+				c.ctxt.Diag("Invalid n or b for CLRLSLWI: %x %x\n%v", v, b)
+			}
+			// This is an extended mnemonic described in the ISA C.8.2
+			// clrlslwi ra,rs,n,b -> rlwinm ra,rs,n,b-n,31-n
+			// It generates the rlwinm directly here.
+			o1 = OP_RLW(OP_RLWINM, uint32(p.To.Reg), uint32(p.Reg), uint32(v), uint32(b-v), uint32(31-v))
+		default:
+			var mask [2]uint8
+			c.maskgen(p, mask[:], uint32(c.regoff(p.GetFrom3())))
+			o1 = AOP_RRR(c.opirr(p.As), uint32(p.Reg), uint32(p.To.Reg), uint32(v))
+			o1 |= (uint32(mask[0])&31)<<6 | (uint32(mask[1])&31)<<1
+		}
+
+	case 64: /* mtfsf fr[, $m] {,fpcsr} */
+		var v int32
+		if p.From3Type() != obj.TYPE_NONE {
+			v = c.regoff(p.GetFrom3()) & 255
+		} else {
+			v = 255
+		}
+		o1 = OP_MTFSF | uint32(v)<<17 | uint32(p.From.Reg)<<11
+
+	case 65: /* MOVFL $imm,FPSCR(n) => mtfsfi crfd,imm */
+		if p.To.Reg == 0 {
+			c.ctxt.Diag("must specify FPSCR(n)\n%v", p)
+		}
+		o1 = OP_MTFSFI | (uint32(p.To.Reg)&15)<<23 | (uint32(c.regoff(&p.From))&31)<<12
+
+	case 66: /* mov spr,r1; mov r1,spr, also dcr */
+		var r int
+		var v int32
+		if REG_R0 <= p.From.Reg && p.From.Reg <= REG_R31 {
+			r = int(p.From.Reg)
+			v = int32(p.To.Reg)
+			if REG_DCR0 <= v && v <= REG_DCR0+1023 {
+				o1 = OPVCC(31, 451, 0, 0) /* mtdcr */
+			} else {
+				o1 = OPVCC(31, 467, 0, 0) /* mtspr */
+			}
+		} else {
+			r = int(p.To.Reg)
+			v = int32(p.From.Reg)
+			if REG_DCR0 <= v && v <= REG_DCR0+1023 {
+				o1 = OPVCC(31, 323, 0, 0) /* mfdcr */
+			} else {
+				o1 = OPVCC(31, 339, 0, 0) /* mfspr */
+			}
+		}
+
+		o1 = AOP_RRR(o1, uint32(r), 0, 0) | (uint32(v)&0x1f)<<16 | ((uint32(v)>>5)&0x1f)<<11
+
+	case 67: /* mcrf crfD,crfS */
+		if p.From.Type != obj.TYPE_REG || p.From.Reg < REG_CR0 || REG_CR7 < p.From.Reg || p.To.Type != obj.TYPE_REG || p.To.Reg < REG_CR0 || REG_CR7 < p.To.Reg {
+			c.ctxt.Diag("illegal CR field number\n%v", p)
+		}
+		o1 = AOP_RRR(OP_MCRF, ((uint32(p.To.Reg) & 7) << 2), ((uint32(p.From.Reg) & 7) << 2), 0)
+
+	case 68: /* mfcr rD; mfocrf CRM,rD */
+		if p.From.Type == obj.TYPE_REG && REG_CR0 <= p.From.Reg && p.From.Reg <= REG_CR7 {
+			v := int32(1 << uint(7-(p.To.Reg&7)))                                 /* CR(n) */
+			o1 = AOP_RRR(OP_MFCR, uint32(p.To.Reg), 0, 0) | 1<<20 | uint32(v)<<12 /* new form, mfocrf */
+		} else {
+			o1 = AOP_RRR(OP_MFCR, uint32(p.To.Reg), 0, 0) /* old form, whole register */
+		}
+
+	case 69: /* mtcrf CRM,rS */
+		var v int32
+		if p.From3Type() != obj.TYPE_NONE {
+			if p.To.Reg != 0 {
+				c.ctxt.Diag("can't use both mask and CR(n)\n%v", p)
+			}
+			v = c.regoff(p.GetFrom3()) & 0xff
+		} else {
+			if p.To.Reg == 0 {
+				v = 0xff /* CR */
+			} else {
+				v = 1 << uint(7-(p.To.Reg&7)) /* CR(n) */
+			}
+		}
+
+		o1 = AOP_RRR(OP_MTCRF, uint32(p.From.Reg), 0, 0) | uint32(v)<<12
+
+	case 70: /* [f]cmp r,r,cr*/
+		var r int
+		if p.Reg == 0 {
+			r = 0
+		} else {
+			r = (int(p.Reg) & 7) << 2
+		}
+		o1 = AOP_RRR(c.oprrr(p.As), uint32(r), uint32(p.From.Reg), uint32(p.To.Reg))
+
+	case 71: /* cmp[l] r,i,cr*/
+		var r int
+		if p.Reg == 0 {
+			r = 0
+		} else {
+			r = (int(p.Reg) & 7) << 2
+		}
+		o1 = AOP_RRR(c.opirr(p.As), uint32(r), uint32(p.From.Reg), 0) | uint32(c.regoff(&p.To))&0xffff
+
+	case 72: /* slbmte (Rb+Rs -> slb[Rb]) -> Rs, Rb */
+		o1 = AOP_RRR(c.oprrr(p.As), uint32(p.From.Reg), 0, uint32(p.To.Reg))
+
+	case 73: /* mcrfs crfD,crfS */
+		if p.From.Type != obj.TYPE_REG || p.From.Reg != REG_FPSCR || p.To.Type != obj.TYPE_REG || p.To.Reg < REG_CR0 || REG_CR7 < p.To.Reg {
+			c.ctxt.Diag("illegal FPSCR/CR field number\n%v", p)
+		}
+		o1 = AOP_RRR(OP_MCRFS, ((uint32(p.To.Reg) & 7) << 2), ((0 & 7) << 2), 0)
+
+	case 77: /* syscall $scon, syscall Rx */
+		if p.From.Type == obj.TYPE_CONST {
+			if p.From.Offset > BIG || p.From.Offset < -BIG {
+				c.ctxt.Diag("illegal syscall, sysnum too large: %v", p)
+			}
+			o1 = AOP_IRR(OP_ADDI, REGZERO, REGZERO, uint32(p.From.Offset))
+		} else if p.From.Type == obj.TYPE_REG {
+			o1 = LOP_RRR(OP_OR, REGZERO, uint32(p.From.Reg), uint32(p.From.Reg))
+		} else {
+			c.ctxt.Diag("illegal syscall: %v", p)
+			o1 = 0x7fe00008 // trap always
+		}
+
+		o2 = c.oprrr(p.As)
+		o3 = AOP_RRR(c.oprrr(AXOR), REGZERO, REGZERO, REGZERO) // XOR R0, R0
+
+	case 78: /* undef */
+		o1 = 0 /* "An instruction consisting entirely of binary 0s is guaranteed
+		   always to be an illegal instruction."  */
+
+	/* relocation operations */
+	case 74:
+		v := c.vregoff(&p.To)
+		// Offsets in DS form stores must be a multiple of 4
+		inst := c.opstore(p.As)
+		if c.opform(inst) == DS_FORM && v&0x3 != 0 {
+			log.Fatalf("invalid offset for DS form load/store %v", p)
+		}
+		o1, o2 = c.symbolAccess(p.To.Sym, v, p.From.Reg, inst)
+
+	//if(dlm) reloc(&p->to, p->pc, 1);
+
+	case 75:
+		v := c.vregoff(&p.From)
+		// Offsets in DS form loads must be a multiple of 4
+		inst := c.opload(p.As)
+		if c.opform(inst) == DS_FORM && v&0x3 != 0 {
+			log.Fatalf("invalid offset for DS form load/store %v", p)
+		}
+		o1, o2 = c.symbolAccess(p.From.Sym, v, p.To.Reg, inst)
+
+	//if(dlm) reloc(&p->from, p->pc, 1);
+
+	case 76:
+		v := c.vregoff(&p.From)
+		// Offsets in DS form loads must be a multiple of 4
+		inst := c.opload(p.As)
+		if c.opform(inst) == DS_FORM && v&0x3 != 0 {
+			log.Fatalf("invalid offset for DS form load/store %v", p)
+		}
+		o1, o2 = c.symbolAccess(p.From.Sym, v, p.To.Reg, inst)
+		o3 = LOP_RRR(OP_EXTSB, uint32(p.To.Reg), uint32(p.To.Reg), 0)
+
+		//if(dlm) reloc(&p->from, p->pc, 1);
+
+	case 79:
+		if p.From.Offset != 0 {
+			c.ctxt.Diag("invalid offset against tls var %v", p)
+		}
+		o1 = AOP_IRR(OP_ADDI, uint32(p.To.Reg), REGZERO, 0)
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 4
+		rel.Sym = p.From.Sym
+		rel.Type = objabi.R_POWER_TLS_LE
+
+	case 80:
+		if p.From.Offset != 0 {
+			c.ctxt.Diag("invalid offset against tls var %v", p)
+		}
+		o1 = AOP_IRR(OP_ADDIS, uint32(p.To.Reg), REG_R2, 0)
+		o2 = AOP_IRR(c.opload(AMOVD), uint32(p.To.Reg), uint32(p.To.Reg), 0)
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 8
+		rel.Sym = p.From.Sym
+		rel.Type = objabi.R_POWER_TLS_IE
+
+	case 81:
+		v := c.vregoff(&p.To)
+		if v != 0 {
+			c.ctxt.Diag("invalid offset against GOT slot %v", p)
+		}
+
+		o1 = AOP_IRR(OP_ADDIS, uint32(p.To.Reg), REG_R2, 0)
+		o2 = AOP_IRR(c.opload(AMOVD), uint32(p.To.Reg), uint32(p.To.Reg), 0)
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 8
+		rel.Sym = p.From.Sym
+		rel.Type = objabi.R_ADDRPOWER_GOT
+	case 82: /* vector instructions, VX-form and VC-form */
+		if p.From.Type == obj.TYPE_REG {
+			/* reg reg none OR reg reg reg */
+			/* 3-register operand order: VRA, VRB, VRT */
+			/* 2-register operand order: VRA, VRT */
+			o1 = AOP_RRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg))
+		} else if p.From3Type() == obj.TYPE_CONST {
+			/* imm imm reg reg */
+			/* operand order: SIX, VRA, ST, VRT */
+			six := int(c.regoff(&p.From))
+			st := int(c.regoff(p.GetFrom3()))
+			o1 = AOP_IIRR(c.opiirr(p.As), uint32(p.To.Reg), uint32(p.Reg), uint32(st), uint32(six))
+		} else if p.From3Type() == obj.TYPE_NONE && p.Reg != 0 {
+			/* imm reg reg */
+			/* operand order: UIM, VRB, VRT */
+			uim := int(c.regoff(&p.From))
+			o1 = AOP_VIRR(c.opirr(p.As), uint32(p.To.Reg), uint32(p.Reg), uint32(uim))
+		} else {
+			/* imm reg */
+			/* operand order: SIM, VRT */
+			sim := int(c.regoff(&p.From))
+			o1 = AOP_IR(c.opirr(p.As), uint32(p.To.Reg), uint32(sim))
+		}
+
+	case 83: /* vector instructions, VA-form */
+		if p.From.Type == obj.TYPE_REG {
+			/* reg reg reg reg */
+			/* 4-register operand order: VRA, VRB, VRC, VRT */
+			o1 = AOP_RRRR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), uint32(p.GetFrom3().Reg))
+		} else if p.From.Type == obj.TYPE_CONST {
+			/* imm reg reg reg */
+			/* operand order: SHB, VRA, VRB, VRT */
+			shb := int(c.regoff(&p.From))
+			o1 = AOP_IRRR(c.opirrr(p.As), uint32(p.To.Reg), uint32(p.Reg), uint32(p.GetFrom3().Reg), uint32(shb))
+		}
+
+	case 84: // ISEL BC,RA,RB,RT -> isel rt,ra,rb,bc
+		bc := c.vregoff(&p.From)
+
+		// rt = To.Reg, ra = p.Reg, rb = p.From3.Reg
+		o1 = AOP_ISEL(OP_ISEL, uint32(p.To.Reg), uint32(p.Reg), uint32(p.GetFrom3().Reg), uint32(bc))
+
+	case 85: /* vector instructions, VX-form */
+		/* reg none reg */
+		/* 2-register operand order: VRB, VRT */
+		o1 = AOP_RR(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg))
+
+	case 86: /* VSX indexed store, XX1-form */
+		/* reg reg reg */
+		/* 3-register operand order: XT, (RB)(RA*1) */
+		o1 = AOP_XX1(c.opstorex(p.As), uint32(p.From.Reg), uint32(p.To.Index), uint32(p.To.Reg))
+
+	case 87: /* VSX indexed load, XX1-form */
+		/* reg reg reg */
+		/* 3-register operand order: (RB)(RA*1), XT */
+		o1 = AOP_XX1(c.oploadx(p.As), uint32(p.To.Reg), uint32(p.From.Index), uint32(p.From.Reg))
+
+	case 88: /* VSX instructions, XX1-form */
+		/* reg reg none OR reg reg reg */
+		/* 3-register operand order: RA, RB, XT */
+		/* 2-register operand order: XS, RA or RA, XT */
+		xt := int32(p.To.Reg)
+		xs := int32(p.From.Reg)
+		/* We need to treat the special case of extended mnemonics that may have a FREG/VREG as an argument */
+		if REG_V0 <= xt && xt <= REG_V31 {
+			/* Convert V0-V31 to VS32-VS63 */
+			xt = xt + 64
+			o1 = AOP_XX1(c.oprrr(p.As), uint32(xt), uint32(p.From.Reg), uint32(p.Reg))
+		} else if REG_F0 <= xt && xt <= REG_F31 {
+			/* Convert F0-F31 to VS0-VS31 */
+			xt = xt + 64
+			o1 = AOP_XX1(c.oprrr(p.As), uint32(xt), uint32(p.From.Reg), uint32(p.Reg))
+		} else if REG_VS0 <= xt && xt <= REG_VS63 {
+			o1 = AOP_XX1(c.oprrr(p.As), uint32(xt), uint32(p.From.Reg), uint32(p.Reg))
+		} else if REG_V0 <= xs && xs <= REG_V31 {
+			/* Likewise for XS */
+			xs = xs + 64
+			o1 = AOP_XX1(c.oprrr(p.As), uint32(xs), uint32(p.To.Reg), uint32(p.Reg))
+		} else if REG_F0 <= xs && xs <= REG_F31 {
+			xs = xs + 64
+			o1 = AOP_XX1(c.oprrr(p.As), uint32(xs), uint32(p.To.Reg), uint32(p.Reg))
+		} else if REG_VS0 <= xs && xs <= REG_VS63 {
+			o1 = AOP_XX1(c.oprrr(p.As), uint32(xs), uint32(p.To.Reg), uint32(p.Reg))
+		}
+
+	case 89: /* VSX instructions, XX2-form */
+		/* reg none reg OR reg imm reg */
+		/* 2-register operand order: XB, XT or XB, UIM, XT*/
+		uim := int(c.regoff(p.GetFrom3()))
+		o1 = AOP_XX2(c.oprrr(p.As), uint32(p.To.Reg), uint32(uim), uint32(p.From.Reg))
+
+	case 90: /* VSX instructions, XX3-form */
+		if p.From3Type() == obj.TYPE_NONE {
+			/* reg reg reg */
+			/* 3-register operand order: XA, XB, XT */
+			o1 = AOP_XX3(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg))
+		} else if p.From3Type() == obj.TYPE_CONST {
+			/* reg reg reg imm */
+			/* operand order: XA, XB, DM, XT */
+			dm := int(c.regoff(p.GetFrom3()))
+			o1 = AOP_XX3I(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), uint32(dm))
+		}
+
+	case 91: /* VSX instructions, XX4-form */
+		/* reg reg reg reg */
+		/* 3-register operand order: XA, XB, XC, XT */
+		o1 = AOP_XX4(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), uint32(p.GetFrom3().Reg))
+
+	case 92: /* X-form instructions, 3-operands */
+		if p.To.Type == obj.TYPE_CONST {
+			/* imm reg reg */
+			xf := int32(p.From.Reg)
+			if REG_F0 <= xf && xf <= REG_F31 {
+				/* operand order: FRA, FRB, BF */
+				bf := int(c.regoff(&p.To)) << 2
+				o1 = AOP_RRR(c.opirr(p.As), uint32(bf), uint32(p.From.Reg), uint32(p.Reg))
+			} else {
+				/* operand order: RA, RB, L */
+				l := int(c.regoff(&p.To))
+				o1 = AOP_RRR(c.opirr(p.As), uint32(l), uint32(p.From.Reg), uint32(p.Reg))
+			}
+		} else if p.From3Type() == obj.TYPE_CONST {
+			/* reg reg imm */
+			/* operand order: RB, L, RA */
+			l := int(c.regoff(p.GetFrom3()))
+			o1 = AOP_RRR(c.opirr(p.As), uint32(l), uint32(p.To.Reg), uint32(p.From.Reg))
+		} else if p.To.Type == obj.TYPE_REG {
+			cr := int32(p.To.Reg)
+			if REG_CR0 <= cr && cr <= REG_CR7 {
+				/* cr reg reg */
+				/* operand order: RA, RB, BF */
+				bf := (int(p.To.Reg) & 7) << 2
+				o1 = AOP_RRR(c.opirr(p.As), uint32(bf), uint32(p.From.Reg), uint32(p.Reg))
+			} else if p.From.Type == obj.TYPE_CONST {
+				/* reg imm */
+				/* operand order: L, RT */
+				l := int(c.regoff(&p.From))
+				o1 = AOP_RRR(c.opirr(p.As), uint32(p.To.Reg), uint32(l), uint32(p.Reg))
+			} else {
+				switch p.As {
+				case ACOPY, APASTECC:
+					o1 = AOP_RRR(c.opirr(p.As), uint32(1), uint32(p.From.Reg), uint32(p.To.Reg))
+				default:
+					/* reg reg reg */
+					/* operand order: RS, RB, RA */
+					o1 = AOP_RRR(c.oprrr(p.As), uint32(p.From.Reg), uint32(p.To.Reg), uint32(p.Reg))
+				}
+			}
+		}
+
+	case 93: /* X-form instructions, 2-operands */
+		if p.To.Type == obj.TYPE_CONST {
+			/* imm reg */
+			/* operand order: FRB, BF */
+			bf := int(c.regoff(&p.To)) << 2
+			o1 = AOP_RR(c.opirr(p.As), uint32(bf), uint32(p.From.Reg))
+		} else if p.Reg == 0 {
+			/* popcnt* r,r, X-form */
+			/* operand order: RS, RA */
+			o1 = AOP_RRR(c.oprrr(p.As), uint32(p.From.Reg), uint32(p.To.Reg), uint32(p.Reg))
+		}
+
+	case 94: /* Z23-form instructions, 4-operands */
+		/* reg reg reg imm */
+		/* operand order: RA, RB, CY, RT */
+		cy := int(c.regoff(p.GetFrom3()))
+		o1 = AOP_Z23I(c.oprrr(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), uint32(cy))
+
+	case 95: /* Retrieve TOC relative symbol */
+		/* This code is for AIX only */
+		v := c.vregoff(&p.From)
+		if v != 0 {
+			c.ctxt.Diag("invalid offset against TOC slot %v", p)
+		}
+
+		inst := c.opload(p.As)
+		if c.opform(inst) != DS_FORM {
+			c.ctxt.Diag("invalid form for a TOC access in %v", p)
+		}
+
+		o1 = AOP_IRR(OP_ADDIS, uint32(p.To.Reg), REG_R2, 0)
+		o2 = AOP_IRR(inst, uint32(p.To.Reg), uint32(p.To.Reg), 0)
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc)
+		rel.Siz = 8
+		rel.Sym = p.From.Sym
+		rel.Type = objabi.R_ADDRPOWER_TOCREL_DS
+
+	case 96: /* VSX load, DQ-form */
+		/* reg imm reg */
+		/* operand order: (RA)(DQ), XT */
+		dq := int16(c.regoff(&p.From))
+		if (dq & 15) != 0 {
+			c.ctxt.Diag("invalid offset for DQ form load/store %v", dq)
+		}
+		o1 = AOP_DQ(c.opload(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(dq))
+
+	case 97: /* VSX store, DQ-form */
+		/* reg imm reg */
+		/* operand order: XT, (RA)(DQ) */
+		dq := int16(c.regoff(&p.To))
+		if (dq & 15) != 0 {
+			c.ctxt.Diag("invalid offset for DQ form load/store %v", dq)
+		}
+		o1 = AOP_DQ(c.opstore(p.As), uint32(p.From.Reg), uint32(p.To.Reg), uint32(dq))
+	case 98: /* VSX indexed load or load with length (also left-justified), x-form */
+		/* vsreg, reg, reg */
+		o1 = AOP_XX1(c.opload(p.As), uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg))
+	case 99: /* VSX store with length (also left-justified) x-form */
+		/* reg, reg, vsreg */
+		o1 = AOP_XX1(c.opstore(p.As), uint32(p.From.Reg), uint32(p.Reg), uint32(p.To.Reg))
+	case 100: /* VSX X-form XXSPLTIB */
+		if p.From.Type == obj.TYPE_CONST {
+			/* imm reg */
+			uim := int(c.regoff(&p.From))
+			/* imm reg */
+			/* Use AOP_XX1 form with 0 for one of the registers. */
+			o1 = AOP_XX1(c.oprrr(p.As), uint32(p.To.Reg), uint32(0), uint32(uim))
+		} else {
+			c.ctxt.Diag("invalid ops for %v", p.As)
+		}
+	case 101:
+		o1 = AOP_XX2(c.oprrr(p.As), uint32(p.To.Reg), uint32(0), uint32(p.From.Reg))
+	}
+
+	out[0] = o1
+	out[1] = o2
+	out[2] = o3
+	out[3] = o4
+	out[4] = o5
+}
+
+func (c *ctxt9) vregoff(a *obj.Addr) int64 {
+	c.instoffset = 0
+	if a != nil {
+		c.aclass(a)
+	}
+	return c.instoffset
+}
+
+func (c *ctxt9) regoff(a *obj.Addr) int32 {
+	return int32(c.vregoff(a))
+}
+
+func (c *ctxt9) oprrr(a obj.As) uint32 {
+	switch a {
+	case AADD:
+		return OPVCC(31, 266, 0, 0)
+	case AADDCC:
+		return OPVCC(31, 266, 0, 1)
+	case AADDV:
+		return OPVCC(31, 266, 1, 0)
+	case AADDVCC:
+		return OPVCC(31, 266, 1, 1)
+	case AADDC:
+		return OPVCC(31, 10, 0, 0)
+	case AADDCCC:
+		return OPVCC(31, 10, 0, 1)
+	case AADDCV:
+		return OPVCC(31, 10, 1, 0)
+	case AADDCVCC:
+		return OPVCC(31, 10, 1, 1)
+	case AADDE:
+		return OPVCC(31, 138, 0, 0)
+	case AADDECC:
+		return OPVCC(31, 138, 0, 1)
+	case AADDEV:
+		return OPVCC(31, 138, 1, 0)
+	case AADDEVCC:
+		return OPVCC(31, 138, 1, 1)
+	case AADDME:
+		return OPVCC(31, 234, 0, 0)
+	case AADDMECC:
+		return OPVCC(31, 234, 0, 1)
+	case AADDMEV:
+		return OPVCC(31, 234, 1, 0)
+	case AADDMEVCC:
+		return OPVCC(31, 234, 1, 1)
+	case AADDZE:
+		return OPVCC(31, 202, 0, 0)
+	case AADDZECC:
+		return OPVCC(31, 202, 0, 1)
+	case AADDZEV:
+		return OPVCC(31, 202, 1, 0)
+	case AADDZEVCC:
+		return OPVCC(31, 202, 1, 1)
+	case AADDEX:
+		return OPVCC(31, 170, 0, 0) /* addex - v3.0b */
+
+	case AAND:
+		return OPVCC(31, 28, 0, 0)
+	case AANDCC:
+		return OPVCC(31, 28, 0, 1)
+	case AANDN:
+		return OPVCC(31, 60, 0, 0)
+	case AANDNCC:
+		return OPVCC(31, 60, 0, 1)
+
+	case ACMP:
+		return OPVCC(31, 0, 0, 0) | 1<<21 /* L=1 */
+	case ACMPU:
+		return OPVCC(31, 32, 0, 0) | 1<<21
+	case ACMPW:
+		return OPVCC(31, 0, 0, 0) /* L=0 */
+	case ACMPWU:
+		return OPVCC(31, 32, 0, 0)
+	case ACMPB:
+		return OPVCC(31, 508, 0, 0) /* cmpb - v2.05 */
+	case ACMPEQB:
+		return OPVCC(31, 224, 0, 0) /* cmpeqb - v3.00 */
+
+	case ACNTLZW:
+		return OPVCC(31, 26, 0, 0)
+	case ACNTLZWCC:
+		return OPVCC(31, 26, 0, 1)
+	case ACNTLZD:
+		return OPVCC(31, 58, 0, 0)
+	case ACNTLZDCC:
+		return OPVCC(31, 58, 0, 1)
+
+	case ACRAND:
+		return OPVCC(19, 257, 0, 0)
+	case ACRANDN:
+		return OPVCC(19, 129, 0, 0)
+	case ACREQV:
+		return OPVCC(19, 289, 0, 0)
+	case ACRNAND:
+		return OPVCC(19, 225, 0, 0)
+	case ACRNOR:
+		return OPVCC(19, 33, 0, 0)
+	case ACROR:
+		return OPVCC(19, 449, 0, 0)
+	case ACRORN:
+		return OPVCC(19, 417, 0, 0)
+	case ACRXOR:
+		return OPVCC(19, 193, 0, 0)
+
+	case ADCBF:
+		return OPVCC(31, 86, 0, 0)
+	case ADCBI:
+		return OPVCC(31, 470, 0, 0)
+	case ADCBST:
+		return OPVCC(31, 54, 0, 0)
+	case ADCBT:
+		return OPVCC(31, 278, 0, 0)
+	case ADCBTST:
+		return OPVCC(31, 246, 0, 0)
+	case ADCBZ:
+		return OPVCC(31, 1014, 0, 0)
+
+	case AMODUD:
+		return OPVCC(31, 265, 0, 0) /* modud - v3.0 */
+	case AMODUW:
+		return OPVCC(31, 267, 0, 0) /* moduw - v3.0 */
+	case AMODSD:
+		return OPVCC(31, 777, 0, 0) /* modsd - v3.0 */
+	case AMODSW:
+		return OPVCC(31, 779, 0, 0) /* modsw - v3.0 */
+
+	case ADIVW, AREM:
+		return OPVCC(31, 491, 0, 0)
+
+	case ADIVWCC:
+		return OPVCC(31, 491, 0, 1)
+
+	case ADIVWV:
+		return OPVCC(31, 491, 1, 0)
+
+	case ADIVWVCC:
+		return OPVCC(31, 491, 1, 1)
+
+	case ADIVWU, AREMU:
+		return OPVCC(31, 459, 0, 0)
+
+	case ADIVWUCC:
+		return OPVCC(31, 459, 0, 1)
+
+	case ADIVWUV:
+		return OPVCC(31, 459, 1, 0)
+
+	case ADIVWUVCC:
+		return OPVCC(31, 459, 1, 1)
+
+	case ADIVD, AREMD:
+		return OPVCC(31, 489, 0, 0)
+
+	case ADIVDCC:
+		return OPVCC(31, 489, 0, 1)
+
+	case ADIVDE:
+		return OPVCC(31, 425, 0, 0)
+
+	case ADIVDECC:
+		return OPVCC(31, 425, 0, 1)
+
+	case ADIVDEU:
+		return OPVCC(31, 393, 0, 0)
+
+	case ADIVDEUCC:
+		return OPVCC(31, 393, 0, 1)
+
+	case ADIVDV:
+		return OPVCC(31, 489, 1, 0)
+
+	case ADIVDVCC:
+		return OPVCC(31, 489, 1, 1)
+
+	case ADIVDU, AREMDU:
+		return OPVCC(31, 457, 0, 0)
+
+	case ADIVDUCC:
+		return OPVCC(31, 457, 0, 1)
+
+	case ADIVDUV:
+		return OPVCC(31, 457, 1, 0)
+
+	case ADIVDUVCC:
+		return OPVCC(31, 457, 1, 1)
+
+	case AEIEIO:
+		return OPVCC(31, 854, 0, 0)
+
+	case AEQV:
+		return OPVCC(31, 284, 0, 0)
+	case AEQVCC:
+		return OPVCC(31, 284, 0, 1)
+
+	case AEXTSB:
+		return OPVCC(31, 954, 0, 0)
+	case AEXTSBCC:
+		return OPVCC(31, 954, 0, 1)
+	case AEXTSH:
+		return OPVCC(31, 922, 0, 0)
+	case AEXTSHCC:
+		return OPVCC(31, 922, 0, 1)
+	case AEXTSW:
+		return OPVCC(31, 986, 0, 0)
+	case AEXTSWCC:
+		return OPVCC(31, 986, 0, 1)
+
+	case AFABS:
+		return OPVCC(63, 264, 0, 0)
+	case AFABSCC:
+		return OPVCC(63, 264, 0, 1)
+	case AFADD:
+		return OPVCC(63, 21, 0, 0)
+	case AFADDCC:
+		return OPVCC(63, 21, 0, 1)
+	case AFADDS:
+		return OPVCC(59, 21, 0, 0)
+	case AFADDSCC:
+		return OPVCC(59, 21, 0, 1)
+	case AFCMPO:
+		return OPVCC(63, 32, 0, 0)
+	case AFCMPU:
+		return OPVCC(63, 0, 0, 0)
+	case AFCFID:
+		return OPVCC(63, 846, 0, 0)
+	case AFCFIDCC:
+		return OPVCC(63, 846, 0, 1)
+	case AFCFIDU:
+		return OPVCC(63, 974, 0, 0)
+	case AFCFIDUCC:
+		return OPVCC(63, 974, 0, 1)
+	case AFCFIDS:
+		return OPVCC(59, 846, 0, 0)
+	case AFCFIDSCC:
+		return OPVCC(59, 846, 0, 1)
+	case AFCTIW:
+		return OPVCC(63, 14, 0, 0)
+	case AFCTIWCC:
+		return OPVCC(63, 14, 0, 1)
+	case AFCTIWZ:
+		return OPVCC(63, 15, 0, 0)
+	case AFCTIWZCC:
+		return OPVCC(63, 15, 0, 1)
+	case AFCTID:
+		return OPVCC(63, 814, 0, 0)
+	case AFCTIDCC:
+		return OPVCC(63, 814, 0, 1)
+	case AFCTIDZ:
+		return OPVCC(63, 815, 0, 0)
+	case AFCTIDZCC:
+		return OPVCC(63, 815, 0, 1)
+	case AFDIV:
+		return OPVCC(63, 18, 0, 0)
+	case AFDIVCC:
+		return OPVCC(63, 18, 0, 1)
+	case AFDIVS:
+		return OPVCC(59, 18, 0, 0)
+	case AFDIVSCC:
+		return OPVCC(59, 18, 0, 1)
+	case AFMADD:
+		return OPVCC(63, 29, 0, 0)
+	case AFMADDCC:
+		return OPVCC(63, 29, 0, 1)
+	case AFMADDS:
+		return OPVCC(59, 29, 0, 0)
+	case AFMADDSCC:
+		return OPVCC(59, 29, 0, 1)
+
+	case AFMOVS, AFMOVD:
+		return OPVCC(63, 72, 0, 0) /* load */
+	case AFMOVDCC:
+		return OPVCC(63, 72, 0, 1)
+	case AFMSUB:
+		return OPVCC(63, 28, 0, 0)
+	case AFMSUBCC:
+		return OPVCC(63, 28, 0, 1)
+	case AFMSUBS:
+		return OPVCC(59, 28, 0, 0)
+	case AFMSUBSCC:
+		return OPVCC(59, 28, 0, 1)
+	case AFMUL:
+		return OPVCC(63, 25, 0, 0)
+	case AFMULCC:
+		return OPVCC(63, 25, 0, 1)
+	case AFMULS:
+		return OPVCC(59, 25, 0, 0)
+	case AFMULSCC:
+		return OPVCC(59, 25, 0, 1)
+	case AFNABS:
+		return OPVCC(63, 136, 0, 0)
+	case AFNABSCC:
+		return OPVCC(63, 136, 0, 1)
+	case AFNEG:
+		return OPVCC(63, 40, 0, 0)
+	case AFNEGCC:
+		return OPVCC(63, 40, 0, 1)
+	case AFNMADD:
+		return OPVCC(63, 31, 0, 0)
+	case AFNMADDCC:
+		return OPVCC(63, 31, 0, 1)
+	case AFNMADDS:
+		return OPVCC(59, 31, 0, 0)
+	case AFNMADDSCC:
+		return OPVCC(59, 31, 0, 1)
+	case AFNMSUB:
+		return OPVCC(63, 30, 0, 0)
+	case AFNMSUBCC:
+		return OPVCC(63, 30, 0, 1)
+	case AFNMSUBS:
+		return OPVCC(59, 30, 0, 0)
+	case AFNMSUBSCC:
+		return OPVCC(59, 30, 0, 1)
+	case AFCPSGN:
+		return OPVCC(63, 8, 0, 0)
+	case AFCPSGNCC:
+		return OPVCC(63, 8, 0, 1)
+	case AFRES:
+		return OPVCC(59, 24, 0, 0)
+	case AFRESCC:
+		return OPVCC(59, 24, 0, 1)
+	case AFRIM:
+		return OPVCC(63, 488, 0, 0)
+	case AFRIMCC:
+		return OPVCC(63, 488, 0, 1)
+	case AFRIP:
+		return OPVCC(63, 456, 0, 0)
+	case AFRIPCC:
+		return OPVCC(63, 456, 0, 1)
+	case AFRIZ:
+		return OPVCC(63, 424, 0, 0)
+	case AFRIZCC:
+		return OPVCC(63, 424, 0, 1)
+	case AFRIN:
+		return OPVCC(63, 392, 0, 0)
+	case AFRINCC:
+		return OPVCC(63, 392, 0, 1)
+	case AFRSP:
+		return OPVCC(63, 12, 0, 0)
+	case AFRSPCC:
+		return OPVCC(63, 12, 0, 1)
+	case AFRSQRTE:
+		return OPVCC(63, 26, 0, 0)
+	case AFRSQRTECC:
+		return OPVCC(63, 26, 0, 1)
+	case AFSEL:
+		return OPVCC(63, 23, 0, 0)
+	case AFSELCC:
+		return OPVCC(63, 23, 0, 1)
+	case AFSQRT:
+		return OPVCC(63, 22, 0, 0)
+	case AFSQRTCC:
+		return OPVCC(63, 22, 0, 1)
+	case AFSQRTS:
+		return OPVCC(59, 22, 0, 0)
+	case AFSQRTSCC:
+		return OPVCC(59, 22, 0, 1)
+	case AFSUB:
+		return OPVCC(63, 20, 0, 0)
+	case AFSUBCC:
+		return OPVCC(63, 20, 0, 1)
+	case AFSUBS:
+		return OPVCC(59, 20, 0, 0)
+	case AFSUBSCC:
+		return OPVCC(59, 20, 0, 1)
+
+	case AICBI:
+		return OPVCC(31, 982, 0, 0)
+	case AISYNC:
+		return OPVCC(19, 150, 0, 0)
+
+	case AMTFSB0:
+		return OPVCC(63, 70, 0, 0)
+	case AMTFSB0CC:
+		return OPVCC(63, 70, 0, 1)
+	case AMTFSB1:
+		return OPVCC(63, 38, 0, 0)
+	case AMTFSB1CC:
+		return OPVCC(63, 38, 0, 1)
+
+	case AMULHW:
+		return OPVCC(31, 75, 0, 0)
+	case AMULHWCC:
+		return OPVCC(31, 75, 0, 1)
+	case AMULHWU:
+		return OPVCC(31, 11, 0, 0)
+	case AMULHWUCC:
+		return OPVCC(31, 11, 0, 1)
+	case AMULLW:
+		return OPVCC(31, 235, 0, 0)
+	case AMULLWCC:
+		return OPVCC(31, 235, 0, 1)
+	case AMULLWV:
+		return OPVCC(31, 235, 1, 0)
+	case AMULLWVCC:
+		return OPVCC(31, 235, 1, 1)
+
+	case AMULHD:
+		return OPVCC(31, 73, 0, 0)
+	case AMULHDCC:
+		return OPVCC(31, 73, 0, 1)
+	case AMULHDU:
+		return OPVCC(31, 9, 0, 0)
+	case AMULHDUCC:
+		return OPVCC(31, 9, 0, 1)
+	case AMULLD:
+		return OPVCC(31, 233, 0, 0)
+	case AMULLDCC:
+		return OPVCC(31, 233, 0, 1)
+	case AMULLDV:
+		return OPVCC(31, 233, 1, 0)
+	case AMULLDVCC:
+		return OPVCC(31, 233, 1, 1)
+
+	case ANAND:
+		return OPVCC(31, 476, 0, 0)
+	case ANANDCC:
+		return OPVCC(31, 476, 0, 1)
+	case ANEG:
+		return OPVCC(31, 104, 0, 0)
+	case ANEGCC:
+		return OPVCC(31, 104, 0, 1)
+	case ANEGV:
+		return OPVCC(31, 104, 1, 0)
+	case ANEGVCC:
+		return OPVCC(31, 104, 1, 1)
+	case ANOR:
+		return OPVCC(31, 124, 0, 0)
+	case ANORCC:
+		return OPVCC(31, 124, 0, 1)
+	case AOR:
+		return OPVCC(31, 444, 0, 0)
+	case AORCC:
+		return OPVCC(31, 444, 0, 1)
+	case AORN:
+		return OPVCC(31, 412, 0, 0)
+	case AORNCC:
+		return OPVCC(31, 412, 0, 1)
+
+	case APOPCNTD:
+		return OPVCC(31, 506, 0, 0) /* popcntd - v2.06 */
+	case APOPCNTW:
+		return OPVCC(31, 378, 0, 0) /* popcntw - v2.06 */
+	case APOPCNTB:
+		return OPVCC(31, 122, 0, 0) /* popcntb - v2.02 */
+	case ACNTTZW:
+		return OPVCC(31, 538, 0, 0) /* cnttzw - v3.00 */
+	case ACNTTZWCC:
+		return OPVCC(31, 538, 0, 1) /* cnttzw. - v3.00 */
+	case ACNTTZD:
+		return OPVCC(31, 570, 0, 0) /* cnttzd - v3.00 */
+	case ACNTTZDCC:
+		return OPVCC(31, 570, 0, 1) /* cnttzd. - v3.00 */
+
+	case ARFI:
+		return OPVCC(19, 50, 0, 0)
+	case ARFCI:
+		return OPVCC(19, 51, 0, 0)
+	case ARFID:
+		return OPVCC(19, 18, 0, 0)
+	case AHRFID:
+		return OPVCC(19, 274, 0, 0)
+
+	case ARLWMI:
+		return OPVCC(20, 0, 0, 0)
+	case ARLWMICC:
+		return OPVCC(20, 0, 0, 1)
+	case ARLWNM:
+		return OPVCC(23, 0, 0, 0)
+	case ARLWNMCC:
+		return OPVCC(23, 0, 0, 1)
+
+	case ARLDCL:
+		return OPVCC(30, 8, 0, 0)
+	case ARLDCLCC:
+		return OPVCC(30, 0, 0, 1)
+
+	case ARLDCR:
+		return OPVCC(30, 9, 0, 0)
+	case ARLDCRCC:
+		return OPVCC(30, 9, 0, 1)
+
+	case ARLDICL:
+		return OPVCC(30, 0, 0, 0)
+	case ARLDICLCC:
+		return OPVCC(30, 0, 0, 1)
+	case ARLDICR:
+		return OPVCC(30, 0, 0, 0) | 2<<1 // rldicr
+	case ARLDICRCC:
+		return OPVCC(30, 0, 0, 1) | 2<<1 // rldicr.
+
+	case ARLDIC:
+		return OPVCC(30, 0, 0, 0) | 4<<1 // rldic
+	case ARLDICCC:
+		return OPVCC(30, 0, 0, 1) | 4<<1 // rldic.
+
+	case ASYSCALL:
+		return OPVCC(17, 1, 0, 0)
+
+	case ASLW:
+		return OPVCC(31, 24, 0, 0)
+	case ASLWCC:
+		return OPVCC(31, 24, 0, 1)
+	case ASLD:
+		return OPVCC(31, 27, 0, 0)
+	case ASLDCC:
+		return OPVCC(31, 27, 0, 1)
+
+	case ASRAW:
+		return OPVCC(31, 792, 0, 0)
+	case ASRAWCC:
+		return OPVCC(31, 792, 0, 1)
+	case ASRAD:
+		return OPVCC(31, 794, 0, 0)
+	case ASRADCC:
+		return OPVCC(31, 794, 0, 1)
+
+	case ASRW:
+		return OPVCC(31, 536, 0, 0)
+	case ASRWCC:
+		return OPVCC(31, 536, 0, 1)
+	case ASRD:
+		return OPVCC(31, 539, 0, 0)
+	case ASRDCC:
+		return OPVCC(31, 539, 0, 1)
+
+	case ASUB:
+		return OPVCC(31, 40, 0, 0)
+	case ASUBCC:
+		return OPVCC(31, 40, 0, 1)
+	case ASUBV:
+		return OPVCC(31, 40, 1, 0)
+	case ASUBVCC:
+		return OPVCC(31, 40, 1, 1)
+	case ASUBC:
+		return OPVCC(31, 8, 0, 0)
+	case ASUBCCC:
+		return OPVCC(31, 8, 0, 1)
+	case ASUBCV:
+		return OPVCC(31, 8, 1, 0)
+	case ASUBCVCC:
+		return OPVCC(31, 8, 1, 1)
+	case ASUBE:
+		return OPVCC(31, 136, 0, 0)
+	case ASUBECC:
+		return OPVCC(31, 136, 0, 1)
+	case ASUBEV:
+		return OPVCC(31, 136, 1, 0)
+	case ASUBEVCC:
+		return OPVCC(31, 136, 1, 1)
+	case ASUBME:
+		return OPVCC(31, 232, 0, 0)
+	case ASUBMECC:
+		return OPVCC(31, 232, 0, 1)
+	case ASUBMEV:
+		return OPVCC(31, 232, 1, 0)
+	case ASUBMEVCC:
+		return OPVCC(31, 232, 1, 1)
+	case ASUBZE:
+		return OPVCC(31, 200, 0, 0)
+	case ASUBZECC:
+		return OPVCC(31, 200, 0, 1)
+	case ASUBZEV:
+		return OPVCC(31, 200, 1, 0)
+	case ASUBZEVCC:
+		return OPVCC(31, 200, 1, 1)
+
+	case ASYNC:
+		return OPVCC(31, 598, 0, 0)
+	case ALWSYNC:
+		return OPVCC(31, 598, 0, 0) | 1<<21
+
+	case APTESYNC:
+		return OPVCC(31, 598, 0, 0) | 2<<21
+
+	case ATLBIE:
+		return OPVCC(31, 306, 0, 0)
+	case ATLBIEL:
+		return OPVCC(31, 274, 0, 0)
+	case ATLBSYNC:
+		return OPVCC(31, 566, 0, 0)
+	case ASLBIA:
+		return OPVCC(31, 498, 0, 0)
+	case ASLBIE:
+		return OPVCC(31, 434, 0, 0)
+	case ASLBMFEE:
+		return OPVCC(31, 915, 0, 0)
+	case ASLBMFEV:
+		return OPVCC(31, 851, 0, 0)
+	case ASLBMTE:
+		return OPVCC(31, 402, 0, 0)
+
+	case ATW:
+		return OPVCC(31, 4, 0, 0)
+	case ATD:
+		return OPVCC(31, 68, 0, 0)
+
+	/* Vector (VMX/Altivec) instructions */
+	/* ISA 2.03 enables these for PPC970. For POWERx processors, these */
+	/* are enabled starting at POWER6 (ISA 2.05). */
+	case AVAND:
+		return OPVX(4, 1028, 0, 0) /* vand - v2.03 */
+	case AVANDC:
+		return OPVX(4, 1092, 0, 0) /* vandc - v2.03 */
+	case AVNAND:
+		return OPVX(4, 1412, 0, 0) /* vnand - v2.07 */
+
+	case AVOR:
+		return OPVX(4, 1156, 0, 0) /* vor - v2.03 */
+	case AVORC:
+		return OPVX(4, 1348, 0, 0) /* vorc - v2.07 */
+	case AVNOR:
+		return OPVX(4, 1284, 0, 0) /* vnor - v2.03 */
+	case AVXOR:
+		return OPVX(4, 1220, 0, 0) /* vxor - v2.03 */
+	case AVEQV:
+		return OPVX(4, 1668, 0, 0) /* veqv - v2.07 */
+
+	case AVADDUBM:
+		return OPVX(4, 0, 0, 0) /* vaddubm - v2.03 */
+	case AVADDUHM:
+		return OPVX(4, 64, 0, 0) /* vadduhm - v2.03 */
+	case AVADDUWM:
+		return OPVX(4, 128, 0, 0) /* vadduwm - v2.03 */
+	case AVADDUDM:
+		return OPVX(4, 192, 0, 0) /* vaddudm - v2.07 */
+	case AVADDUQM:
+		return OPVX(4, 256, 0, 0) /* vadduqm - v2.07 */
+
+	case AVADDCUQ:
+		return OPVX(4, 320, 0, 0) /* vaddcuq - v2.07 */
+	case AVADDCUW:
+		return OPVX(4, 384, 0, 0) /* vaddcuw - v2.03 */
+
+	case AVADDUBS:
+		return OPVX(4, 512, 0, 0) /* vaddubs - v2.03 */
+	case AVADDUHS:
+		return OPVX(4, 576, 0, 0) /* vadduhs - v2.03 */
+	case AVADDUWS:
+		return OPVX(4, 640, 0, 0) /* vadduws - v2.03 */
+
+	case AVADDSBS:
+		return OPVX(4, 768, 0, 0) /* vaddsbs - v2.03 */
+	case AVADDSHS:
+		return OPVX(4, 832, 0, 0) /* vaddshs - v2.03 */
+	case AVADDSWS:
+		return OPVX(4, 896, 0, 0) /* vaddsws - v2.03 */
+
+	case AVADDEUQM:
+		return OPVX(4, 60, 0, 0) /* vaddeuqm - v2.07 */
+	case AVADDECUQ:
+		return OPVX(4, 61, 0, 0) /* vaddecuq - v2.07 */
+
+	case AVMULESB:
+		return OPVX(4, 776, 0, 0) /* vmulesb - v2.03 */
+	case AVMULOSB:
+		return OPVX(4, 264, 0, 0) /* vmulosb - v2.03 */
+	case AVMULEUB:
+		return OPVX(4, 520, 0, 0) /* vmuleub - v2.03 */
+	case AVMULOUB:
+		return OPVX(4, 8, 0, 0) /* vmuloub - v2.03 */
+	case AVMULESH:
+		return OPVX(4, 840, 0, 0) /* vmulesh - v2.03 */
+	case AVMULOSH:
+		return OPVX(4, 328, 0, 0) /* vmulosh - v2.03 */
+	case AVMULEUH:
+		return OPVX(4, 584, 0, 0) /* vmuleuh - v2.03 */
+	case AVMULOUH:
+		return OPVX(4, 72, 0, 0) /* vmulouh - v2.03 */
+	case AVMULESW:
+		return OPVX(4, 904, 0, 0) /* vmulesw - v2.07 */
+	case AVMULOSW:
+		return OPVX(4, 392, 0, 0) /* vmulosw - v2.07 */
+	case AVMULEUW:
+		return OPVX(4, 648, 0, 0) /* vmuleuw - v2.07 */
+	case AVMULOUW:
+		return OPVX(4, 136, 0, 0) /* vmulouw - v2.07 */
+	case AVMULUWM:
+		return OPVX(4, 137, 0, 0) /* vmuluwm - v2.07 */
+
+	case AVPMSUMB:
+		return OPVX(4, 1032, 0, 0) /* vpmsumb - v2.07 */
+	case AVPMSUMH:
+		return OPVX(4, 1096, 0, 0) /* vpmsumh - v2.07 */
+	case AVPMSUMW:
+		return OPVX(4, 1160, 0, 0) /* vpmsumw - v2.07 */
+	case AVPMSUMD:
+		return OPVX(4, 1224, 0, 0) /* vpmsumd - v2.07 */
+
+	case AVMSUMUDM:
+		return OPVX(4, 35, 0, 0) /* vmsumudm - v3.00b */
+
+	case AVSUBUBM:
+		return OPVX(4, 1024, 0, 0) /* vsububm - v2.03 */
+	case AVSUBUHM:
+		return OPVX(4, 1088, 0, 0) /* vsubuhm - v2.03 */
+	case AVSUBUWM:
+		return OPVX(4, 1152, 0, 0) /* vsubuwm - v2.03 */
+	case AVSUBUDM:
+		return OPVX(4, 1216, 0, 0) /* vsubudm - v2.07 */
+	case AVSUBUQM:
+		return OPVX(4, 1280, 0, 0) /* vsubuqm - v2.07 */
+
+	case AVSUBCUQ:
+		return OPVX(4, 1344, 0, 0) /* vsubcuq - v2.07 */
+	case AVSUBCUW:
+		return OPVX(4, 1408, 0, 0) /* vsubcuw - v2.03 */
+
+	case AVSUBUBS:
+		return OPVX(4, 1536, 0, 0) /* vsububs - v2.03 */
+	case AVSUBUHS:
+		return OPVX(4, 1600, 0, 0) /* vsubuhs - v2.03 */
+	case AVSUBUWS:
+		return OPVX(4, 1664, 0, 0) /* vsubuws - v2.03 */
+
+	case AVSUBSBS:
+		return OPVX(4, 1792, 0, 0) /* vsubsbs - v2.03 */
+	case AVSUBSHS:
+		return OPVX(4, 1856, 0, 0) /* vsubshs - v2.03 */
+	case AVSUBSWS:
+		return OPVX(4, 1920, 0, 0) /* vsubsws - v2.03 */
+
+	case AVSUBEUQM:
+		return OPVX(4, 62, 0, 0) /* vsubeuqm - v2.07 */
+	case AVSUBECUQ:
+		return OPVX(4, 63, 0, 0) /* vsubecuq - v2.07 */
+
+	case AVRLB:
+		return OPVX(4, 4, 0, 0) /* vrlb - v2.03 */
+	case AVRLH:
+		return OPVX(4, 68, 0, 0) /* vrlh - v2.03 */
+	case AVRLW:
+		return OPVX(4, 132, 0, 0) /* vrlw - v2.03 */
+	case AVRLD:
+		return OPVX(4, 196, 0, 0) /* vrld - v2.07 */
+
+	case AVMRGOW:
+		return OPVX(4, 1676, 0, 0) /* vmrgow - v2.07 */
+	case AVMRGEW:
+		return OPVX(4, 1932, 0, 0) /* vmrgew - v2.07 */
+
+	case AVSLB:
+		return OPVX(4, 260, 0, 0) /* vslh - v2.03 */
+	case AVSLH:
+		return OPVX(4, 324, 0, 0) /* vslh - v2.03 */
+	case AVSLW:
+		return OPVX(4, 388, 0, 0) /* vslw - v2.03 */
+	case AVSL:
+		return OPVX(4, 452, 0, 0) /* vsl - v2.03 */
+	case AVSLO:
+		return OPVX(4, 1036, 0, 0) /* vsl - v2.03 */
+	case AVSRB:
+		return OPVX(4, 516, 0, 0) /* vsrb - v2.03 */
+	case AVSRH:
+		return OPVX(4, 580, 0, 0) /* vsrh - v2.03 */
+	case AVSRW:
+		return OPVX(4, 644, 0, 0) /* vsrw - v2.03 */
+	case AVSR:
+		return OPVX(4, 708, 0, 0) /* vsr - v2.03 */
+	case AVSRO:
+		return OPVX(4, 1100, 0, 0) /* vsro - v2.03 */
+	case AVSLD:
+		return OPVX(4, 1476, 0, 0) /* vsld - v2.07 */
+	case AVSRD:
+		return OPVX(4, 1732, 0, 0) /* vsrd - v2.07 */
+
+	case AVSRAB:
+		return OPVX(4, 772, 0, 0) /* vsrab - v2.03 */
+	case AVSRAH:
+		return OPVX(4, 836, 0, 0) /* vsrah - v2.03 */
+	case AVSRAW:
+		return OPVX(4, 900, 0, 0) /* vsraw - v2.03 */
+	case AVSRAD:
+		return OPVX(4, 964, 0, 0) /* vsrad - v2.07 */
+
+	case AVBPERMQ:
+		return OPVC(4, 1356, 0, 0) /* vbpermq - v2.07 */
+	case AVBPERMD:
+		return OPVC(4, 1484, 0, 0) /* vbpermd - v3.00 */
+
+	case AVCLZB:
+		return OPVX(4, 1794, 0, 0) /* vclzb - v2.07 */
+	case AVCLZH:
+		return OPVX(4, 1858, 0, 0) /* vclzh - v2.07 */
+	case AVCLZW:
+		return OPVX(4, 1922, 0, 0) /* vclzw - v2.07 */
+	case AVCLZD:
+		return OPVX(4, 1986, 0, 0) /* vclzd - v2.07 */
+
+	case AVPOPCNTB:
+		return OPVX(4, 1795, 0, 0) /* vpopcntb - v2.07 */
+	case AVPOPCNTH:
+		return OPVX(4, 1859, 0, 0) /* vpopcnth - v2.07 */
+	case AVPOPCNTW:
+		return OPVX(4, 1923, 0, 0) /* vpopcntw - v2.07 */
+	case AVPOPCNTD:
+		return OPVX(4, 1987, 0, 0) /* vpopcntd - v2.07 */
+
+	case AVCMPEQUB:
+		return OPVC(4, 6, 0, 0) /* vcmpequb - v2.03 */
+	case AVCMPEQUBCC:
+		return OPVC(4, 6, 0, 1) /* vcmpequb. - v2.03 */
+	case AVCMPEQUH:
+		return OPVC(4, 70, 0, 0) /* vcmpequh - v2.03 */
+	case AVCMPEQUHCC:
+		return OPVC(4, 70, 0, 1) /* vcmpequh. - v2.03 */
+	case AVCMPEQUW:
+		return OPVC(4, 134, 0, 0) /* vcmpequw - v2.03 */
+	case AVCMPEQUWCC:
+		return OPVC(4, 134, 0, 1) /* vcmpequw. - v2.03 */
+	case AVCMPEQUD:
+		return OPVC(4, 199, 0, 0) /* vcmpequd - v2.07 */
+	case AVCMPEQUDCC:
+		return OPVC(4, 199, 0, 1) /* vcmpequd. - v2.07 */
+
+	case AVCMPGTUB:
+		return OPVC(4, 518, 0, 0) /* vcmpgtub - v2.03 */
+	case AVCMPGTUBCC:
+		return OPVC(4, 518, 0, 1) /* vcmpgtub. - v2.03 */
+	case AVCMPGTUH:
+		return OPVC(4, 582, 0, 0) /* vcmpgtuh - v2.03 */
+	case AVCMPGTUHCC:
+		return OPVC(4, 582, 0, 1) /* vcmpgtuh. - v2.03 */
+	case AVCMPGTUW:
+		return OPVC(4, 646, 0, 0) /* vcmpgtuw - v2.03 */
+	case AVCMPGTUWCC:
+		return OPVC(4, 646, 0, 1) /* vcmpgtuw. - v2.03 */
+	case AVCMPGTUD:
+		return OPVC(4, 711, 0, 0) /* vcmpgtud - v2.07 */
+	case AVCMPGTUDCC:
+		return OPVC(4, 711, 0, 1) /* vcmpgtud. v2.07 */
+	case AVCMPGTSB:
+		return OPVC(4, 774, 0, 0) /* vcmpgtsb - v2.03 */
+	case AVCMPGTSBCC:
+		return OPVC(4, 774, 0, 1) /* vcmpgtsb. - v2.03 */
+	case AVCMPGTSH:
+		return OPVC(4, 838, 0, 0) /* vcmpgtsh - v2.03 */
+	case AVCMPGTSHCC:
+		return OPVC(4, 838, 0, 1) /* vcmpgtsh. - v2.03 */
+	case AVCMPGTSW:
+		return OPVC(4, 902, 0, 0) /* vcmpgtsw - v2.03 */
+	case AVCMPGTSWCC:
+		return OPVC(4, 902, 0, 1) /* vcmpgtsw. - v2.03 */
+	case AVCMPGTSD:
+		return OPVC(4, 967, 0, 0) /* vcmpgtsd - v2.07 */
+	case AVCMPGTSDCC:
+		return OPVC(4, 967, 0, 1) /* vcmpgtsd. - v2.07 */
+
+	case AVCMPNEZB:
+		return OPVC(4, 263, 0, 0) /* vcmpnezb - v3.00 */
+	case AVCMPNEZBCC:
+		return OPVC(4, 263, 0, 1) /* vcmpnezb. - v3.00 */
+	case AVCMPNEB:
+		return OPVC(4, 7, 0, 0) /* vcmpneb - v3.00 */
+	case AVCMPNEBCC:
+		return OPVC(4, 7, 0, 1) /* vcmpneb. - v3.00 */
+	case AVCMPNEH:
+		return OPVC(4, 71, 0, 0) /* vcmpneh - v3.00 */
+	case AVCMPNEHCC:
+		return OPVC(4, 71, 0, 1) /* vcmpneh. - v3.00 */
+	case AVCMPNEW:
+		return OPVC(4, 135, 0, 0) /* vcmpnew - v3.00 */
+	case AVCMPNEWCC:
+		return OPVC(4, 135, 0, 1) /* vcmpnew. - v3.00 */
+
+	case AVPERM:
+		return OPVX(4, 43, 0, 0) /* vperm - v2.03 */
+	case AVPERMXOR:
+		return OPVX(4, 45, 0, 0) /* vpermxor - v2.03 */
+	case AVPERMR:
+		return OPVX(4, 59, 0, 0) /* vpermr - v3.0 */
+
+	case AVSEL:
+		return OPVX(4, 42, 0, 0) /* vsel - v2.03 */
+
+	case AVCIPHER:
+		return OPVX(4, 1288, 0, 0) /* vcipher - v2.07 */
+	case AVCIPHERLAST:
+		return OPVX(4, 1289, 0, 0) /* vcipherlast - v2.07 */
+	case AVNCIPHER:
+		return OPVX(4, 1352, 0, 0) /* vncipher - v2.07 */
+	case AVNCIPHERLAST:
+		return OPVX(4, 1353, 0, 0) /* vncipherlast - v2.07 */
+	case AVSBOX:
+		return OPVX(4, 1480, 0, 0) /* vsbox - v2.07 */
+	/* End of vector instructions */
+
+	/* Vector scalar (VSX) instructions */
+	/* ISA 2.06 enables these for POWER7. */
+	case AMFVSRD, AMFVRD, AMFFPRD:
+		return OPVXX1(31, 51, 0) /* mfvsrd - v2.07 */
+	case AMFVSRWZ:
+		return OPVXX1(31, 115, 0) /* mfvsrwz - v2.07 */
+	case AMFVSRLD:
+		return OPVXX1(31, 307, 0) /* mfvsrld - v3.00 */
+
+	case AMTVSRD, AMTFPRD, AMTVRD:
+		return OPVXX1(31, 179, 0) /* mtvsrd - v2.07 */
+	case AMTVSRWA:
+		return OPVXX1(31, 211, 0) /* mtvsrwa - v2.07 */
+	case AMTVSRWZ:
+		return OPVXX1(31, 243, 0) /* mtvsrwz - v2.07 */
+	case AMTVSRDD:
+		return OPVXX1(31, 435, 0) /* mtvsrdd - v3.00 */
+	case AMTVSRWS:
+		return OPVXX1(31, 403, 0) /* mtvsrws - v3.00 */
+
+	case AXXLAND:
+		return OPVXX3(60, 130, 0) /* xxland - v2.06 */
+	case AXXLANDC:
+		return OPVXX3(60, 138, 0) /* xxlandc - v2.06 */
+	case AXXLEQV:
+		return OPVXX3(60, 186, 0) /* xxleqv - v2.07 */
+	case AXXLNAND:
+		return OPVXX3(60, 178, 0) /* xxlnand - v2.07 */
+
+	case AXXLORC:
+		return OPVXX3(60, 170, 0) /* xxlorc - v2.07 */
+	case AXXLNOR:
+		return OPVXX3(60, 162, 0) /* xxlnor - v2.06 */
+	case AXXLOR, AXXLORQ:
+		return OPVXX3(60, 146, 0) /* xxlor - v2.06 */
+	case AXXLXOR:
+		return OPVXX3(60, 154, 0) /* xxlxor - v2.06 */
+
+	case AXXSEL:
+		return OPVXX4(60, 3, 0) /* xxsel - v2.06 */
+
+	case AXXMRGHW:
+		return OPVXX3(60, 18, 0) /* xxmrghw - v2.06 */
+	case AXXMRGLW:
+		return OPVXX3(60, 50, 0) /* xxmrglw - v2.06 */
+
+	case AXXSPLTW:
+		return OPVXX2(60, 164, 0) /* xxspltw - v2.06 */
+
+	case AXXSPLTIB:
+		return OPVCC(60, 360, 0, 0) /* xxspltib - v3.0 */
+
+	case AXXPERM:
+		return OPVXX3(60, 26, 0) /* xxperm - v2.06 */
+	case AXXPERMDI:
+		return OPVXX3(60, 10, 0) /* xxpermdi - v2.06 */
+
+	case AXXSLDWI:
+		return OPVXX3(60, 2, 0) /* xxsldwi - v2.06 */
+
+	case AXXBRQ:
+		return OPVXX2VA(60, 475, 31) /* xxbrq - v3.0 */
+	case AXXBRD:
+		return OPVXX2VA(60, 475, 23) /* xxbrd - v3.0 */
+	case AXXBRW:
+		return OPVXX2VA(60, 475, 15) /* xxbrw - v3.0 */
+	case AXXBRH:
+		return OPVXX2VA(60, 475, 7) /* xxbrh - v3.0 */
+
+	case AXSCVDPSP:
+		return OPVXX2(60, 265, 0) /* xscvdpsp - v2.06 */
+	case AXSCVSPDP:
+		return OPVXX2(60, 329, 0) /* xscvspdp - v2.06 */
+	case AXSCVDPSPN:
+		return OPVXX2(60, 267, 0) /* xscvdpspn - v2.07 */
+	case AXSCVSPDPN:
+		return OPVXX2(60, 331, 0) /* xscvspdpn - v2.07 */
+
+	case AXVCVDPSP:
+		return OPVXX2(60, 393, 0) /* xvcvdpsp - v2.06 */
+	case AXVCVSPDP:
+		return OPVXX2(60, 457, 0) /* xvcvspdp - v2.06 */
+
+	case AXSCVDPSXDS:
+		return OPVXX2(60, 344, 0) /* xscvdpsxds - v2.06 */
+	case AXSCVDPSXWS:
+		return OPVXX2(60, 88, 0) /* xscvdpsxws - v2.06 */
+	case AXSCVDPUXDS:
+		return OPVXX2(60, 328, 0) /* xscvdpuxds - v2.06 */
+	case AXSCVDPUXWS:
+		return OPVXX2(60, 72, 0) /* xscvdpuxws - v2.06 */
+
+	case AXSCVSXDDP:
+		return OPVXX2(60, 376, 0) /* xscvsxddp - v2.06 */
+	case AXSCVUXDDP:
+		return OPVXX2(60, 360, 0) /* xscvuxddp - v2.06 */
+	case AXSCVSXDSP:
+		return OPVXX2(60, 312, 0) /* xscvsxdsp - v2.06 */
+	case AXSCVUXDSP:
+		return OPVXX2(60, 296, 0) /* xscvuxdsp - v2.06 */
+
+	case AXVCVDPSXDS:
+		return OPVXX2(60, 472, 0) /* xvcvdpsxds - v2.06 */
+	case AXVCVDPSXWS:
+		return OPVXX2(60, 216, 0) /* xvcvdpsxws - v2.06 */
+	case AXVCVDPUXDS:
+		return OPVXX2(60, 456, 0) /* xvcvdpuxds - v2.06 */
+	case AXVCVDPUXWS:
+		return OPVXX2(60, 200, 0) /* xvcvdpuxws - v2.06 */
+	case AXVCVSPSXDS:
+		return OPVXX2(60, 408, 0) /* xvcvspsxds - v2.07 */
+	case AXVCVSPSXWS:
+		return OPVXX2(60, 152, 0) /* xvcvspsxws - v2.07 */
+	case AXVCVSPUXDS:
+		return OPVXX2(60, 392, 0) /* xvcvspuxds - v2.07 */
+	case AXVCVSPUXWS:
+		return OPVXX2(60, 136, 0) /* xvcvspuxws - v2.07 */
+
+	case AXVCVSXDDP:
+		return OPVXX2(60, 504, 0) /* xvcvsxddp - v2.06 */
+	case AXVCVSXWDP:
+		return OPVXX2(60, 248, 0) /* xvcvsxwdp - v2.06 */
+	case AXVCVUXDDP:
+		return OPVXX2(60, 488, 0) /* xvcvuxddp - v2.06 */
+	case AXVCVUXWDP:
+		return OPVXX2(60, 232, 0) /* xvcvuxwdp - v2.06 */
+	case AXVCVSXDSP:
+		return OPVXX2(60, 440, 0) /* xvcvsxdsp - v2.06 */
+	case AXVCVSXWSP:
+		return OPVXX2(60, 184, 0) /* xvcvsxwsp - v2.06 */
+	case AXVCVUXDSP:
+		return OPVXX2(60, 424, 0) /* xvcvuxdsp - v2.06 */
+	case AXVCVUXWSP:
+		return OPVXX2(60, 168, 0) /* xvcvuxwsp - v2.06 */
+	/* End of VSX instructions */
+
+	case AMADDHD:
+		return OPVX(4, 48, 0, 0) /* maddhd - v3.00 */
+	case AMADDHDU:
+		return OPVX(4, 49, 0, 0) /* maddhdu - v3.00 */
+	case AMADDLD:
+		return OPVX(4, 51, 0, 0) /* maddld - v3.00 */
+
+	case AXOR:
+		return OPVCC(31, 316, 0, 0)
+	case AXORCC:
+		return OPVCC(31, 316, 0, 1)
+	}
+
+	c.ctxt.Diag("bad r/r, r/r/r or r/r/r/r opcode %v", a)
+	return 0
+}
+
+func (c *ctxt9) opirrr(a obj.As) uint32 {
+	switch a {
+	/* Vector (VMX/Altivec) instructions */
+	/* ISA 2.03 enables these for PPC970. For POWERx processors, these */
+	/* are enabled starting at POWER6 (ISA 2.05). */
+	case AVSLDOI:
+		return OPVX(4, 44, 0, 0) /* vsldoi - v2.03 */
+	}
+
+	c.ctxt.Diag("bad i/r/r/r opcode %v", a)
+	return 0
+}
+
+func (c *ctxt9) opiirr(a obj.As) uint32 {
+	switch a {
+	/* Vector (VMX/Altivec) instructions */
+	/* ISA 2.07 enables these for POWER8 and beyond. */
+	case AVSHASIGMAW:
+		return OPVX(4, 1666, 0, 0) /* vshasigmaw - v2.07 */
+	case AVSHASIGMAD:
+		return OPVX(4, 1730, 0, 0) /* vshasigmad - v2.07 */
+	}
+
+	c.ctxt.Diag("bad i/i/r/r opcode %v", a)
+	return 0
+}
+
+func (c *ctxt9) opirr(a obj.As) uint32 {
+	switch a {
+	case AADD:
+		return OPVCC(14, 0, 0, 0)
+	case AADDC:
+		return OPVCC(12, 0, 0, 0)
+	case AADDCCC:
+		return OPVCC(13, 0, 0, 0)
+	case AADDIS:
+		return OPVCC(15, 0, 0, 0) /* ADDIS */
+
+	case AANDCC:
+		return OPVCC(28, 0, 0, 0)
+	case AANDISCC:
+		return OPVCC(29, 0, 0, 0) /* ANDIS. */
+
+	case ABR:
+		return OPVCC(18, 0, 0, 0)
+	case ABL:
+		return OPVCC(18, 0, 0, 0) | 1
+	case obj.ADUFFZERO:
+		return OPVCC(18, 0, 0, 0) | 1
+	case obj.ADUFFCOPY:
+		return OPVCC(18, 0, 0, 0) | 1
+	case ABC:
+		return OPVCC(16, 0, 0, 0)
+	case ABCL:
+		return OPVCC(16, 0, 0, 0) | 1
+
+	case ABEQ:
+		return AOP_RRR(16<<26, 12, 2, 0)
+	case ABGE:
+		return AOP_RRR(16<<26, 4, 0, 0)
+	case ABGT:
+		return AOP_RRR(16<<26, 12, 1, 0)
+	case ABLE:
+		return AOP_RRR(16<<26, 4, 1, 0)
+	case ABLT:
+		return AOP_RRR(16<<26, 12, 0, 0)
+	case ABNE:
+		return AOP_RRR(16<<26, 4, 2, 0)
+	case ABVC:
+		return AOP_RRR(16<<26, 4, 3, 0) // apparently unordered-clear
+	case ABVS:
+		return AOP_RRR(16<<26, 12, 3, 0) // apparently unordered-set
+
+	case ACMP:
+		return OPVCC(11, 0, 0, 0) | 1<<21 /* L=1 */
+	case ACMPU:
+		return OPVCC(10, 0, 0, 0) | 1<<21
+	case ACMPW:
+		return OPVCC(11, 0, 0, 0) /* L=0 */
+	case ACMPWU:
+		return OPVCC(10, 0, 0, 0)
+	case ACMPEQB:
+		return OPVCC(31, 224, 0, 0) /* cmpeqb - v3.00 */
+
+	case ALSW:
+		return OPVCC(31, 597, 0, 0)
+
+	case ACOPY:
+		return OPVCC(31, 774, 0, 0) /* copy - v3.00 */
+	case APASTECC:
+		return OPVCC(31, 902, 0, 1) /* paste. - v3.00 */
+	case ADARN:
+		return OPVCC(31, 755, 0, 0) /* darn - v3.00 */
+
+	case AMULLW:
+		return OPVCC(7, 0, 0, 0)
+
+	case AOR:
+		return OPVCC(24, 0, 0, 0)
+	case AORIS:
+		return OPVCC(25, 0, 0, 0) /* ORIS */
+
+	case ARLWMI:
+		return OPVCC(20, 0, 0, 0) /* rlwimi */
+	case ARLWMICC:
+		return OPVCC(20, 0, 0, 1)
+	case ARLDMI:
+		return OPVCC(30, 0, 0, 0) | 3<<2 /* rldimi */
+	case ARLDMICC:
+		return OPVCC(30, 0, 0, 1) | 3<<2
+	case ARLDIMI:
+		return OPVCC(30, 0, 0, 0) | 3<<2 /* rldimi */
+	case ARLDIMICC:
+		return OPVCC(30, 0, 0, 1) | 3<<2
+	case ARLWNM:
+		return OPVCC(21, 0, 0, 0) /* rlwinm */
+	case ARLWNMCC:
+		return OPVCC(21, 0, 0, 1)
+
+	case ARLDCL:
+		return OPVCC(30, 0, 0, 0) /* rldicl */
+	case ARLDCLCC:
+		return OPVCC(30, 0, 0, 1)
+	case ARLDCR:
+		return OPVCC(30, 1, 0, 0) /* rldicr */
+	case ARLDCRCC:
+		return OPVCC(30, 1, 0, 1)
+	case ARLDC:
+		return OPVCC(30, 0, 0, 0) | 2<<2
+	case ARLDCCC:
+		return OPVCC(30, 0, 0, 1) | 2<<2
+
+	case ASRAW:
+		return OPVCC(31, 824, 0, 0)
+	case ASRAWCC:
+		return OPVCC(31, 824, 0, 1)
+	case ASRAD:
+		return OPVCC(31, (413 << 1), 0, 0)
+	case ASRADCC:
+		return OPVCC(31, (413 << 1), 0, 1)
+
+	case ASTSW:
+		return OPVCC(31, 725, 0, 0)
+
+	case ASUBC:
+		return OPVCC(8, 0, 0, 0)
+
+	case ATW:
+		return OPVCC(3, 0, 0, 0)
+	case ATD:
+		return OPVCC(2, 0, 0, 0)
+
+	/* Vector (VMX/Altivec) instructions */
+	/* ISA 2.03 enables these for PPC970. For POWERx processors, these */
+	/* are enabled starting at POWER6 (ISA 2.05). */
+	case AVSPLTB:
+		return OPVX(4, 524, 0, 0) /* vspltb - v2.03 */
+	case AVSPLTH:
+		return OPVX(4, 588, 0, 0) /* vsplth - v2.03 */
+	case AVSPLTW:
+		return OPVX(4, 652, 0, 0) /* vspltw - v2.03 */
+
+	case AVSPLTISB:
+		return OPVX(4, 780, 0, 0) /* vspltisb - v2.03 */
+	case AVSPLTISH:
+		return OPVX(4, 844, 0, 0) /* vspltish - v2.03 */
+	case AVSPLTISW:
+		return OPVX(4, 908, 0, 0) /* vspltisw - v2.03 */
+	/* End of vector instructions */
+
+	case AFTDIV:
+		return OPVCC(63, 128, 0, 0) /* ftdiv - v2.06 */
+	case AFTSQRT:
+		return OPVCC(63, 160, 0, 0) /* ftsqrt - v2.06 */
+
+	case AXOR:
+		return OPVCC(26, 0, 0, 0) /* XORIL */
+	case AXORIS:
+		return OPVCC(27, 0, 0, 0) /* XORIS */
+	}
+
+	c.ctxt.Diag("bad opcode i/r or i/r/r %v", a)
+	return 0
+}
+
+/*
+ * load o(a),d
+ */
+func (c *ctxt9) opload(a obj.As) uint32 {
+	switch a {
+	case AMOVD:
+		return OPVCC(58, 0, 0, 0) /* ld */
+	case AMOVDU:
+		return OPVCC(58, 0, 0, 1) /* ldu */
+	case AMOVWZ:
+		return OPVCC(32, 0, 0, 0) /* lwz */
+	case AMOVWZU:
+		return OPVCC(33, 0, 0, 0) /* lwzu */
+	case AMOVW:
+		return OPVCC(58, 0, 0, 0) | 1<<1 /* lwa */
+	case ALXV:
+		return OPDQ(61, 1, 0) /* lxv - ISA v3.0 */
+	case ALXVL:
+		return OPVXX1(31, 269, 0) /* lxvl - ISA v3.0 */
+	case ALXVLL:
+		return OPVXX1(31, 301, 0) /* lxvll - ISA v3.0 */
+	case ALXVX:
+		return OPVXX1(31, 268, 0) /* lxvx - ISA v3.0 */
+
+		/* no AMOVWU */
+	case AMOVB, AMOVBZ:
+		return OPVCC(34, 0, 0, 0)
+		/* load */
+
+	case AMOVBU, AMOVBZU:
+		return OPVCC(35, 0, 0, 0)
+	case AFMOVD:
+		return OPVCC(50, 0, 0, 0)
+	case AFMOVDU:
+		return OPVCC(51, 0, 0, 0)
+	case AFMOVS:
+		return OPVCC(48, 0, 0, 0)
+	case AFMOVSU:
+		return OPVCC(49, 0, 0, 0)
+	case AMOVH:
+		return OPVCC(42, 0, 0, 0)
+	case AMOVHU:
+		return OPVCC(43, 0, 0, 0)
+	case AMOVHZ:
+		return OPVCC(40, 0, 0, 0)
+	case AMOVHZU:
+		return OPVCC(41, 0, 0, 0)
+	case AMOVMW:
+		return OPVCC(46, 0, 0, 0) /* lmw */
+	}
+
+	c.ctxt.Diag("bad load opcode %v", a)
+	return 0
+}
+
+/*
+ * indexed load a(b),d
+ */
+func (c *ctxt9) oploadx(a obj.As) uint32 {
+	switch a {
+	case AMOVWZ:
+		return OPVCC(31, 23, 0, 0) /* lwzx */
+	case AMOVWZU:
+		return OPVCC(31, 55, 0, 0) /* lwzux */
+	case AMOVW:
+		return OPVCC(31, 341, 0, 0) /* lwax */
+	case AMOVWU:
+		return OPVCC(31, 373, 0, 0) /* lwaux */
+
+	case AMOVB, AMOVBZ:
+		return OPVCC(31, 87, 0, 0) /* lbzx */
+
+	case AMOVBU, AMOVBZU:
+		return OPVCC(31, 119, 0, 0) /* lbzux */
+	case AFMOVD:
+		return OPVCC(31, 599, 0, 0) /* lfdx */
+	case AFMOVDU:
+		return OPVCC(31, 631, 0, 0) /*  lfdux */
+	case AFMOVS:
+		return OPVCC(31, 535, 0, 0) /* lfsx */
+	case AFMOVSU:
+		return OPVCC(31, 567, 0, 0) /* lfsux */
+	case AFMOVSX:
+		return OPVCC(31, 855, 0, 0) /* lfiwax - power6, isa 2.05 */
+	case AFMOVSZ:
+		return OPVCC(31, 887, 0, 0) /* lfiwzx - power7, isa 2.06 */
+	case AMOVH:
+		return OPVCC(31, 343, 0, 0) /* lhax */
+	case AMOVHU:
+		return OPVCC(31, 375, 0, 0) /* lhaux */
+	case AMOVHBR:
+		return OPVCC(31, 790, 0, 0) /* lhbrx */
+	case AMOVWBR:
+		return OPVCC(31, 534, 0, 0) /* lwbrx */
+	case AMOVDBR:
+		return OPVCC(31, 532, 0, 0) /* ldbrx */
+	case AMOVHZ:
+		return OPVCC(31, 279, 0, 0) /* lhzx */
+	case AMOVHZU:
+		return OPVCC(31, 311, 0, 0) /* lhzux */
+	case AECIWX:
+		return OPVCC(31, 310, 0, 0) /* eciwx */
+	case ALBAR:
+		return OPVCC(31, 52, 0, 0) /* lbarx */
+	case ALHAR:
+		return OPVCC(31, 116, 0, 0) /* lharx */
+	case ALWAR:
+		return OPVCC(31, 20, 0, 0) /* lwarx */
+	case ALDAR:
+		return OPVCC(31, 84, 0, 0) /* ldarx */
+	case ALSW:
+		return OPVCC(31, 533, 0, 0) /* lswx */
+	case AMOVD:
+		return OPVCC(31, 21, 0, 0) /* ldx */
+	case AMOVDU:
+		return OPVCC(31, 53, 0, 0) /* ldux */
+	case ALDMX:
+		return OPVCC(31, 309, 0, 0) /* ldmx */
+
+	/* Vector (VMX/Altivec) instructions */
+	case ALVEBX:
+		return OPVCC(31, 7, 0, 0) /* lvebx - v2.03 */
+	case ALVEHX:
+		return OPVCC(31, 39, 0, 0) /* lvehx - v2.03 */
+	case ALVEWX:
+		return OPVCC(31, 71, 0, 0) /* lvewx - v2.03 */
+	case ALVX:
+		return OPVCC(31, 103, 0, 0) /* lvx - v2.03 */
+	case ALVXL:
+		return OPVCC(31, 359, 0, 0) /* lvxl - v2.03 */
+	case ALVSL:
+		return OPVCC(31, 6, 0, 0) /* lvsl - v2.03 */
+	case ALVSR:
+		return OPVCC(31, 38, 0, 0) /* lvsr - v2.03 */
+		/* End of vector instructions */
+
+	/* Vector scalar (VSX) instructions */
+	case ALXVX:
+		return OPVXX1(31, 268, 0) /* lxvx - ISA v3.0 */
+	case ALXVD2X:
+		return OPVXX1(31, 844, 0) /* lxvd2x - v2.06 */
+	case ALXVW4X:
+		return OPVXX1(31, 780, 0) /* lxvw4x - v2.06 */
+	case ALXVH8X:
+		return OPVXX1(31, 812, 0) /* lxvh8x - v3.00 */
+	case ALXVB16X:
+		return OPVXX1(31, 876, 0) /* lxvb16x - v3.00 */
+	case ALXVDSX:
+		return OPVXX1(31, 332, 0) /* lxvdsx - v2.06 */
+	case ALXSDX:
+		return OPVXX1(31, 588, 0) /* lxsdx - v2.06 */
+	case ALXSIWAX:
+		return OPVXX1(31, 76, 0) /* lxsiwax - v2.07 */
+	case ALXSIWZX:
+		return OPVXX1(31, 12, 0) /* lxsiwzx - v2.07 */
+	}
+
+	c.ctxt.Diag("bad loadx opcode %v", a)
+	return 0
+}
+
+/*
+ * store s,o(d)
+ */
+func (c *ctxt9) opstore(a obj.As) uint32 {
+	switch a {
+	case AMOVB, AMOVBZ:
+		return OPVCC(38, 0, 0, 0) /* stb */
+
+	case AMOVBU, AMOVBZU:
+		return OPVCC(39, 0, 0, 0) /* stbu */
+	case AFMOVD:
+		return OPVCC(54, 0, 0, 0) /* stfd */
+	case AFMOVDU:
+		return OPVCC(55, 0, 0, 0) /* stfdu */
+	case AFMOVS:
+		return OPVCC(52, 0, 0, 0) /* stfs */
+	case AFMOVSU:
+		return OPVCC(53, 0, 0, 0) /* stfsu */
+
+	case AMOVHZ, AMOVH:
+		return OPVCC(44, 0, 0, 0) /* sth */
+
+	case AMOVHZU, AMOVHU:
+		return OPVCC(45, 0, 0, 0) /* sthu */
+	case AMOVMW:
+		return OPVCC(47, 0, 0, 0) /* stmw */
+	case ASTSW:
+		return OPVCC(31, 725, 0, 0) /* stswi */
+
+	case AMOVWZ, AMOVW:
+		return OPVCC(36, 0, 0, 0) /* stw */
+
+	case AMOVWZU, AMOVWU:
+		return OPVCC(37, 0, 0, 0) /* stwu */
+	case AMOVD:
+		return OPVCC(62, 0, 0, 0) /* std */
+	case AMOVDU:
+		return OPVCC(62, 0, 0, 1) /* stdu */
+	case ASTXV:
+		return OPDQ(61, 5, 0) /* stxv ISA 3.0 */
+	case ASTXVL:
+		return OPVXX1(31, 397, 0) /* stxvl ISA 3.0 */
+	case ASTXVLL:
+		return OPVXX1(31, 429, 0) /* stxvll ISA 3.0 */
+	case ASTXVX:
+		return OPVXX1(31, 396, 0) /* stxvx - ISA v3.0 */
+
+	}
+
+	c.ctxt.Diag("unknown store opcode %v", a)
+	return 0
+}
+
+/*
+ * indexed store s,a(b)
+ */
+func (c *ctxt9) opstorex(a obj.As) uint32 {
+	switch a {
+	case AMOVB, AMOVBZ:
+		return OPVCC(31, 215, 0, 0) /* stbx */
+
+	case AMOVBU, AMOVBZU:
+		return OPVCC(31, 247, 0, 0) /* stbux */
+	case AFMOVD:
+		return OPVCC(31, 727, 0, 0) /* stfdx */
+	case AFMOVDU:
+		return OPVCC(31, 759, 0, 0) /* stfdux */
+	case AFMOVS:
+		return OPVCC(31, 663, 0, 0) /* stfsx */
+	case AFMOVSU:
+		return OPVCC(31, 695, 0, 0) /* stfsux */
+	case AFMOVSX:
+		return OPVCC(31, 983, 0, 0) /* stfiwx */
+
+	case AMOVHZ, AMOVH:
+		return OPVCC(31, 407, 0, 0) /* sthx */
+	case AMOVHBR:
+		return OPVCC(31, 918, 0, 0) /* sthbrx */
+
+	case AMOVHZU, AMOVHU:
+		return OPVCC(31, 439, 0, 0) /* sthux */
+
+	case AMOVWZ, AMOVW:
+		return OPVCC(31, 151, 0, 0) /* stwx */
+
+	case AMOVWZU, AMOVWU:
+		return OPVCC(31, 183, 0, 0) /* stwux */
+	case ASTSW:
+		return OPVCC(31, 661, 0, 0) /* stswx */
+	case AMOVWBR:
+		return OPVCC(31, 662, 0, 0) /* stwbrx */
+	case AMOVDBR:
+		return OPVCC(31, 660, 0, 0) /* stdbrx */
+	case ASTBCCC:
+		return OPVCC(31, 694, 0, 1) /* stbcx. */
+	case ASTHCCC:
+		return OPVCC(31, 726, 0, 1) /* sthcx. */
+	case ASTWCCC:
+		return OPVCC(31, 150, 0, 1) /* stwcx. */
+	case ASTDCCC:
+		return OPVCC(31, 214, 0, 1) /* stwdx. */
+	case AECOWX:
+		return OPVCC(31, 438, 0, 0) /* ecowx */
+	case AMOVD:
+		return OPVCC(31, 149, 0, 0) /* stdx */
+	case AMOVDU:
+		return OPVCC(31, 181, 0, 0) /* stdux */
+
+	/* Vector (VMX/Altivec) instructions */
+	case ASTVEBX:
+		return OPVCC(31, 135, 0, 0) /* stvebx - v2.03 */
+	case ASTVEHX:
+		return OPVCC(31, 167, 0, 0) /* stvehx - v2.03 */
+	case ASTVEWX:
+		return OPVCC(31, 199, 0, 0) /* stvewx - v2.03 */
+	case ASTVX:
+		return OPVCC(31, 231, 0, 0) /* stvx - v2.03 */
+	case ASTVXL:
+		return OPVCC(31, 487, 0, 0) /* stvxl - v2.03 */
+		/* End of vector instructions */
+
+	/* Vector scalar (VSX) instructions */
+	case ASTXVX:
+		return OPVXX1(31, 396, 0) /* stxvx - v3.0 */
+	case ASTXVD2X:
+		return OPVXX1(31, 972, 0) /* stxvd2x - v2.06 */
+	case ASTXVW4X:
+		return OPVXX1(31, 908, 0) /* stxvw4x - v2.06 */
+	case ASTXVH8X:
+		return OPVXX1(31, 940, 0) /* stxvh8x - v3.0 */
+	case ASTXVB16X:
+		return OPVXX1(31, 1004, 0) /* stxvb16x - v3.0 */
+
+	case ASTXSDX:
+		return OPVXX1(31, 716, 0) /* stxsdx - v2.06 */
+
+	case ASTXSIWX:
+		return OPVXX1(31, 140, 0) /* stxsiwx - v2.07 */
+
+		/* End of vector scalar instructions */
+
+	}
+
+	c.ctxt.Diag("unknown storex opcode %v", a)
+	return 0
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/doc.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/doc.go
new file mode 100644
index 000000000..6e601df82
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/doc.go
@@ -0,0 +1,244 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Package ppc64 implements a PPC64 assembler that assembles Go asm into
+the corresponding PPC64 instructions as defined by the Power ISA 3.0B.
+
+This document provides information on how to write code in Go assembler
+for PPC64, focusing on the differences between Go and PPC64 assembly language.
+It assumes some knowledge of PPC64 assembler. The original implementation of
+PPC64 in Go defined many opcodes that are different from PPC64 opcodes, but
+updates to the Go assembly language used mnemonics that are mostly similar if not
+identical to the PPC64 mneumonics, such as VMX and VSX instructions. Not all detail
+is included here; refer to the Power ISA document if interested in more detail.
+
+Starting with Go 1.15 the Go objdump supports the -gnu option, which provides a
+side by side view of the Go assembler and the PPC64 assembler output. This is
+extremely helpful in determining what final PPC64 assembly is generated from the
+corresponding Go assembly.
+
+In the examples below, the Go assembly is on the left, PPC64 assembly on the right.
+
+1. Operand ordering
+
+  In Go asm, the last operand (right) is the target operand, but with PPC64 asm,
+  the first operand (left) is the target. The order of the remaining operands is
+  not consistent: in general opcodes with 3 operands that perform math or logical
+  operations have their operands in reverse order. Opcodes for vector instructions
+  and those with more than 3 operands usually have operands in the same order except
+  for the target operand, which is first in PPC64 asm and last in Go asm.
+
+  Example:
+    ADD R3, R4, R5		<=>	add r5, r4, r3
+
+2. Constant operands
+
+  In Go asm, an operand that starts with '$' indicates a constant value. If the
+  instruction using the constant has an immediate version of the opcode, then an
+  immediate value is used with the opcode if possible.
+
+  Example:
+    ADD $1, R3, R4		<=> 	addi r4, r3, 1
+
+3. Opcodes setting condition codes
+
+  In PPC64 asm, some instructions other than compares have variations that can set
+  the condition code where meaningful. This is indicated by adding '.' to the end
+  of the PPC64 instruction. In Go asm, these instructions have 'CC' at the end of
+  the opcode. The possible settings of the condition code depend on the instruction.
+  CR0 is the default for fixed-point instructions; CR1 for floating point; CR6 for
+  vector instructions.
+
+  Example:
+    ANDCC R3, R4, R5		<=>	and. r5, r3, r4 (set CR0)
+
+4. Loads and stores from memory
+
+  In Go asm, opcodes starting with 'MOV' indicate a load or store. When the target
+  is a memory reference, then it is a store; when the target is a register and the
+  source is a memory reference, then it is a load.
+
+  MOV{B,H,W,D} variations identify the size as byte, halfword, word, doubleword.
+
+  Adding 'Z' to the opcode for a load indicates zero extend; if omitted it is sign extend.
+  Adding 'U' to a load or store indicates an update of the base register with the offset.
+  Adding 'BR' to an opcode indicates byte-reversed load or store, or the order opposite
+  of the expected endian order. If 'BR' is used then zero extend is assumed.
+
+  Memory references n(Ra) indicate the address in Ra + n. When used with an update form
+  of an opcode, the value in Ra is incremented by n.
+
+  Memory references (Ra+Rb) or (Ra)(Rb) indicate the address Ra + Rb, used by indexed
+  loads or stores. Both forms are accepted. When used with an update then the base register
+  is updated by the value in the index register.
+
+  Examples:
+    MOVD (R3), R4		<=>	ld r4,0(r3)
+    MOVW (R3), R4		<=>	lwa r4,0(r3)
+    MOVWZU 4(R3), R4		<=>	lwzu r4,4(r3)
+    MOVWZ (R3+R5), R4		<=>	lwzx r4,r3,r5
+    MOVHZ  (R3), R4		<=>	lhz r4,0(r3)
+    MOVHU 2(R3), R4		<=>	lhau r4,2(r3)
+    MOVBZ (R3), R4		<=>	lbz r4,0(r3)
+
+    MOVD R4,(R3)		<=>	std r4,0(r3)
+    MOVW R4,(R3)		<=>	stw r4,0(r3)
+    MOVW R4,(R3+R5)		<=>	stwx r4,r3,r5
+    MOVWU R4,4(R3)		<=>	stwu r4,4(r3)
+    MOVH R4,2(R3)		<=>	sth r4,2(r3)
+    MOVBU R4,(R3)(R5)		<=>	stbux r4,r3,r5
+
+4. Compares
+
+  When an instruction does a compare or other operation that might
+  result in a condition code, then the resulting condition is set
+  in a field of the condition register. The condition register consists
+  of 8 4-bit fields named CR0 - CR7. When a compare instruction
+  identifies a CR then the resulting condition is set in that field
+  to be read by a later branch or isel instruction. Within these fields,
+  bits are set to indicate less than, greater than, or equal conditions.
+
+  Once an instruction sets a condition, then a subsequent branch, isel or
+  other instruction can read the condition field and operate based on the
+  bit settings.
+
+  Examples:
+    CMP R3, R4			<=>	cmp r3, r4	(CR0 assumed)
+    CMP R3, R4, CR1		<=>	cmp cr1, r3, r4
+
+  Note that the condition register is the target operand of compare opcodes, so
+  the remaining operands are in the same order for Go asm and PPC64 asm.
+  When CR0 is used then it is implicit and does not need to be specified.
+
+5. Branches
+
+  Many branches are represented as a form of the BC instruction. There are
+  other extended opcodes to make it easier to see what type of branch is being
+  used.
+
+  The following is a brief description of the BC instruction and its commonly
+  used operands.
+
+  BC op1, op2, op3
+
+    op1: type of branch
+        16 -> bctr (branch on ctr)
+        12 -> bcr  (branch if cr bit is set)
+        8  -> bcr+bctr (branch on ctr and cr values)
+	4  -> bcr != 0 (branch if specified cr bit is not set)
+
+	There are more combinations but these are the most common.
+
+    op2: condition register field and condition bit
+
+	This contains an immediate value indicating which condition field
+	to read and what bits to test. Each field is 4 bits long with CR0
+        at bit 0, CR1 at bit 4, etc. The value is computed as 4*CR+condition
+        with these condition values:
+
+        0 -> LT
+        1 -> GT
+        2 -> EQ
+        3 -> OVG
+
+	Thus 0 means test CR0 for LT, 5 means CR1 for GT, 30 means CR7 for EQ.
+
+    op3: branch target
+
+  Examples:
+
+    BC 12, 0, target		<=>	blt cr0, target
+    BC 12, 2, target		<=>	beq cr0, target
+    BC 12, 5, target		<=>	bgt cr1, target
+    BC 12, 30, target		<=>	beq cr7, target
+    BC 4, 6, target		<=>	bne cr1, target
+    BC 4, 1, target		<=>	ble cr1, target
+
+    The following extended opcodes are available for ease of use and readability:
+
+    BNE CR2, target		<=>	bne cr2, target
+    BEQ CR4, target		<=>	beq cr4, target
+    BLT target			<=>	blt target (cr0 default)
+    BGE CR7, target		<=>	bge cr7, target
+
+  Refer to the ISA for more information on additional values for the BC instruction,
+  how to handle OVG information, and much more.
+
+5. Align directive
+
+  Starting with Go 1.12, Go asm supports the PCALIGN directive, which indicates
+  that the next instruction should be aligned to the specified value. Currently
+  8 and 16 are the only supported values, and a maximum of 2 NOPs will be added
+  to align the code. That means in the case where the code is aligned to 4 but
+  PCALIGN $16 is at that location, the code will only be aligned to 8 to avoid
+  adding 3 NOPs.
+
+  The purpose of this directive is to improve performance for cases like loops
+  where better alignment (8 or 16 instead of 4) might be helpful. This directive
+  exists in PPC64 assembler and is frequently used by PPC64 assembler writers.
+
+  PCALIGN $16
+  PCALIGN $8
+
+  Functions in Go are aligned to 16 bytes, as is the case in all other compilers
+  for PPC64.
+
+6. Shift instructions
+
+  The simple scalar shifts on PPC64 expect a shift count that fits in 5 bits for
+  32-bit values or 6 bit for 64-bit values. If the shift count is a constant value
+  greater than the max then the assembler sets it to the max for that size (31 for
+  32 bit values, 63 for 64 bit values). If the shift count is in a register, then
+  only the low 5 or 6 bits of the register will be used as the shift count. The
+  Go compiler will add appropriate code to compare the shift value to achieve the
+  the correct result, and the assembler does not add extra checking.
+
+  Examples:
+
+    SRAD $8,R3,R4		=>	sradi r4,r3,8
+    SRD $8,R3,R4		=>	rldicl r4,r3,56,8
+    SLD $8,R3,R4		=>	rldicr r4,r3,8,55
+    SRAW $16,R4,R5		=>	srawi r5,r4,16
+    SRW $40,R4,R5		=>	rlwinm r5,r4,0,0,31
+    SLW $12,R4,R5		=>	rlwinm r5,r4,12,0,19
+
+  Some non-simple shifts have operands in the Go assembly which don't map directly
+  onto operands in the PPC64 assembly. When an operand in a shift instruction in the
+  Go assembly is a bit mask, that mask is represented as a start and end bit in the
+  PPC64 assembly instead of a mask. See the ISA for more detail on these types of shifts.
+  Here are a few examples:
+
+    RLWMI $7,R3,$65535,R6 	=>	rlwimi r6,r3,7,16,31
+    RLDMI $0,R4,$7,R6 		=>	rldimi r6,r4,0,61
+
+  More recently, Go opcodes were added which map directly onto the PPC64 opcodes. It is
+  recommended to use the newer opcodes to avoid confusion.
+
+    RLDICL $0,R4,$15,R6		=>	rldicl r6,r4,0,15
+    RLDICR $0,R4,$15,R6		=>	rldicr r6.r4,0,15
+
+Register naming
+
+1. Special register usage in Go asm
+
+  The following registers should not be modified by user Go assembler code.
+
+  R0: Go code expects this register to contain the value 0.
+  R1: Stack pointer
+  R2: TOC pointer when compiled with -shared or -dynlink (a.k.a position independent code)
+  R13: TLS pointer
+  R30: g (goroutine)
+
+  Register names:
+
+  Rn is used for general purpose registers. (0-31)
+  Fn is used for floating point registers. (0-31)
+  Vn is used for vector registers. Slot 0 of Vn overlaps with Fn. (0-31)
+  VSn is used for vector-scalar registers. V0-V31 overlap with VS32-VS63. (0-63)
+  CTR represents the count register.
+  LR represents the link register.
+
+*/
+package ppc64
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/list9.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/list9.go
new file mode 100644
index 000000000..451333367
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/list9.go
@@ -0,0 +1,104 @@
+// cmd/9l/list.c from Vita Nuova.
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2008 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package ppc64
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"fmt"
+)
+
+func init() {
+	obj.RegisterRegister(obj.RBasePPC64, REG_DCR0+1024, rconv)
+	obj.RegisterOpcode(obj.ABasePPC64, Anames)
+}
+
+func rconv(r int) string {
+	if r == 0 {
+		return "NONE"
+	}
+	if r == REGG {
+		// Special case.
+		return "g"
+	}
+	if REG_R0 <= r && r <= REG_R31 {
+		return fmt.Sprintf("R%d", r-REG_R0)
+	}
+	if REG_F0 <= r && r <= REG_F31 {
+		return fmt.Sprintf("F%d", r-REG_F0)
+	}
+	if REG_V0 <= r && r <= REG_V31 {
+		return fmt.Sprintf("V%d", r-REG_V0)
+	}
+	if REG_VS0 <= r && r <= REG_VS63 {
+		return fmt.Sprintf("VS%d", r-REG_VS0)
+	}
+	if REG_CR0 <= r && r <= REG_CR7 {
+		return fmt.Sprintf("CR%d", r-REG_CR0)
+	}
+	if r == REG_CR {
+		return "CR"
+	}
+	if REG_SPR0 <= r && r <= REG_SPR0+1023 {
+		switch r {
+		case REG_XER:
+			return "XER"
+
+		case REG_LR:
+			return "LR"
+
+		case REG_CTR:
+			return "CTR"
+		}
+
+		return fmt.Sprintf("SPR(%d)", r-REG_SPR0)
+	}
+
+	if REG_DCR0 <= r && r <= REG_DCR0+1023 {
+		return fmt.Sprintf("DCR(%d)", r-REG_DCR0)
+	}
+	if r == REG_FPSCR {
+		return "FPSCR"
+	}
+	if r == REG_MSR {
+		return "MSR"
+	}
+
+	return fmt.Sprintf("Rgok(%d)", r-obj.RBasePPC64)
+}
+
+func DRconv(a int) string {
+	s := "C_??"
+	if a >= C_NONE && a <= C_NCLASS {
+		s = cnames9[a]
+	}
+	var fp string
+	fp += s
+	return fp
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/obj9.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/obj9.go
new file mode 100644
index 000000000..7997b1942
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/ppc64/obj9.go
@@ -0,0 +1,1278 @@
+// cmd/9l/noop.c, cmd/9l/pass.c, cmd/9l/span.c from Vita Nuova.
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2008 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package ppc64
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"github.com/twitchyliquid64/golang-asm/sys"
+)
+
+func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
+	p.From.Class = 0
+	p.To.Class = 0
+
+	c := ctxt9{ctxt: ctxt, newprog: newprog}
+
+	// Rewrite BR/BL to symbol as TYPE_BRANCH.
+	switch p.As {
+	case ABR,
+		ABL,
+		obj.ARET,
+		obj.ADUFFZERO,
+		obj.ADUFFCOPY:
+		if p.To.Sym != nil {
+			p.To.Type = obj.TYPE_BRANCH
+		}
+	}
+
+	// Rewrite float constants to values stored in memory.
+	switch p.As {
+	case AFMOVS:
+		if p.From.Type == obj.TYPE_FCONST {
+			f32 := float32(p.From.Val.(float64))
+			p.From.Type = obj.TYPE_MEM
+			p.From.Sym = ctxt.Float32Sym(f32)
+			p.From.Name = obj.NAME_EXTERN
+			p.From.Offset = 0
+		}
+
+	case AFMOVD:
+		if p.From.Type == obj.TYPE_FCONST {
+			f64 := p.From.Val.(float64)
+			// Constant not needed in memory for float +/- 0
+			if f64 != 0 {
+				p.From.Type = obj.TYPE_MEM
+				p.From.Sym = ctxt.Float64Sym(f64)
+				p.From.Name = obj.NAME_EXTERN
+				p.From.Offset = 0
+			}
+		}
+
+		// Put >32-bit constants in memory and load them
+	case AMOVD:
+		if p.From.Type == obj.TYPE_CONST && p.From.Name == obj.NAME_NONE && p.From.Reg == 0 && int64(int32(p.From.Offset)) != p.From.Offset {
+			p.From.Type = obj.TYPE_MEM
+			p.From.Sym = ctxt.Int64Sym(p.From.Offset)
+			p.From.Name = obj.NAME_EXTERN
+			p.From.Offset = 0
+		}
+	}
+
+	// Rewrite SUB constants into ADD.
+	switch p.As {
+	case ASUBC:
+		if p.From.Type == obj.TYPE_CONST {
+			p.From.Offset = -p.From.Offset
+			p.As = AADDC
+		}
+
+	case ASUBCCC:
+		if p.From.Type == obj.TYPE_CONST {
+			p.From.Offset = -p.From.Offset
+			p.As = AADDCCC
+		}
+
+	case ASUB:
+		if p.From.Type == obj.TYPE_CONST {
+			p.From.Offset = -p.From.Offset
+			p.As = AADD
+		}
+	}
+	if c.ctxt.Headtype == objabi.Haix {
+		c.rewriteToUseTOC(p)
+	} else if c.ctxt.Flag_dynlink {
+		c.rewriteToUseGot(p)
+	}
+}
+
+// Rewrite p, if necessary, to access a symbol using its TOC anchor.
+// This code is for AIX only.
+func (c *ctxt9) rewriteToUseTOC(p *obj.Prog) {
+	if p.As == obj.ATEXT || p.As == obj.AFUNCDATA || p.As == obj.ACALL || p.As == obj.ARET || p.As == obj.AJMP {
+		return
+	}
+
+	if p.As == obj.ADUFFCOPY || p.As == obj.ADUFFZERO {
+		// ADUFFZERO/ADUFFCOPY is considered as an ABL except in dynamic
+		// link where it should be an indirect call.
+		if !c.ctxt.Flag_dynlink {
+			return
+		}
+		//     ADUFFxxx $offset
+		// becomes
+		//     MOVD runtime.duffxxx@TOC, R12
+		//     ADD $offset, R12
+		//     MOVD R12, LR
+		//     BL (LR)
+		var sym *obj.LSym
+		if p.As == obj.ADUFFZERO {
+			sym = c.ctxt.Lookup("runtime.duffzero")
+		} else {
+			sym = c.ctxt.Lookup("runtime.duffcopy")
+		}
+		// Retrieve or create the TOC anchor.
+		symtoc := c.ctxt.LookupInit("TOC."+sym.Name, func(s *obj.LSym) {
+			s.Type = objabi.SDATA
+			s.Set(obj.AttrDuplicateOK, true)
+			s.Set(obj.AttrStatic, true)
+			c.ctxt.Data = append(c.ctxt.Data, s)
+			s.WriteAddr(c.ctxt, 0, 8, sym, 0)
+		})
+
+		offset := p.To.Offset
+		p.As = AMOVD
+		p.From.Type = obj.TYPE_MEM
+		p.From.Name = obj.NAME_TOCREF
+		p.From.Sym = symtoc
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R12
+		p.To.Name = obj.NAME_NONE
+		p.To.Offset = 0
+		p.To.Sym = nil
+		p1 := obj.Appendp(p, c.newprog)
+		p1.As = AADD
+		p1.From.Type = obj.TYPE_CONST
+		p1.From.Offset = offset
+		p1.To.Type = obj.TYPE_REG
+		p1.To.Reg = REG_R12
+		p2 := obj.Appendp(p1, c.newprog)
+		p2.As = AMOVD
+		p2.From.Type = obj.TYPE_REG
+		p2.From.Reg = REG_R12
+		p2.To.Type = obj.TYPE_REG
+		p2.To.Reg = REG_LR
+		p3 := obj.Appendp(p2, c.newprog)
+		p3.As = obj.ACALL
+		p3.To.Type = obj.TYPE_REG
+		p3.To.Reg = REG_LR
+	}
+
+	var source *obj.Addr
+	if p.From.Name == obj.NAME_EXTERN || p.From.Name == obj.NAME_STATIC {
+		if p.From.Type == obj.TYPE_ADDR {
+			if p.As == ADWORD {
+				// ADWORD $sym doesn't need TOC anchor
+				return
+			}
+			if p.As != AMOVD {
+				c.ctxt.Diag("do not know how to handle TYPE_ADDR in %v", p)
+				return
+			}
+			if p.To.Type != obj.TYPE_REG {
+				c.ctxt.Diag("do not know how to handle LEAQ-type insn to non-register in %v", p)
+				return
+			}
+		} else if p.From.Type != obj.TYPE_MEM {
+			c.ctxt.Diag("do not know how to handle %v without TYPE_MEM", p)
+			return
+		}
+		source = &p.From
+
+	} else if p.To.Name == obj.NAME_EXTERN || p.To.Name == obj.NAME_STATIC {
+		if p.To.Type != obj.TYPE_MEM {
+			c.ctxt.Diag("do not know how to handle %v without TYPE_MEM", p)
+			return
+		}
+		if source != nil {
+			c.ctxt.Diag("cannot handle symbols on both sides in %v", p)
+			return
+		}
+		source = &p.To
+	} else {
+		return
+
+	}
+
+	if source.Sym == nil {
+		c.ctxt.Diag("do not know how to handle nil symbol in %v", p)
+		return
+	}
+
+	if source.Sym.Type == objabi.STLSBSS {
+		return
+	}
+
+	// Retrieve or create the TOC anchor.
+	symtoc := c.ctxt.LookupInit("TOC."+source.Sym.Name, func(s *obj.LSym) {
+		s.Type = objabi.SDATA
+		s.Set(obj.AttrDuplicateOK, true)
+		s.Set(obj.AttrStatic, true)
+		c.ctxt.Data = append(c.ctxt.Data, s)
+		s.WriteAddr(c.ctxt, 0, 8, source.Sym, 0)
+	})
+
+	if source.Type == obj.TYPE_ADDR {
+		// MOVD $sym, Rx becomes MOVD symtoc, Rx
+		// MOVD $sym+<off>, Rx becomes MOVD symtoc, Rx; ADD <off>, Rx
+		p.From.Type = obj.TYPE_MEM
+		p.From.Sym = symtoc
+		p.From.Name = obj.NAME_TOCREF
+
+		if p.From.Offset != 0 {
+			q := obj.Appendp(p, c.newprog)
+			q.As = AADD
+			q.From.Type = obj.TYPE_CONST
+			q.From.Offset = p.From.Offset
+			p.From.Offset = 0
+			q.To = p.To
+		}
+		return
+
+	}
+
+	// MOVx sym, Ry becomes MOVD symtoc, REGTMP; MOVx (REGTMP), Ry
+	// MOVx Ry, sym becomes MOVD symtoc, REGTMP; MOVx Ry, (REGTMP)
+	// An addition may be inserted between the two MOVs if there is an offset.
+
+	q := obj.Appendp(p, c.newprog)
+	q.As = AMOVD
+	q.From.Type = obj.TYPE_MEM
+	q.From.Sym = symtoc
+	q.From.Name = obj.NAME_TOCREF
+	q.To.Type = obj.TYPE_REG
+	q.To.Reg = REGTMP
+
+	q = obj.Appendp(q, c.newprog)
+	q.As = p.As
+	q.From = p.From
+	q.To = p.To
+	if p.From.Name != obj.NAME_NONE {
+		q.From.Type = obj.TYPE_MEM
+		q.From.Reg = REGTMP
+		q.From.Name = obj.NAME_NONE
+		q.From.Sym = nil
+	} else if p.To.Name != obj.NAME_NONE {
+		q.To.Type = obj.TYPE_MEM
+		q.To.Reg = REGTMP
+		q.To.Name = obj.NAME_NONE
+		q.To.Sym = nil
+	} else {
+		c.ctxt.Diag("unreachable case in rewriteToUseTOC with %v", p)
+	}
+
+	obj.Nopout(p)
+}
+
+// Rewrite p, if necessary, to access global data via the global offset table.
+func (c *ctxt9) rewriteToUseGot(p *obj.Prog) {
+	if p.As == obj.ADUFFCOPY || p.As == obj.ADUFFZERO {
+		//     ADUFFxxx $offset
+		// becomes
+		//     MOVD runtime.duffxxx@GOT, R12
+		//     ADD $offset, R12
+		//     MOVD R12, LR
+		//     BL (LR)
+		var sym *obj.LSym
+		if p.As == obj.ADUFFZERO {
+			sym = c.ctxt.Lookup("runtime.duffzero")
+		} else {
+			sym = c.ctxt.Lookup("runtime.duffcopy")
+		}
+		offset := p.To.Offset
+		p.As = AMOVD
+		p.From.Type = obj.TYPE_MEM
+		p.From.Name = obj.NAME_GOTREF
+		p.From.Sym = sym
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R12
+		p.To.Name = obj.NAME_NONE
+		p.To.Offset = 0
+		p.To.Sym = nil
+		p1 := obj.Appendp(p, c.newprog)
+		p1.As = AADD
+		p1.From.Type = obj.TYPE_CONST
+		p1.From.Offset = offset
+		p1.To.Type = obj.TYPE_REG
+		p1.To.Reg = REG_R12
+		p2 := obj.Appendp(p1, c.newprog)
+		p2.As = AMOVD
+		p2.From.Type = obj.TYPE_REG
+		p2.From.Reg = REG_R12
+		p2.To.Type = obj.TYPE_REG
+		p2.To.Reg = REG_LR
+		p3 := obj.Appendp(p2, c.newprog)
+		p3.As = obj.ACALL
+		p3.To.Type = obj.TYPE_REG
+		p3.To.Reg = REG_LR
+	}
+
+	// We only care about global data: NAME_EXTERN means a global
+	// symbol in the Go sense, and p.Sym.Local is true for a few
+	// internally defined symbols.
+	if p.From.Type == obj.TYPE_ADDR && p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
+		// MOVD $sym, Rx becomes MOVD sym@GOT, Rx
+		// MOVD $sym+<off>, Rx becomes MOVD sym@GOT, Rx; ADD <off>, Rx
+		if p.As != AMOVD {
+			c.ctxt.Diag("do not know how to handle TYPE_ADDR in %v with -dynlink", p)
+		}
+		if p.To.Type != obj.TYPE_REG {
+			c.ctxt.Diag("do not know how to handle LEAQ-type insn to non-register in %v with -dynlink", p)
+		}
+		p.From.Type = obj.TYPE_MEM
+		p.From.Name = obj.NAME_GOTREF
+		if p.From.Offset != 0 {
+			q := obj.Appendp(p, c.newprog)
+			q.As = AADD
+			q.From.Type = obj.TYPE_CONST
+			q.From.Offset = p.From.Offset
+			q.To = p.To
+			p.From.Offset = 0
+		}
+	}
+	if p.GetFrom3() != nil && p.GetFrom3().Name == obj.NAME_EXTERN {
+		c.ctxt.Diag("don't know how to handle %v with -dynlink", p)
+	}
+	var source *obj.Addr
+	// MOVx sym, Ry becomes MOVD sym@GOT, REGTMP; MOVx (REGTMP), Ry
+	// MOVx Ry, sym becomes MOVD sym@GOT, REGTMP; MOVx Ry, (REGTMP)
+	// An addition may be inserted between the two MOVs if there is an offset.
+	if p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
+		if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
+			c.ctxt.Diag("cannot handle NAME_EXTERN on both sides in %v with -dynlink", p)
+		}
+		source = &p.From
+	} else if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
+		source = &p.To
+	} else {
+		return
+	}
+	if p.As == obj.ATEXT || p.As == obj.AFUNCDATA || p.As == obj.ACALL || p.As == obj.ARET || p.As == obj.AJMP {
+		return
+	}
+	if source.Sym.Type == objabi.STLSBSS {
+		return
+	}
+	if source.Type != obj.TYPE_MEM {
+		c.ctxt.Diag("don't know how to handle %v with -dynlink", p)
+	}
+	p1 := obj.Appendp(p, c.newprog)
+	p2 := obj.Appendp(p1, c.newprog)
+
+	p1.As = AMOVD
+	p1.From.Type = obj.TYPE_MEM
+	p1.From.Sym = source.Sym
+	p1.From.Name = obj.NAME_GOTREF
+	p1.To.Type = obj.TYPE_REG
+	p1.To.Reg = REGTMP
+
+	p2.As = p.As
+	p2.From = p.From
+	p2.To = p.To
+	if p.From.Name == obj.NAME_EXTERN {
+		p2.From.Reg = REGTMP
+		p2.From.Name = obj.NAME_NONE
+		p2.From.Sym = nil
+	} else if p.To.Name == obj.NAME_EXTERN {
+		p2.To.Reg = REGTMP
+		p2.To.Name = obj.NAME_NONE
+		p2.To.Sym = nil
+	} else {
+		return
+	}
+	obj.Nopout(p)
+}
+
+func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
+	// TODO(minux): add morestack short-cuts with small fixed frame-size.
+	if cursym.Func.Text == nil || cursym.Func.Text.Link == nil {
+		return
+	}
+
+	c := ctxt9{ctxt: ctxt, cursym: cursym, newprog: newprog}
+
+	p := c.cursym.Func.Text
+	textstksiz := p.To.Offset
+	if textstksiz == -8 {
+		// Compatibility hack.
+		p.From.Sym.Set(obj.AttrNoFrame, true)
+		textstksiz = 0
+	}
+	if textstksiz%8 != 0 {
+		c.ctxt.Diag("frame size %d not a multiple of 8", textstksiz)
+	}
+	if p.From.Sym.NoFrame() {
+		if textstksiz != 0 {
+			c.ctxt.Diag("NOFRAME functions must have a frame size of 0, not %d", textstksiz)
+		}
+	}
+
+	c.cursym.Func.Args = p.To.Val.(int32)
+	c.cursym.Func.Locals = int32(textstksiz)
+
+	/*
+	 * find leaf subroutines
+	 * expand RET
+	 * expand BECOME pseudo
+	 */
+
+	var q *obj.Prog
+	var q1 *obj.Prog
+	for p := c.cursym.Func.Text; p != nil; p = p.Link {
+		switch p.As {
+		/* too hard, just leave alone */
+		case obj.ATEXT:
+			q = p
+
+			p.Mark |= LABEL | LEAF | SYNC
+			if p.Link != nil {
+				p.Link.Mark |= LABEL
+			}
+
+		case ANOR:
+			q = p
+			if p.To.Type == obj.TYPE_REG {
+				if p.To.Reg == REGZERO {
+					p.Mark |= LABEL | SYNC
+				}
+			}
+
+		case ALWAR,
+			ALBAR,
+			ASTBCCC,
+			ASTWCCC,
+			AECIWX,
+			AECOWX,
+			AEIEIO,
+			AICBI,
+			AISYNC,
+			ATLBIE,
+			ATLBIEL,
+			ASLBIA,
+			ASLBIE,
+			ASLBMFEE,
+			ASLBMFEV,
+			ASLBMTE,
+			ADCBF,
+			ADCBI,
+			ADCBST,
+			ADCBT,
+			ADCBTST,
+			ADCBZ,
+			ASYNC,
+			ATLBSYNC,
+			APTESYNC,
+			ALWSYNC,
+			ATW,
+			AWORD,
+			ARFI,
+			ARFCI,
+			ARFID,
+			AHRFID:
+			q = p
+			p.Mark |= LABEL | SYNC
+			continue
+
+		case AMOVW, AMOVWZ, AMOVD:
+			q = p
+			if p.From.Reg >= REG_SPECIAL || p.To.Reg >= REG_SPECIAL {
+				p.Mark |= LABEL | SYNC
+			}
+			continue
+
+		case AFABS,
+			AFABSCC,
+			AFADD,
+			AFADDCC,
+			AFCTIW,
+			AFCTIWCC,
+			AFCTIWZ,
+			AFCTIWZCC,
+			AFDIV,
+			AFDIVCC,
+			AFMADD,
+			AFMADDCC,
+			AFMOVD,
+			AFMOVDU,
+			/* case AFMOVDS: */
+			AFMOVS,
+			AFMOVSU,
+
+			/* case AFMOVSD: */
+			AFMSUB,
+			AFMSUBCC,
+			AFMUL,
+			AFMULCC,
+			AFNABS,
+			AFNABSCC,
+			AFNEG,
+			AFNEGCC,
+			AFNMADD,
+			AFNMADDCC,
+			AFNMSUB,
+			AFNMSUBCC,
+			AFRSP,
+			AFRSPCC,
+			AFSUB,
+			AFSUBCC:
+			q = p
+
+			p.Mark |= FLOAT
+			continue
+
+		case ABL,
+			ABCL,
+			obj.ADUFFZERO,
+			obj.ADUFFCOPY:
+			c.cursym.Func.Text.Mark &^= LEAF
+			fallthrough
+
+		case ABC,
+			ABEQ,
+			ABGE,
+			ABGT,
+			ABLE,
+			ABLT,
+			ABNE,
+			ABR,
+			ABVC,
+			ABVS:
+			p.Mark |= BRANCH
+			q = p
+			q1 = p.To.Target()
+			if q1 != nil {
+				// NOPs are not removed due to #40689.
+
+				if q1.Mark&LEAF == 0 {
+					q1.Mark |= LABEL
+				}
+			} else {
+				p.Mark |= LABEL
+			}
+			q1 = p.Link
+			if q1 != nil {
+				q1.Mark |= LABEL
+			}
+			continue
+
+		case AFCMPO, AFCMPU:
+			q = p
+			p.Mark |= FCMP | FLOAT
+			continue
+
+		case obj.ARET:
+			q = p
+			if p.Link != nil {
+				p.Link.Mark |= LABEL
+			}
+			continue
+
+		case obj.ANOP:
+			// NOPs are not removed due to
+			// #40689
+			continue
+
+		default:
+			q = p
+			continue
+		}
+	}
+
+	autosize := int32(0)
+	var p1 *obj.Prog
+	var p2 *obj.Prog
+	for p := c.cursym.Func.Text; p != nil; p = p.Link {
+		o := p.As
+		switch o {
+		case obj.ATEXT:
+			autosize = int32(textstksiz)
+
+			if p.Mark&LEAF != 0 && autosize == 0 {
+				// A leaf function with no locals has no frame.
+				p.From.Sym.Set(obj.AttrNoFrame, true)
+			}
+
+			if !p.From.Sym.NoFrame() {
+				// If there is a stack frame at all, it includes
+				// space to save the LR.
+				autosize += int32(c.ctxt.FixedFrameSize())
+			}
+
+			if p.Mark&LEAF != 0 && autosize < objabi.StackSmall {
+				// A leaf function with a small stack can be marked
+				// NOSPLIT, avoiding a stack check.
+				p.From.Sym.Set(obj.AttrNoSplit, true)
+			}
+
+			p.To.Offset = int64(autosize)
+
+			q = p
+
+			if c.ctxt.Flag_shared && c.cursym.Name != "runtime.duffzero" && c.cursym.Name != "runtime.duffcopy" {
+				// When compiling Go into PIC, all functions must start
+				// with instructions to load the TOC pointer into r2:
+				//
+				//	addis r2, r12, .TOC.-func@ha
+				//	addi r2, r2, .TOC.-func@l+4
+				//
+				// We could probably skip this prologue in some situations
+				// but it's a bit subtle. However, it is both safe and
+				// necessary to leave the prologue off duffzero and
+				// duffcopy as we rely on being able to jump to a specific
+				// instruction offset for them.
+				//
+				// These are AWORDS because there is no (afaict) way to
+				// generate the addis instruction except as part of the
+				// load of a large constant, and in that case there is no
+				// way to use r12 as the source.
+				//
+				// Note that the same condition is tested in
+				// putelfsym in cmd/link/internal/ld/symtab.go
+				// where we set the st_other field to indicate
+				// the presence of these instructions.
+				q = obj.Appendp(q, c.newprog)
+				q.As = AWORD
+				q.Pos = p.Pos
+				q.From.Type = obj.TYPE_CONST
+				q.From.Offset = 0x3c4c0000
+				q = obj.Appendp(q, c.newprog)
+				q.As = AWORD
+				q.Pos = p.Pos
+				q.From.Type = obj.TYPE_CONST
+				q.From.Offset = 0x38420000
+				rel := obj.Addrel(c.cursym)
+				rel.Off = 0
+				rel.Siz = 8
+				rel.Sym = c.ctxt.Lookup(".TOC.")
+				rel.Type = objabi.R_ADDRPOWER_PCREL
+			}
+
+			if !c.cursym.Func.Text.From.Sym.NoSplit() {
+				q = c.stacksplit(q, autosize) // emit split check
+			}
+
+			// Special handling of the racecall thunk. Assume that its asm code will
+			// save the link register and update the stack, since that code is
+			// called directly from C/C++ and can't clobber REGTMP (R31).
+			if autosize != 0 && c.cursym.Name != "runtime.racecallbackthunk" {
+				// Save the link register and update the SP.  MOVDU is used unless
+				// the frame size is too large.  The link register must be saved
+				// even for non-empty leaf functions so that traceback works.
+				if autosize >= -BIG && autosize <= BIG {
+					// Use MOVDU to adjust R1 when saving R31, if autosize is small.
+					q = obj.Appendp(q, c.newprog)
+					q.As = AMOVD
+					q.Pos = p.Pos
+					q.From.Type = obj.TYPE_REG
+					q.From.Reg = REG_LR
+					q.To.Type = obj.TYPE_REG
+					q.To.Reg = REGTMP
+
+					q = obj.Appendp(q, c.newprog)
+					q.As = AMOVDU
+					q.Pos = p.Pos
+					q.From.Type = obj.TYPE_REG
+					q.From.Reg = REGTMP
+					q.To.Type = obj.TYPE_MEM
+					q.To.Offset = int64(-autosize)
+					q.To.Reg = REGSP
+					q.Spadj = autosize
+				} else {
+					// Frame size is too large for a MOVDU instruction.
+					// Store link register before decrementing SP, so if a signal comes
+					// during the execution of the function prologue, the traceback
+					// code will not see a half-updated stack frame.
+					// This sequence is not async preemptible, as if we open a frame
+					// at the current SP, it will clobber the saved LR.
+					q = obj.Appendp(q, c.newprog)
+					q.As = AMOVD
+					q.Pos = p.Pos
+					q.From.Type = obj.TYPE_REG
+					q.From.Reg = REG_LR
+					q.To.Type = obj.TYPE_REG
+					q.To.Reg = REG_R29 // REGTMP may be used to synthesize large offset in the next instruction
+
+					q = c.ctxt.StartUnsafePoint(q, c.newprog)
+
+					q = obj.Appendp(q, c.newprog)
+					q.As = AMOVD
+					q.Pos = p.Pos
+					q.From.Type = obj.TYPE_REG
+					q.From.Reg = REG_R29
+					q.To.Type = obj.TYPE_MEM
+					q.To.Offset = int64(-autosize)
+					q.To.Reg = REGSP
+
+					q = obj.Appendp(q, c.newprog)
+					q.As = AADD
+					q.Pos = p.Pos
+					q.From.Type = obj.TYPE_CONST
+					q.From.Offset = int64(-autosize)
+					q.To.Type = obj.TYPE_REG
+					q.To.Reg = REGSP
+					q.Spadj = +autosize
+
+					q = c.ctxt.EndUnsafePoint(q, c.newprog, -1)
+
+				}
+			} else if c.cursym.Func.Text.Mark&LEAF == 0 {
+				// A very few functions that do not return to their caller
+				// (e.g. gogo) are not identified as leaves but still have
+				// no frame.
+				c.cursym.Func.Text.Mark |= LEAF
+			}
+
+			if c.cursym.Func.Text.Mark&LEAF != 0 {
+				c.cursym.Set(obj.AttrLeaf, true)
+				break
+			}
+
+			if c.ctxt.Flag_shared {
+				q = obj.Appendp(q, c.newprog)
+				q.As = AMOVD
+				q.Pos = p.Pos
+				q.From.Type = obj.TYPE_REG
+				q.From.Reg = REG_R2
+				q.To.Type = obj.TYPE_MEM
+				q.To.Reg = REGSP
+				q.To.Offset = 24
+			}
+
+			if c.cursym.Func.Text.From.Sym.Wrapper() {
+				// if(g->panic != nil && g->panic->argp == FP) g->panic->argp = bottom-of-frame
+				//
+				//	MOVD g_panic(g), R3
+				//	CMP R0, R3
+				//	BEQ end
+				//	MOVD panic_argp(R3), R4
+				//	ADD $(autosize+8), R1, R5
+				//	CMP R4, R5
+				//	BNE end
+				//	ADD $8, R1, R6
+				//	MOVD R6, panic_argp(R3)
+				// end:
+				//	NOP
+				//
+				// The NOP is needed to give the jumps somewhere to land.
+				// It is a liblink NOP, not a ppc64 NOP: it encodes to 0 instruction bytes.
+
+				q = obj.Appendp(q, c.newprog)
+
+				q.As = AMOVD
+				q.From.Type = obj.TYPE_MEM
+				q.From.Reg = REGG
+				q.From.Offset = 4 * int64(c.ctxt.Arch.PtrSize) // G.panic
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R3
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = ACMP
+				q.From.Type = obj.TYPE_REG
+				q.From.Reg = REG_R0
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R3
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = ABEQ
+				q.To.Type = obj.TYPE_BRANCH
+				p1 = q
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = AMOVD
+				q.From.Type = obj.TYPE_MEM
+				q.From.Reg = REG_R3
+				q.From.Offset = 0 // Panic.argp
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R4
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = AADD
+				q.From.Type = obj.TYPE_CONST
+				q.From.Offset = int64(autosize) + c.ctxt.FixedFrameSize()
+				q.Reg = REGSP
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R5
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = ACMP
+				q.From.Type = obj.TYPE_REG
+				q.From.Reg = REG_R4
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R5
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = ABNE
+				q.To.Type = obj.TYPE_BRANCH
+				p2 = q
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = AADD
+				q.From.Type = obj.TYPE_CONST
+				q.From.Offset = c.ctxt.FixedFrameSize()
+				q.Reg = REGSP
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R6
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = AMOVD
+				q.From.Type = obj.TYPE_REG
+				q.From.Reg = REG_R6
+				q.To.Type = obj.TYPE_MEM
+				q.To.Reg = REG_R3
+				q.To.Offset = 0 // Panic.argp
+
+				q = obj.Appendp(q, c.newprog)
+
+				q.As = obj.ANOP
+				p1.To.SetTarget(q)
+				p2.To.SetTarget(q)
+			}
+
+		case obj.ARET:
+			if p.From.Type == obj.TYPE_CONST {
+				c.ctxt.Diag("using BECOME (%v) is not supported!", p)
+				break
+			}
+
+			retTarget := p.To.Sym
+
+			if c.cursym.Func.Text.Mark&LEAF != 0 {
+				if autosize == 0 || c.cursym.Name == "runtime.racecallbackthunk" {
+					p.As = ABR
+					p.From = obj.Addr{}
+					if retTarget == nil {
+						p.To.Type = obj.TYPE_REG
+						p.To.Reg = REG_LR
+					} else {
+						p.To.Type = obj.TYPE_BRANCH
+						p.To.Sym = retTarget
+					}
+					p.Mark |= BRANCH
+					break
+				}
+
+				p.As = AADD
+				p.From.Type = obj.TYPE_CONST
+				p.From.Offset = int64(autosize)
+				p.To.Type = obj.TYPE_REG
+				p.To.Reg = REGSP
+				p.Spadj = -autosize
+
+				q = c.newprog()
+				q.As = ABR
+				q.Pos = p.Pos
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_LR
+				q.Mark |= BRANCH
+				q.Spadj = +autosize
+
+				q.Link = p.Link
+				p.Link = q
+				break
+			}
+
+			p.As = AMOVD
+			p.From.Type = obj.TYPE_MEM
+			p.From.Offset = 0
+			p.From.Reg = REGSP
+			p.To.Type = obj.TYPE_REG
+			p.To.Reg = REGTMP
+
+			q = c.newprog()
+			q.As = AMOVD
+			q.Pos = p.Pos
+			q.From.Type = obj.TYPE_REG
+			q.From.Reg = REGTMP
+			q.To.Type = obj.TYPE_REG
+			q.To.Reg = REG_LR
+
+			q.Link = p.Link
+			p.Link = q
+			p = q
+
+			if false {
+				// Debug bad returns
+				q = c.newprog()
+
+				q.As = AMOVD
+				q.Pos = p.Pos
+				q.From.Type = obj.TYPE_MEM
+				q.From.Offset = 0
+				q.From.Reg = REGTMP
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REGTMP
+
+				q.Link = p.Link
+				p.Link = q
+				p = q
+			}
+			prev := p
+			if autosize != 0 && c.cursym.Name != "runtime.racecallbackthunk" {
+				q = c.newprog()
+				q.As = AADD
+				q.Pos = p.Pos
+				q.From.Type = obj.TYPE_CONST
+				q.From.Offset = int64(autosize)
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REGSP
+				q.Spadj = -autosize
+
+				q.Link = p.Link
+				prev.Link = q
+				prev = q
+			}
+
+			q1 = c.newprog()
+			q1.As = ABR
+			q1.Pos = p.Pos
+			if retTarget == nil {
+				q1.To.Type = obj.TYPE_REG
+				q1.To.Reg = REG_LR
+			} else {
+				q1.To.Type = obj.TYPE_BRANCH
+				q1.To.Sym = retTarget
+			}
+			q1.Mark |= BRANCH
+			q1.Spadj = +autosize
+
+			q1.Link = q.Link
+			prev.Link = q1
+		case AADD:
+			if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.From.Type == obj.TYPE_CONST {
+				p.Spadj = int32(-p.From.Offset)
+			}
+		case AMOVDU:
+			if p.To.Type == obj.TYPE_MEM && p.To.Reg == REGSP {
+				p.Spadj = int32(-p.To.Offset)
+			}
+			if p.From.Type == obj.TYPE_MEM && p.From.Reg == REGSP {
+				p.Spadj = int32(-p.From.Offset)
+			}
+		case obj.AGETCALLERPC:
+			if cursym.Leaf() {
+				/* MOVD LR, Rd */
+				p.As = AMOVD
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REG_LR
+			} else {
+				/* MOVD (RSP), Rd */
+				p.As = AMOVD
+				p.From.Type = obj.TYPE_MEM
+				p.From.Reg = REGSP
+			}
+		}
+	}
+}
+
+/*
+// instruction scheduling
+	if(debug['Q'] == 0)
+		return;
+
+	curtext = nil;
+	q = nil;	// p - 1
+	q1 = firstp;	// top of block
+	o = 0;		// count of instructions
+	for(p = firstp; p != nil; p = p1) {
+		p1 = p->link;
+		o++;
+		if(p->mark & NOSCHED){
+			if(q1 != p){
+				sched(q1, q);
+			}
+			for(; p != nil; p = p->link){
+				if(!(p->mark & NOSCHED))
+					break;
+				q = p;
+			}
+			p1 = p;
+			q1 = p;
+			o = 0;
+			continue;
+		}
+		if(p->mark & (LABEL|SYNC)) {
+			if(q1 != p)
+				sched(q1, q);
+			q1 = p;
+			o = 1;
+		}
+		if(p->mark & (BRANCH|SYNC)) {
+			sched(q1, p);
+			q1 = p1;
+			o = 0;
+		}
+		if(o >= NSCHED) {
+			sched(q1, p);
+			q1 = p1;
+			o = 0;
+		}
+		q = p;
+	}
+*/
+func (c *ctxt9) stacksplit(p *obj.Prog, framesize int32) *obj.Prog {
+	p0 := p // save entry point, but skipping the two instructions setting R2 in shared mode
+
+	// MOVD	g_stackguard(g), R3
+	p = obj.Appendp(p, c.newprog)
+
+	p.As = AMOVD
+	p.From.Type = obj.TYPE_MEM
+	p.From.Reg = REGG
+	p.From.Offset = 2 * int64(c.ctxt.Arch.PtrSize) // G.stackguard0
+	if c.cursym.CFunc() {
+		p.From.Offset = 3 * int64(c.ctxt.Arch.PtrSize) // G.stackguard1
+	}
+	p.To.Type = obj.TYPE_REG
+	p.To.Reg = REG_R3
+
+	// Mark the stack bound check and morestack call async nonpreemptible.
+	// If we get preempted here, when resumed the preemption request is
+	// cleared, but we'll still call morestack, which will double the stack
+	// unnecessarily. See issue #35470.
+	p = c.ctxt.StartUnsafePoint(p, c.newprog)
+
+	var q *obj.Prog
+	if framesize <= objabi.StackSmall {
+		// small stack: SP < stackguard
+		//	CMP	stackguard, SP
+		p = obj.Appendp(p, c.newprog)
+
+		p.As = ACMPU
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R3
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REGSP
+	} else if framesize <= objabi.StackBig {
+		// large stack: SP-framesize < stackguard-StackSmall
+		//	ADD $-(framesize-StackSmall), SP, R4
+		//	CMP stackguard, R4
+		p = obj.Appendp(p, c.newprog)
+
+		p.As = AADD
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = -(int64(framesize) - objabi.StackSmall)
+		p.Reg = REGSP
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R4
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = ACMPU
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R3
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R4
+	} else {
+		// Such a large stack we need to protect against wraparound.
+		// If SP is close to zero:
+		//	SP-stackguard+StackGuard <= framesize + (StackGuard-StackSmall)
+		// The +StackGuard on both sides is required to keep the left side positive:
+		// SP is allowed to be slightly below stackguard. See stack.h.
+		//
+		// Preemption sets stackguard to StackPreempt, a very large value.
+		// That breaks the math above, so we have to check for that explicitly.
+		//	// stackguard is R3
+		//	CMP	R3, $StackPreempt
+		//	BEQ	label-of-call-to-morestack
+		//	ADD	$StackGuard, SP, R4
+		//	SUB	R3, R4
+		//	MOVD	$(framesize+(StackGuard-StackSmall)), R31
+		//	CMPU	R31, R4
+		p = obj.Appendp(p, c.newprog)
+
+		p.As = ACMP
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R3
+		p.To.Type = obj.TYPE_CONST
+		p.To.Offset = objabi.StackPreempt
+
+		p = obj.Appendp(p, c.newprog)
+		q = p
+		p.As = ABEQ
+		p.To.Type = obj.TYPE_BRANCH
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = AADD
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = int64(objabi.StackGuard)
+		p.Reg = REGSP
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R4
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = ASUB
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R3
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R4
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = AMOVD
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = int64(framesize) + int64(objabi.StackGuard) - objabi.StackSmall
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REGTMP
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = ACMPU
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REGTMP
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R4
+	}
+
+	// q1: BLT	done
+	p = obj.Appendp(p, c.newprog)
+	q1 := p
+
+	p.As = ABLT
+	p.To.Type = obj.TYPE_BRANCH
+
+	// MOVD	LR, R5
+	p = obj.Appendp(p, c.newprog)
+
+	p.As = AMOVD
+	p.From.Type = obj.TYPE_REG
+	p.From.Reg = REG_LR
+	p.To.Type = obj.TYPE_REG
+	p.To.Reg = REG_R5
+	if q != nil {
+		q.To.SetTarget(p)
+	}
+
+	p = c.ctxt.EmitEntryStackMap(c.cursym, p, c.newprog)
+
+	var morestacksym *obj.LSym
+	if c.cursym.CFunc() {
+		morestacksym = c.ctxt.Lookup("runtime.morestackc")
+	} else if !c.cursym.Func.Text.From.Sym.NeedCtxt() {
+		morestacksym = c.ctxt.Lookup("runtime.morestack_noctxt")
+	} else {
+		morestacksym = c.ctxt.Lookup("runtime.morestack")
+	}
+
+	if c.ctxt.Flag_shared {
+		// In PPC64 PIC code, R2 is used as TOC pointer derived from R12
+		// which is the address of function entry point when entering
+		// the function. We need to preserve R2 across call to morestack.
+		// Fortunately, in shared mode, 8(SP) and 16(SP) are reserved in
+		// the caller's frame, but not used (0(SP) is caller's saved LR,
+		// 24(SP) is caller's saved R2). Use 8(SP) to save this function's R2.
+
+		// MOVD R12, 8(SP)
+		p = obj.Appendp(p, c.newprog)
+		p.As = AMOVD
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R2
+		p.To.Type = obj.TYPE_MEM
+		p.To.Reg = REGSP
+		p.To.Offset = 8
+	}
+
+	if c.ctxt.Flag_dynlink {
+		// Avoid calling morestack via a PLT when dynamically linking. The
+		// PLT stubs generated by the system linker on ppc64le when "std r2,
+		// 24(r1)" to save the TOC pointer in their callers stack
+		// frame. Unfortunately (and necessarily) morestack is called before
+		// the function that calls it sets up its frame and so the PLT ends
+		// up smashing the saved TOC pointer for its caller's caller.
+		//
+		// According to the ABI documentation there is a mechanism to avoid
+		// the TOC save that the PLT stub does (put a R_PPC64_TOCSAVE
+		// relocation on the nop after the call to morestack) but at the time
+		// of writing it is not supported at all by gold and my attempt to
+		// use it with ld.bfd caused an internal linker error. So this hack
+		// seems preferable.
+
+		// MOVD $runtime.morestack(SB), R12
+		p = obj.Appendp(p, c.newprog)
+		p.As = AMOVD
+		p.From.Type = obj.TYPE_MEM
+		p.From.Sym = morestacksym
+		p.From.Name = obj.NAME_GOTREF
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R12
+
+		// MOVD R12, LR
+		p = obj.Appendp(p, c.newprog)
+		p.As = AMOVD
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R12
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_LR
+
+		// BL LR
+		p = obj.Appendp(p, c.newprog)
+		p.As = obj.ACALL
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_LR
+	} else {
+		// BL	runtime.morestack(SB)
+		p = obj.Appendp(p, c.newprog)
+
+		p.As = ABL
+		p.To.Type = obj.TYPE_BRANCH
+		p.To.Sym = morestacksym
+	}
+
+	if c.ctxt.Flag_shared {
+		// MOVD 8(SP), R2
+		p = obj.Appendp(p, c.newprog)
+		p.As = AMOVD
+		p.From.Type = obj.TYPE_MEM
+		p.From.Reg = REGSP
+		p.From.Offset = 8
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R2
+	}
+
+	p = c.ctxt.EndUnsafePoint(p, c.newprog, -1)
+
+	// BR	start
+	p = obj.Appendp(p, c.newprog)
+	p.As = ABR
+	p.To.Type = obj.TYPE_BRANCH
+	p.To.SetTarget(p0.Link)
+
+	// placeholder for q1's jump target
+	p = obj.Appendp(p, c.newprog)
+
+	p.As = obj.ANOP // zero-width place holder
+	q1.To.SetTarget(p)
+
+	return p
+}
+
+var Linkppc64 = obj.LinkArch{
+	Arch:           sys.ArchPPC64,
+	Init:           buildop,
+	Preprocess:     preprocess,
+	Assemble:       span9,
+	Progedit:       progedit,
+	DWARFRegisters: PPC64DWARFRegisters,
+}
+
+var Linkppc64le = obj.LinkArch{
+	Arch:           sys.ArchPPC64LE,
+	Init:           buildop,
+	Preprocess:     preprocess,
+	Assemble:       span9,
+	Progedit:       progedit,
+	DWARFRegisters: PPC64DWARFRegisters,
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/riscv/anames.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/riscv/anames.go
new file mode 100644
index 000000000..230a01fe0
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/riscv/anames.go
@@ -0,0 +1,258 @@
+// Code generated by stringer -i cpu.go -o anames.go -p riscv; DO NOT EDIT.
+
+package riscv
+
+import "github.com/twitchyliquid64/golang-asm/obj"
+
+var Anames = []string{
+	obj.A_ARCHSPECIFIC: "ADDI",
+	"SLTI",
+	"SLTIU",
+	"ANDI",
+	"ORI",
+	"XORI",
+	"SLLI",
+	"SRLI",
+	"SRAI",
+	"LUI",
+	"AUIPC",
+	"ADD",
+	"SLT",
+	"SLTU",
+	"AND",
+	"OR",
+	"XOR",
+	"SLL",
+	"SRL",
+	"SUB",
+	"SRA",
+	"SLLIRV32",
+	"SRLIRV32",
+	"SRAIRV32",
+	"JAL",
+	"JALR",
+	"BEQ",
+	"BNE",
+	"BLT",
+	"BLTU",
+	"BGE",
+	"BGEU",
+	"LW",
+	"LWU",
+	"LH",
+	"LHU",
+	"LB",
+	"LBU",
+	"SW",
+	"SH",
+	"SB",
+	"FENCE",
+	"FENCEI",
+	"FENCETSO",
+	"ADDIW",
+	"SLLIW",
+	"SRLIW",
+	"SRAIW",
+	"ADDW",
+	"SLLW",
+	"SRLW",
+	"SUBW",
+	"SRAW",
+	"LD",
+	"SD",
+	"MUL",
+	"MULH",
+	"MULHU",
+	"MULHSU",
+	"MULW",
+	"DIV",
+	"DIVU",
+	"REM",
+	"REMU",
+	"DIVW",
+	"DIVUW",
+	"REMW",
+	"REMUW",
+	"LRD",
+	"SCD",
+	"LRW",
+	"SCW",
+	"AMOSWAPD",
+	"AMOADDD",
+	"AMOANDD",
+	"AMOORD",
+	"AMOXORD",
+	"AMOMAXD",
+	"AMOMAXUD",
+	"AMOMIND",
+	"AMOMINUD",
+	"AMOSWAPW",
+	"AMOADDW",
+	"AMOANDW",
+	"AMOORW",
+	"AMOXORW",
+	"AMOMAXW",
+	"AMOMAXUW",
+	"AMOMINW",
+	"AMOMINUW",
+	"RDCYCLE",
+	"RDCYCLEH",
+	"RDTIME",
+	"RDTIMEH",
+	"RDINSTRET",
+	"RDINSTRETH",
+	"FRCSR",
+	"FSCSR",
+	"FRRM",
+	"FSRM",
+	"FRFLAGS",
+	"FSFLAGS",
+	"FSRMI",
+	"FSFLAGSI",
+	"FLW",
+	"FSW",
+	"FADDS",
+	"FSUBS",
+	"FMULS",
+	"FDIVS",
+	"FMINS",
+	"FMAXS",
+	"FSQRTS",
+	"FMADDS",
+	"FMSUBS",
+	"FNMADDS",
+	"FNMSUBS",
+	"FCVTWS",
+	"FCVTLS",
+	"FCVTSW",
+	"FCVTSL",
+	"FCVTWUS",
+	"FCVTLUS",
+	"FCVTSWU",
+	"FCVTSLU",
+	"FSGNJS",
+	"FSGNJNS",
+	"FSGNJXS",
+	"FMVXS",
+	"FMVSX",
+	"FMVXW",
+	"FMVWX",
+	"FEQS",
+	"FLTS",
+	"FLES",
+	"FCLASSS",
+	"FLD",
+	"FSD",
+	"FADDD",
+	"FSUBD",
+	"FMULD",
+	"FDIVD",
+	"FMIND",
+	"FMAXD",
+	"FSQRTD",
+	"FMADDD",
+	"FMSUBD",
+	"FNMADDD",
+	"FNMSUBD",
+	"FCVTWD",
+	"FCVTLD",
+	"FCVTDW",
+	"FCVTDL",
+	"FCVTWUD",
+	"FCVTLUD",
+	"FCVTDWU",
+	"FCVTDLU",
+	"FCVTSD",
+	"FCVTDS",
+	"FSGNJD",
+	"FSGNJND",
+	"FSGNJXD",
+	"FMVXD",
+	"FMVDX",
+	"FEQD",
+	"FLTD",
+	"FLED",
+	"FCLASSD",
+	"FLQ",
+	"FSQ",
+	"FADDQ",
+	"FSUBQ",
+	"FMULQ",
+	"FDIVQ",
+	"FMINQ",
+	"FMAXQ",
+	"FSQRTQ",
+	"FMADDQ",
+	"FMSUBQ",
+	"FNMADDQ",
+	"FNMSUBQ",
+	"FCVTWQ",
+	"FCVTLQ",
+	"FCVTSQ",
+	"FCVTDQ",
+	"FCVTQW",
+	"FCVTQL",
+	"FCVTQS",
+	"FCVTQD",
+	"FCVTWUQ",
+	"FCVTLUQ",
+	"FCVTQWU",
+	"FCVTQLU",
+	"FSGNJQ",
+	"FSGNJNQ",
+	"FSGNJXQ",
+	"FMVXQ",
+	"FMVQX",
+	"FEQQ",
+	"FLEQ",
+	"FLTQ",
+	"FCLASSQ",
+	"CSRRW",
+	"CSRRS",
+	"CSRRC",
+	"CSRRWI",
+	"CSRRSI",
+	"CSRRCI",
+	"ECALL",
+	"SCALL",
+	"EBREAK",
+	"SBREAK",
+	"MRET",
+	"SRET",
+	"URET",
+	"DRET",
+	"WFI",
+	"SFENCEVMA",
+	"HFENCEGVMA",
+	"HFENCEVVMA",
+	"WORD",
+	"BEQZ",
+	"BGEZ",
+	"BGT",
+	"BGTU",
+	"BGTZ",
+	"BLE",
+	"BLEU",
+	"BLEZ",
+	"BLTZ",
+	"BNEZ",
+	"FNEGD",
+	"FNEGS",
+	"FNED",
+	"FNES",
+	"MOV",
+	"MOVB",
+	"MOVBU",
+	"MOVF",
+	"MOVD",
+	"MOVH",
+	"MOVHU",
+	"MOVW",
+	"MOVWU",
+	"NEG",
+	"NEGW",
+	"NOT",
+	"SEQZ",
+	"SNEZ",
+	"LAST",
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/riscv/cpu.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/riscv/cpu.go
new file mode 100644
index 000000000..63a4e9e9d
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/riscv/cpu.go
@@ -0,0 +1,644 @@
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2008 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors.  All rights reserved.
+//	Portions Copyright © 2019 The Go Authors.  All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package riscv
+
+import "github.com/twitchyliquid64/golang-asm/obj"
+
+//go:generate go run ../stringer.go -i $GOFILE -o anames.go -p riscv
+
+const (
+	// Base register numberings.
+	REG_X0 = obj.RBaseRISCV + iota
+	REG_X1
+	REG_X2
+	REG_X3
+	REG_X4
+	REG_X5
+	REG_X6
+	REG_X7
+	REG_X8
+	REG_X9
+	REG_X10
+	REG_X11
+	REG_X12
+	REG_X13
+	REG_X14
+	REG_X15
+	REG_X16
+	REG_X17
+	REG_X18
+	REG_X19
+	REG_X20
+	REG_X21
+	REG_X22
+	REG_X23
+	REG_X24
+	REG_X25
+	REG_X26
+	REG_X27
+	REG_X28
+	REG_X29
+	REG_X30
+	REG_X31
+
+	// FP register numberings.
+	REG_F0
+	REG_F1
+	REG_F2
+	REG_F3
+	REG_F4
+	REG_F5
+	REG_F6
+	REG_F7
+	REG_F8
+	REG_F9
+	REG_F10
+	REG_F11
+	REG_F12
+	REG_F13
+	REG_F14
+	REG_F15
+	REG_F16
+	REG_F17
+	REG_F18
+	REG_F19
+	REG_F20
+	REG_F21
+	REG_F22
+	REG_F23
+	REG_F24
+	REG_F25
+	REG_F26
+	REG_F27
+	REG_F28
+	REG_F29
+	REG_F30
+	REG_F31
+
+	// This marks the end of the register numbering.
+	REG_END
+
+	// General registers reassigned to ABI names.
+	REG_ZERO = REG_X0
+	REG_RA   = REG_X1 // aka REG_LR
+	REG_SP   = REG_X2
+	REG_GP   = REG_X3 // aka REG_SB
+	REG_TP   = REG_X4 // aka REG_G
+	REG_T0   = REG_X5
+	REG_T1   = REG_X6
+	REG_T2   = REG_X7
+	REG_S0   = REG_X8
+	REG_S1   = REG_X9
+	REG_A0   = REG_X10
+	REG_A1   = REG_X11
+	REG_A2   = REG_X12
+	REG_A3   = REG_X13
+	REG_A4   = REG_X14
+	REG_A5   = REG_X15
+	REG_A6   = REG_X16
+	REG_A7   = REG_X17
+	REG_S2   = REG_X18
+	REG_S3   = REG_X19
+	REG_S4   = REG_X20 // aka REG_CTXT
+	REG_S5   = REG_X21
+	REG_S6   = REG_X22
+	REG_S7   = REG_X23
+	REG_S8   = REG_X24
+	REG_S9   = REG_X25
+	REG_S10  = REG_X26
+	REG_S11  = REG_X27
+	REG_T3   = REG_X28
+	REG_T4   = REG_X29
+	REG_T5   = REG_X30
+	REG_T6   = REG_X31 // aka REG_TMP
+
+	// Go runtime register names.
+	REG_G    = REG_TP // G pointer.
+	REG_CTXT = REG_S4 // Context for closures.
+	REG_LR   = REG_RA // Link register.
+	REG_TMP  = REG_T6 // Reserved for assembler use.
+
+	// ABI names for floating point registers.
+	REG_FT0  = REG_F0
+	REG_FT1  = REG_F1
+	REG_FT2  = REG_F2
+	REG_FT3  = REG_F3
+	REG_FT4  = REG_F4
+	REG_FT5  = REG_F5
+	REG_FT6  = REG_F6
+	REG_FT7  = REG_F7
+	REG_FS0  = REG_F8
+	REG_FS1  = REG_F9
+	REG_FA0  = REG_F10
+	REG_FA1  = REG_F11
+	REG_FA2  = REG_F12
+	REG_FA3  = REG_F13
+	REG_FA4  = REG_F14
+	REG_FA5  = REG_F15
+	REG_FA6  = REG_F16
+	REG_FA7  = REG_F17
+	REG_FS2  = REG_F18
+	REG_FS3  = REG_F19
+	REG_FS4  = REG_F20
+	REG_FS5  = REG_F21
+	REG_FS6  = REG_F22
+	REG_FS7  = REG_F23
+	REG_FS8  = REG_F24
+	REG_FS9  = REG_F25
+	REG_FS10 = REG_F26
+	REG_FS11 = REG_F27
+	REG_FT8  = REG_F28
+	REG_FT9  = REG_F29
+	REG_FT10 = REG_F30
+	REG_FT11 = REG_F31
+
+	// Names generated by the SSA compiler.
+	REGSP = REG_SP
+	REGG  = REG_G
+)
+
+// https://github.com/riscv/riscv-elf-psabi-doc/blob/master/riscv-elf.md#dwarf-register-numbers
+var RISCV64DWARFRegisters = map[int16]int16{
+	// Integer Registers.
+	REG_X0:  0,
+	REG_X1:  1,
+	REG_X2:  2,
+	REG_X3:  3,
+	REG_X4:  4,
+	REG_X5:  5,
+	REG_X6:  6,
+	REG_X7:  7,
+	REG_X8:  8,
+	REG_X9:  9,
+	REG_X10: 10,
+	REG_X11: 11,
+	REG_X12: 12,
+	REG_X13: 13,
+	REG_X14: 14,
+	REG_X15: 15,
+	REG_X16: 16,
+	REG_X17: 17,
+	REG_X18: 18,
+	REG_X19: 19,
+	REG_X20: 20,
+	REG_X21: 21,
+	REG_X22: 22,
+	REG_X23: 23,
+	REG_X24: 24,
+	REG_X25: 25,
+	REG_X26: 26,
+	REG_X27: 27,
+	REG_X28: 28,
+	REG_X29: 29,
+	REG_X30: 30,
+	REG_X31: 31,
+
+	// Floating-Point Registers.
+	REG_F0:  32,
+	REG_F1:  33,
+	REG_F2:  34,
+	REG_F3:  35,
+	REG_F4:  36,
+	REG_F5:  37,
+	REG_F6:  38,
+	REG_F7:  39,
+	REG_F8:  40,
+	REG_F9:  41,
+	REG_F10: 42,
+	REG_F11: 43,
+	REG_F12: 44,
+	REG_F13: 45,
+	REG_F14: 46,
+	REG_F15: 47,
+	REG_F16: 48,
+	REG_F17: 49,
+	REG_F18: 50,
+	REG_F19: 51,
+	REG_F20: 52,
+	REG_F21: 53,
+	REG_F22: 54,
+	REG_F23: 55,
+	REG_F24: 56,
+	REG_F25: 57,
+	REG_F26: 58,
+	REG_F27: 59,
+	REG_F28: 60,
+	REG_F29: 61,
+	REG_F30: 62,
+	REG_F31: 63,
+}
+
+// Prog.Mark flags.
+const (
+	// NEED_PCREL_ITYPE_RELOC is set on AUIPC instructions to indicate that
+	// it is the first instruction in an AUIPC + I-type pair that needs a
+	// R_RISCV_PCREL_ITYPE relocation.
+	NEED_PCREL_ITYPE_RELOC = 1 << 0
+
+	// NEED_PCREL_STYPE_RELOC is set on AUIPC instructions to indicate that
+	// it is the first instruction in an AUIPC + S-type pair that needs a
+	// R_RISCV_PCREL_STYPE relocation.
+	NEED_PCREL_STYPE_RELOC = 1 << 1
+)
+
+// RISC-V mnemonics, as defined in the "opcodes" and "opcodes-pseudo" files
+// from:
+//
+//    https://github.com/riscv/riscv-opcodes
+//
+// As well as some pseudo-mnemonics (e.g. MOV) used only in the assembler.
+//
+// See also "The RISC-V Instruction Set Manual" at:
+//
+//    https://riscv.org/specifications/
+//
+// If you modify this table, you MUST run 'go generate' to regenerate anames.go!
+const (
+	// Unprivileged ISA (Document Version 20190608-Base-Ratified)
+
+	// 2.4: Integer Computational Instructions
+	AADDI = obj.ABaseRISCV + obj.A_ARCHSPECIFIC + iota
+	ASLTI
+	ASLTIU
+	AANDI
+	AORI
+	AXORI
+	ASLLI
+	ASRLI
+	ASRAI
+	ALUI
+	AAUIPC
+	AADD
+	ASLT
+	ASLTU
+	AAND
+	AOR
+	AXOR
+	ASLL
+	ASRL
+	ASUB
+	ASRA
+
+	// The SLL/SRL/SRA instructions differ slightly between RV32 and RV64,
+	// hence there are pseudo-opcodes for the RV32 specific versions.
+	ASLLIRV32
+	ASRLIRV32
+	ASRAIRV32
+
+	// 2.5: Control Transfer Instructions
+	AJAL
+	AJALR
+	ABEQ
+	ABNE
+	ABLT
+	ABLTU
+	ABGE
+	ABGEU
+
+	// 2.6: Load and Store Instructions
+	ALW
+	ALWU
+	ALH
+	ALHU
+	ALB
+	ALBU
+	ASW
+	ASH
+	ASB
+
+	// 2.7: Memory Ordering Instructions
+	AFENCE
+	AFENCEI
+	AFENCETSO
+
+	// 5.2: Integer Computational Instructions (RV64I)
+	AADDIW
+	ASLLIW
+	ASRLIW
+	ASRAIW
+	AADDW
+	ASLLW
+	ASRLW
+	ASUBW
+	ASRAW
+
+	// 5.3: Load and Store Instructions (RV64I)
+	ALD
+	ASD
+
+	// 7.1: Multiplication Operations
+	AMUL
+	AMULH
+	AMULHU
+	AMULHSU
+	AMULW
+	ADIV
+	ADIVU
+	AREM
+	AREMU
+	ADIVW
+	ADIVUW
+	AREMW
+	AREMUW
+
+	// 8.2: Load-Reserved/Store-Conditional Instructions
+	ALRD
+	ASCD
+	ALRW
+	ASCW
+
+	// 8.3: Atomic Memory Operations
+	AAMOSWAPD
+	AAMOADDD
+	AAMOANDD
+	AAMOORD
+	AAMOXORD
+	AAMOMAXD
+	AAMOMAXUD
+	AAMOMIND
+	AAMOMINUD
+	AAMOSWAPW
+	AAMOADDW
+	AAMOANDW
+	AAMOORW
+	AAMOXORW
+	AAMOMAXW
+	AAMOMAXUW
+	AAMOMINW
+	AAMOMINUW
+
+	// 10.1: Base Counters and Timers
+	ARDCYCLE
+	ARDCYCLEH
+	ARDTIME
+	ARDTIMEH
+	ARDINSTRET
+	ARDINSTRETH
+
+	// 11.2: Floating-Point Control and Status Register
+	AFRCSR
+	AFSCSR
+	AFRRM
+	AFSRM
+	AFRFLAGS
+	AFSFLAGS
+	AFSRMI
+	AFSFLAGSI
+
+	// 11.5: Single-Precision Load and Store Instructions
+	AFLW
+	AFSW
+
+	// 11.6: Single-Precision Floating-Point Computational Instructions
+	AFADDS
+	AFSUBS
+	AFMULS
+	AFDIVS
+	AFMINS
+	AFMAXS
+	AFSQRTS
+	AFMADDS
+	AFMSUBS
+	AFNMADDS
+	AFNMSUBS
+
+	// 11.7: Single-Precision Floating-Point Conversion and Move Instructions
+	AFCVTWS
+	AFCVTLS
+	AFCVTSW
+	AFCVTSL
+	AFCVTWUS
+	AFCVTLUS
+	AFCVTSWU
+	AFCVTSLU
+	AFSGNJS
+	AFSGNJNS
+	AFSGNJXS
+	AFMVXS
+	AFMVSX
+	AFMVXW
+	AFMVWX
+
+	// 11.8: Single-Precision Floating-Point Compare Instructions
+	AFEQS
+	AFLTS
+	AFLES
+
+	// 11.9: Single-Precision Floating-Point Classify Instruction
+	AFCLASSS
+
+	// 12.3: Double-Precision Load and Store Instructions
+	AFLD
+	AFSD
+
+	// 12.4: Double-Precision Floating-Point Computational Instructions
+	AFADDD
+	AFSUBD
+	AFMULD
+	AFDIVD
+	AFMIND
+	AFMAXD
+	AFSQRTD
+	AFMADDD
+	AFMSUBD
+	AFNMADDD
+	AFNMSUBD
+
+	// 12.5: Double-Precision Floating-Point Conversion and Move Instructions
+	AFCVTWD
+	AFCVTLD
+	AFCVTDW
+	AFCVTDL
+	AFCVTWUD
+	AFCVTLUD
+	AFCVTDWU
+	AFCVTDLU
+	AFCVTSD
+	AFCVTDS
+	AFSGNJD
+	AFSGNJND
+	AFSGNJXD
+	AFMVXD
+	AFMVDX
+
+	// 12.6: Double-Precision Floating-Point Compare Instructions
+	AFEQD
+	AFLTD
+	AFLED
+
+	// 12.7: Double-Precision Floating-Point Classify Instruction
+	AFCLASSD
+
+	// 13.1 Quad-Precision Load and Store Instructions
+	AFLQ
+	AFSQ
+
+	// 13.2: Quad-Precision Computational Instructions
+	AFADDQ
+	AFSUBQ
+	AFMULQ
+	AFDIVQ
+	AFMINQ
+	AFMAXQ
+	AFSQRTQ
+	AFMADDQ
+	AFMSUBQ
+	AFNMADDQ
+	AFNMSUBQ
+
+	// 13.3 Quad-Precision Convert and Move Instructions
+	AFCVTWQ
+	AFCVTLQ
+	AFCVTSQ
+	AFCVTDQ
+	AFCVTQW
+	AFCVTQL
+	AFCVTQS
+	AFCVTQD
+	AFCVTWUQ
+	AFCVTLUQ
+	AFCVTQWU
+	AFCVTQLU
+	AFSGNJQ
+	AFSGNJNQ
+	AFSGNJXQ
+	AFMVXQ
+	AFMVQX
+
+	// 13.4 Quad-Precision Floating-Point Compare Instructions
+	AFEQQ
+	AFLEQ
+	AFLTQ
+
+	// 13.5 Quad-Precision Floating-Point Classify Instruction
+	AFCLASSQ
+
+	// Privileged ISA (Version 20190608-Priv-MSU-Ratified)
+
+	// 3.1.9: Instructions to Access CSRs
+	ACSRRW
+	ACSRRS
+	ACSRRC
+	ACSRRWI
+	ACSRRSI
+	ACSRRCI
+
+	// 3.2.1: Environment Call and Breakpoint
+	AECALL
+	ASCALL
+	AEBREAK
+	ASBREAK
+
+	// 3.2.2: Trap-Return Instructions
+	AMRET
+	ASRET
+	AURET
+	ADRET
+
+	// 3.2.3: Wait for Interrupt
+	AWFI
+
+	// 4.2.1: Supervisor Memory-Management Fence Instruction
+	ASFENCEVMA
+
+	// Hypervisor Memory-Management Instructions
+	AHFENCEGVMA
+	AHFENCEVVMA
+
+	// The escape hatch. Inserts a single 32-bit word.
+	AWORD
+
+	// Pseudo-instructions.  These get translated by the assembler into other
+	// instructions, based on their operands.
+	ABEQZ
+	ABGEZ
+	ABGT
+	ABGTU
+	ABGTZ
+	ABLE
+	ABLEU
+	ABLEZ
+	ABLTZ
+	ABNEZ
+	AFNEGD
+	AFNEGS
+	AFNED
+	AFNES
+	AMOV
+	AMOVB
+	AMOVBU
+	AMOVF
+	AMOVD
+	AMOVH
+	AMOVHU
+	AMOVW
+	AMOVWU
+	ANEG
+	ANEGW
+	ANOT
+	ASEQZ
+	ASNEZ
+
+	// End marker
+	ALAST
+)
+
+// All unary instructions which write to their arguments (as opposed to reading
+// from them) go here. The assembly parser uses this information to populate
+// its AST in a semantically reasonable way.
+//
+// Any instructions not listed here are assumed to either be non-unary or to read
+// from its argument.
+var unaryDst = map[obj.As]bool{
+	ARDCYCLE:    true,
+	ARDCYCLEH:   true,
+	ARDTIME:     true,
+	ARDTIMEH:    true,
+	ARDINSTRET:  true,
+	ARDINSTRETH: true,
+}
+
+// Instruction encoding masks.
+const (
+	// ITypeImmMask is a mask including only the immediate portion of
+	// I-type instructions.
+	ITypeImmMask = 0xfff00000
+
+	// STypeImmMask is a mask including only the immediate portion of
+	// S-type instructions.
+	STypeImmMask = 0xfe000f80
+
+	// UTypeImmMask is a mask including only the immediate portion of
+	// U-type instructions.
+	UTypeImmMask = 0xfffff000
+
+	// UJTypeImmMask is a mask including only the immediate portion of
+	// UJ-type instructions.
+	UJTypeImmMask = UTypeImmMask
+)
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/riscv/inst.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/riscv/inst.go
new file mode 100644
index 000000000..2771ebc0d
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/riscv/inst.go
@@ -0,0 +1,459 @@
+// Code generated by parse_opcodes -go; DO NOT EDIT.
+
+package riscv
+
+import "github.com/twitchyliquid64/golang-asm/obj"
+
+type inst struct {
+	opcode uint32
+	funct3 uint32
+	rs2    uint32
+	csr    int64
+	funct7 uint32
+}
+
+func encode(a obj.As) *inst {
+	switch a {
+	case ABEQ:
+		return &inst{0x63, 0x0, 0x0, 0, 0x0}
+	case ABNE:
+		return &inst{0x63, 0x1, 0x0, 0, 0x0}
+	case ABLT:
+		return &inst{0x63, 0x4, 0x0, 0, 0x0}
+	case ABGE:
+		return &inst{0x63, 0x5, 0x0, 0, 0x0}
+	case ABLTU:
+		return &inst{0x63, 0x6, 0x0, 0, 0x0}
+	case ABGEU:
+		return &inst{0x63, 0x7, 0x0, 0, 0x0}
+	case AJALR:
+		return &inst{0x67, 0x0, 0x0, 0, 0x0}
+	case AJAL:
+		return &inst{0x6f, 0x0, 0x0, 0, 0x0}
+	case ALUI:
+		return &inst{0x37, 0x0, 0x0, 0, 0x0}
+	case AAUIPC:
+		return &inst{0x17, 0x0, 0x0, 0, 0x0}
+	case AADDI:
+		return &inst{0x13, 0x0, 0x0, 0, 0x0}
+	case ASLLI:
+		return &inst{0x13, 0x1, 0x0, 0, 0x0}
+	case ASLTI:
+		return &inst{0x13, 0x2, 0x0, 0, 0x0}
+	case ASLTIU:
+		return &inst{0x13, 0x3, 0x0, 0, 0x0}
+	case AXORI:
+		return &inst{0x13, 0x4, 0x0, 0, 0x0}
+	case ASRLI:
+		return &inst{0x13, 0x5, 0x0, 0, 0x0}
+	case ASRAI:
+		return &inst{0x13, 0x5, 0x0, 1024, 0x20}
+	case AORI:
+		return &inst{0x13, 0x6, 0x0, 0, 0x0}
+	case AANDI:
+		return &inst{0x13, 0x7, 0x0, 0, 0x0}
+	case AADD:
+		return &inst{0x33, 0x0, 0x0, 0, 0x0}
+	case ASUB:
+		return &inst{0x33, 0x0, 0x0, 1024, 0x20}
+	case ASLL:
+		return &inst{0x33, 0x1, 0x0, 0, 0x0}
+	case ASLT:
+		return &inst{0x33, 0x2, 0x0, 0, 0x0}
+	case ASLTU:
+		return &inst{0x33, 0x3, 0x0, 0, 0x0}
+	case AXOR:
+		return &inst{0x33, 0x4, 0x0, 0, 0x0}
+	case ASRL:
+		return &inst{0x33, 0x5, 0x0, 0, 0x0}
+	case ASRA:
+		return &inst{0x33, 0x5, 0x0, 1024, 0x20}
+	case AOR:
+		return &inst{0x33, 0x6, 0x0, 0, 0x0}
+	case AAND:
+		return &inst{0x33, 0x7, 0x0, 0, 0x0}
+	case AADDIW:
+		return &inst{0x1b, 0x0, 0x0, 0, 0x0}
+	case ASLLIW:
+		return &inst{0x1b, 0x1, 0x0, 0, 0x0}
+	case ASRLIW:
+		return &inst{0x1b, 0x5, 0x0, 0, 0x0}
+	case ASRAIW:
+		return &inst{0x1b, 0x5, 0x0, 1024, 0x20}
+	case AADDW:
+		return &inst{0x3b, 0x0, 0x0, 0, 0x0}
+	case ASUBW:
+		return &inst{0x3b, 0x0, 0x0, 1024, 0x20}
+	case ASLLW:
+		return &inst{0x3b, 0x1, 0x0, 0, 0x0}
+	case ASRLW:
+		return &inst{0x3b, 0x5, 0x0, 0, 0x0}
+	case ASRAW:
+		return &inst{0x3b, 0x5, 0x0, 1024, 0x20}
+	case ALB:
+		return &inst{0x3, 0x0, 0x0, 0, 0x0}
+	case ALH:
+		return &inst{0x3, 0x1, 0x0, 0, 0x0}
+	case ALW:
+		return &inst{0x3, 0x2, 0x0, 0, 0x0}
+	case ALD:
+		return &inst{0x3, 0x3, 0x0, 0, 0x0}
+	case ALBU:
+		return &inst{0x3, 0x4, 0x0, 0, 0x0}
+	case ALHU:
+		return &inst{0x3, 0x5, 0x0, 0, 0x0}
+	case ALWU:
+		return &inst{0x3, 0x6, 0x0, 0, 0x0}
+	case ASB:
+		return &inst{0x23, 0x0, 0x0, 0, 0x0}
+	case ASH:
+		return &inst{0x23, 0x1, 0x0, 0, 0x0}
+	case ASW:
+		return &inst{0x23, 0x2, 0x0, 0, 0x0}
+	case ASD:
+		return &inst{0x23, 0x3, 0x0, 0, 0x0}
+	case AFENCE:
+		return &inst{0xf, 0x0, 0x0, 0, 0x0}
+	case AFENCEI:
+		return &inst{0xf, 0x1, 0x0, 0, 0x0}
+	case AMUL:
+		return &inst{0x33, 0x0, 0x0, 32, 0x1}
+	case AMULH:
+		return &inst{0x33, 0x1, 0x0, 32, 0x1}
+	case AMULHSU:
+		return &inst{0x33, 0x2, 0x0, 32, 0x1}
+	case AMULHU:
+		return &inst{0x33, 0x3, 0x0, 32, 0x1}
+	case ADIV:
+		return &inst{0x33, 0x4, 0x0, 32, 0x1}
+	case ADIVU:
+		return &inst{0x33, 0x5, 0x0, 32, 0x1}
+	case AREM:
+		return &inst{0x33, 0x6, 0x0, 32, 0x1}
+	case AREMU:
+		return &inst{0x33, 0x7, 0x0, 32, 0x1}
+	case AMULW:
+		return &inst{0x3b, 0x0, 0x0, 32, 0x1}
+	case ADIVW:
+		return &inst{0x3b, 0x4, 0x0, 32, 0x1}
+	case ADIVUW:
+		return &inst{0x3b, 0x5, 0x0, 32, 0x1}
+	case AREMW:
+		return &inst{0x3b, 0x6, 0x0, 32, 0x1}
+	case AREMUW:
+		return &inst{0x3b, 0x7, 0x0, 32, 0x1}
+	case AAMOADDW:
+		return &inst{0x2f, 0x2, 0x0, 0, 0x0}
+	case AAMOXORW:
+		return &inst{0x2f, 0x2, 0x0, 512, 0x10}
+	case AAMOORW:
+		return &inst{0x2f, 0x2, 0x0, 1024, 0x20}
+	case AAMOANDW:
+		return &inst{0x2f, 0x2, 0x0, 1536, 0x30}
+	case AAMOMINW:
+		return &inst{0x2f, 0x2, 0x0, -2048, 0x40}
+	case AAMOMAXW:
+		return &inst{0x2f, 0x2, 0x0, -1536, 0x50}
+	case AAMOMINUW:
+		return &inst{0x2f, 0x2, 0x0, -1024, 0x60}
+	case AAMOMAXUW:
+		return &inst{0x2f, 0x2, 0x0, -512, 0x70}
+	case AAMOSWAPW:
+		return &inst{0x2f, 0x2, 0x0, 128, 0x4}
+	case ALRW:
+		return &inst{0x2f, 0x2, 0x0, 256, 0x8}
+	case ASCW:
+		return &inst{0x2f, 0x2, 0x0, 384, 0xc}
+	case AAMOADDD:
+		return &inst{0x2f, 0x3, 0x0, 0, 0x0}
+	case AAMOXORD:
+		return &inst{0x2f, 0x3, 0x0, 512, 0x10}
+	case AAMOORD:
+		return &inst{0x2f, 0x3, 0x0, 1024, 0x20}
+	case AAMOANDD:
+		return &inst{0x2f, 0x3, 0x0, 1536, 0x30}
+	case AAMOMIND:
+		return &inst{0x2f, 0x3, 0x0, -2048, 0x40}
+	case AAMOMAXD:
+		return &inst{0x2f, 0x3, 0x0, -1536, 0x50}
+	case AAMOMINUD:
+		return &inst{0x2f, 0x3, 0x0, -1024, 0x60}
+	case AAMOMAXUD:
+		return &inst{0x2f, 0x3, 0x0, -512, 0x70}
+	case AAMOSWAPD:
+		return &inst{0x2f, 0x3, 0x0, 128, 0x4}
+	case ALRD:
+		return &inst{0x2f, 0x3, 0x0, 256, 0x8}
+	case ASCD:
+		return &inst{0x2f, 0x3, 0x0, 384, 0xc}
+	case AECALL:
+		return &inst{0x73, 0x0, 0x0, 0, 0x0}
+	case AEBREAK:
+		return &inst{0x73, 0x0, 0x1, 1, 0x0}
+	case AURET:
+		return &inst{0x73, 0x0, 0x2, 2, 0x0}
+	case ASRET:
+		return &inst{0x73, 0x0, 0x2, 258, 0x8}
+	case AMRET:
+		return &inst{0x73, 0x0, 0x2, 770, 0x18}
+	case ADRET:
+		return &inst{0x73, 0x0, 0x12, 1970, 0x3d}
+	case ASFENCEVMA:
+		return &inst{0x73, 0x0, 0x0, 288, 0x9}
+	case AWFI:
+		return &inst{0x73, 0x0, 0x5, 261, 0x8}
+	case ACSRRW:
+		return &inst{0x73, 0x1, 0x0, 0, 0x0}
+	case ACSRRS:
+		return &inst{0x73, 0x2, 0x0, 0, 0x0}
+	case ACSRRC:
+		return &inst{0x73, 0x3, 0x0, 0, 0x0}
+	case ACSRRWI:
+		return &inst{0x73, 0x5, 0x0, 0, 0x0}
+	case ACSRRSI:
+		return &inst{0x73, 0x6, 0x0, 0, 0x0}
+	case ACSRRCI:
+		return &inst{0x73, 0x7, 0x0, 0, 0x0}
+	case AHFENCEVVMA:
+		return &inst{0x73, 0x0, 0x0, 544, 0x11}
+	case AHFENCEGVMA:
+		return &inst{0x73, 0x0, 0x0, 1568, 0x31}
+	case AFADDS:
+		return &inst{0x53, 0x0, 0x0, 0, 0x0}
+	case AFSUBS:
+		return &inst{0x53, 0x0, 0x0, 128, 0x4}
+	case AFMULS:
+		return &inst{0x53, 0x0, 0x0, 256, 0x8}
+	case AFDIVS:
+		return &inst{0x53, 0x0, 0x0, 384, 0xc}
+	case AFSGNJS:
+		return &inst{0x53, 0x0, 0x0, 512, 0x10}
+	case AFSGNJNS:
+		return &inst{0x53, 0x1, 0x0, 512, 0x10}
+	case AFSGNJXS:
+		return &inst{0x53, 0x2, 0x0, 512, 0x10}
+	case AFMINS:
+		return &inst{0x53, 0x0, 0x0, 640, 0x14}
+	case AFMAXS:
+		return &inst{0x53, 0x1, 0x0, 640, 0x14}
+	case AFSQRTS:
+		return &inst{0x53, 0x0, 0x0, 1408, 0x2c}
+	case AFADDD:
+		return &inst{0x53, 0x0, 0x0, 32, 0x1}
+	case AFSUBD:
+		return &inst{0x53, 0x0, 0x0, 160, 0x5}
+	case AFMULD:
+		return &inst{0x53, 0x0, 0x0, 288, 0x9}
+	case AFDIVD:
+		return &inst{0x53, 0x0, 0x0, 416, 0xd}
+	case AFSGNJD:
+		return &inst{0x53, 0x0, 0x0, 544, 0x11}
+	case AFSGNJND:
+		return &inst{0x53, 0x1, 0x0, 544, 0x11}
+	case AFSGNJXD:
+		return &inst{0x53, 0x2, 0x0, 544, 0x11}
+	case AFMIND:
+		return &inst{0x53, 0x0, 0x0, 672, 0x15}
+	case AFMAXD:
+		return &inst{0x53, 0x1, 0x0, 672, 0x15}
+	case AFCVTSD:
+		return &inst{0x53, 0x0, 0x1, 1025, 0x20}
+	case AFCVTDS:
+		return &inst{0x53, 0x0, 0x0, 1056, 0x21}
+	case AFSQRTD:
+		return &inst{0x53, 0x0, 0x0, 1440, 0x2d}
+	case AFADDQ:
+		return &inst{0x53, 0x0, 0x0, 96, 0x3}
+	case AFSUBQ:
+		return &inst{0x53, 0x0, 0x0, 224, 0x7}
+	case AFMULQ:
+		return &inst{0x53, 0x0, 0x0, 352, 0xb}
+	case AFDIVQ:
+		return &inst{0x53, 0x0, 0x0, 480, 0xf}
+	case AFSGNJQ:
+		return &inst{0x53, 0x0, 0x0, 608, 0x13}
+	case AFSGNJNQ:
+		return &inst{0x53, 0x1, 0x0, 608, 0x13}
+	case AFSGNJXQ:
+		return &inst{0x53, 0x2, 0x0, 608, 0x13}
+	case AFMINQ:
+		return &inst{0x53, 0x0, 0x0, 736, 0x17}
+	case AFMAXQ:
+		return &inst{0x53, 0x1, 0x0, 736, 0x17}
+	case AFCVTSQ:
+		return &inst{0x53, 0x0, 0x3, 1027, 0x20}
+	case AFCVTQS:
+		return &inst{0x53, 0x0, 0x0, 1120, 0x23}
+	case AFCVTDQ:
+		return &inst{0x53, 0x0, 0x3, 1059, 0x21}
+	case AFCVTQD:
+		return &inst{0x53, 0x0, 0x1, 1121, 0x23}
+	case AFSQRTQ:
+		return &inst{0x53, 0x0, 0x0, 1504, 0x2f}
+	case AFLES:
+		return &inst{0x53, 0x0, 0x0, -1536, 0x50}
+	case AFLTS:
+		return &inst{0x53, 0x1, 0x0, -1536, 0x50}
+	case AFEQS:
+		return &inst{0x53, 0x2, 0x0, -1536, 0x50}
+	case AFLED:
+		return &inst{0x53, 0x0, 0x0, -1504, 0x51}
+	case AFLTD:
+		return &inst{0x53, 0x1, 0x0, -1504, 0x51}
+	case AFEQD:
+		return &inst{0x53, 0x2, 0x0, -1504, 0x51}
+	case AFLEQ:
+		return &inst{0x53, 0x0, 0x0, -1440, 0x53}
+	case AFLTQ:
+		return &inst{0x53, 0x1, 0x0, -1440, 0x53}
+	case AFEQQ:
+		return &inst{0x53, 0x2, 0x0, -1440, 0x53}
+	case AFCVTWS:
+		return &inst{0x53, 0x0, 0x0, -1024, 0x60}
+	case AFCVTWUS:
+		return &inst{0x53, 0x0, 0x1, -1023, 0x60}
+	case AFCVTLS:
+		return &inst{0x53, 0x0, 0x2, -1022, 0x60}
+	case AFCVTLUS:
+		return &inst{0x53, 0x0, 0x3, -1021, 0x60}
+	case AFMVXW:
+		return &inst{0x53, 0x0, 0x0, -512, 0x70}
+	case AFCLASSS:
+		return &inst{0x53, 0x1, 0x0, -512, 0x70}
+	case AFCVTWD:
+		return &inst{0x53, 0x0, 0x0, -992, 0x61}
+	case AFCVTWUD:
+		return &inst{0x53, 0x0, 0x1, -991, 0x61}
+	case AFCVTLD:
+		return &inst{0x53, 0x0, 0x2, -990, 0x61}
+	case AFCVTLUD:
+		return &inst{0x53, 0x0, 0x3, -989, 0x61}
+	case AFMVXD:
+		return &inst{0x53, 0x0, 0x0, -480, 0x71}
+	case AFCLASSD:
+		return &inst{0x53, 0x1, 0x0, -480, 0x71}
+	case AFCVTWQ:
+		return &inst{0x53, 0x0, 0x0, -928, 0x63}
+	case AFCVTWUQ:
+		return &inst{0x53, 0x0, 0x1, -927, 0x63}
+	case AFCVTLQ:
+		return &inst{0x53, 0x0, 0x2, -926, 0x63}
+	case AFCVTLUQ:
+		return &inst{0x53, 0x0, 0x3, -925, 0x63}
+	case AFMVXQ:
+		return &inst{0x53, 0x0, 0x0, -416, 0x73}
+	case AFCLASSQ:
+		return &inst{0x53, 0x1, 0x0, -416, 0x73}
+	case AFCVTSW:
+		return &inst{0x53, 0x0, 0x0, -768, 0x68}
+	case AFCVTSWU:
+		return &inst{0x53, 0x0, 0x1, -767, 0x68}
+	case AFCVTSL:
+		return &inst{0x53, 0x0, 0x2, -766, 0x68}
+	case AFCVTSLU:
+		return &inst{0x53, 0x0, 0x3, -765, 0x68}
+	case AFMVWX:
+		return &inst{0x53, 0x0, 0x0, -256, 0x78}
+	case AFCVTDW:
+		return &inst{0x53, 0x0, 0x0, -736, 0x69}
+	case AFCVTDWU:
+		return &inst{0x53, 0x0, 0x1, -735, 0x69}
+	case AFCVTDL:
+		return &inst{0x53, 0x0, 0x2, -734, 0x69}
+	case AFCVTDLU:
+		return &inst{0x53, 0x0, 0x3, -733, 0x69}
+	case AFMVDX:
+		return &inst{0x53, 0x0, 0x0, -224, 0x79}
+	case AFCVTQW:
+		return &inst{0x53, 0x0, 0x0, -672, 0x6b}
+	case AFCVTQWU:
+		return &inst{0x53, 0x0, 0x1, -671, 0x6b}
+	case AFCVTQL:
+		return &inst{0x53, 0x0, 0x2, -670, 0x6b}
+	case AFCVTQLU:
+		return &inst{0x53, 0x0, 0x3, -669, 0x6b}
+	case AFMVQX:
+		return &inst{0x53, 0x0, 0x0, -160, 0x7b}
+	case AFLW:
+		return &inst{0x7, 0x2, 0x0, 0, 0x0}
+	case AFLD:
+		return &inst{0x7, 0x3, 0x0, 0, 0x0}
+	case AFLQ:
+		return &inst{0x7, 0x4, 0x0, 0, 0x0}
+	case AFSW:
+		return &inst{0x27, 0x2, 0x0, 0, 0x0}
+	case AFSD:
+		return &inst{0x27, 0x3, 0x0, 0, 0x0}
+	case AFSQ:
+		return &inst{0x27, 0x4, 0x0, 0, 0x0}
+	case AFMADDS:
+		return &inst{0x43, 0x0, 0x0, 0, 0x0}
+	case AFMSUBS:
+		return &inst{0x47, 0x0, 0x0, 0, 0x0}
+	case AFNMSUBS:
+		return &inst{0x4b, 0x0, 0x0, 0, 0x0}
+	case AFNMADDS:
+		return &inst{0x4f, 0x0, 0x0, 0, 0x0}
+	case AFMADDD:
+		return &inst{0x43, 0x0, 0x0, 32, 0x1}
+	case AFMSUBD:
+		return &inst{0x47, 0x0, 0x0, 32, 0x1}
+	case AFNMSUBD:
+		return &inst{0x4b, 0x0, 0x0, 32, 0x1}
+	case AFNMADDD:
+		return &inst{0x4f, 0x0, 0x0, 32, 0x1}
+	case AFMADDQ:
+		return &inst{0x43, 0x0, 0x0, 96, 0x3}
+	case AFMSUBQ:
+		return &inst{0x47, 0x0, 0x0, 96, 0x3}
+	case AFNMSUBQ:
+		return &inst{0x4b, 0x0, 0x0, 96, 0x3}
+	case AFNMADDQ:
+		return &inst{0x4f, 0x0, 0x0, 96, 0x3}
+	case ASLLIRV32:
+		return &inst{0x13, 0x1, 0x0, 0, 0x0}
+	case ASRLIRV32:
+		return &inst{0x13, 0x5, 0x0, 0, 0x0}
+	case ASRAIRV32:
+		return &inst{0x13, 0x5, 0x0, 1024, 0x20}
+	case AFRFLAGS:
+		return &inst{0x73, 0x2, 0x1, 1, 0x0}
+	case AFSFLAGS:
+		return &inst{0x73, 0x1, 0x1, 1, 0x0}
+	case AFSFLAGSI:
+		return &inst{0x73, 0x5, 0x1, 1, 0x0}
+	case AFRRM:
+		return &inst{0x73, 0x2, 0x2, 2, 0x0}
+	case AFSRM:
+		return &inst{0x73, 0x1, 0x2, 2, 0x0}
+	case AFSRMI:
+		return &inst{0x73, 0x5, 0x2, 2, 0x0}
+	case AFSCSR:
+		return &inst{0x73, 0x1, 0x3, 3, 0x0}
+	case AFRCSR:
+		return &inst{0x73, 0x2, 0x3, 3, 0x0}
+	case ARDCYCLE:
+		return &inst{0x73, 0x2, 0x0, -1024, 0x60}
+	case ARDTIME:
+		return &inst{0x73, 0x2, 0x1, -1023, 0x60}
+	case ARDINSTRET:
+		return &inst{0x73, 0x2, 0x2, -1022, 0x60}
+	case ARDCYCLEH:
+		return &inst{0x73, 0x2, 0x0, -896, 0x64}
+	case ARDTIMEH:
+		return &inst{0x73, 0x2, 0x1, -895, 0x64}
+	case ARDINSTRETH:
+		return &inst{0x73, 0x2, 0x2, -894, 0x64}
+	case ASCALL:
+		return &inst{0x73, 0x0, 0x0, 0, 0x0}
+	case ASBREAK:
+		return &inst{0x73, 0x0, 0x1, 1, 0x0}
+	case AFMVXS:
+		return &inst{0x53, 0x0, 0x0, -512, 0x70}
+	case AFMVSX:
+		return &inst{0x53, 0x0, 0x0, -256, 0x78}
+	case AFENCETSO:
+		return &inst{0xf, 0x0, 0x13, -1997, 0x41}
+	}
+	return nil
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/riscv/list.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/riscv/list.go
new file mode 100644
index 000000000..b73f7041d
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/riscv/list.go
@@ -0,0 +1,33 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package riscv
+
+import (
+	"fmt"
+
+	"github.com/twitchyliquid64/golang-asm/obj"
+)
+
+func init() {
+	obj.RegisterRegister(obj.RBaseRISCV, REG_END, RegName)
+	obj.RegisterOpcode(obj.ABaseRISCV, Anames)
+}
+
+func RegName(r int) string {
+	switch {
+	case r == 0:
+		return "NONE"
+	case r == REG_G:
+		return "g"
+	case r == REG_SP:
+		return "SP"
+	case REG_X0 <= r && r <= REG_X31:
+		return fmt.Sprintf("X%d", r-REG_X0)
+	case REG_F0 <= r && r <= REG_F31:
+		return fmt.Sprintf("F%d", r-REG_F0)
+	default:
+		return fmt.Sprintf("Rgok(%d)", r-obj.RBaseRISCV)
+	}
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/riscv/obj.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/riscv/obj.go
new file mode 100644
index 000000000..a9ca000f5
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/riscv/obj.go
@@ -0,0 +1,1999 @@
+// Copyright © 2015 The Go Authors.  All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package riscv
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"github.com/twitchyliquid64/golang-asm/sys"
+	"fmt"
+)
+
+func buildop(ctxt *obj.Link) {}
+
+// jalrToSym replaces p with a set of Progs needed to jump to the Sym in p.
+// lr is the link register to use for the JALR.
+// p must be a CALL, JMP or RET.
+func jalrToSym(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc, lr int16) *obj.Prog {
+	if p.As != obj.ACALL && p.As != obj.AJMP && p.As != obj.ARET {
+		ctxt.Diag("unexpected Prog in jalrToSym: %v", p)
+		return p
+	}
+
+	// TODO(jsing): Consider using a single JAL instruction and teaching
+	// the linker to provide trampolines for the case where the destination
+	// offset is too large. This would potentially reduce instructions for
+	// the common case, but would require three instructions to go via the
+	// trampoline.
+
+	to := p.To
+
+	p.As = AAUIPC
+	p.Mark |= NEED_PCREL_ITYPE_RELOC
+	p.RestArgs = []obj.Addr{obj.Addr{Type: obj.TYPE_CONST, Offset: to.Offset, Sym: to.Sym}}
+	p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: 0}
+	p.Reg = 0
+	p.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_TMP}
+	p = obj.Appendp(p, newprog)
+
+	// Leave Sym only for the CALL reloc in assemble.
+	p.As = AJALR
+	p.From.Type = obj.TYPE_REG
+	p.From.Reg = lr
+	p.Reg = 0
+	p.To.Type = obj.TYPE_REG
+	p.To.Reg = REG_TMP
+	p.To.Sym = to.Sym
+
+	return p
+}
+
+// progedit is called individually for each *obj.Prog. It normalizes instruction
+// formats and eliminates as many pseudo-instructions as possible.
+func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
+
+	// Expand binary instructions to ternary ones.
+	if p.Reg == 0 {
+		switch p.As {
+		case AADDI, ASLTI, ASLTIU, AANDI, AORI, AXORI, ASLLI, ASRLI, ASRAI,
+			AADD, AAND, AOR, AXOR, ASLL, ASRL, ASUB, ASRA,
+			AMUL, AMULH, AMULHU, AMULHSU, AMULW, ADIV, ADIVU, ADIVW, ADIVUW,
+			AREM, AREMU, AREMW, AREMUW:
+			p.Reg = p.To.Reg
+		}
+	}
+
+	// Rewrite instructions with constant operands to refer to the immediate
+	// form of the instruction.
+	if p.From.Type == obj.TYPE_CONST {
+		switch p.As {
+		case AADD:
+			p.As = AADDI
+		case ASLT:
+			p.As = ASLTI
+		case ASLTU:
+			p.As = ASLTIU
+		case AAND:
+			p.As = AANDI
+		case AOR:
+			p.As = AORI
+		case AXOR:
+			p.As = AXORI
+		case ASLL:
+			p.As = ASLLI
+		case ASRL:
+			p.As = ASRLI
+		case ASRA:
+			p.As = ASRAI
+		}
+	}
+
+	switch p.As {
+	case obj.AJMP:
+		// Turn JMP into JAL ZERO or JALR ZERO.
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_ZERO
+
+		switch p.To.Type {
+		case obj.TYPE_BRANCH:
+			p.As = AJAL
+		case obj.TYPE_MEM:
+			switch p.To.Name {
+			case obj.NAME_NONE:
+				p.As = AJALR
+			case obj.NAME_EXTERN:
+				// Handled in preprocess.
+			default:
+				ctxt.Diag("unsupported name %d for %v", p.To.Name, p)
+			}
+		default:
+			panic(fmt.Sprintf("unhandled type %+v", p.To.Type))
+		}
+
+	case obj.ACALL:
+		switch p.To.Type {
+		case obj.TYPE_MEM:
+			// Handled in preprocess.
+		case obj.TYPE_REG:
+			p.As = AJALR
+			p.From.Type = obj.TYPE_REG
+			p.From.Reg = REG_LR
+		default:
+			ctxt.Diag("unknown destination type %+v in CALL: %v", p.To.Type, p)
+		}
+
+	case obj.AUNDEF:
+		p.As = AEBREAK
+
+	case ASCALL:
+		// SCALL is the old name for ECALL.
+		p.As = AECALL
+
+	case ASBREAK:
+		// SBREAK is the old name for EBREAK.
+		p.As = AEBREAK
+	}
+}
+
+// addrToReg extracts the register from an Addr, handling special Addr.Names.
+func addrToReg(a obj.Addr) int16 {
+	switch a.Name {
+	case obj.NAME_PARAM, obj.NAME_AUTO:
+		return REG_SP
+	}
+	return a.Reg
+}
+
+// movToLoad converts a MOV mnemonic into the corresponding load instruction.
+func movToLoad(mnemonic obj.As) obj.As {
+	switch mnemonic {
+	case AMOV:
+		return ALD
+	case AMOVB:
+		return ALB
+	case AMOVH:
+		return ALH
+	case AMOVW:
+		return ALW
+	case AMOVBU:
+		return ALBU
+	case AMOVHU:
+		return ALHU
+	case AMOVWU:
+		return ALWU
+	case AMOVF:
+		return AFLW
+	case AMOVD:
+		return AFLD
+	default:
+		panic(fmt.Sprintf("%+v is not a MOV", mnemonic))
+	}
+}
+
+// movToStore converts a MOV mnemonic into the corresponding store instruction.
+func movToStore(mnemonic obj.As) obj.As {
+	switch mnemonic {
+	case AMOV:
+		return ASD
+	case AMOVB:
+		return ASB
+	case AMOVH:
+		return ASH
+	case AMOVW:
+		return ASW
+	case AMOVF:
+		return AFSW
+	case AMOVD:
+		return AFSD
+	default:
+		panic(fmt.Sprintf("%+v is not a MOV", mnemonic))
+	}
+}
+
+// rewriteMOV rewrites MOV pseudo-instructions.
+func rewriteMOV(ctxt *obj.Link, newprog obj.ProgAlloc, p *obj.Prog) {
+	switch p.As {
+	case AMOV, AMOVB, AMOVH, AMOVW, AMOVBU, AMOVHU, AMOVWU, AMOVF, AMOVD:
+	default:
+		panic(fmt.Sprintf("%+v is not a MOV pseudo-instruction", p.As))
+	}
+
+	switch p.From.Type {
+	case obj.TYPE_MEM: // MOV c(Rs), Rd -> L $c, Rs, Rd
+		switch p.From.Name {
+		case obj.NAME_AUTO, obj.NAME_PARAM, obj.NAME_NONE:
+			if p.To.Type != obj.TYPE_REG {
+				ctxt.Diag("unsupported load at %v", p)
+			}
+			p.As = movToLoad(p.As)
+			p.From.Reg = addrToReg(p.From)
+
+		case obj.NAME_EXTERN, obj.NAME_STATIC:
+			// AUIPC $off_hi, R
+			// L $off_lo, R
+			as := p.As
+			to := p.To
+
+			p.As = AAUIPC
+			p.Mark |= NEED_PCREL_ITYPE_RELOC
+			p.RestArgs = []obj.Addr{obj.Addr{Type: obj.TYPE_CONST, Offset: p.From.Offset, Sym: p.From.Sym}}
+			p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: 0}
+			p.Reg = 0
+			p.To = obj.Addr{Type: obj.TYPE_REG, Reg: to.Reg}
+			p = obj.Appendp(p, newprog)
+
+			p.As = movToLoad(as)
+			p.From = obj.Addr{Type: obj.TYPE_MEM, Reg: to.Reg, Offset: 0}
+			p.To = to
+
+		default:
+			ctxt.Diag("unsupported name %d for %v", p.From.Name, p)
+		}
+
+	case obj.TYPE_REG:
+		switch p.To.Type {
+		case obj.TYPE_REG:
+			switch p.As {
+			case AMOV: // MOV Ra, Rb -> ADDI $0, Ra, Rb
+				p.As = AADDI
+				p.Reg = p.From.Reg
+				p.From = obj.Addr{Type: obj.TYPE_CONST}
+
+			case AMOVF: // MOVF Ra, Rb -> FSGNJS Ra, Ra, Rb
+				p.As = AFSGNJS
+				p.Reg = p.From.Reg
+
+			case AMOVD: // MOVD Ra, Rb -> FSGNJD Ra, Ra, Rb
+				p.As = AFSGNJD
+				p.Reg = p.From.Reg
+
+			default:
+				ctxt.Diag("unsupported register-register move at %v", p)
+			}
+
+		case obj.TYPE_MEM: // MOV Rs, c(Rd) -> S $c, Rs, Rd
+			switch p.As {
+			case AMOVBU, AMOVHU, AMOVWU:
+				ctxt.Diag("unsupported unsigned store at %v", p)
+			}
+			switch p.To.Name {
+			case obj.NAME_AUTO, obj.NAME_PARAM, obj.NAME_NONE:
+				p.As = movToStore(p.As)
+				p.To.Reg = addrToReg(p.To)
+
+			case obj.NAME_EXTERN:
+				// AUIPC $off_hi, TMP
+				// S $off_lo, TMP, R
+				as := p.As
+				from := p.From
+
+				p.As = AAUIPC
+				p.Mark |= NEED_PCREL_STYPE_RELOC
+				p.RestArgs = []obj.Addr{obj.Addr{Type: obj.TYPE_CONST, Offset: p.To.Offset, Sym: p.To.Sym}}
+				p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: 0}
+				p.Reg = 0
+				p.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_TMP}
+				p = obj.Appendp(p, newprog)
+
+				p.As = movToStore(as)
+				p.From = from
+				p.To = obj.Addr{Type: obj.TYPE_MEM, Reg: REG_TMP, Offset: 0}
+
+			default:
+				ctxt.Diag("unsupported name %d for %v", p.From.Name, p)
+			}
+
+		default:
+			ctxt.Diag("unsupported MOV at %v", p)
+		}
+
+	case obj.TYPE_CONST:
+		// MOV $c, R
+		// If c is small enough, convert to:
+		//   ADD $c, ZERO, R
+		// If not, convert to:
+		//   LUI top20bits(c), R
+		//   ADD bottom12bits(c), R, R
+		if p.As != AMOV {
+			ctxt.Diag("unsupported constant load at %v", p)
+		}
+		off := p.From.Offset
+		to := p.To
+
+		low, high, err := Split32BitImmediate(off)
+		if err != nil {
+			ctxt.Diag("%v: constant %d too large: %v", p, off, err)
+		}
+
+		// LUI is only necessary if the offset doesn't fit in 12-bits.
+		needLUI := high != 0
+		if needLUI {
+			p.As = ALUI
+			p.To = to
+			// Pass top 20 bits to LUI.
+			p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: high}
+			p = obj.Appendp(p, newprog)
+		}
+		p.As = AADDIW
+		p.To = to
+		p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: low}
+		p.Reg = REG_ZERO
+		if needLUI {
+			p.Reg = to.Reg
+		}
+
+	case obj.TYPE_ADDR: // MOV $sym+off(SP/SB), R
+		if p.To.Type != obj.TYPE_REG || p.As != AMOV {
+			ctxt.Diag("unsupported addr MOV at %v", p)
+		}
+		switch p.From.Name {
+		case obj.NAME_EXTERN, obj.NAME_STATIC:
+			// AUIPC $off_hi, R
+			// ADDI $off_lo, R
+			to := p.To
+
+			p.As = AAUIPC
+			p.Mark |= NEED_PCREL_ITYPE_RELOC
+			p.RestArgs = []obj.Addr{obj.Addr{Type: obj.TYPE_CONST, Offset: p.From.Offset, Sym: p.From.Sym}}
+			p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: 0}
+			p.Reg = 0
+			p.To = to
+			p = obj.Appendp(p, newprog)
+
+			p.As = AADDI
+			p.From = obj.Addr{Type: obj.TYPE_CONST}
+			p.Reg = to.Reg
+			p.To = to
+
+		case obj.NAME_PARAM, obj.NAME_AUTO:
+			p.As = AADDI
+			p.Reg = REG_SP
+			p.From.Type = obj.TYPE_CONST
+
+		case obj.NAME_NONE:
+			p.As = AADDI
+			p.Reg = p.From.Reg
+			p.From.Type = obj.TYPE_CONST
+			p.From.Reg = 0
+
+		default:
+			ctxt.Diag("bad addr MOV from name %v at %v", p.From.Name, p)
+		}
+
+	default:
+		ctxt.Diag("unsupported MOV at %v", p)
+	}
+}
+
+// InvertBranch inverts the condition of a conditional branch.
+func InvertBranch(as obj.As) obj.As {
+	switch as {
+	case ABEQ:
+		return ABNE
+	case ABEQZ:
+		return ABNEZ
+	case ABGE:
+		return ABLT
+	case ABGEU:
+		return ABLTU
+	case ABGEZ:
+		return ABLTZ
+	case ABGT:
+		return ABLE
+	case ABGTU:
+		return ABLEU
+	case ABGTZ:
+		return ABLEZ
+	case ABLE:
+		return ABGT
+	case ABLEU:
+		return ABGTU
+	case ABLEZ:
+		return ABGTZ
+	case ABLT:
+		return ABGE
+	case ABLTU:
+		return ABGEU
+	case ABLTZ:
+		return ABGEZ
+	case ABNE:
+		return ABEQ
+	case ABNEZ:
+		return ABEQZ
+	default:
+		panic("InvertBranch: not a branch")
+	}
+}
+
+// containsCall reports whether the symbol contains a CALL (or equivalent)
+// instruction. Must be called after progedit.
+func containsCall(sym *obj.LSym) bool {
+	// CALLs are CALL or JAL(R) with link register LR.
+	for p := sym.Func.Text; p != nil; p = p.Link {
+		switch p.As {
+		case obj.ACALL:
+			return true
+		case AJAL, AJALR:
+			if p.From.Type == obj.TYPE_REG && p.From.Reg == REG_LR {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+// setPCs sets the Pc field in all instructions reachable from p.
+// It uses pc as the initial value.
+func setPCs(p *obj.Prog, pc int64) {
+	for ; p != nil; p = p.Link {
+		p.Pc = pc
+		for _, ins := range instructionsForProg(p) {
+			pc += int64(ins.length())
+		}
+	}
+}
+
+// stackOffset updates Addr offsets based on the current stack size.
+//
+// The stack looks like:
+// -------------------
+// |                 |
+// |      PARAMs     |
+// |                 |
+// |                 |
+// -------------------
+// |    Parent RA    |   SP on function entry
+// -------------------
+// |                 |
+// |                 |
+// |       AUTOs     |
+// |                 |
+// |                 |
+// -------------------
+// |        RA       |   SP during function execution
+// -------------------
+//
+// FixedFrameSize makes other packages aware of the space allocated for RA.
+//
+// A nicer version of this diagram can be found on slide 21 of the presentation
+// attached to:
+//
+//   https://golang.org/issue/16922#issuecomment-243748180
+//
+func stackOffset(a *obj.Addr, stacksize int64) {
+	switch a.Name {
+	case obj.NAME_AUTO:
+		// Adjust to the top of AUTOs.
+		a.Offset += stacksize
+	case obj.NAME_PARAM:
+		// Adjust to the bottom of PARAMs.
+		a.Offset += stacksize + 8
+	}
+}
+
+// preprocess generates prologue and epilogue code, computes PC-relative branch
+// and jump offsets, and resolves pseudo-registers.
+//
+// preprocess is called once per linker symbol.
+//
+// When preprocess finishes, all instructions in the symbol are either
+// concrete, real RISC-V instructions or directive pseudo-ops like TEXT,
+// PCDATA, and FUNCDATA.
+func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
+	if cursym.Func.Text == nil || cursym.Func.Text.Link == nil {
+		return
+	}
+
+	// Generate the prologue.
+	text := cursym.Func.Text
+	if text.As != obj.ATEXT {
+		ctxt.Diag("preprocess: found symbol that does not start with TEXT directive")
+		return
+	}
+
+	stacksize := text.To.Offset
+	if stacksize == -8 {
+		// Historical way to mark NOFRAME.
+		text.From.Sym.Set(obj.AttrNoFrame, true)
+		stacksize = 0
+	}
+	if stacksize < 0 {
+		ctxt.Diag("negative frame size %d - did you mean NOFRAME?", stacksize)
+	}
+	if text.From.Sym.NoFrame() {
+		if stacksize != 0 {
+			ctxt.Diag("NOFRAME functions must have a frame size of 0, not %d", stacksize)
+		}
+	}
+
+	if !containsCall(cursym) {
+		text.From.Sym.Set(obj.AttrLeaf, true)
+		if stacksize == 0 {
+			// A leaf function with no locals has no frame.
+			text.From.Sym.Set(obj.AttrNoFrame, true)
+		}
+	}
+
+	// Save LR unless there is no frame.
+	if !text.From.Sym.NoFrame() {
+		stacksize += ctxt.FixedFrameSize()
+	}
+
+	cursym.Func.Args = text.To.Val.(int32)
+	cursym.Func.Locals = int32(stacksize)
+
+	prologue := text
+
+	if !cursym.Func.Text.From.Sym.NoSplit() {
+		prologue = stacksplit(ctxt, prologue, cursym, newprog, stacksize) // emit split check
+	}
+
+	if stacksize != 0 {
+		prologue = ctxt.StartUnsafePoint(prologue, newprog)
+
+		// Actually save LR.
+		prologue = obj.Appendp(prologue, newprog)
+		prologue.As = AMOV
+		prologue.From = obj.Addr{Type: obj.TYPE_REG, Reg: REG_LR}
+		prologue.To = obj.Addr{Type: obj.TYPE_MEM, Reg: REG_SP, Offset: -stacksize}
+
+		// Insert stack adjustment.
+		prologue = obj.Appendp(prologue, newprog)
+		prologue.As = AADDI
+		prologue.From = obj.Addr{Type: obj.TYPE_CONST, Offset: -stacksize}
+		prologue.Reg = REG_SP
+		prologue.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_SP}
+		prologue.Spadj = int32(stacksize)
+
+		prologue = ctxt.EndUnsafePoint(prologue, newprog, -1)
+	}
+
+	if cursym.Func.Text.From.Sym.Wrapper() {
+		// if(g->panic != nil && g->panic->argp == FP) g->panic->argp = bottom-of-frame
+		//
+		//   MOV g_panic(g), X11
+		//   BNE X11, ZERO, adjust
+		// end:
+		//   NOP
+		// ...rest of function..
+		// adjust:
+		//   MOV panic_argp(X11), X12
+		//   ADD $(autosize+FIXED_FRAME), SP, X13
+		//   BNE X12, X13, end
+		//   ADD $FIXED_FRAME, SP, X12
+		//   MOV X12, panic_argp(X11)
+		//   JMP end
+		//
+		// The NOP is needed to give the jumps somewhere to land.
+
+		ldpanic := obj.Appendp(prologue, newprog)
+
+		ldpanic.As = AMOV
+		ldpanic.From = obj.Addr{Type: obj.TYPE_MEM, Reg: REGG, Offset: 4 * int64(ctxt.Arch.PtrSize)} // G.panic
+		ldpanic.Reg = 0
+		ldpanic.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_X11}
+
+		bneadj := obj.Appendp(ldpanic, newprog)
+		bneadj.As = ABNE
+		bneadj.From = obj.Addr{Type: obj.TYPE_REG, Reg: REG_X11}
+		bneadj.Reg = REG_ZERO
+		bneadj.To.Type = obj.TYPE_BRANCH
+
+		endadj := obj.Appendp(bneadj, newprog)
+		endadj.As = obj.ANOP
+
+		last := endadj
+		for last.Link != nil {
+			last = last.Link
+		}
+
+		getargp := obj.Appendp(last, newprog)
+		getargp.As = AMOV
+		getargp.From = obj.Addr{Type: obj.TYPE_MEM, Reg: REG_X11, Offset: 0} // Panic.argp
+		getargp.Reg = 0
+		getargp.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_X12}
+
+		bneadj.To.SetTarget(getargp)
+
+		calcargp := obj.Appendp(getargp, newprog)
+		calcargp.As = AADDI
+		calcargp.From = obj.Addr{Type: obj.TYPE_CONST, Offset: stacksize + ctxt.FixedFrameSize()}
+		calcargp.Reg = REG_SP
+		calcargp.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_X13}
+
+		testargp := obj.Appendp(calcargp, newprog)
+		testargp.As = ABNE
+		testargp.From = obj.Addr{Type: obj.TYPE_REG, Reg: REG_X12}
+		testargp.Reg = REG_X13
+		testargp.To.Type = obj.TYPE_BRANCH
+		testargp.To.SetTarget(endadj)
+
+		adjargp := obj.Appendp(testargp, newprog)
+		adjargp.As = AADDI
+		adjargp.From = obj.Addr{Type: obj.TYPE_CONST, Offset: int64(ctxt.Arch.PtrSize)}
+		adjargp.Reg = REG_SP
+		adjargp.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_X12}
+
+		setargp := obj.Appendp(adjargp, newprog)
+		setargp.As = AMOV
+		setargp.From = obj.Addr{Type: obj.TYPE_REG, Reg: REG_X12}
+		setargp.Reg = 0
+		setargp.To = obj.Addr{Type: obj.TYPE_MEM, Reg: REG_X11, Offset: 0} // Panic.argp
+
+		godone := obj.Appendp(setargp, newprog)
+		godone.As = AJAL
+		godone.From = obj.Addr{Type: obj.TYPE_REG, Reg: REG_ZERO}
+		godone.To.Type = obj.TYPE_BRANCH
+		godone.To.SetTarget(endadj)
+	}
+
+	// Update stack-based offsets.
+	for p := cursym.Func.Text; p != nil; p = p.Link {
+		stackOffset(&p.From, stacksize)
+		stackOffset(&p.To, stacksize)
+	}
+
+	// Additional instruction rewriting.
+	for p := cursym.Func.Text; p != nil; p = p.Link {
+		switch p.As {
+		case obj.AGETCALLERPC:
+			if cursym.Leaf() {
+				// MOV LR, Rd
+				p.As = AMOV
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REG_LR
+			} else {
+				// MOV (RSP), Rd
+				p.As = AMOV
+				p.From.Type = obj.TYPE_MEM
+				p.From.Reg = REG_SP
+			}
+
+		case obj.ACALL:
+			switch p.To.Type {
+			case obj.TYPE_MEM:
+				jalrToSym(ctxt, p, newprog, REG_LR)
+			}
+
+		case obj.AJMP:
+			switch p.To.Type {
+			case obj.TYPE_MEM:
+				switch p.To.Name {
+				case obj.NAME_EXTERN:
+					// JMP to symbol.
+					jalrToSym(ctxt, p, newprog, REG_ZERO)
+				}
+			}
+
+		case obj.ARET:
+			// Replace RET with epilogue.
+			retJMP := p.To.Sym
+
+			if stacksize != 0 {
+				// Restore LR.
+				p.As = AMOV
+				p.From = obj.Addr{Type: obj.TYPE_MEM, Reg: REG_SP, Offset: 0}
+				p.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_LR}
+				p = obj.Appendp(p, newprog)
+
+				p.As = AADDI
+				p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: stacksize}
+				p.Reg = REG_SP
+				p.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_SP}
+				p.Spadj = int32(-stacksize)
+				p = obj.Appendp(p, newprog)
+			}
+
+			if retJMP != nil {
+				p.As = obj.ARET
+				p.To.Sym = retJMP
+				p = jalrToSym(ctxt, p, newprog, REG_ZERO)
+			} else {
+				p.As = AJALR
+				p.From = obj.Addr{Type: obj.TYPE_REG, Reg: REG_ZERO}
+				p.Reg = 0
+				p.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_LR}
+			}
+
+			// "Add back" the stack removed in the previous instruction.
+			//
+			// This is to avoid confusing pctospadj, which sums
+			// Spadj from function entry to each PC, and shouldn't
+			// count adjustments from earlier epilogues, since they
+			// won't affect later PCs.
+			p.Spadj = int32(stacksize)
+
+		case AADDI:
+			// Refine Spadjs account for adjustment via ADDI instruction.
+			if p.To.Type == obj.TYPE_REG && p.To.Reg == REG_SP && p.From.Type == obj.TYPE_CONST {
+				p.Spadj = int32(-p.From.Offset)
+			}
+		}
+	}
+
+	// Rewrite MOV pseudo-instructions. This cannot be done in
+	// progedit, as SP offsets need to be applied before we split
+	// up some of the Addrs.
+	for p := cursym.Func.Text; p != nil; p = p.Link {
+		switch p.As {
+		case AMOV, AMOVB, AMOVH, AMOVW, AMOVBU, AMOVHU, AMOVWU, AMOVF, AMOVD:
+			rewriteMOV(ctxt, newprog, p)
+		}
+	}
+
+	// Split immediates larger than 12-bits.
+	for p := cursym.Func.Text; p != nil; p = p.Link {
+		switch p.As {
+		// <opi> $imm, REG, TO
+		case AADDI, AANDI, AORI, AXORI:
+			// LUI $high, TMP
+			// ADDI $low, TMP, TMP
+			// <op> TMP, REG, TO
+			q := *p
+			low, high, err := Split32BitImmediate(p.From.Offset)
+			if err != nil {
+				ctxt.Diag("%v: constant %d too large", p, p.From.Offset, err)
+			}
+			if high == 0 {
+				break // no need to split
+			}
+
+			p.As = ALUI
+			p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: high}
+			p.Reg = 0
+			p.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_TMP}
+			p.Spadj = 0 // needed if TO is SP
+			p = obj.Appendp(p, newprog)
+
+			p.As = AADDIW
+			p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: low}
+			p.Reg = REG_TMP
+			p.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_TMP}
+			p = obj.Appendp(p, newprog)
+
+			switch q.As {
+			case AADDI:
+				p.As = AADD
+			case AANDI:
+				p.As = AAND
+			case AORI:
+				p.As = AOR
+			case AXORI:
+				p.As = AXOR
+			default:
+				ctxt.Diag("unsupported instruction %v for splitting", q)
+			}
+			p.Spadj = q.Spadj
+			p.To = q.To
+			p.Reg = q.Reg
+			p.From = obj.Addr{Type: obj.TYPE_REG, Reg: REG_TMP}
+
+		// <load> $imm, REG, TO (load $imm+(REG), TO)
+		case ALD, ALB, ALH, ALW, ALBU, ALHU, ALWU, AFLW, AFLD:
+			low, high, err := Split32BitImmediate(p.From.Offset)
+			if err != nil {
+				ctxt.Diag("%v: constant %d too large", p, p.From.Offset)
+			}
+			if high == 0 {
+				break // no need to split
+			}
+			q := *p
+
+			// LUI $high, TMP
+			// ADD TMP, REG, TMP
+			// <load> $low, TMP, TO
+			p.As = ALUI
+			p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: high}
+			p.Reg = 0
+			p.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_TMP}
+			p.Spadj = 0 // needed if TO is SP
+			p = obj.Appendp(p, newprog)
+
+			p.As = AADD
+			p.From = obj.Addr{Type: obj.TYPE_REG, Reg: REG_TMP}
+			p.Reg = q.From.Reg
+			p.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_TMP}
+			p = obj.Appendp(p, newprog)
+
+			p.As = q.As
+			p.To = q.To
+			p.From = obj.Addr{Type: obj.TYPE_MEM, Reg: REG_TMP, Offset: low}
+			p.Reg = obj.REG_NONE
+
+		// <store> $imm, REG, TO (store $imm+(TO), REG)
+		case ASD, ASB, ASH, ASW, AFSW, AFSD:
+			low, high, err := Split32BitImmediate(p.To.Offset)
+			if err != nil {
+				ctxt.Diag("%v: constant %d too large", p, p.To.Offset)
+			}
+			if high == 0 {
+				break // no need to split
+			}
+			q := *p
+
+			// LUI $high, TMP
+			// ADD TMP, TO, TMP
+			// <store> $low, REG, TMP
+			p.As = ALUI
+			p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: high}
+			p.Reg = 0
+			p.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_TMP}
+			p.Spadj = 0 // needed if TO is SP
+			p = obj.Appendp(p, newprog)
+
+			p.As = AADD
+			p.From = obj.Addr{Type: obj.TYPE_REG, Reg: REG_TMP}
+			p.Reg = q.To.Reg
+			p.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_TMP}
+			p = obj.Appendp(p, newprog)
+
+			p.As = q.As
+			p.From = obj.Addr{Type: obj.TYPE_REG, Reg: q.From.Reg, Offset: 0}
+			p.To = obj.Addr{Type: obj.TYPE_MEM, Reg: REG_TMP, Offset: low}
+		}
+	}
+
+	// Compute instruction addresses.  Once we do that, we need to check for
+	// overextended jumps and branches.  Within each iteration, Pc differences
+	// are always lower bounds (since the program gets monotonically longer,
+	// a fixed point will be reached).  No attempt to handle functions > 2GiB.
+	for {
+		rescan := false
+		setPCs(cursym.Func.Text, 0)
+
+		for p := cursym.Func.Text; p != nil; p = p.Link {
+			switch p.As {
+			case ABEQ, ABEQZ, ABGE, ABGEU, ABGEZ, ABGT, ABGTU, ABGTZ, ABLE, ABLEU, ABLEZ, ABLT, ABLTU, ABLTZ, ABNE, ABNEZ:
+				if p.To.Type != obj.TYPE_BRANCH {
+					panic("assemble: instruction with branch-like opcode lacks destination")
+				}
+				offset := p.To.Target().Pc - p.Pc
+				if offset < -4096 || 4096 <= offset {
+					// Branch is long.  Replace it with a jump.
+					jmp := obj.Appendp(p, newprog)
+					jmp.As = AJAL
+					jmp.From = obj.Addr{Type: obj.TYPE_REG, Reg: REG_ZERO}
+					jmp.To = obj.Addr{Type: obj.TYPE_BRANCH}
+					jmp.To.SetTarget(p.To.Target())
+
+					p.As = InvertBranch(p.As)
+					p.To.SetTarget(jmp.Link)
+
+					// We may have made previous branches too long,
+					// so recheck them.
+					rescan = true
+				}
+			case AJAL:
+				if p.To.Target() == nil {
+					panic("intersymbol jumps should be expressed as AUIPC+JALR")
+				}
+				offset := p.To.Target().Pc - p.Pc
+				if offset < -(1<<20) || (1<<20) <= offset {
+					// Replace with 2-instruction sequence. This assumes
+					// that TMP is not live across J instructions, since
+					// it is reserved by SSA.
+					jmp := obj.Appendp(p, newprog)
+					jmp.As = AJALR
+					jmp.From = p.From
+					jmp.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_TMP}
+
+					// p.From is not generally valid, however will be
+					// fixed up in the next loop.
+					p.As = AAUIPC
+					p.From = obj.Addr{Type: obj.TYPE_BRANCH, Sym: p.From.Sym}
+					p.From.SetTarget(p.To.Target())
+					p.Reg = 0
+					p.To = obj.Addr{Type: obj.TYPE_REG, Reg: REG_TMP}
+
+					rescan = true
+				}
+			}
+		}
+
+		if !rescan {
+			break
+		}
+	}
+
+	// Now that there are no long branches, resolve branch and jump targets.
+	// At this point, instruction rewriting which changes the number of
+	// instructions will break everything--don't do it!
+	for p := cursym.Func.Text; p != nil; p = p.Link {
+		switch p.As {
+		case ABEQ, ABEQZ, ABGE, ABGEU, ABGEZ, ABGT, ABGTU, ABGTZ, ABLE, ABLEU, ABLEZ, ABLT, ABLTU, ABLTZ, ABNE, ABNEZ, AJAL:
+			switch p.To.Type {
+			case obj.TYPE_BRANCH:
+				p.To.Type, p.To.Offset = obj.TYPE_CONST, p.To.Target().Pc-p.Pc
+			case obj.TYPE_MEM:
+				panic("unhandled type")
+			}
+
+		case AAUIPC:
+			if p.From.Type == obj.TYPE_BRANCH {
+				low, high, err := Split32BitImmediate(p.From.Target().Pc - p.Pc)
+				if err != nil {
+					ctxt.Diag("%v: jump displacement %d too large", p, p.To.Target().Pc-p.Pc)
+				}
+				p.From = obj.Addr{Type: obj.TYPE_CONST, Offset: high, Sym: cursym}
+				p.Link.From.Offset = low
+			}
+		}
+	}
+
+	// Validate all instructions - this provides nice error messages.
+	for p := cursym.Func.Text; p != nil; p = p.Link {
+		for _, ins := range instructionsForProg(p) {
+			ins.validate(ctxt)
+		}
+	}
+}
+
+func stacksplit(ctxt *obj.Link, p *obj.Prog, cursym *obj.LSym, newprog obj.ProgAlloc, framesize int64) *obj.Prog {
+	// Leaf function with no frame is effectively NOSPLIT.
+	if framesize == 0 {
+		return p
+	}
+
+	// MOV	g_stackguard(g), X10
+	p = obj.Appendp(p, newprog)
+	p.As = AMOV
+	p.From.Type = obj.TYPE_MEM
+	p.From.Reg = REGG
+	p.From.Offset = 2 * int64(ctxt.Arch.PtrSize) // G.stackguard0
+	if cursym.CFunc() {
+		p.From.Offset = 3 * int64(ctxt.Arch.PtrSize) // G.stackguard1
+	}
+	p.To.Type = obj.TYPE_REG
+	p.To.Reg = REG_X10
+
+	var to_done, to_more *obj.Prog
+
+	if framesize <= objabi.StackSmall {
+		// small stack: SP < stackguard
+		//	BLTU	SP, stackguard, done
+		p = obj.Appendp(p, newprog)
+		p.As = ABLTU
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_X10
+		p.Reg = REG_SP
+		p.To.Type = obj.TYPE_BRANCH
+		to_done = p
+	} else if framesize <= objabi.StackBig {
+		// large stack: SP-framesize < stackguard-StackSmall
+		//	ADD	$-(framesize-StackSmall), SP, X11
+		//	BLTU	X11, stackguard, done
+		p = obj.Appendp(p, newprog)
+		// TODO(sorear): logic inconsistent with comment, but both match all non-x86 arches
+		p.As = AADDI
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = -(int64(framesize) - objabi.StackSmall)
+		p.Reg = REG_SP
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_X11
+
+		p = obj.Appendp(p, newprog)
+		p.As = ABLTU
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_X10
+		p.Reg = REG_X11
+		p.To.Type = obj.TYPE_BRANCH
+		to_done = p
+	} else {
+		// Such a large stack we need to protect against wraparound.
+		// If SP is close to zero:
+		//	SP-stackguard+StackGuard <= framesize + (StackGuard-StackSmall)
+		// The +StackGuard on both sides is required to keep the left side positive:
+		// SP is allowed to be slightly below stackguard. See stack.h.
+		//
+		// Preemption sets stackguard to StackPreempt, a very large value.
+		// That breaks the math above, so we have to check for that explicitly.
+		//	// stackguard is X10
+		//	MOV	$StackPreempt, X11
+		//	BEQ	X10, X11, more
+		//	ADD	$StackGuard, SP, X11
+		//	SUB	X10, X11
+		//	MOV	$(framesize+(StackGuard-StackSmall)), X10
+		//	BGTU	X11, X10, done
+		p = obj.Appendp(p, newprog)
+		p.As = AMOV
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = objabi.StackPreempt
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_X11
+
+		p = obj.Appendp(p, newprog)
+		to_more = p
+		p.As = ABEQ
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_X10
+		p.Reg = REG_X11
+		p.To.Type = obj.TYPE_BRANCH
+
+		p = obj.Appendp(p, newprog)
+		p.As = AADDI
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = int64(objabi.StackGuard)
+		p.Reg = REG_SP
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_X11
+
+		p = obj.Appendp(p, newprog)
+		p.As = ASUB
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_X10
+		p.Reg = REG_X11
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_X11
+
+		p = obj.Appendp(p, newprog)
+		p.As = AMOV
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = int64(framesize) + int64(objabi.StackGuard) - objabi.StackSmall
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_X10
+
+		p = obj.Appendp(p, newprog)
+		p.As = ABLTU
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_X10
+		p.Reg = REG_X11
+		p.To.Type = obj.TYPE_BRANCH
+		to_done = p
+	}
+
+	p = ctxt.EmitEntryLiveness(cursym, p, newprog)
+
+	// CALL runtime.morestack(SB)
+	p = obj.Appendp(p, newprog)
+	p.As = obj.ACALL
+	p.To.Type = obj.TYPE_BRANCH
+	if cursym.CFunc() {
+		p.To.Sym = ctxt.Lookup("runtime.morestackc")
+	} else if !cursym.Func.Text.From.Sym.NeedCtxt() {
+		p.To.Sym = ctxt.Lookup("runtime.morestack_noctxt")
+	} else {
+		p.To.Sym = ctxt.Lookup("runtime.morestack")
+	}
+	if to_more != nil {
+		to_more.To.SetTarget(p)
+	}
+	p = jalrToSym(ctxt, p, newprog, REG_X5)
+
+	// JMP start
+	p = obj.Appendp(p, newprog)
+	p.As = AJAL
+	p.To = obj.Addr{Type: obj.TYPE_BRANCH}
+	p.From = obj.Addr{Type: obj.TYPE_REG, Reg: REG_ZERO}
+	p.To.SetTarget(cursym.Func.Text.Link)
+
+	// placeholder for to_done's jump target
+	p = obj.Appendp(p, newprog)
+	p.As = obj.ANOP // zero-width place holder
+	to_done.To.SetTarget(p)
+
+	return p
+}
+
+// signExtend sign extends val starting at bit bit.
+func signExtend(val int64, bit uint) int64 {
+	return val << (64 - bit) >> (64 - bit)
+}
+
+// Split32BitImmediate splits a signed 32-bit immediate into a signed 20-bit
+// upper immediate and a signed 12-bit lower immediate to be added to the upper
+// result. For example, high may be used in LUI and low in a following ADDI to
+// generate a full 32-bit constant.
+func Split32BitImmediate(imm int64) (low, high int64, err error) {
+	if !immIFits(imm, 32) {
+		return 0, 0, fmt.Errorf("immediate does not fit in 32-bits: %d", imm)
+	}
+
+	// Nothing special needs to be done if the immediate fits in 12-bits.
+	if immIFits(imm, 12) {
+		return imm, 0, nil
+	}
+
+	high = imm >> 12
+
+	// The bottom 12 bits will be treated as signed.
+	//
+	// If that will result in a negative 12 bit number, add 1 to
+	// our upper bits to adjust for the borrow.
+	//
+	// It is not possible for this increment to overflow. To
+	// overflow, the 20 top bits would be 1, and the sign bit for
+	// the low 12 bits would be set, in which case the entire 32
+	// bit pattern fits in a 12 bit signed value.
+	if imm&(1<<11) != 0 {
+		high++
+	}
+
+	low = signExtend(imm, 12)
+	high = signExtend(high, 20)
+
+	return low, high, nil
+}
+
+func regVal(r, min, max uint32) uint32 {
+	if r < min || r > max {
+		panic(fmt.Sprintf("register out of range, want %d < %d < %d", min, r, max))
+	}
+	return r - min
+}
+
+// regI returns an integer register.
+func regI(r uint32) uint32 {
+	return regVal(r, REG_X0, REG_X31)
+}
+
+// regF returns a float register.
+func regF(r uint32) uint32 {
+	return regVal(r, REG_F0, REG_F31)
+}
+
+// regAddr extracts a register from an Addr.
+func regAddr(a obj.Addr, min, max uint32) uint32 {
+	if a.Type != obj.TYPE_REG {
+		panic(fmt.Sprintf("ill typed: %+v", a))
+	}
+	return regVal(uint32(a.Reg), min, max)
+}
+
+// regIAddr extracts the integer register from an Addr.
+func regIAddr(a obj.Addr) uint32 {
+	return regAddr(a, REG_X0, REG_X31)
+}
+
+// regFAddr extracts the float register from an Addr.
+func regFAddr(a obj.Addr) uint32 {
+	return regAddr(a, REG_F0, REG_F31)
+}
+
+// immIFits reports whether immediate value x fits in nbits bits
+// as a signed integer.
+func immIFits(x int64, nbits uint) bool {
+	nbits--
+	var min int64 = -1 << nbits
+	var max int64 = 1<<nbits - 1
+	return min <= x && x <= max
+}
+
+// immI extracts the signed integer of the specified size from an immediate.
+func immI(as obj.As, imm int64, nbits uint) uint32 {
+	if !immIFits(imm, nbits) {
+		panic(fmt.Sprintf("%v\tsigned immediate %d cannot fit in %d bits", as, imm, nbits))
+	}
+	return uint32(imm)
+}
+
+func wantImmI(ctxt *obj.Link, as obj.As, imm int64, nbits uint) {
+	if !immIFits(imm, nbits) {
+		ctxt.Diag("%v\tsigned immediate cannot be larger than %d bits but got %d", as, nbits, imm)
+	}
+}
+
+func wantReg(ctxt *obj.Link, as obj.As, pos string, descr string, r, min, max uint32) {
+	if r < min || r > max {
+		var suffix string
+		if r != obj.REG_NONE {
+			suffix = fmt.Sprintf(" but got non-%s register %s", descr, RegName(int(r)))
+		}
+		ctxt.Diag("%v\texpected %s register in %s position%s", as, descr, pos, suffix)
+	}
+}
+
+func wantNoneReg(ctxt *obj.Link, as obj.As, pos string, r uint32) {
+	if r != obj.REG_NONE {
+		ctxt.Diag("%v\texpected no register in %s but got register %s", as, pos, RegName(int(r)))
+	}
+}
+
+// wantIntReg checks that r is an integer register.
+func wantIntReg(ctxt *obj.Link, as obj.As, pos string, r uint32) {
+	wantReg(ctxt, as, pos, "integer", r, REG_X0, REG_X31)
+}
+
+// wantFloatReg checks that r is a floating-point register.
+func wantFloatReg(ctxt *obj.Link, as obj.As, pos string, r uint32) {
+	wantReg(ctxt, as, pos, "float", r, REG_F0, REG_F31)
+}
+
+// wantEvenOffset checks that the offset is a multiple of two.
+func wantEvenOffset(ctxt *obj.Link, as obj.As, offset int64) {
+	if offset%1 != 0 {
+		ctxt.Diag("%v\tjump offset %v must be even", as, offset)
+	}
+}
+
+func validateRIII(ctxt *obj.Link, ins *instruction) {
+	wantIntReg(ctxt, ins.as, "rd", ins.rd)
+	wantIntReg(ctxt, ins.as, "rs1", ins.rs1)
+	wantIntReg(ctxt, ins.as, "rs2", ins.rs2)
+}
+
+func validateRFFF(ctxt *obj.Link, ins *instruction) {
+	wantFloatReg(ctxt, ins.as, "rd", ins.rd)
+	wantFloatReg(ctxt, ins.as, "rs1", ins.rs1)
+	wantFloatReg(ctxt, ins.as, "rs2", ins.rs2)
+}
+
+func validateRFFI(ctxt *obj.Link, ins *instruction) {
+	wantIntReg(ctxt, ins.as, "rd", ins.rd)
+	wantFloatReg(ctxt, ins.as, "rs1", ins.rs1)
+	wantFloatReg(ctxt, ins.as, "rs2", ins.rs2)
+}
+
+func validateRFI(ctxt *obj.Link, ins *instruction) {
+	wantIntReg(ctxt, ins.as, "rd", ins.rd)
+	wantNoneReg(ctxt, ins.as, "rs1", ins.rs1)
+	wantFloatReg(ctxt, ins.as, "rs2", ins.rs2)
+}
+
+func validateRIF(ctxt *obj.Link, ins *instruction) {
+	wantFloatReg(ctxt, ins.as, "rd", ins.rd)
+	wantNoneReg(ctxt, ins.as, "rs1", ins.rs1)
+	wantIntReg(ctxt, ins.as, "rs2", ins.rs2)
+}
+
+func validateRFF(ctxt *obj.Link, ins *instruction) {
+	wantFloatReg(ctxt, ins.as, "rd", ins.rd)
+	wantNoneReg(ctxt, ins.as, "rs1", ins.rs1)
+	wantFloatReg(ctxt, ins.as, "rs2", ins.rs2)
+}
+
+func validateII(ctxt *obj.Link, ins *instruction) {
+	wantImmI(ctxt, ins.as, ins.imm, 12)
+	wantIntReg(ctxt, ins.as, "rd", ins.rd)
+	wantIntReg(ctxt, ins.as, "rs1", ins.rs1)
+}
+
+func validateIF(ctxt *obj.Link, ins *instruction) {
+	wantImmI(ctxt, ins.as, ins.imm, 12)
+	wantFloatReg(ctxt, ins.as, "rd", ins.rd)
+	wantIntReg(ctxt, ins.as, "rs1", ins.rs1)
+}
+
+func validateSI(ctxt *obj.Link, ins *instruction) {
+	wantImmI(ctxt, ins.as, ins.imm, 12)
+	wantIntReg(ctxt, ins.as, "rd", ins.rd)
+	wantIntReg(ctxt, ins.as, "rs1", ins.rs1)
+}
+
+func validateSF(ctxt *obj.Link, ins *instruction) {
+	wantImmI(ctxt, ins.as, ins.imm, 12)
+	wantIntReg(ctxt, ins.as, "rd", ins.rd)
+	wantFloatReg(ctxt, ins.as, "rs1", ins.rs1)
+}
+
+func validateB(ctxt *obj.Link, ins *instruction) {
+	// Offsets are multiples of two, so accept 13 bit immediates for the
+	// 12 bit slot. We implicitly drop the least significant bit in encodeB.
+	wantEvenOffset(ctxt, ins.as, ins.imm)
+	wantImmI(ctxt, ins.as, ins.imm, 13)
+	wantNoneReg(ctxt, ins.as, "rd", ins.rd)
+	wantIntReg(ctxt, ins.as, "rs1", ins.rs1)
+	wantIntReg(ctxt, ins.as, "rs2", ins.rs2)
+}
+
+func validateU(ctxt *obj.Link, ins *instruction) {
+	wantImmI(ctxt, ins.as, ins.imm, 20)
+	wantIntReg(ctxt, ins.as, "rd", ins.rd)
+	wantNoneReg(ctxt, ins.as, "rs1", ins.rs1)
+	wantNoneReg(ctxt, ins.as, "rs2", ins.rs2)
+}
+
+func validateJ(ctxt *obj.Link, ins *instruction) {
+	// Offsets are multiples of two, so accept 21 bit immediates for the
+	// 20 bit slot. We implicitly drop the least significant bit in encodeJ.
+	wantEvenOffset(ctxt, ins.as, ins.imm)
+	wantImmI(ctxt, ins.as, ins.imm, 21)
+	wantIntReg(ctxt, ins.as, "rd", ins.rd)
+	wantNoneReg(ctxt, ins.as, "rs1", ins.rs1)
+	wantNoneReg(ctxt, ins.as, "rs2", ins.rs2)
+}
+
+func validateRaw(ctxt *obj.Link, ins *instruction) {
+	// Treat the raw value specially as a 32-bit unsigned integer.
+	// Nobody wants to enter negative machine code.
+	if ins.imm < 0 || 1<<32 <= ins.imm {
+		ctxt.Diag("%v\timmediate in raw position cannot be larger than 32 bits but got %d", ins.as, ins.imm)
+	}
+}
+
+// encodeR encodes an R-type RISC-V instruction.
+func encodeR(as obj.As, rs1, rs2, rd, funct3, funct7 uint32) uint32 {
+	enc := encode(as)
+	if enc == nil {
+		panic("encodeR: could not encode instruction")
+	}
+	if enc.rs2 != 0 && rs2 != 0 {
+		panic("encodeR: instruction uses rs2, but rs2 was nonzero")
+	}
+	return funct7<<25 | enc.funct7<<25 | enc.rs2<<20 | rs2<<20 | rs1<<15 | enc.funct3<<12 | funct3<<12 | rd<<7 | enc.opcode
+}
+
+func encodeRIII(ins *instruction) uint32 {
+	return encodeR(ins.as, regI(ins.rs1), regI(ins.rs2), regI(ins.rd), ins.funct3, ins.funct7)
+}
+
+func encodeRFFF(ins *instruction) uint32 {
+	return encodeR(ins.as, regF(ins.rs1), regF(ins.rs2), regF(ins.rd), ins.funct3, ins.funct7)
+}
+
+func encodeRFFI(ins *instruction) uint32 {
+	return encodeR(ins.as, regF(ins.rs1), regF(ins.rs2), regI(ins.rd), ins.funct3, ins.funct7)
+}
+
+func encodeRFI(ins *instruction) uint32 {
+	return encodeR(ins.as, regF(ins.rs2), 0, regI(ins.rd), ins.funct3, ins.funct7)
+}
+
+func encodeRIF(ins *instruction) uint32 {
+	return encodeR(ins.as, regI(ins.rs2), 0, regF(ins.rd), ins.funct3, ins.funct7)
+}
+
+func encodeRFF(ins *instruction) uint32 {
+	return encodeR(ins.as, regF(ins.rs2), 0, regF(ins.rd), ins.funct3, ins.funct7)
+}
+
+// encodeI encodes an I-type RISC-V instruction.
+func encodeI(as obj.As, rs1, rd, imm uint32) uint32 {
+	enc := encode(as)
+	if enc == nil {
+		panic("encodeI: could not encode instruction")
+	}
+	imm |= uint32(enc.csr)
+	return imm<<20 | rs1<<15 | enc.funct3<<12 | rd<<7 | enc.opcode
+}
+
+func encodeII(ins *instruction) uint32 {
+	return encodeI(ins.as, regI(ins.rs1), regI(ins.rd), uint32(ins.imm))
+}
+
+func encodeIF(ins *instruction) uint32 {
+	return encodeI(ins.as, regI(ins.rs1), regF(ins.rd), uint32(ins.imm))
+}
+
+// encodeS encodes an S-type RISC-V instruction.
+func encodeS(as obj.As, rs1, rs2, imm uint32) uint32 {
+	enc := encode(as)
+	if enc == nil {
+		panic("encodeS: could not encode instruction")
+	}
+	return (imm>>5)<<25 | rs2<<20 | rs1<<15 | enc.funct3<<12 | (imm&0x1f)<<7 | enc.opcode
+}
+
+func encodeSI(ins *instruction) uint32 {
+	return encodeS(ins.as, regI(ins.rd), regI(ins.rs1), uint32(ins.imm))
+}
+
+func encodeSF(ins *instruction) uint32 {
+	return encodeS(ins.as, regI(ins.rd), regF(ins.rs1), uint32(ins.imm))
+}
+
+// encodeB encodes a B-type RISC-V instruction.
+func encodeB(ins *instruction) uint32 {
+	imm := immI(ins.as, ins.imm, 13)
+	rs2 := regI(ins.rs1)
+	rs1 := regI(ins.rs2)
+	enc := encode(ins.as)
+	if enc == nil {
+		panic("encodeB: could not encode instruction")
+	}
+	return (imm>>12)<<31 | ((imm>>5)&0x3f)<<25 | rs2<<20 | rs1<<15 | enc.funct3<<12 | ((imm>>1)&0xf)<<8 | ((imm>>11)&0x1)<<7 | enc.opcode
+}
+
+// encodeU encodes a U-type RISC-V instruction.
+func encodeU(ins *instruction) uint32 {
+	// The immediates for encodeU are the upper 20 bits of a 32 bit value.
+	// Rather than have the user/compiler generate a 32 bit constant, the
+	// bottommost bits of which must all be zero, instead accept just the
+	// top bits.
+	imm := immI(ins.as, ins.imm, 20)
+	rd := regI(ins.rd)
+	enc := encode(ins.as)
+	if enc == nil {
+		panic("encodeU: could not encode instruction")
+	}
+	return imm<<12 | rd<<7 | enc.opcode
+}
+
+// encodeJ encodes a J-type RISC-V instruction.
+func encodeJ(ins *instruction) uint32 {
+	imm := immI(ins.as, ins.imm, 21)
+	rd := regI(ins.rd)
+	enc := encode(ins.as)
+	if enc == nil {
+		panic("encodeJ: could not encode instruction")
+	}
+	return (imm>>20)<<31 | ((imm>>1)&0x3ff)<<21 | ((imm>>11)&0x1)<<20 | ((imm>>12)&0xff)<<12 | rd<<7 | enc.opcode
+}
+
+func encodeRawIns(ins *instruction) uint32 {
+	// Treat the raw value specially as a 32-bit unsigned integer.
+	// Nobody wants to enter negative machine code.
+	if ins.imm < 0 || 1<<32 <= ins.imm {
+		panic(fmt.Sprintf("immediate %d cannot fit in 32 bits", ins.imm))
+	}
+	return uint32(ins.imm)
+}
+
+func EncodeIImmediate(imm int64) (int64, error) {
+	if !immIFits(imm, 12) {
+		return 0, fmt.Errorf("immediate %#x does not fit in 12 bits", imm)
+	}
+	return imm << 20, nil
+}
+
+func EncodeSImmediate(imm int64) (int64, error) {
+	if !immIFits(imm, 12) {
+		return 0, fmt.Errorf("immediate %#x does not fit in 12 bits", imm)
+	}
+	return ((imm >> 5) << 25) | ((imm & 0x1f) << 7), nil
+}
+
+func EncodeUImmediate(imm int64) (int64, error) {
+	if !immIFits(imm, 20) {
+		return 0, fmt.Errorf("immediate %#x does not fit in 20 bits", imm)
+	}
+	return imm << 12, nil
+}
+
+type encoding struct {
+	encode   func(*instruction) uint32     // encode returns the machine code for an instruction
+	validate func(*obj.Link, *instruction) // validate validates an instruction
+	length   int                           // length of encoded instruction; 0 for pseudo-ops, 4 otherwise
+}
+
+var (
+	// Encodings have the following naming convention:
+	//
+	//  1. the instruction encoding (R/I/S/B/U/J), in lowercase
+	//  2. zero or more register operand identifiers (I = integer
+	//     register, F = float register), in uppercase
+	//  3. the word "Encoding"
+	//
+	// For example, rIIIEncoding indicates an R-type instruction with two
+	// integer register inputs and an integer register output; sFEncoding
+	// indicates an S-type instruction with rs2 being a float register.
+
+	rIIIEncoding = encoding{encode: encodeRIII, validate: validateRIII, length: 4}
+	rFFFEncoding = encoding{encode: encodeRFFF, validate: validateRFFF, length: 4}
+	rFFIEncoding = encoding{encode: encodeRFFI, validate: validateRFFI, length: 4}
+	rFIEncoding  = encoding{encode: encodeRFI, validate: validateRFI, length: 4}
+	rIFEncoding  = encoding{encode: encodeRIF, validate: validateRIF, length: 4}
+	rFFEncoding  = encoding{encode: encodeRFF, validate: validateRFF, length: 4}
+
+	iIEncoding = encoding{encode: encodeII, validate: validateII, length: 4}
+	iFEncoding = encoding{encode: encodeIF, validate: validateIF, length: 4}
+
+	sIEncoding = encoding{encode: encodeSI, validate: validateSI, length: 4}
+	sFEncoding = encoding{encode: encodeSF, validate: validateSF, length: 4}
+
+	bEncoding = encoding{encode: encodeB, validate: validateB, length: 4}
+	uEncoding = encoding{encode: encodeU, validate: validateU, length: 4}
+	jEncoding = encoding{encode: encodeJ, validate: validateJ, length: 4}
+
+	// rawEncoding encodes a raw instruction byte sequence.
+	rawEncoding = encoding{encode: encodeRawIns, validate: validateRaw, length: 4}
+
+	// pseudoOpEncoding panics if encoding is attempted, but does no validation.
+	pseudoOpEncoding = encoding{encode: nil, validate: func(*obj.Link, *instruction) {}, length: 0}
+
+	// badEncoding is used when an invalid op is encountered.
+	// An error has already been generated, so let anything else through.
+	badEncoding = encoding{encode: func(*instruction) uint32 { return 0 }, validate: func(*obj.Link, *instruction) {}, length: 0}
+)
+
+// encodings contains the encodings for RISC-V instructions.
+// Instructions are masked with obj.AMask to keep indices small.
+var encodings = [ALAST & obj.AMask]encoding{
+
+	// Unprivileged ISA
+
+	// 2.4: Integer Computational Instructions
+	AADDI & obj.AMask:  iIEncoding,
+	ASLTI & obj.AMask:  iIEncoding,
+	ASLTIU & obj.AMask: iIEncoding,
+	AANDI & obj.AMask:  iIEncoding,
+	AORI & obj.AMask:   iIEncoding,
+	AXORI & obj.AMask:  iIEncoding,
+	ASLLI & obj.AMask:  iIEncoding,
+	ASRLI & obj.AMask:  iIEncoding,
+	ASRAI & obj.AMask:  iIEncoding,
+	ALUI & obj.AMask:   uEncoding,
+	AAUIPC & obj.AMask: uEncoding,
+	AADD & obj.AMask:   rIIIEncoding,
+	ASLT & obj.AMask:   rIIIEncoding,
+	ASLTU & obj.AMask:  rIIIEncoding,
+	AAND & obj.AMask:   rIIIEncoding,
+	AOR & obj.AMask:    rIIIEncoding,
+	AXOR & obj.AMask:   rIIIEncoding,
+	ASLL & obj.AMask:   rIIIEncoding,
+	ASRL & obj.AMask:   rIIIEncoding,
+	ASUB & obj.AMask:   rIIIEncoding,
+	ASRA & obj.AMask:   rIIIEncoding,
+
+	// 2.5: Control Transfer Instructions
+	AJAL & obj.AMask:  jEncoding,
+	AJALR & obj.AMask: iIEncoding,
+	ABEQ & obj.AMask:  bEncoding,
+	ABNE & obj.AMask:  bEncoding,
+	ABLT & obj.AMask:  bEncoding,
+	ABLTU & obj.AMask: bEncoding,
+	ABGE & obj.AMask:  bEncoding,
+	ABGEU & obj.AMask: bEncoding,
+
+	// 2.6: Load and Store Instructions
+	ALW & obj.AMask:  iIEncoding,
+	ALWU & obj.AMask: iIEncoding,
+	ALH & obj.AMask:  iIEncoding,
+	ALHU & obj.AMask: iIEncoding,
+	ALB & obj.AMask:  iIEncoding,
+	ALBU & obj.AMask: iIEncoding,
+	ASW & obj.AMask:  sIEncoding,
+	ASH & obj.AMask:  sIEncoding,
+	ASB & obj.AMask:  sIEncoding,
+
+	// 2.7: Memory Ordering
+	AFENCE & obj.AMask: iIEncoding,
+
+	// 5.2: Integer Computational Instructions (RV64I)
+	AADDIW & obj.AMask: iIEncoding,
+	ASLLIW & obj.AMask: iIEncoding,
+	ASRLIW & obj.AMask: iIEncoding,
+	ASRAIW & obj.AMask: iIEncoding,
+	AADDW & obj.AMask:  rIIIEncoding,
+	ASLLW & obj.AMask:  rIIIEncoding,
+	ASRLW & obj.AMask:  rIIIEncoding,
+	ASUBW & obj.AMask:  rIIIEncoding,
+	ASRAW & obj.AMask:  rIIIEncoding,
+
+	// 5.3: Load and Store Instructions (RV64I)
+	ALD & obj.AMask: iIEncoding,
+	ASD & obj.AMask: sIEncoding,
+
+	// 7.1: Multiplication Operations
+	AMUL & obj.AMask:    rIIIEncoding,
+	AMULH & obj.AMask:   rIIIEncoding,
+	AMULHU & obj.AMask:  rIIIEncoding,
+	AMULHSU & obj.AMask: rIIIEncoding,
+	AMULW & obj.AMask:   rIIIEncoding,
+	ADIV & obj.AMask:    rIIIEncoding,
+	ADIVU & obj.AMask:   rIIIEncoding,
+	AREM & obj.AMask:    rIIIEncoding,
+	AREMU & obj.AMask:   rIIIEncoding,
+	ADIVW & obj.AMask:   rIIIEncoding,
+	ADIVUW & obj.AMask:  rIIIEncoding,
+	AREMW & obj.AMask:   rIIIEncoding,
+	AREMUW & obj.AMask:  rIIIEncoding,
+
+	// 8.2: Load-Reserved/Store-Conditional
+	ALRW & obj.AMask: rIIIEncoding,
+	ALRD & obj.AMask: rIIIEncoding,
+	ASCW & obj.AMask: rIIIEncoding,
+	ASCD & obj.AMask: rIIIEncoding,
+
+	// 8.3: Atomic Memory Operations
+	AAMOSWAPW & obj.AMask: rIIIEncoding,
+	AAMOSWAPD & obj.AMask: rIIIEncoding,
+	AAMOADDW & obj.AMask:  rIIIEncoding,
+	AAMOADDD & obj.AMask:  rIIIEncoding,
+	AAMOANDW & obj.AMask:  rIIIEncoding,
+	AAMOANDD & obj.AMask:  rIIIEncoding,
+	AAMOORW & obj.AMask:   rIIIEncoding,
+	AAMOORD & obj.AMask:   rIIIEncoding,
+	AAMOXORW & obj.AMask:  rIIIEncoding,
+	AAMOXORD & obj.AMask:  rIIIEncoding,
+	AAMOMAXW & obj.AMask:  rIIIEncoding,
+	AAMOMAXD & obj.AMask:  rIIIEncoding,
+	AAMOMAXUW & obj.AMask: rIIIEncoding,
+	AAMOMAXUD & obj.AMask: rIIIEncoding,
+	AAMOMINW & obj.AMask:  rIIIEncoding,
+	AAMOMIND & obj.AMask:  rIIIEncoding,
+	AAMOMINUW & obj.AMask: rIIIEncoding,
+	AAMOMINUD & obj.AMask: rIIIEncoding,
+
+	// 10.1: Base Counters and Timers
+	ARDCYCLE & obj.AMask:   iIEncoding,
+	ARDTIME & obj.AMask:    iIEncoding,
+	ARDINSTRET & obj.AMask: iIEncoding,
+
+	// 11.5: Single-Precision Load and Store Instructions
+	AFLW & obj.AMask: iFEncoding,
+	AFSW & obj.AMask: sFEncoding,
+
+	// 11.6: Single-Precision Floating-Point Computational Instructions
+	AFADDS & obj.AMask:  rFFFEncoding,
+	AFSUBS & obj.AMask:  rFFFEncoding,
+	AFMULS & obj.AMask:  rFFFEncoding,
+	AFDIVS & obj.AMask:  rFFFEncoding,
+	AFMINS & obj.AMask:  rFFFEncoding,
+	AFMAXS & obj.AMask:  rFFFEncoding,
+	AFSQRTS & obj.AMask: rFFFEncoding,
+
+	// 11.7: Single-Precision Floating-Point Conversion and Move Instructions
+	AFCVTWS & obj.AMask:  rFIEncoding,
+	AFCVTLS & obj.AMask:  rFIEncoding,
+	AFCVTSW & obj.AMask:  rIFEncoding,
+	AFCVTSL & obj.AMask:  rIFEncoding,
+	AFCVTWUS & obj.AMask: rFIEncoding,
+	AFCVTLUS & obj.AMask: rFIEncoding,
+	AFCVTSWU & obj.AMask: rIFEncoding,
+	AFCVTSLU & obj.AMask: rIFEncoding,
+	AFSGNJS & obj.AMask:  rFFFEncoding,
+	AFSGNJNS & obj.AMask: rFFFEncoding,
+	AFSGNJXS & obj.AMask: rFFFEncoding,
+	AFMVXS & obj.AMask:   rFIEncoding,
+	AFMVSX & obj.AMask:   rIFEncoding,
+	AFMVXW & obj.AMask:   rFIEncoding,
+	AFMVWX & obj.AMask:   rIFEncoding,
+
+	// 11.8: Single-Precision Floating-Point Compare Instructions
+	AFEQS & obj.AMask: rFFIEncoding,
+	AFLTS & obj.AMask: rFFIEncoding,
+	AFLES & obj.AMask: rFFIEncoding,
+
+	// 11.9: Single-Precision Floating-Point Classify Instruction
+	AFCLASSS & obj.AMask: rFIEncoding,
+
+	// 12.3: Double-Precision Load and Store Instructions
+	AFLD & obj.AMask: iFEncoding,
+	AFSD & obj.AMask: sFEncoding,
+
+	// 12.4: Double-Precision Floating-Point Computational Instructions
+	AFADDD & obj.AMask:  rFFFEncoding,
+	AFSUBD & obj.AMask:  rFFFEncoding,
+	AFMULD & obj.AMask:  rFFFEncoding,
+	AFDIVD & obj.AMask:  rFFFEncoding,
+	AFMIND & obj.AMask:  rFFFEncoding,
+	AFMAXD & obj.AMask:  rFFFEncoding,
+	AFSQRTD & obj.AMask: rFFFEncoding,
+
+	// 12.5: Double-Precision Floating-Point Conversion and Move Instructions
+	AFCVTWD & obj.AMask:  rFIEncoding,
+	AFCVTLD & obj.AMask:  rFIEncoding,
+	AFCVTDW & obj.AMask:  rIFEncoding,
+	AFCVTDL & obj.AMask:  rIFEncoding,
+	AFCVTWUD & obj.AMask: rFIEncoding,
+	AFCVTLUD & obj.AMask: rFIEncoding,
+	AFCVTDWU & obj.AMask: rIFEncoding,
+	AFCVTDLU & obj.AMask: rIFEncoding,
+	AFCVTSD & obj.AMask:  rFFEncoding,
+	AFCVTDS & obj.AMask:  rFFEncoding,
+	AFSGNJD & obj.AMask:  rFFFEncoding,
+	AFSGNJND & obj.AMask: rFFFEncoding,
+	AFSGNJXD & obj.AMask: rFFFEncoding,
+	AFMVXD & obj.AMask:   rFIEncoding,
+	AFMVDX & obj.AMask:   rIFEncoding,
+
+	// 12.6: Double-Precision Floating-Point Compare Instructions
+	AFEQD & obj.AMask: rFFIEncoding,
+	AFLTD & obj.AMask: rFFIEncoding,
+	AFLED & obj.AMask: rFFIEncoding,
+
+	// 12.7: Double-Precision Floating-Point Classify Instruction
+	AFCLASSD & obj.AMask: rFIEncoding,
+
+	// Privileged ISA
+
+	// 3.2.1: Environment Call and Breakpoint
+	AECALL & obj.AMask:  iIEncoding,
+	AEBREAK & obj.AMask: iIEncoding,
+
+	// Escape hatch
+	AWORD & obj.AMask: rawEncoding,
+
+	// Pseudo-operations
+	obj.AFUNCDATA: pseudoOpEncoding,
+	obj.APCDATA:   pseudoOpEncoding,
+	obj.ATEXT:     pseudoOpEncoding,
+	obj.ANOP:      pseudoOpEncoding,
+}
+
+// encodingForAs returns the encoding for an obj.As.
+func encodingForAs(as obj.As) (encoding, error) {
+	if base := as &^ obj.AMask; base != obj.ABaseRISCV && base != 0 {
+		return badEncoding, fmt.Errorf("encodingForAs: not a RISC-V instruction %s", as)
+	}
+	asi := as & obj.AMask
+	if int(asi) >= len(encodings) {
+		return badEncoding, fmt.Errorf("encodingForAs: bad RISC-V instruction %s", as)
+	}
+	enc := encodings[asi]
+	if enc.validate == nil {
+		return badEncoding, fmt.Errorf("encodingForAs: no encoding for instruction %s", as)
+	}
+	return enc, nil
+}
+
+type instruction struct {
+	as     obj.As // Assembler opcode
+	rd     uint32 // Destination register
+	rs1    uint32 // Source register 1
+	rs2    uint32 // Source register 2
+	imm    int64  // Immediate
+	funct3 uint32 // Function 3
+	funct7 uint32 // Function 7
+}
+
+func (ins *instruction) encode() (uint32, error) {
+	enc, err := encodingForAs(ins.as)
+	if err != nil {
+		return 0, err
+	}
+	if enc.length > 0 {
+		return enc.encode(ins), nil
+	}
+	return 0, fmt.Errorf("fixme")
+}
+
+func (ins *instruction) length() int {
+	enc, err := encodingForAs(ins.as)
+	if err != nil {
+		return 0
+	}
+	return enc.length
+}
+
+func (ins *instruction) validate(ctxt *obj.Link) {
+	enc, err := encodingForAs(ins.as)
+	if err != nil {
+		ctxt.Diag(err.Error())
+		return
+	}
+	enc.validate(ctxt, ins)
+}
+
+// instructionsForProg returns the machine instructions for an *obj.Prog.
+func instructionsForProg(p *obj.Prog) []*instruction {
+	ins := &instruction{
+		as:  p.As,
+		rd:  uint32(p.To.Reg),
+		rs1: uint32(p.Reg),
+		rs2: uint32(p.From.Reg),
+		imm: p.From.Offset,
+	}
+
+	inss := []*instruction{ins}
+	switch ins.as {
+	case AJAL, AJALR:
+		ins.rd, ins.rs1, ins.rs2 = uint32(p.From.Reg), uint32(p.To.Reg), obj.REG_NONE
+		ins.imm = p.To.Offset
+
+	case ABEQ, ABEQZ, ABGE, ABGEU, ABGEZ, ABGT, ABGTU, ABGTZ, ABLE, ABLEU, ABLEZ, ABLT, ABLTU, ABLTZ, ABNE, ABNEZ:
+		switch ins.as {
+		case ABEQZ:
+			ins.as, ins.rs1, ins.rs2 = ABEQ, REG_ZERO, uint32(p.From.Reg)
+		case ABGEZ:
+			ins.as, ins.rs1, ins.rs2 = ABGE, REG_ZERO, uint32(p.From.Reg)
+		case ABGT:
+			ins.as, ins.rs1, ins.rs2 = ABLT, uint32(p.Reg), uint32(p.From.Reg)
+		case ABGTU:
+			ins.as, ins.rs1, ins.rs2 = ABLTU, uint32(p.Reg), uint32(p.From.Reg)
+		case ABGTZ:
+			ins.as, ins.rs1, ins.rs2 = ABLT, uint32(p.From.Reg), REG_ZERO
+		case ABLE:
+			ins.as, ins.rs1, ins.rs2 = ABGE, uint32(p.Reg), uint32(p.From.Reg)
+		case ABLEU:
+			ins.as, ins.rs1, ins.rs2 = ABGEU, uint32(p.Reg), uint32(p.From.Reg)
+		case ABLEZ:
+			ins.as, ins.rs1, ins.rs2 = ABGE, uint32(p.From.Reg), REG_ZERO
+		case ABLTZ:
+			ins.as, ins.rs1, ins.rs2 = ABLT, REG_ZERO, uint32(p.From.Reg)
+		case ABNEZ:
+			ins.as, ins.rs1, ins.rs2 = ABNE, REG_ZERO, uint32(p.From.Reg)
+		}
+		ins.imm = p.To.Offset
+
+	case ALW, ALWU, ALH, ALHU, ALB, ALBU, ALD, AFLW, AFLD:
+		if p.From.Type != obj.TYPE_MEM {
+			p.Ctxt.Diag("%v requires memory for source", p)
+			return nil
+		}
+		ins.rs1, ins.rs2 = uint32(p.From.Reg), obj.REG_NONE
+		ins.imm = p.From.Offset
+
+	case ASW, ASH, ASB, ASD, AFSW, AFSD:
+		if p.To.Type != obj.TYPE_MEM {
+			p.Ctxt.Diag("%v requires memory for destination", p)
+			return nil
+		}
+		ins.rs1, ins.rs2 = uint32(p.From.Reg), obj.REG_NONE
+		ins.imm = p.To.Offset
+
+	case ALRW, ALRD:
+		// Set aq to use acquire access ordering, which matches Go's memory requirements.
+		ins.funct7 = 2
+		ins.rs1, ins.rs2 = uint32(p.From.Reg), REG_ZERO
+
+	case ASCW, ASCD, AAMOSWAPW, AAMOSWAPD, AAMOADDW, AAMOADDD, AAMOANDW, AAMOANDD, AAMOORW, AAMOORD,
+		AAMOXORW, AAMOXORD, AAMOMINW, AAMOMIND, AAMOMINUW, AAMOMINUD, AAMOMAXW, AAMOMAXD, AAMOMAXUW, AAMOMAXUD:
+		// Set aq to use acquire access ordering, which matches Go's memory requirements.
+		ins.funct7 = 2
+		ins.rd, ins.rs1, ins.rs2 = uint32(p.RegTo2), uint32(p.To.Reg), uint32(p.From.Reg)
+
+	case AECALL, AEBREAK, ARDCYCLE, ARDTIME, ARDINSTRET:
+		insEnc := encode(p.As)
+		if p.To.Type == obj.TYPE_NONE {
+			ins.rd = REG_ZERO
+		}
+		ins.rs1 = REG_ZERO
+		ins.imm = insEnc.csr
+
+	case AFENCE:
+		ins.rd, ins.rs1, ins.rs2 = REG_ZERO, REG_ZERO, obj.REG_NONE
+		ins.imm = 0x0ff
+
+	case AFCVTWS, AFCVTLS, AFCVTWUS, AFCVTLUS, AFCVTWD, AFCVTLD, AFCVTWUD, AFCVTLUD:
+		// Set the rounding mode in funct3 to round to zero.
+		ins.funct3 = 1
+
+	case AFNES, AFNED:
+		// Replace FNE[SD] with FEQ[SD] and NOT.
+		if p.To.Type != obj.TYPE_REG {
+			p.Ctxt.Diag("%v needs an integer register output", ins.as)
+			return nil
+		}
+		if ins.as == AFNES {
+			ins.as = AFEQS
+		} else {
+			ins.as = AFEQD
+		}
+		ins = &instruction{
+			as:  AXORI, // [bit] xor 1 = not [bit]
+			rd:  ins.rd,
+			rs1: ins.rd,
+			imm: 1,
+		}
+		inss = append(inss, ins)
+
+	case AFSQRTS, AFSQRTD:
+		// These instructions expect a zero (i.e. float register 0)
+		// to be the second input operand.
+		ins.rs1 = uint32(p.From.Reg)
+		ins.rs2 = REG_F0
+
+	case ANEG, ANEGW:
+		// NEG rs, rd -> SUB rs, X0, rd
+		ins.as = ASUB
+		if p.As == ANEGW {
+			ins.as = ASUBW
+		}
+		ins.rs1 = REG_ZERO
+		if ins.rd == obj.REG_NONE {
+			ins.rd = ins.rs2
+		}
+
+	case ANOT:
+		// NOT rs, rd -> XORI $-1, rs, rd
+		ins.as = AXORI
+		ins.rs1, ins.rs2 = uint32(p.From.Reg), obj.REG_NONE
+		if ins.rd == obj.REG_NONE {
+			ins.rd = ins.rs1
+		}
+		ins.imm = -1
+
+	case ASEQZ:
+		// SEQZ rs, rd -> SLTIU $1, rs, rd
+		ins.as = ASLTIU
+		ins.rs1 = uint32(p.From.Reg)
+		ins.imm = 1
+
+	case ASNEZ:
+		// SNEZ rs, rd -> SLTU rs, x0, rd
+		ins.as = ASLTU
+		ins.rs1 = REG_ZERO
+
+	case AFNEGS:
+		// FNEGS rs, rd -> FSGNJNS rs, rs, rd
+		ins.as = AFSGNJNS
+		ins.rs1 = uint32(p.From.Reg)
+
+	case AFNEGD:
+		// FNEGD rs, rd -> FSGNJND rs, rs, rd
+		ins.as = AFSGNJND
+		ins.rs1 = uint32(p.From.Reg)
+	}
+	return inss
+}
+
+// assemble emits machine code.
+// It is called at the very end of the assembly process.
+func assemble(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
+	if ctxt.Retpoline {
+		ctxt.Diag("-spectre=ret not supported on riscv")
+		ctxt.Retpoline = false // don't keep printing
+	}
+
+	var symcode []uint32
+	for p := cursym.Func.Text; p != nil; p = p.Link {
+		switch p.As {
+		case AJALR:
+			if p.To.Sym != nil {
+				// This is a CALL/JMP. We add a relocation only
+				// for linker stack checking. No actual
+				// relocation is needed.
+				rel := obj.Addrel(cursym)
+				rel.Off = int32(p.Pc)
+				rel.Siz = 4
+				rel.Sym = p.To.Sym
+				rel.Add = p.To.Offset
+				rel.Type = objabi.R_CALLRISCV
+			}
+		case AAUIPC:
+			var rt objabi.RelocType
+			if p.Mark&NEED_PCREL_ITYPE_RELOC == NEED_PCREL_ITYPE_RELOC {
+				rt = objabi.R_RISCV_PCREL_ITYPE
+			} else if p.Mark&NEED_PCREL_STYPE_RELOC == NEED_PCREL_STYPE_RELOC {
+				rt = objabi.R_RISCV_PCREL_STYPE
+			} else {
+				break
+			}
+			if p.Link == nil {
+				ctxt.Diag("AUIPC needing PC-relative reloc missing following instruction")
+				break
+			}
+			addr := p.RestArgs[0]
+			if addr.Sym == nil {
+				ctxt.Diag("AUIPC needing PC-relative reloc missing symbol")
+				break
+			}
+
+			rel := obj.Addrel(cursym)
+			rel.Off = int32(p.Pc)
+			rel.Siz = 8
+			rel.Sym = addr.Sym
+			rel.Add = addr.Offset
+			rel.Type = rt
+		}
+
+		for _, ins := range instructionsForProg(p) {
+			ic, err := ins.encode()
+			if err == nil {
+				symcode = append(symcode, ic)
+			}
+		}
+	}
+	cursym.Size = int64(4 * len(symcode))
+
+	cursym.Grow(cursym.Size)
+	for p, i := cursym.P, 0; i < len(symcode); p, i = p[4:], i+1 {
+		ctxt.Arch.ByteOrder.PutUint32(p, symcode[i])
+	}
+
+	obj.MarkUnsafePoints(ctxt, cursym.Func.Text, newprog, isUnsafePoint, nil)
+}
+
+func isUnsafePoint(p *obj.Prog) bool {
+	return p.From.Reg == REG_TMP || p.To.Reg == REG_TMP || p.Reg == REG_TMP
+}
+
+var LinkRISCV64 = obj.LinkArch{
+	Arch:           sys.ArchRISCV64,
+	Init:           buildop,
+	Preprocess:     preprocess,
+	Assemble:       assemble,
+	Progedit:       progedit,
+	UnaryDst:       unaryDst,
+	DWARFRegisters: RISCV64DWARFRegisters,
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/a.out.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/a.out.go
new file mode 100644
index 000000000..0fb28b291
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/a.out.go
@@ -0,0 +1,1003 @@
+// Based on cmd/internal/obj/ppc64/a.out.go.
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2008 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package s390x
+
+import "github.com/twitchyliquid64/golang-asm/obj"
+
+//go:generate go run ../stringer.go -i $GOFILE -o anames.go -p s390x
+
+const (
+	NSNAME = 8
+	NSYM   = 50
+	NREG   = 16 // number of general purpose registers
+	NFREG  = 16 // number of floating point registers
+)
+
+const (
+	// General purpose registers (GPRs).
+	REG_R0 = obj.RBaseS390X + iota
+	REG_R1
+	REG_R2
+	REG_R3
+	REG_R4
+	REG_R5
+	REG_R6
+	REG_R7
+	REG_R8
+	REG_R9
+	REG_R10
+	REG_R11
+	REG_R12
+	REG_R13
+	REG_R14
+	REG_R15
+
+	// Floating point registers (FPRs).
+	REG_F0
+	REG_F1
+	REG_F2
+	REG_F3
+	REG_F4
+	REG_F5
+	REG_F6
+	REG_F7
+	REG_F8
+	REG_F9
+	REG_F10
+	REG_F11
+	REG_F12
+	REG_F13
+	REG_F14
+	REG_F15
+
+	// Vector registers (VRs) - only available when the vector
+	// facility is installed.
+	// V0-V15 are aliases for F0-F15.
+	// We keep them in a separate space to make printing etc. easier
+	// If the code generator ever emits vector instructions it will
+	// need to take into account the aliasing.
+	REG_V0
+	REG_V1
+	REG_V2
+	REG_V3
+	REG_V4
+	REG_V5
+	REG_V6
+	REG_V7
+	REG_V8
+	REG_V9
+	REG_V10
+	REG_V11
+	REG_V12
+	REG_V13
+	REG_V14
+	REG_V15
+	REG_V16
+	REG_V17
+	REG_V18
+	REG_V19
+	REG_V20
+	REG_V21
+	REG_V22
+	REG_V23
+	REG_V24
+	REG_V25
+	REG_V26
+	REG_V27
+	REG_V28
+	REG_V29
+	REG_V30
+	REG_V31
+
+	// Access registers (ARs).
+	// The thread pointer is typically stored in the register pair
+	// AR0 and AR1.
+	REG_AR0
+	REG_AR1
+	REG_AR2
+	REG_AR3
+	REG_AR4
+	REG_AR5
+	REG_AR6
+	REG_AR7
+	REG_AR8
+	REG_AR9
+	REG_AR10
+	REG_AR11
+	REG_AR12
+	REG_AR13
+	REG_AR14
+	REG_AR15
+
+	REG_RESERVED // end of allocated registers
+
+	REGARG  = -1      // -1 disables passing the first argument in register
+	REGRT1  = REG_R3  // used during zeroing of the stack - not reserved
+	REGRT2  = REG_R4  // used during zeroing of the stack - not reserved
+	REGTMP  = REG_R10 // scratch register used in the assembler and linker
+	REGTMP2 = REG_R11 // scratch register used in the assembler and linker
+	REGCTXT = REG_R12 // context for closures
+	REGG    = REG_R13 // G
+	REG_LR  = REG_R14 // link register
+	REGSP   = REG_R15 // stack pointer
+)
+
+// LINUX for zSeries ELF Application Binary Interface Supplement
+// https://refspecs.linuxfoundation.org/ELF/zSeries/lzsabi0_zSeries/x1472.html
+var S390XDWARFRegisters = map[int16]int16{}
+
+func init() {
+	// f assigns dwarfregisters[from:to by step] = (base):((to-from)/step+base)
+	f := func(from, step, to, base int16) {
+		for r := int16(from); r <= to; r += step {
+			S390XDWARFRegisters[r] = (r-from)/step + base
+		}
+	}
+	f(REG_R0, 1, REG_R15, 0)
+
+	f(REG_F0, 2, REG_F6, 16)
+	f(REG_F1, 2, REG_F7, 20)
+	f(REG_F8, 2, REG_F14, 24)
+	f(REG_F9, 2, REG_F15, 28)
+
+	f(REG_V0, 2, REG_V6, 16) // V0:15 aliased to F0:15
+	f(REG_V1, 2, REG_V7, 20) // TODO what about V16:31?
+	f(REG_V8, 2, REG_V14, 24)
+	f(REG_V9, 2, REG_V15, 28)
+
+	f(REG_AR0, 1, REG_AR15, 48)
+}
+
+const (
+	BIG    = 32768 - 8
+	DISP12 = 4096
+	DISP16 = 65536
+	DISP20 = 1048576
+)
+
+const (
+	// mark flags
+	LEAF = 1 << iota
+	BRANCH
+	USETMP // generated code of this Prog uses REGTMP
+)
+
+const ( // comments from func aclass in asmz.go
+	C_NONE     = iota
+	C_REG      // general-purpose register (64-bit)
+	C_FREG     // floating-point register (64-bit)
+	C_VREG     // vector register (128-bit)
+	C_AREG     // access register (32-bit)
+	C_ZCON     // constant == 0
+	C_SCON     // 0 <= constant <= 0x7fff (positive int16)
+	C_UCON     // constant & 0xffff == 0 (int16 or uint16)
+	C_ADDCON   // 0 > constant >= -0x8000 (negative int16)
+	C_ANDCON   // constant <= 0xffff
+	C_LCON     // constant (int32 or uint32)
+	C_DCON     // constant (int64 or uint64)
+	C_SACON    // computed address, 16-bit displacement, possibly SP-relative
+	C_LACON    // computed address, 32-bit displacement, possibly SP-relative
+	C_DACON    // computed address, 64-bit displacment?
+	C_SBRA     // short branch
+	C_LBRA     // long branch
+	C_SAUTO    // short auto
+	C_LAUTO    // long auto
+	C_ZOREG    // heap address, register-based, displacement == 0
+	C_SOREG    // heap address, register-based, int16 displacement
+	C_LOREG    // heap address, register-based, int32 displacement
+	C_TLS_LE   // TLS - local exec model (for executables)
+	C_TLS_IE   // TLS - initial exec model (for shared libraries loaded at program startup)
+	C_GOK      // general address
+	C_ADDR     // relocation for extern or static symbols (loads and stores)
+	C_SYMADDR  // relocation for extern or static symbols (address taking)
+	C_GOTADDR  // GOT slot for a symbol in -dynlink mode
+	C_TEXTSIZE // text size
+	C_ANY
+	C_NCLASS // must be the last
+)
+
+const (
+	// integer arithmetic
+	AADD = obj.ABaseS390X + obj.A_ARCHSPECIFIC + iota
+	AADDC
+	AADDE
+	AADDW
+	ADIVW
+	ADIVWU
+	ADIVD
+	ADIVDU
+	AMODW
+	AMODWU
+	AMODD
+	AMODDU
+	AMULLW
+	AMULLD
+	AMULHD
+	AMULHDU
+	AMLGR
+	ASUB
+	ASUBC
+	ASUBV
+	ASUBE
+	ASUBW
+	ANEG
+	ANEGW
+
+	// integer moves
+	AMOVWBR
+	AMOVB
+	AMOVBZ
+	AMOVH
+	AMOVHBR
+	AMOVHZ
+	AMOVW
+	AMOVWZ
+	AMOVD
+	AMOVDBR
+
+	// conditional moves
+	AMOVDEQ
+	AMOVDGE
+	AMOVDGT
+	AMOVDLE
+	AMOVDLT
+	AMOVDNE
+	ALOCR
+	ALOCGR
+
+	// find leftmost one
+	AFLOGR
+
+	// population count
+	APOPCNT
+
+	// integer bitwise
+	AAND
+	AANDW
+	AOR
+	AORW
+	AXOR
+	AXORW
+	ASLW
+	ASLD
+	ASRW
+	ASRAW
+	ASRD
+	ASRAD
+	ARLL
+	ARLLG
+	ARNSBG
+	ARXSBG
+	AROSBG
+	ARNSBGT
+	ARXSBGT
+	AROSBGT
+	ARISBG
+	ARISBGN
+	ARISBGZ
+	ARISBGNZ
+	ARISBHG
+	ARISBLG
+	ARISBHGZ
+	ARISBLGZ
+
+	// floating point
+	AFABS
+	AFADD
+	AFADDS
+	AFCMPO
+	AFCMPU
+	ACEBR
+	AFDIV
+	AFDIVS
+	AFMADD
+	AFMADDS
+	AFMOVD
+	AFMOVS
+	AFMSUB
+	AFMSUBS
+	AFMUL
+	AFMULS
+	AFNABS
+	AFNEG
+	AFNEGS
+	ALEDBR
+	ALDEBR
+	ALPDFR
+	ALNDFR
+	AFSUB
+	AFSUBS
+	AFSQRT
+	AFSQRTS
+	AFIEBR
+	AFIDBR
+	ACPSDR
+	ALTEBR
+	ALTDBR
+	ATCEB
+	ATCDB
+
+	// move from GPR to FPR and vice versa
+	ALDGR
+	ALGDR
+
+	// convert from int32/int64 to float/float64
+	ACEFBRA
+	ACDFBRA
+	ACEGBRA
+	ACDGBRA
+
+	// convert from float/float64 to int32/int64
+	ACFEBRA
+	ACFDBRA
+	ACGEBRA
+	ACGDBRA
+
+	// convert from uint32/uint64 to float/float64
+	ACELFBR
+	ACDLFBR
+	ACELGBR
+	ACDLGBR
+
+	// convert from float/float64 to uint32/uint64
+	ACLFEBR
+	ACLFDBR
+	ACLGEBR
+	ACLGDBR
+
+	// compare
+	ACMP
+	ACMPU
+	ACMPW
+	ACMPWU
+
+	// test under mask
+	ATMHH
+	ATMHL
+	ATMLH
+	ATMLL
+
+	// insert program mask
+	AIPM
+
+	// set program mask
+	ASPM
+
+	// compare and swap
+	ACS
+	ACSG
+
+	// serialize
+	ASYNC
+
+	// branch
+	ABC
+	ABCL
+	ABRC
+	ABEQ
+	ABGE
+	ABGT
+	ABLE
+	ABLT
+	ABLEU
+	ABLTU
+	ABNE
+	ABVC
+	ABVS
+	ASYSCALL
+
+	// branch on count
+	ABRCT
+	ABRCTG
+
+	// compare and branch
+	ACRJ
+	ACGRJ
+	ACLRJ
+	ACLGRJ
+	ACIJ
+	ACGIJ
+	ACLIJ
+	ACLGIJ
+	ACMPBEQ
+	ACMPBGE
+	ACMPBGT
+	ACMPBLE
+	ACMPBLT
+	ACMPBNE
+	ACMPUBEQ
+	ACMPUBGE
+	ACMPUBGT
+	ACMPUBLE
+	ACMPUBLT
+	ACMPUBNE
+
+	// storage-and-storage
+	AMVC
+	AMVCIN
+	ACLC
+	AXC
+	AOC
+	ANC
+
+	// load
+	AEXRL
+	ALARL
+	ALA
+	ALAY
+
+	// interlocked load and op
+	ALAA
+	ALAAG
+	ALAAL
+	ALAALG
+	ALAN
+	ALANG
+	ALAX
+	ALAXG
+	ALAO
+	ALAOG
+
+	// load/store multiple
+	ALMY
+	ALMG
+	ASTMY
+	ASTMG
+
+	// store clock
+	ASTCK
+	ASTCKC
+	ASTCKE
+	ASTCKF
+
+	// macros
+	ACLEAR
+
+	// vector
+	AVA
+	AVAB
+	AVAH
+	AVAF
+	AVAG
+	AVAQ
+	AVACC
+	AVACCB
+	AVACCH
+	AVACCF
+	AVACCG
+	AVACCQ
+	AVAC
+	AVACQ
+	AVACCC
+	AVACCCQ
+	AVN
+	AVNC
+	AVAVG
+	AVAVGB
+	AVAVGH
+	AVAVGF
+	AVAVGG
+	AVAVGL
+	AVAVGLB
+	AVAVGLH
+	AVAVGLF
+	AVAVGLG
+	AVCKSM
+	AVCEQ
+	AVCEQB
+	AVCEQH
+	AVCEQF
+	AVCEQG
+	AVCEQBS
+	AVCEQHS
+	AVCEQFS
+	AVCEQGS
+	AVCH
+	AVCHB
+	AVCHH
+	AVCHF
+	AVCHG
+	AVCHBS
+	AVCHHS
+	AVCHFS
+	AVCHGS
+	AVCHL
+	AVCHLB
+	AVCHLH
+	AVCHLF
+	AVCHLG
+	AVCHLBS
+	AVCHLHS
+	AVCHLFS
+	AVCHLGS
+	AVCLZ
+	AVCLZB
+	AVCLZH
+	AVCLZF
+	AVCLZG
+	AVCTZ
+	AVCTZB
+	AVCTZH
+	AVCTZF
+	AVCTZG
+	AVEC
+	AVECB
+	AVECH
+	AVECF
+	AVECG
+	AVECL
+	AVECLB
+	AVECLH
+	AVECLF
+	AVECLG
+	AVERIM
+	AVERIMB
+	AVERIMH
+	AVERIMF
+	AVERIMG
+	AVERLL
+	AVERLLB
+	AVERLLH
+	AVERLLF
+	AVERLLG
+	AVERLLV
+	AVERLLVB
+	AVERLLVH
+	AVERLLVF
+	AVERLLVG
+	AVESLV
+	AVESLVB
+	AVESLVH
+	AVESLVF
+	AVESLVG
+	AVESL
+	AVESLB
+	AVESLH
+	AVESLF
+	AVESLG
+	AVESRA
+	AVESRAB
+	AVESRAH
+	AVESRAF
+	AVESRAG
+	AVESRAV
+	AVESRAVB
+	AVESRAVH
+	AVESRAVF
+	AVESRAVG
+	AVESRL
+	AVESRLB
+	AVESRLH
+	AVESRLF
+	AVESRLG
+	AVESRLV
+	AVESRLVB
+	AVESRLVH
+	AVESRLVF
+	AVESRLVG
+	AVX
+	AVFAE
+	AVFAEB
+	AVFAEH
+	AVFAEF
+	AVFAEBS
+	AVFAEHS
+	AVFAEFS
+	AVFAEZB
+	AVFAEZH
+	AVFAEZF
+	AVFAEZBS
+	AVFAEZHS
+	AVFAEZFS
+	AVFEE
+	AVFEEB
+	AVFEEH
+	AVFEEF
+	AVFEEBS
+	AVFEEHS
+	AVFEEFS
+	AVFEEZB
+	AVFEEZH
+	AVFEEZF
+	AVFEEZBS
+	AVFEEZHS
+	AVFEEZFS
+	AVFENE
+	AVFENEB
+	AVFENEH
+	AVFENEF
+	AVFENEBS
+	AVFENEHS
+	AVFENEFS
+	AVFENEZB
+	AVFENEZH
+	AVFENEZF
+	AVFENEZBS
+	AVFENEZHS
+	AVFENEZFS
+	AVFA
+	AVFADB
+	AWFADB
+	AWFK
+	AWFKDB
+	AVFCE
+	AVFCEDB
+	AVFCEDBS
+	AWFCEDB
+	AWFCEDBS
+	AVFCH
+	AVFCHDB
+	AVFCHDBS
+	AWFCHDB
+	AWFCHDBS
+	AVFCHE
+	AVFCHEDB
+	AVFCHEDBS
+	AWFCHEDB
+	AWFCHEDBS
+	AWFC
+	AWFCDB
+	AVCDG
+	AVCDGB
+	AWCDGB
+	AVCDLG
+	AVCDLGB
+	AWCDLGB
+	AVCGD
+	AVCGDB
+	AWCGDB
+	AVCLGD
+	AVCLGDB
+	AWCLGDB
+	AVFD
+	AVFDDB
+	AWFDDB
+	AVLDE
+	AVLDEB
+	AWLDEB
+	AVLED
+	AVLEDB
+	AWLEDB
+	AVFM
+	AVFMDB
+	AWFMDB
+	AVFMA
+	AVFMADB
+	AWFMADB
+	AVFMS
+	AVFMSDB
+	AWFMSDB
+	AVFPSO
+	AVFPSODB
+	AWFPSODB
+	AVFLCDB
+	AWFLCDB
+	AVFLNDB
+	AWFLNDB
+	AVFLPDB
+	AWFLPDB
+	AVFSQ
+	AVFSQDB
+	AWFSQDB
+	AVFS
+	AVFSDB
+	AWFSDB
+	AVFTCI
+	AVFTCIDB
+	AWFTCIDB
+	AVGFM
+	AVGFMB
+	AVGFMH
+	AVGFMF
+	AVGFMG
+	AVGFMA
+	AVGFMAB
+	AVGFMAH
+	AVGFMAF
+	AVGFMAG
+	AVGEF
+	AVGEG
+	AVGBM
+	AVZERO
+	AVONE
+	AVGM
+	AVGMB
+	AVGMH
+	AVGMF
+	AVGMG
+	AVISTR
+	AVISTRB
+	AVISTRH
+	AVISTRF
+	AVISTRBS
+	AVISTRHS
+	AVISTRFS
+	AVL
+	AVLR
+	AVLREP
+	AVLREPB
+	AVLREPH
+	AVLREPF
+	AVLREPG
+	AVLC
+	AVLCB
+	AVLCH
+	AVLCF
+	AVLCG
+	AVLEH
+	AVLEF
+	AVLEG
+	AVLEB
+	AVLEIH
+	AVLEIF
+	AVLEIG
+	AVLEIB
+	AVFI
+	AVFIDB
+	AWFIDB
+	AVLGV
+	AVLGVB
+	AVLGVH
+	AVLGVF
+	AVLGVG
+	AVLLEZ
+	AVLLEZB
+	AVLLEZH
+	AVLLEZF
+	AVLLEZG
+	AVLM
+	AVLP
+	AVLPB
+	AVLPH
+	AVLPF
+	AVLPG
+	AVLBB
+	AVLVG
+	AVLVGB
+	AVLVGH
+	AVLVGF
+	AVLVGG
+	AVLVGP
+	AVLL
+	AVMX
+	AVMXB
+	AVMXH
+	AVMXF
+	AVMXG
+	AVMXL
+	AVMXLB
+	AVMXLH
+	AVMXLF
+	AVMXLG
+	AVMRH
+	AVMRHB
+	AVMRHH
+	AVMRHF
+	AVMRHG
+	AVMRL
+	AVMRLB
+	AVMRLH
+	AVMRLF
+	AVMRLG
+	AVMN
+	AVMNB
+	AVMNH
+	AVMNF
+	AVMNG
+	AVMNL
+	AVMNLB
+	AVMNLH
+	AVMNLF
+	AVMNLG
+	AVMAE
+	AVMAEB
+	AVMAEH
+	AVMAEF
+	AVMAH
+	AVMAHB
+	AVMAHH
+	AVMAHF
+	AVMALE
+	AVMALEB
+	AVMALEH
+	AVMALEF
+	AVMALH
+	AVMALHB
+	AVMALHH
+	AVMALHF
+	AVMALO
+	AVMALOB
+	AVMALOH
+	AVMALOF
+	AVMAL
+	AVMALB
+	AVMALHW
+	AVMALF
+	AVMAO
+	AVMAOB
+	AVMAOH
+	AVMAOF
+	AVME
+	AVMEB
+	AVMEH
+	AVMEF
+	AVMH
+	AVMHB
+	AVMHH
+	AVMHF
+	AVMLE
+	AVMLEB
+	AVMLEH
+	AVMLEF
+	AVMLH
+	AVMLHB
+	AVMLHH
+	AVMLHF
+	AVMLO
+	AVMLOB
+	AVMLOH
+	AVMLOF
+	AVML
+	AVMLB
+	AVMLHW
+	AVMLF
+	AVMO
+	AVMOB
+	AVMOH
+	AVMOF
+	AVNO
+	AVNOT
+	AVO
+	AVPK
+	AVPKH
+	AVPKF
+	AVPKG
+	AVPKLS
+	AVPKLSH
+	AVPKLSF
+	AVPKLSG
+	AVPKLSHS
+	AVPKLSFS
+	AVPKLSGS
+	AVPKS
+	AVPKSH
+	AVPKSF
+	AVPKSG
+	AVPKSHS
+	AVPKSFS
+	AVPKSGS
+	AVPERM
+	AVPDI
+	AVPOPCT
+	AVREP
+	AVREPB
+	AVREPH
+	AVREPF
+	AVREPG
+	AVREPI
+	AVREPIB
+	AVREPIH
+	AVREPIF
+	AVREPIG
+	AVSCEF
+	AVSCEG
+	AVSEL
+	AVSL
+	AVSLB
+	AVSLDB
+	AVSRA
+	AVSRAB
+	AVSRL
+	AVSRLB
+	AVSEG
+	AVSEGB
+	AVSEGH
+	AVSEGF
+	AVST
+	AVSTEH
+	AVSTEF
+	AVSTEG
+	AVSTEB
+	AVSTM
+	AVSTL
+	AVSTRC
+	AVSTRCB
+	AVSTRCH
+	AVSTRCF
+	AVSTRCBS
+	AVSTRCHS
+	AVSTRCFS
+	AVSTRCZB
+	AVSTRCZH
+	AVSTRCZF
+	AVSTRCZBS
+	AVSTRCZHS
+	AVSTRCZFS
+	AVS
+	AVSB
+	AVSH
+	AVSF
+	AVSG
+	AVSQ
+	AVSCBI
+	AVSCBIB
+	AVSCBIH
+	AVSCBIF
+	AVSCBIG
+	AVSCBIQ
+	AVSBCBI
+	AVSBCBIQ
+	AVSBI
+	AVSBIQ
+	AVSUMG
+	AVSUMGH
+	AVSUMGF
+	AVSUMQ
+	AVSUMQF
+	AVSUMQG
+	AVSUM
+	AVSUMB
+	AVSUMH
+	AVTM
+	AVUPH
+	AVUPHB
+	AVUPHH
+	AVUPHF
+	AVUPLH
+	AVUPLHB
+	AVUPLHH
+	AVUPLHF
+	AVUPLL
+	AVUPLLB
+	AVUPLLH
+	AVUPLLF
+	AVUPL
+	AVUPLB
+	AVUPLHW
+	AVUPLF
+	AVMSLG
+	AVMSLEG
+	AVMSLOG
+	AVMSLEOG
+
+	ANOPH // NOP
+
+	// binary
+	ABYTE
+	AWORD
+	ADWORD
+
+	// end marker
+	ALAST
+
+	// aliases
+	ABR = obj.AJMP
+	ABL = obj.ACALL
+)
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/anames.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/anames.go
new file mode 100644
index 000000000..b15cabc87
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/anames.go
@@ -0,0 +1,720 @@
+// Code generated by stringer -i a.out.go -o anames.go -p s390x; DO NOT EDIT.
+
+package s390x
+
+import "github.com/twitchyliquid64/golang-asm/obj"
+
+var Anames = []string{
+	obj.A_ARCHSPECIFIC: "ADD",
+	"ADDC",
+	"ADDE",
+	"ADDW",
+	"DIVW",
+	"DIVWU",
+	"DIVD",
+	"DIVDU",
+	"MODW",
+	"MODWU",
+	"MODD",
+	"MODDU",
+	"MULLW",
+	"MULLD",
+	"MULHD",
+	"MULHDU",
+	"MLGR",
+	"SUB",
+	"SUBC",
+	"SUBV",
+	"SUBE",
+	"SUBW",
+	"NEG",
+	"NEGW",
+	"MOVWBR",
+	"MOVB",
+	"MOVBZ",
+	"MOVH",
+	"MOVHBR",
+	"MOVHZ",
+	"MOVW",
+	"MOVWZ",
+	"MOVD",
+	"MOVDBR",
+	"MOVDEQ",
+	"MOVDGE",
+	"MOVDGT",
+	"MOVDLE",
+	"MOVDLT",
+	"MOVDNE",
+	"LOCR",
+	"LOCGR",
+	"FLOGR",
+	"POPCNT",
+	"AND",
+	"ANDW",
+	"OR",
+	"ORW",
+	"XOR",
+	"XORW",
+	"SLW",
+	"SLD",
+	"SRW",
+	"SRAW",
+	"SRD",
+	"SRAD",
+	"RLL",
+	"RLLG",
+	"RNSBG",
+	"RXSBG",
+	"ROSBG",
+	"RNSBGT",
+	"RXSBGT",
+	"ROSBGT",
+	"RISBG",
+	"RISBGN",
+	"RISBGZ",
+	"RISBGNZ",
+	"RISBHG",
+	"RISBLG",
+	"RISBHGZ",
+	"RISBLGZ",
+	"FABS",
+	"FADD",
+	"FADDS",
+	"FCMPO",
+	"FCMPU",
+	"CEBR",
+	"FDIV",
+	"FDIVS",
+	"FMADD",
+	"FMADDS",
+	"FMOVD",
+	"FMOVS",
+	"FMSUB",
+	"FMSUBS",
+	"FMUL",
+	"FMULS",
+	"FNABS",
+	"FNEG",
+	"FNEGS",
+	"LEDBR",
+	"LDEBR",
+	"LPDFR",
+	"LNDFR",
+	"FSUB",
+	"FSUBS",
+	"FSQRT",
+	"FSQRTS",
+	"FIEBR",
+	"FIDBR",
+	"CPSDR",
+	"LTEBR",
+	"LTDBR",
+	"TCEB",
+	"TCDB",
+	"LDGR",
+	"LGDR",
+	"CEFBRA",
+	"CDFBRA",
+	"CEGBRA",
+	"CDGBRA",
+	"CFEBRA",
+	"CFDBRA",
+	"CGEBRA",
+	"CGDBRA",
+	"CELFBR",
+	"CDLFBR",
+	"CELGBR",
+	"CDLGBR",
+	"CLFEBR",
+	"CLFDBR",
+	"CLGEBR",
+	"CLGDBR",
+	"CMP",
+	"CMPU",
+	"CMPW",
+	"CMPWU",
+	"TMHH",
+	"TMHL",
+	"TMLH",
+	"TMLL",
+	"IPM",
+	"SPM",
+	"CS",
+	"CSG",
+	"SYNC",
+	"BC",
+	"BCL",
+	"BRC",
+	"BEQ",
+	"BGE",
+	"BGT",
+	"BLE",
+	"BLT",
+	"BLEU",
+	"BLTU",
+	"BNE",
+	"BVC",
+	"BVS",
+	"SYSCALL",
+	"BRCT",
+	"BRCTG",
+	"CRJ",
+	"CGRJ",
+	"CLRJ",
+	"CLGRJ",
+	"CIJ",
+	"CGIJ",
+	"CLIJ",
+	"CLGIJ",
+	"CMPBEQ",
+	"CMPBGE",
+	"CMPBGT",
+	"CMPBLE",
+	"CMPBLT",
+	"CMPBNE",
+	"CMPUBEQ",
+	"CMPUBGE",
+	"CMPUBGT",
+	"CMPUBLE",
+	"CMPUBLT",
+	"CMPUBNE",
+	"MVC",
+	"MVCIN",
+	"CLC",
+	"XC",
+	"OC",
+	"NC",
+	"EXRL",
+	"LARL",
+	"LA",
+	"LAY",
+	"LAA",
+	"LAAG",
+	"LAAL",
+	"LAALG",
+	"LAN",
+	"LANG",
+	"LAX",
+	"LAXG",
+	"LAO",
+	"LAOG",
+	"LMY",
+	"LMG",
+	"STMY",
+	"STMG",
+	"STCK",
+	"STCKC",
+	"STCKE",
+	"STCKF",
+	"CLEAR",
+	"VA",
+	"VAB",
+	"VAH",
+	"VAF",
+	"VAG",
+	"VAQ",
+	"VACC",
+	"VACCB",
+	"VACCH",
+	"VACCF",
+	"VACCG",
+	"VACCQ",
+	"VAC",
+	"VACQ",
+	"VACCC",
+	"VACCCQ",
+	"VN",
+	"VNC",
+	"VAVG",
+	"VAVGB",
+	"VAVGH",
+	"VAVGF",
+	"VAVGG",
+	"VAVGL",
+	"VAVGLB",
+	"VAVGLH",
+	"VAVGLF",
+	"VAVGLG",
+	"VCKSM",
+	"VCEQ",
+	"VCEQB",
+	"VCEQH",
+	"VCEQF",
+	"VCEQG",
+	"VCEQBS",
+	"VCEQHS",
+	"VCEQFS",
+	"VCEQGS",
+	"VCH",
+	"VCHB",
+	"VCHH",
+	"VCHF",
+	"VCHG",
+	"VCHBS",
+	"VCHHS",
+	"VCHFS",
+	"VCHGS",
+	"VCHL",
+	"VCHLB",
+	"VCHLH",
+	"VCHLF",
+	"VCHLG",
+	"VCHLBS",
+	"VCHLHS",
+	"VCHLFS",
+	"VCHLGS",
+	"VCLZ",
+	"VCLZB",
+	"VCLZH",
+	"VCLZF",
+	"VCLZG",
+	"VCTZ",
+	"VCTZB",
+	"VCTZH",
+	"VCTZF",
+	"VCTZG",
+	"VEC",
+	"VECB",
+	"VECH",
+	"VECF",
+	"VECG",
+	"VECL",
+	"VECLB",
+	"VECLH",
+	"VECLF",
+	"VECLG",
+	"VERIM",
+	"VERIMB",
+	"VERIMH",
+	"VERIMF",
+	"VERIMG",
+	"VERLL",
+	"VERLLB",
+	"VERLLH",
+	"VERLLF",
+	"VERLLG",
+	"VERLLV",
+	"VERLLVB",
+	"VERLLVH",
+	"VERLLVF",
+	"VERLLVG",
+	"VESLV",
+	"VESLVB",
+	"VESLVH",
+	"VESLVF",
+	"VESLVG",
+	"VESL",
+	"VESLB",
+	"VESLH",
+	"VESLF",
+	"VESLG",
+	"VESRA",
+	"VESRAB",
+	"VESRAH",
+	"VESRAF",
+	"VESRAG",
+	"VESRAV",
+	"VESRAVB",
+	"VESRAVH",
+	"VESRAVF",
+	"VESRAVG",
+	"VESRL",
+	"VESRLB",
+	"VESRLH",
+	"VESRLF",
+	"VESRLG",
+	"VESRLV",
+	"VESRLVB",
+	"VESRLVH",
+	"VESRLVF",
+	"VESRLVG",
+	"VX",
+	"VFAE",
+	"VFAEB",
+	"VFAEH",
+	"VFAEF",
+	"VFAEBS",
+	"VFAEHS",
+	"VFAEFS",
+	"VFAEZB",
+	"VFAEZH",
+	"VFAEZF",
+	"VFAEZBS",
+	"VFAEZHS",
+	"VFAEZFS",
+	"VFEE",
+	"VFEEB",
+	"VFEEH",
+	"VFEEF",
+	"VFEEBS",
+	"VFEEHS",
+	"VFEEFS",
+	"VFEEZB",
+	"VFEEZH",
+	"VFEEZF",
+	"VFEEZBS",
+	"VFEEZHS",
+	"VFEEZFS",
+	"VFENE",
+	"VFENEB",
+	"VFENEH",
+	"VFENEF",
+	"VFENEBS",
+	"VFENEHS",
+	"VFENEFS",
+	"VFENEZB",
+	"VFENEZH",
+	"VFENEZF",
+	"VFENEZBS",
+	"VFENEZHS",
+	"VFENEZFS",
+	"VFA",
+	"VFADB",
+	"WFADB",
+	"WFK",
+	"WFKDB",
+	"VFCE",
+	"VFCEDB",
+	"VFCEDBS",
+	"WFCEDB",
+	"WFCEDBS",
+	"VFCH",
+	"VFCHDB",
+	"VFCHDBS",
+	"WFCHDB",
+	"WFCHDBS",
+	"VFCHE",
+	"VFCHEDB",
+	"VFCHEDBS",
+	"WFCHEDB",
+	"WFCHEDBS",
+	"WFC",
+	"WFCDB",
+	"VCDG",
+	"VCDGB",
+	"WCDGB",
+	"VCDLG",
+	"VCDLGB",
+	"WCDLGB",
+	"VCGD",
+	"VCGDB",
+	"WCGDB",
+	"VCLGD",
+	"VCLGDB",
+	"WCLGDB",
+	"VFD",
+	"VFDDB",
+	"WFDDB",
+	"VLDE",
+	"VLDEB",
+	"WLDEB",
+	"VLED",
+	"VLEDB",
+	"WLEDB",
+	"VFM",
+	"VFMDB",
+	"WFMDB",
+	"VFMA",
+	"VFMADB",
+	"WFMADB",
+	"VFMS",
+	"VFMSDB",
+	"WFMSDB",
+	"VFPSO",
+	"VFPSODB",
+	"WFPSODB",
+	"VFLCDB",
+	"WFLCDB",
+	"VFLNDB",
+	"WFLNDB",
+	"VFLPDB",
+	"WFLPDB",
+	"VFSQ",
+	"VFSQDB",
+	"WFSQDB",
+	"VFS",
+	"VFSDB",
+	"WFSDB",
+	"VFTCI",
+	"VFTCIDB",
+	"WFTCIDB",
+	"VGFM",
+	"VGFMB",
+	"VGFMH",
+	"VGFMF",
+	"VGFMG",
+	"VGFMA",
+	"VGFMAB",
+	"VGFMAH",
+	"VGFMAF",
+	"VGFMAG",
+	"VGEF",
+	"VGEG",
+	"VGBM",
+	"VZERO",
+	"VONE",
+	"VGM",
+	"VGMB",
+	"VGMH",
+	"VGMF",
+	"VGMG",
+	"VISTR",
+	"VISTRB",
+	"VISTRH",
+	"VISTRF",
+	"VISTRBS",
+	"VISTRHS",
+	"VISTRFS",
+	"VL",
+	"VLR",
+	"VLREP",
+	"VLREPB",
+	"VLREPH",
+	"VLREPF",
+	"VLREPG",
+	"VLC",
+	"VLCB",
+	"VLCH",
+	"VLCF",
+	"VLCG",
+	"VLEH",
+	"VLEF",
+	"VLEG",
+	"VLEB",
+	"VLEIH",
+	"VLEIF",
+	"VLEIG",
+	"VLEIB",
+	"VFI",
+	"VFIDB",
+	"WFIDB",
+	"VLGV",
+	"VLGVB",
+	"VLGVH",
+	"VLGVF",
+	"VLGVG",
+	"VLLEZ",
+	"VLLEZB",
+	"VLLEZH",
+	"VLLEZF",
+	"VLLEZG",
+	"VLM",
+	"VLP",
+	"VLPB",
+	"VLPH",
+	"VLPF",
+	"VLPG",
+	"VLBB",
+	"VLVG",
+	"VLVGB",
+	"VLVGH",
+	"VLVGF",
+	"VLVGG",
+	"VLVGP",
+	"VLL",
+	"VMX",
+	"VMXB",
+	"VMXH",
+	"VMXF",
+	"VMXG",
+	"VMXL",
+	"VMXLB",
+	"VMXLH",
+	"VMXLF",
+	"VMXLG",
+	"VMRH",
+	"VMRHB",
+	"VMRHH",
+	"VMRHF",
+	"VMRHG",
+	"VMRL",
+	"VMRLB",
+	"VMRLH",
+	"VMRLF",
+	"VMRLG",
+	"VMN",
+	"VMNB",
+	"VMNH",
+	"VMNF",
+	"VMNG",
+	"VMNL",
+	"VMNLB",
+	"VMNLH",
+	"VMNLF",
+	"VMNLG",
+	"VMAE",
+	"VMAEB",
+	"VMAEH",
+	"VMAEF",
+	"VMAH",
+	"VMAHB",
+	"VMAHH",
+	"VMAHF",
+	"VMALE",
+	"VMALEB",
+	"VMALEH",
+	"VMALEF",
+	"VMALH",
+	"VMALHB",
+	"VMALHH",
+	"VMALHF",
+	"VMALO",
+	"VMALOB",
+	"VMALOH",
+	"VMALOF",
+	"VMAL",
+	"VMALB",
+	"VMALHW",
+	"VMALF",
+	"VMAO",
+	"VMAOB",
+	"VMAOH",
+	"VMAOF",
+	"VME",
+	"VMEB",
+	"VMEH",
+	"VMEF",
+	"VMH",
+	"VMHB",
+	"VMHH",
+	"VMHF",
+	"VMLE",
+	"VMLEB",
+	"VMLEH",
+	"VMLEF",
+	"VMLH",
+	"VMLHB",
+	"VMLHH",
+	"VMLHF",
+	"VMLO",
+	"VMLOB",
+	"VMLOH",
+	"VMLOF",
+	"VML",
+	"VMLB",
+	"VMLHW",
+	"VMLF",
+	"VMO",
+	"VMOB",
+	"VMOH",
+	"VMOF",
+	"VNO",
+	"VNOT",
+	"VO",
+	"VPK",
+	"VPKH",
+	"VPKF",
+	"VPKG",
+	"VPKLS",
+	"VPKLSH",
+	"VPKLSF",
+	"VPKLSG",
+	"VPKLSHS",
+	"VPKLSFS",
+	"VPKLSGS",
+	"VPKS",
+	"VPKSH",
+	"VPKSF",
+	"VPKSG",
+	"VPKSHS",
+	"VPKSFS",
+	"VPKSGS",
+	"VPERM",
+	"VPDI",
+	"VPOPCT",
+	"VREP",
+	"VREPB",
+	"VREPH",
+	"VREPF",
+	"VREPG",
+	"VREPI",
+	"VREPIB",
+	"VREPIH",
+	"VREPIF",
+	"VREPIG",
+	"VSCEF",
+	"VSCEG",
+	"VSEL",
+	"VSL",
+	"VSLB",
+	"VSLDB",
+	"VSRA",
+	"VSRAB",
+	"VSRL",
+	"VSRLB",
+	"VSEG",
+	"VSEGB",
+	"VSEGH",
+	"VSEGF",
+	"VST",
+	"VSTEH",
+	"VSTEF",
+	"VSTEG",
+	"VSTEB",
+	"VSTM",
+	"VSTL",
+	"VSTRC",
+	"VSTRCB",
+	"VSTRCH",
+	"VSTRCF",
+	"VSTRCBS",
+	"VSTRCHS",
+	"VSTRCFS",
+	"VSTRCZB",
+	"VSTRCZH",
+	"VSTRCZF",
+	"VSTRCZBS",
+	"VSTRCZHS",
+	"VSTRCZFS",
+	"VS",
+	"VSB",
+	"VSH",
+	"VSF",
+	"VSG",
+	"VSQ",
+	"VSCBI",
+	"VSCBIB",
+	"VSCBIH",
+	"VSCBIF",
+	"VSCBIG",
+	"VSCBIQ",
+	"VSBCBI",
+	"VSBCBIQ",
+	"VSBI",
+	"VSBIQ",
+	"VSUMG",
+	"VSUMGH",
+	"VSUMGF",
+	"VSUMQ",
+	"VSUMQF",
+	"VSUMQG",
+	"VSUM",
+	"VSUMB",
+	"VSUMH",
+	"VTM",
+	"VUPH",
+	"VUPHB",
+	"VUPHH",
+	"VUPHF",
+	"VUPLH",
+	"VUPLHB",
+	"VUPLHH",
+	"VUPLHF",
+	"VUPLL",
+	"VUPLLB",
+	"VUPLLH",
+	"VUPLLF",
+	"VUPL",
+	"VUPLB",
+	"VUPLHW",
+	"VUPLF",
+	"VMSLG",
+	"VMSLEG",
+	"VMSLOG",
+	"VMSLEOG",
+	"NOPH",
+	"BYTE",
+	"WORD",
+	"DWORD",
+	"LAST",
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/anamesz.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/anamesz.go
new file mode 100644
index 000000000..9c9b4d584
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/anamesz.go
@@ -0,0 +1,39 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package s390x
+
+var cnamesz = []string{
+	"NONE",
+	"REG",
+	"FREG",
+	"VREG",
+	"AREG",
+	"ZCON",
+	"SCON",
+	"UCON",
+	"ADDCON",
+	"ANDCON",
+	"LCON",
+	"DCON",
+	"SACON",
+	"LACON",
+	"DACON",
+	"SBRA",
+	"LBRA",
+	"SAUTO",
+	"LAUTO",
+	"ZOREG",
+	"SOREG",
+	"LOREG",
+	"TLS_LE",
+	"TLS_IE",
+	"GOK",
+	"ADDR",
+	"SYMADDR",
+	"GOTADDR",
+	"TEXTSIZE",
+	"ANY",
+	"NCLASS",
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/asmz.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/asmz.go
new file mode 100644
index 000000000..f436521fe
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/asmz.go
@@ -0,0 +1,5043 @@
+// Based on cmd/internal/obj/ppc64/asm9.go.
+//
+//    Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//    Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//    Portions Copyright © 1997-1999 Vita Nuova Limited
+//    Portions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com)
+//    Portions Copyright © 2004,2006 Bruce Ellis
+//    Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//    Revisions Copyright © 2000-2008 Lucent Technologies Inc. and others
+//    Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package s390x
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"fmt"
+	"log"
+	"math"
+	"sort"
+)
+
+// ctxtz holds state while assembling a single function.
+// Each function gets a fresh ctxtz.
+// This allows for multiple functions to be safely concurrently assembled.
+type ctxtz struct {
+	ctxt       *obj.Link
+	newprog    obj.ProgAlloc
+	cursym     *obj.LSym
+	autosize   int32
+	instoffset int64
+	pc         int64
+}
+
+// instruction layout.
+const (
+	funcAlign = 16
+)
+
+type Optab struct {
+	as obj.As // opcode
+	i  uint8  // handler index
+	a1 uint8  // From
+	a2 uint8  // Reg
+	a3 uint8  // RestArgs[0]
+	a4 uint8  // RestArgs[1]
+	a5 uint8  // RestArgs[2]
+	a6 uint8  // To
+}
+
+var optab = []Optab{
+	// zero-length instructions
+	{i: 0, as: obj.ATEXT, a1: C_ADDR, a6: C_TEXTSIZE},
+	{i: 0, as: obj.ATEXT, a1: C_ADDR, a3: C_LCON, a6: C_TEXTSIZE},
+	{i: 0, as: obj.APCDATA, a1: C_LCON, a6: C_LCON},
+	{i: 0, as: obj.AFUNCDATA, a1: C_SCON, a6: C_ADDR},
+	{i: 0, as: obj.ANOP},
+	{i: 0, as: obj.ANOP, a1: C_SAUTO},
+
+	// move register
+	{i: 1, as: AMOVD, a1: C_REG, a6: C_REG},
+	{i: 1, as: AMOVB, a1: C_REG, a6: C_REG},
+	{i: 1, as: AMOVBZ, a1: C_REG, a6: C_REG},
+	{i: 1, as: AMOVW, a1: C_REG, a6: C_REG},
+	{i: 1, as: AMOVWZ, a1: C_REG, a6: C_REG},
+	{i: 1, as: AFMOVD, a1: C_FREG, a6: C_FREG},
+	{i: 1, as: AMOVDBR, a1: C_REG, a6: C_REG},
+
+	// load constant
+	{i: 26, as: AMOVD, a1: C_LACON, a6: C_REG},
+	{i: 26, as: AMOVW, a1: C_LACON, a6: C_REG},
+	{i: 26, as: AMOVWZ, a1: C_LACON, a6: C_REG},
+	{i: 3, as: AMOVD, a1: C_DCON, a6: C_REG},
+	{i: 3, as: AMOVW, a1: C_DCON, a6: C_REG},
+	{i: 3, as: AMOVWZ, a1: C_DCON, a6: C_REG},
+	{i: 3, as: AMOVB, a1: C_DCON, a6: C_REG},
+	{i: 3, as: AMOVBZ, a1: C_DCON, a6: C_REG},
+
+	// store constant
+	{i: 72, as: AMOVD, a1: C_SCON, a6: C_LAUTO},
+	{i: 72, as: AMOVD, a1: C_ADDCON, a6: C_LAUTO},
+	{i: 72, as: AMOVW, a1: C_SCON, a6: C_LAUTO},
+	{i: 72, as: AMOVW, a1: C_ADDCON, a6: C_LAUTO},
+	{i: 72, as: AMOVWZ, a1: C_SCON, a6: C_LAUTO},
+	{i: 72, as: AMOVWZ, a1: C_ADDCON, a6: C_LAUTO},
+	{i: 72, as: AMOVB, a1: C_SCON, a6: C_LAUTO},
+	{i: 72, as: AMOVB, a1: C_ADDCON, a6: C_LAUTO},
+	{i: 72, as: AMOVBZ, a1: C_SCON, a6: C_LAUTO},
+	{i: 72, as: AMOVBZ, a1: C_ADDCON, a6: C_LAUTO},
+	{i: 72, as: AMOVD, a1: C_SCON, a6: C_LOREG},
+	{i: 72, as: AMOVD, a1: C_ADDCON, a6: C_LOREG},
+	{i: 72, as: AMOVW, a1: C_SCON, a6: C_LOREG},
+	{i: 72, as: AMOVW, a1: C_ADDCON, a6: C_LOREG},
+	{i: 72, as: AMOVWZ, a1: C_SCON, a6: C_LOREG},
+	{i: 72, as: AMOVWZ, a1: C_ADDCON, a6: C_LOREG},
+	{i: 72, as: AMOVB, a1: C_SCON, a6: C_LOREG},
+	{i: 72, as: AMOVB, a1: C_ADDCON, a6: C_LOREG},
+	{i: 72, as: AMOVBZ, a1: C_SCON, a6: C_LOREG},
+	{i: 72, as: AMOVBZ, a1: C_ADDCON, a6: C_LOREG},
+
+	// store
+	{i: 35, as: AMOVD, a1: C_REG, a6: C_LAUTO},
+	{i: 35, as: AMOVW, a1: C_REG, a6: C_LAUTO},
+	{i: 35, as: AMOVWZ, a1: C_REG, a6: C_LAUTO},
+	{i: 35, as: AMOVBZ, a1: C_REG, a6: C_LAUTO},
+	{i: 35, as: AMOVB, a1: C_REG, a6: C_LAUTO},
+	{i: 35, as: AMOVDBR, a1: C_REG, a6: C_LAUTO},
+	{i: 35, as: AMOVHBR, a1: C_REG, a6: C_LAUTO},
+	{i: 35, as: AMOVD, a1: C_REG, a6: C_LOREG},
+	{i: 35, as: AMOVW, a1: C_REG, a6: C_LOREG},
+	{i: 35, as: AMOVWZ, a1: C_REG, a6: C_LOREG},
+	{i: 35, as: AMOVBZ, a1: C_REG, a6: C_LOREG},
+	{i: 35, as: AMOVB, a1: C_REG, a6: C_LOREG},
+	{i: 35, as: AMOVDBR, a1: C_REG, a6: C_LOREG},
+	{i: 35, as: AMOVHBR, a1: C_REG, a6: C_LOREG},
+	{i: 74, as: AMOVD, a1: C_REG, a6: C_ADDR},
+	{i: 74, as: AMOVW, a1: C_REG, a6: C_ADDR},
+	{i: 74, as: AMOVWZ, a1: C_REG, a6: C_ADDR},
+	{i: 74, as: AMOVBZ, a1: C_REG, a6: C_ADDR},
+	{i: 74, as: AMOVB, a1: C_REG, a6: C_ADDR},
+
+	// load
+	{i: 36, as: AMOVD, a1: C_LAUTO, a6: C_REG},
+	{i: 36, as: AMOVW, a1: C_LAUTO, a6: C_REG},
+	{i: 36, as: AMOVWZ, a1: C_LAUTO, a6: C_REG},
+	{i: 36, as: AMOVBZ, a1: C_LAUTO, a6: C_REG},
+	{i: 36, as: AMOVB, a1: C_LAUTO, a6: C_REG},
+	{i: 36, as: AMOVDBR, a1: C_LAUTO, a6: C_REG},
+	{i: 36, as: AMOVHBR, a1: C_LAUTO, a6: C_REG},
+	{i: 36, as: AMOVD, a1: C_LOREG, a6: C_REG},
+	{i: 36, as: AMOVW, a1: C_LOREG, a6: C_REG},
+	{i: 36, as: AMOVWZ, a1: C_LOREG, a6: C_REG},
+	{i: 36, as: AMOVBZ, a1: C_LOREG, a6: C_REG},
+	{i: 36, as: AMOVB, a1: C_LOREG, a6: C_REG},
+	{i: 36, as: AMOVDBR, a1: C_LOREG, a6: C_REG},
+	{i: 36, as: AMOVHBR, a1: C_LOREG, a6: C_REG},
+	{i: 75, as: AMOVD, a1: C_ADDR, a6: C_REG},
+	{i: 75, as: AMOVW, a1: C_ADDR, a6: C_REG},
+	{i: 75, as: AMOVWZ, a1: C_ADDR, a6: C_REG},
+	{i: 75, as: AMOVBZ, a1: C_ADDR, a6: C_REG},
+	{i: 75, as: AMOVB, a1: C_ADDR, a6: C_REG},
+
+	// interlocked load and op
+	{i: 99, as: ALAAG, a1: C_REG, a2: C_REG, a6: C_LOREG},
+
+	// integer arithmetic
+	{i: 2, as: AADD, a1: C_REG, a2: C_REG, a6: C_REG},
+	{i: 2, as: AADD, a1: C_REG, a6: C_REG},
+	{i: 22, as: AADD, a1: C_LCON, a2: C_REG, a6: C_REG},
+	{i: 22, as: AADD, a1: C_LCON, a6: C_REG},
+	{i: 12, as: AADD, a1: C_LOREG, a6: C_REG},
+	{i: 12, as: AADD, a1: C_LAUTO, a6: C_REG},
+	{i: 21, as: ASUB, a1: C_LCON, a2: C_REG, a6: C_REG},
+	{i: 21, as: ASUB, a1: C_LCON, a6: C_REG},
+	{i: 12, as: ASUB, a1: C_LOREG, a6: C_REG},
+	{i: 12, as: ASUB, a1: C_LAUTO, a6: C_REG},
+	{i: 4, as: AMULHD, a1: C_REG, a6: C_REG},
+	{i: 4, as: AMULHD, a1: C_REG, a2: C_REG, a6: C_REG},
+	{i: 62, as: AMLGR, a1: C_REG, a6: C_REG},
+	{i: 2, as: ADIVW, a1: C_REG, a2: C_REG, a6: C_REG},
+	{i: 2, as: ADIVW, a1: C_REG, a6: C_REG},
+	{i: 10, as: ASUB, a1: C_REG, a2: C_REG, a6: C_REG},
+	{i: 10, as: ASUB, a1: C_REG, a6: C_REG},
+	{i: 47, as: ANEG, a1: C_REG, a6: C_REG},
+	{i: 47, as: ANEG, a6: C_REG},
+
+	// integer logical
+	{i: 6, as: AAND, a1: C_REG, a2: C_REG, a6: C_REG},
+	{i: 6, as: AAND, a1: C_REG, a6: C_REG},
+	{i: 23, as: AAND, a1: C_LCON, a6: C_REG},
+	{i: 12, as: AAND, a1: C_LOREG, a6: C_REG},
+	{i: 12, as: AAND, a1: C_LAUTO, a6: C_REG},
+	{i: 6, as: AANDW, a1: C_REG, a2: C_REG, a6: C_REG},
+	{i: 6, as: AANDW, a1: C_REG, a6: C_REG},
+	{i: 24, as: AANDW, a1: C_LCON, a6: C_REG},
+	{i: 12, as: AANDW, a1: C_LOREG, a6: C_REG},
+	{i: 12, as: AANDW, a1: C_LAUTO, a6: C_REG},
+	{i: 7, as: ASLD, a1: C_REG, a6: C_REG},
+	{i: 7, as: ASLD, a1: C_REG, a2: C_REG, a6: C_REG},
+	{i: 7, as: ASLD, a1: C_SCON, a2: C_REG, a6: C_REG},
+	{i: 7, as: ASLD, a1: C_SCON, a6: C_REG},
+	{i: 13, as: ARNSBG, a1: C_SCON, a3: C_SCON, a4: C_SCON, a5: C_REG, a6: C_REG},
+
+	// compare and swap
+	{i: 79, as: ACSG, a1: C_REG, a2: C_REG, a6: C_SOREG},
+
+	// floating point
+	{i: 32, as: AFADD, a1: C_FREG, a6: C_FREG},
+	{i: 33, as: AFABS, a1: C_FREG, a6: C_FREG},
+	{i: 33, as: AFABS, a6: C_FREG},
+	{i: 34, as: AFMADD, a1: C_FREG, a2: C_FREG, a6: C_FREG},
+	{i: 32, as: AFMUL, a1: C_FREG, a6: C_FREG},
+	{i: 36, as: AFMOVD, a1: C_LAUTO, a6: C_FREG},
+	{i: 36, as: AFMOVD, a1: C_LOREG, a6: C_FREG},
+	{i: 75, as: AFMOVD, a1: C_ADDR, a6: C_FREG},
+	{i: 35, as: AFMOVD, a1: C_FREG, a6: C_LAUTO},
+	{i: 35, as: AFMOVD, a1: C_FREG, a6: C_LOREG},
+	{i: 74, as: AFMOVD, a1: C_FREG, a6: C_ADDR},
+	{i: 67, as: AFMOVD, a1: C_ZCON, a6: C_FREG},
+	{i: 81, as: ALDGR, a1: C_REG, a6: C_FREG},
+	{i: 81, as: ALGDR, a1: C_FREG, a6: C_REG},
+	{i: 82, as: ACEFBRA, a1: C_REG, a6: C_FREG},
+	{i: 83, as: ACFEBRA, a1: C_FREG, a6: C_REG},
+	{i: 48, as: AFIEBR, a1: C_SCON, a2: C_FREG, a6: C_FREG},
+	{i: 49, as: ACPSDR, a1: C_FREG, a2: C_FREG, a6: C_FREG},
+	{i: 50, as: ALTDBR, a1: C_FREG, a6: C_FREG},
+	{i: 51, as: ATCDB, a1: C_FREG, a6: C_SCON},
+
+	// load symbol address (plus offset)
+	{i: 19, as: AMOVD, a1: C_SYMADDR, a6: C_REG},
+	{i: 93, as: AMOVD, a1: C_GOTADDR, a6: C_REG},
+	{i: 94, as: AMOVD, a1: C_TLS_LE, a6: C_REG},
+	{i: 95, as: AMOVD, a1: C_TLS_IE, a6: C_REG},
+
+	// system call
+	{i: 5, as: ASYSCALL},
+	{i: 77, as: ASYSCALL, a1: C_SCON},
+
+	// branch
+	{i: 16, as: ABEQ, a6: C_SBRA},
+	{i: 16, as: ABRC, a1: C_SCON, a6: C_SBRA},
+	{i: 11, as: ABR, a6: C_LBRA},
+	{i: 16, as: ABC, a1: C_SCON, a2: C_REG, a6: C_LBRA},
+	{i: 18, as: ABR, a6: C_REG},
+	{i: 18, as: ABR, a1: C_REG, a6: C_REG},
+	{i: 15, as: ABR, a6: C_ZOREG},
+	{i: 15, as: ABC, a6: C_ZOREG},
+
+	// compare and branch
+	{i: 89, as: ACGRJ, a1: C_SCON, a2: C_REG, a3: C_REG, a6: C_SBRA},
+	{i: 89, as: ACMPBEQ, a1: C_REG, a2: C_REG, a6: C_SBRA},
+	{i: 89, as: ACLGRJ, a1: C_SCON, a2: C_REG, a3: C_REG, a6: C_SBRA},
+	{i: 89, as: ACMPUBEQ, a1: C_REG, a2: C_REG, a6: C_SBRA},
+	{i: 90, as: ACGIJ, a1: C_SCON, a2: C_REG, a3: C_ADDCON, a6: C_SBRA},
+	{i: 90, as: ACGIJ, a1: C_SCON, a2: C_REG, a3: C_SCON, a6: C_SBRA},
+	{i: 90, as: ACMPBEQ, a1: C_REG, a3: C_ADDCON, a6: C_SBRA},
+	{i: 90, as: ACMPBEQ, a1: C_REG, a3: C_SCON, a6: C_SBRA},
+	{i: 90, as: ACLGIJ, a1: C_SCON, a2: C_REG, a3: C_ADDCON, a6: C_SBRA},
+	{i: 90, as: ACMPUBEQ, a1: C_REG, a3: C_ANDCON, a6: C_SBRA},
+
+	// branch on count
+	{i: 41, as: ABRCT, a1: C_REG, a6: C_SBRA},
+	{i: 41, as: ABRCTG, a1: C_REG, a6: C_SBRA},
+
+	// move on condition
+	{i: 17, as: AMOVDEQ, a1: C_REG, a6: C_REG},
+
+	// load on condition
+	{i: 25, as: ALOCGR, a1: C_SCON, a2: C_REG, a6: C_REG},
+
+	// find leftmost one
+	{i: 8, as: AFLOGR, a1: C_REG, a6: C_REG},
+
+	// population count
+	{i: 9, as: APOPCNT, a1: C_REG, a6: C_REG},
+
+	// compare
+	{i: 70, as: ACMP, a1: C_REG, a6: C_REG},
+	{i: 71, as: ACMP, a1: C_REG, a6: C_LCON},
+	{i: 70, as: ACMPU, a1: C_REG, a6: C_REG},
+	{i: 71, as: ACMPU, a1: C_REG, a6: C_LCON},
+	{i: 70, as: AFCMPO, a1: C_FREG, a6: C_FREG},
+	{i: 70, as: AFCMPO, a1: C_FREG, a2: C_REG, a6: C_FREG},
+
+	// test under mask
+	{i: 91, as: ATMHH, a1: C_REG, a6: C_ANDCON},
+
+	// insert program mask
+	{i: 92, as: AIPM, a1: C_REG},
+
+	// set program mask
+	{i: 76, as: ASPM, a1: C_REG},
+
+	// 32-bit access registers
+	{i: 68, as: AMOVW, a1: C_AREG, a6: C_REG},
+	{i: 68, as: AMOVWZ, a1: C_AREG, a6: C_REG},
+	{i: 69, as: AMOVW, a1: C_REG, a6: C_AREG},
+	{i: 69, as: AMOVWZ, a1: C_REG, a6: C_AREG},
+
+	// macros
+	{i: 96, as: ACLEAR, a1: C_LCON, a6: C_LOREG},
+	{i: 96, as: ACLEAR, a1: C_LCON, a6: C_LAUTO},
+
+	// load/store multiple
+	{i: 97, as: ASTMG, a1: C_REG, a2: C_REG, a6: C_LOREG},
+	{i: 97, as: ASTMG, a1: C_REG, a2: C_REG, a6: C_LAUTO},
+	{i: 98, as: ALMG, a1: C_LOREG, a2: C_REG, a6: C_REG},
+	{i: 98, as: ALMG, a1: C_LAUTO, a2: C_REG, a6: C_REG},
+
+	// bytes
+	{i: 40, as: ABYTE, a1: C_SCON},
+	{i: 40, as: AWORD, a1: C_LCON},
+	{i: 31, as: ADWORD, a1: C_LCON},
+	{i: 31, as: ADWORD, a1: C_DCON},
+
+	// fast synchronization
+	{i: 80, as: ASYNC},
+
+	// store clock
+	{i: 88, as: ASTCK, a6: C_SAUTO},
+	{i: 88, as: ASTCK, a6: C_SOREG},
+
+	// storage and storage
+	{i: 84, as: AMVC, a1: C_SCON, a3: C_LOREG, a6: C_LOREG},
+	{i: 84, as: AMVC, a1: C_SCON, a3: C_LOREG, a6: C_LAUTO},
+	{i: 84, as: AMVC, a1: C_SCON, a3: C_LAUTO, a6: C_LAUTO},
+
+	// address
+	{i: 85, as: ALARL, a1: C_LCON, a6: C_REG},
+	{i: 85, as: ALARL, a1: C_SYMADDR, a6: C_REG},
+	{i: 86, as: ALA, a1: C_SOREG, a6: C_REG},
+	{i: 86, as: ALA, a1: C_SAUTO, a6: C_REG},
+	{i: 87, as: AEXRL, a1: C_SYMADDR, a6: C_REG},
+
+	// undefined (deliberate illegal instruction)
+	{i: 78, as: obj.AUNDEF},
+
+	// 2 byte no-operation
+	{i: 66, as: ANOPH},
+
+	// vector instructions
+
+	// VRX store
+	{i: 100, as: AVST, a1: C_VREG, a6: C_SOREG},
+	{i: 100, as: AVST, a1: C_VREG, a6: C_SAUTO},
+	{i: 100, as: AVSTEG, a1: C_SCON, a2: C_VREG, a6: C_SOREG},
+	{i: 100, as: AVSTEG, a1: C_SCON, a2: C_VREG, a6: C_SAUTO},
+
+	// VRX load
+	{i: 101, as: AVL, a1: C_SOREG, a6: C_VREG},
+	{i: 101, as: AVL, a1: C_SAUTO, a6: C_VREG},
+	{i: 101, as: AVLEG, a1: C_SCON, a3: C_SOREG, a6: C_VREG},
+	{i: 101, as: AVLEG, a1: C_SCON, a3: C_SAUTO, a6: C_VREG},
+
+	// VRV scatter
+	{i: 102, as: AVSCEG, a1: C_SCON, a2: C_VREG, a6: C_SOREG},
+	{i: 102, as: AVSCEG, a1: C_SCON, a2: C_VREG, a6: C_SAUTO},
+
+	// VRV gather
+	{i: 103, as: AVGEG, a1: C_SCON, a3: C_SOREG, a6: C_VREG},
+	{i: 103, as: AVGEG, a1: C_SCON, a3: C_SAUTO, a6: C_VREG},
+
+	// VRS element shift/rotate and load gr to/from vr element
+	{i: 104, as: AVESLG, a1: C_SCON, a2: C_VREG, a6: C_VREG},
+	{i: 104, as: AVESLG, a1: C_REG, a2: C_VREG, a6: C_VREG},
+	{i: 104, as: AVESLG, a1: C_SCON, a6: C_VREG},
+	{i: 104, as: AVESLG, a1: C_REG, a6: C_VREG},
+	{i: 104, as: AVLGVG, a1: C_SCON, a2: C_VREG, a6: C_REG},
+	{i: 104, as: AVLGVG, a1: C_REG, a2: C_VREG, a6: C_REG},
+	{i: 104, as: AVLVGG, a1: C_SCON, a2: C_REG, a6: C_VREG},
+	{i: 104, as: AVLVGG, a1: C_REG, a2: C_REG, a6: C_VREG},
+
+	// VRS store multiple
+	{i: 105, as: AVSTM, a1: C_VREG, a2: C_VREG, a6: C_SOREG},
+	{i: 105, as: AVSTM, a1: C_VREG, a2: C_VREG, a6: C_SAUTO},
+
+	// VRS load multiple
+	{i: 106, as: AVLM, a1: C_SOREG, a2: C_VREG, a6: C_VREG},
+	{i: 106, as: AVLM, a1: C_SAUTO, a2: C_VREG, a6: C_VREG},
+
+	// VRS store with length
+	{i: 107, as: AVSTL, a1: C_REG, a2: C_VREG, a6: C_SOREG},
+	{i: 107, as: AVSTL, a1: C_REG, a2: C_VREG, a6: C_SAUTO},
+
+	// VRS load with length
+	{i: 108, as: AVLL, a1: C_REG, a3: C_SOREG, a6: C_VREG},
+	{i: 108, as: AVLL, a1: C_REG, a3: C_SAUTO, a6: C_VREG},
+
+	// VRI-a
+	{i: 109, as: AVGBM, a1: C_ANDCON, a6: C_VREG},
+	{i: 109, as: AVZERO, a6: C_VREG},
+	{i: 109, as: AVREPIG, a1: C_ADDCON, a6: C_VREG},
+	{i: 109, as: AVREPIG, a1: C_SCON, a6: C_VREG},
+	{i: 109, as: AVLEIG, a1: C_SCON, a3: C_ADDCON, a6: C_VREG},
+	{i: 109, as: AVLEIG, a1: C_SCON, a3: C_SCON, a6: C_VREG},
+
+	// VRI-b generate mask
+	{i: 110, as: AVGMG, a1: C_SCON, a3: C_SCON, a6: C_VREG},
+
+	// VRI-c replicate
+	{i: 111, as: AVREPG, a1: C_UCON, a2: C_VREG, a6: C_VREG},
+
+	// VRI-d element rotate and insert under mask and
+	// shift left double by byte
+	{i: 112, as: AVERIMG, a1: C_SCON, a2: C_VREG, a3: C_VREG, a6: C_VREG},
+	{i: 112, as: AVSLDB, a1: C_SCON, a2: C_VREG, a3: C_VREG, a6: C_VREG},
+
+	// VRI-d fp test data class immediate
+	{i: 113, as: AVFTCIDB, a1: C_SCON, a2: C_VREG, a6: C_VREG},
+
+	// VRR-a load reg
+	{i: 114, as: AVLR, a1: C_VREG, a6: C_VREG},
+
+	// VRR-a compare
+	{i: 115, as: AVECG, a1: C_VREG, a6: C_VREG},
+
+	// VRR-b
+	{i: 117, as: AVCEQG, a1: C_VREG, a2: C_VREG, a6: C_VREG},
+	{i: 117, as: AVFAEF, a1: C_VREG, a2: C_VREG, a6: C_VREG},
+	{i: 117, as: AVPKSG, a1: C_VREG, a2: C_VREG, a6: C_VREG},
+
+	// VRR-c
+	{i: 118, as: AVAQ, a1: C_VREG, a2: C_VREG, a6: C_VREG},
+	{i: 118, as: AVAQ, a1: C_VREG, a6: C_VREG},
+	{i: 118, as: AVNOT, a1: C_VREG, a6: C_VREG},
+	{i: 123, as: AVPDI, a1: C_SCON, a2: C_VREG, a3: C_VREG, a6: C_VREG},
+
+	// VRR-c shifts
+	{i: 119, as: AVERLLVG, a1: C_VREG, a2: C_VREG, a6: C_VREG},
+	{i: 119, as: AVERLLVG, a1: C_VREG, a6: C_VREG},
+
+	// VRR-d
+	{i: 120, as: AVACQ, a1: C_VREG, a2: C_VREG, a3: C_VREG, a6: C_VREG},
+
+	// VRR-e
+	{i: 121, as: AVSEL, a1: C_VREG, a2: C_VREG, a3: C_VREG, a6: C_VREG},
+
+	// VRR-f
+	{i: 122, as: AVLVGP, a1: C_REG, a2: C_REG, a6: C_VREG},
+}
+
+var oprange [ALAST & obj.AMask][]Optab
+
+var xcmp [C_NCLASS][C_NCLASS]bool
+
+func spanz(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
+	if ctxt.Retpoline {
+		ctxt.Diag("-spectre=ret not supported on s390x")
+		ctxt.Retpoline = false // don't keep printing
+	}
+
+	p := cursym.Func.Text
+	if p == nil || p.Link == nil { // handle external functions and ELF section symbols
+		return
+	}
+
+	if oprange[AORW&obj.AMask] == nil {
+		ctxt.Diag("s390x ops not initialized, call s390x.buildop first")
+	}
+
+	c := ctxtz{ctxt: ctxt, newprog: newprog, cursym: cursym, autosize: int32(p.To.Offset)}
+
+	buffer := make([]byte, 0)
+	changed := true
+	loop := 0
+	for changed {
+		if loop > 100 {
+			c.ctxt.Diag("stuck in spanz loop")
+			break
+		}
+		changed = false
+		buffer = buffer[:0]
+		c.cursym.R = make([]obj.Reloc, 0)
+		for p := c.cursym.Func.Text; p != nil; p = p.Link {
+			pc := int64(len(buffer))
+			if pc != p.Pc {
+				changed = true
+			}
+			p.Pc = pc
+			c.pc = p.Pc
+			c.asmout(p, &buffer)
+			if pc == int64(len(buffer)) {
+				switch p.As {
+				case obj.ANOP, obj.AFUNCDATA, obj.APCDATA, obj.ATEXT:
+					// ok
+				default:
+					c.ctxt.Diag("zero-width instruction\n%v", p)
+				}
+			}
+		}
+		loop++
+	}
+
+	c.cursym.Size = int64(len(buffer))
+	if c.cursym.Size%funcAlign != 0 {
+		c.cursym.Size += funcAlign - (c.cursym.Size % funcAlign)
+	}
+	c.cursym.Grow(c.cursym.Size)
+	copy(c.cursym.P, buffer)
+
+	// Mark nonpreemptible instruction sequences.
+	// We use REGTMP as a scratch register during call injection,
+	// so instruction sequences that use REGTMP are unsafe to
+	// preempt asynchronously.
+	obj.MarkUnsafePoints(c.ctxt, c.cursym.Func.Text, c.newprog, c.isUnsafePoint, nil)
+}
+
+// Return whether p is an unsafe point.
+func (c *ctxtz) isUnsafePoint(p *obj.Prog) bool {
+	if p.From.Reg == REGTMP || p.To.Reg == REGTMP || p.Reg == REGTMP {
+		return true
+	}
+	for _, a := range p.RestArgs {
+		if a.Reg == REGTMP {
+			return true
+		}
+	}
+	return p.Mark&USETMP != 0
+}
+
+func isint32(v int64) bool {
+	return int64(int32(v)) == v
+}
+
+func isuint32(v uint64) bool {
+	return uint64(uint32(v)) == v
+}
+
+func (c *ctxtz) aclass(a *obj.Addr) int {
+	switch a.Type {
+	case obj.TYPE_NONE:
+		return C_NONE
+
+	case obj.TYPE_REG:
+		if REG_R0 <= a.Reg && a.Reg <= REG_R15 {
+			return C_REG
+		}
+		if REG_F0 <= a.Reg && a.Reg <= REG_F15 {
+			return C_FREG
+		}
+		if REG_AR0 <= a.Reg && a.Reg <= REG_AR15 {
+			return C_AREG
+		}
+		if REG_V0 <= a.Reg && a.Reg <= REG_V31 {
+			return C_VREG
+		}
+		return C_GOK
+
+	case obj.TYPE_MEM:
+		switch a.Name {
+		case obj.NAME_EXTERN,
+			obj.NAME_STATIC:
+			if a.Sym == nil {
+				// must have a symbol
+				break
+			}
+			c.instoffset = a.Offset
+			if a.Sym.Type == objabi.STLSBSS {
+				if c.ctxt.Flag_shared {
+					return C_TLS_IE // initial exec model
+				}
+				return C_TLS_LE // local exec model
+			}
+			return C_ADDR
+
+		case obj.NAME_GOTREF:
+			return C_GOTADDR
+
+		case obj.NAME_AUTO:
+			if a.Reg == REGSP {
+				// unset base register for better printing, since
+				// a.Offset is still relative to pseudo-SP.
+				a.Reg = obj.REG_NONE
+			}
+			c.instoffset = int64(c.autosize) + a.Offset
+			if c.instoffset >= -BIG && c.instoffset < BIG {
+				return C_SAUTO
+			}
+			return C_LAUTO
+
+		case obj.NAME_PARAM:
+			if a.Reg == REGSP {
+				// unset base register for better printing, since
+				// a.Offset is still relative to pseudo-FP.
+				a.Reg = obj.REG_NONE
+			}
+			c.instoffset = int64(c.autosize) + a.Offset + c.ctxt.FixedFrameSize()
+			if c.instoffset >= -BIG && c.instoffset < BIG {
+				return C_SAUTO
+			}
+			return C_LAUTO
+
+		case obj.NAME_NONE:
+			c.instoffset = a.Offset
+			if c.instoffset == 0 {
+				return C_ZOREG
+			}
+			if c.instoffset >= -BIG && c.instoffset < BIG {
+				return C_SOREG
+			}
+			return C_LOREG
+		}
+
+		return C_GOK
+
+	case obj.TYPE_TEXTSIZE:
+		return C_TEXTSIZE
+
+	case obj.TYPE_FCONST:
+		if f64, ok := a.Val.(float64); ok && math.Float64bits(f64) == 0 {
+			return C_ZCON
+		}
+		c.ctxt.Diag("cannot handle the floating point constant %v", a.Val)
+
+	case obj.TYPE_CONST,
+		obj.TYPE_ADDR:
+		switch a.Name {
+		case obj.NAME_NONE:
+			c.instoffset = a.Offset
+			if a.Reg != 0 {
+				if -BIG <= c.instoffset && c.instoffset <= BIG {
+					return C_SACON
+				}
+				if isint32(c.instoffset) {
+					return C_LACON
+				}
+				return C_DACON
+			}
+
+		case obj.NAME_EXTERN,
+			obj.NAME_STATIC:
+			s := a.Sym
+			if s == nil {
+				return C_GOK
+			}
+			c.instoffset = a.Offset
+
+			return C_SYMADDR
+
+		case obj.NAME_AUTO:
+			if a.Reg == REGSP {
+				// unset base register for better printing, since
+				// a.Offset is still relative to pseudo-SP.
+				a.Reg = obj.REG_NONE
+			}
+			c.instoffset = int64(c.autosize) + a.Offset
+			if c.instoffset >= -BIG && c.instoffset < BIG {
+				return C_SACON
+			}
+			return C_LACON
+
+		case obj.NAME_PARAM:
+			if a.Reg == REGSP {
+				// unset base register for better printing, since
+				// a.Offset is still relative to pseudo-FP.
+				a.Reg = obj.REG_NONE
+			}
+			c.instoffset = int64(c.autosize) + a.Offset + c.ctxt.FixedFrameSize()
+			if c.instoffset >= -BIG && c.instoffset < BIG {
+				return C_SACON
+			}
+			return C_LACON
+
+		default:
+			return C_GOK
+		}
+
+		if c.instoffset == 0 {
+			return C_ZCON
+		}
+		if c.instoffset >= 0 {
+			if c.instoffset <= 0x7fff {
+				return C_SCON
+			}
+			if c.instoffset <= 0xffff {
+				return C_ANDCON
+			}
+			if c.instoffset&0xffff == 0 && isuint32(uint64(c.instoffset)) { /* && (instoffset & (1<<31)) == 0) */
+				return C_UCON
+			}
+			if isint32(c.instoffset) || isuint32(uint64(c.instoffset)) {
+				return C_LCON
+			}
+			return C_DCON
+		}
+
+		if c.instoffset >= -0x8000 {
+			return C_ADDCON
+		}
+		if c.instoffset&0xffff == 0 && isint32(c.instoffset) {
+			return C_UCON
+		}
+		if isint32(c.instoffset) {
+			return C_LCON
+		}
+		return C_DCON
+
+	case obj.TYPE_BRANCH:
+		return C_SBRA
+	}
+
+	return C_GOK
+}
+
+func (c *ctxtz) oplook(p *obj.Prog) *Optab {
+	// Return cached optab entry if available.
+	if p.Optab != 0 {
+		return &optab[p.Optab-1]
+	}
+	if len(p.RestArgs) > 3 {
+		c.ctxt.Diag("too many RestArgs: got %v, maximum is 3\n", len(p.RestArgs))
+		return nil
+	}
+
+	// Initialize classes for all arguments.
+	p.From.Class = int8(c.aclass(&p.From) + 1)
+	p.To.Class = int8(c.aclass(&p.To) + 1)
+	for i := range p.RestArgs {
+		p.RestArgs[i].Class = int8(c.aclass(&p.RestArgs[i]) + 1)
+	}
+
+	// Mirrors the argument list in Optab.
+	args := [...]int8{
+		p.From.Class - 1,
+		C_NONE, // p.Reg
+		C_NONE, // p.RestArgs[0]
+		C_NONE, // p.RestArgs[1]
+		C_NONE, // p.RestArgs[2]
+		p.To.Class - 1,
+	}
+	// Fill in argument class for p.Reg.
+	switch {
+	case REG_R0 <= p.Reg && p.Reg <= REG_R15:
+		args[1] = C_REG
+	case REG_V0 <= p.Reg && p.Reg <= REG_V31:
+		args[1] = C_VREG
+	case REG_F0 <= p.Reg && p.Reg <= REG_F15:
+		args[1] = C_FREG
+	case REG_AR0 <= p.Reg && p.Reg <= REG_AR15:
+		args[1] = C_AREG
+	}
+	// Fill in argument classes for p.RestArgs.
+	for i, a := range p.RestArgs {
+		args[2+i] = a.Class - 1
+	}
+
+	// Lookup op in optab.
+	ops := oprange[p.As&obj.AMask]
+	cmp := [len(args)]*[C_NCLASS]bool{}
+	for i := range cmp {
+		cmp[i] = &xcmp[args[i]]
+	}
+	for i := range ops {
+		op := &ops[i]
+		if cmp[0][op.a1] && cmp[1][op.a2] &&
+			cmp[2][op.a3] && cmp[3][op.a4] &&
+			cmp[4][op.a5] && cmp[5][op.a6] {
+			p.Optab = uint16(cap(optab) - cap(ops) + i + 1)
+			return op
+		}
+	}
+
+	// Cannot find a case; abort.
+	s := ""
+	for _, a := range args {
+		s += fmt.Sprintf(" %v", DRconv(int(a)))
+	}
+	c.ctxt.Diag("illegal combination %v%v\n", p.As, s)
+	c.ctxt.Diag("prog: %v\n", p)
+	return nil
+}
+
+func cmp(a int, b int) bool {
+	if a == b {
+		return true
+	}
+	switch a {
+	case C_DCON:
+		if b == C_LCON {
+			return true
+		}
+		fallthrough
+	case C_LCON:
+		if b == C_ZCON || b == C_SCON || b == C_UCON || b == C_ADDCON || b == C_ANDCON {
+			return true
+		}
+
+	case C_ADDCON:
+		if b == C_ZCON || b == C_SCON {
+			return true
+		}
+
+	case C_ANDCON:
+		if b == C_ZCON || b == C_SCON {
+			return true
+		}
+
+	case C_UCON:
+		if b == C_ZCON || b == C_SCON {
+			return true
+		}
+
+	case C_SCON:
+		if b == C_ZCON {
+			return true
+		}
+
+	case C_LACON:
+		if b == C_SACON {
+			return true
+		}
+
+	case C_LBRA:
+		if b == C_SBRA {
+			return true
+		}
+
+	case C_LAUTO:
+		if b == C_SAUTO {
+			return true
+		}
+
+	case C_LOREG:
+		if b == C_ZOREG || b == C_SOREG {
+			return true
+		}
+
+	case C_SOREG:
+		if b == C_ZOREG {
+			return true
+		}
+
+	case C_ANY:
+		return true
+	}
+
+	return false
+}
+
+type ocmp []Optab
+
+func (x ocmp) Len() int {
+	return len(x)
+}
+
+func (x ocmp) Swap(i, j int) {
+	x[i], x[j] = x[j], x[i]
+}
+
+func (x ocmp) Less(i, j int) bool {
+	p1 := &x[i]
+	p2 := &x[j]
+	n := int(p1.as) - int(p2.as)
+	if n != 0 {
+		return n < 0
+	}
+	n = int(p1.a1) - int(p2.a1)
+	if n != 0 {
+		return n < 0
+	}
+	n = int(p1.a2) - int(p2.a2)
+	if n != 0 {
+		return n < 0
+	}
+	n = int(p1.a3) - int(p2.a3)
+	if n != 0 {
+		return n < 0
+	}
+	n = int(p1.a4) - int(p2.a4)
+	if n != 0 {
+		return n < 0
+	}
+	return false
+}
+func opset(a, b obj.As) {
+	oprange[a&obj.AMask] = oprange[b&obj.AMask]
+}
+
+func buildop(ctxt *obj.Link) {
+	if oprange[AORW&obj.AMask] != nil {
+		// Already initialized; stop now.
+		// This happens in the cmd/asm tests,
+		// each of which re-initializes the arch.
+		return
+	}
+
+	for i := 0; i < C_NCLASS; i++ {
+		for n := 0; n < C_NCLASS; n++ {
+			if cmp(n, i) {
+				xcmp[i][n] = true
+			}
+		}
+	}
+	sort.Sort(ocmp(optab))
+	for i := 0; i < len(optab); i++ {
+		r := optab[i].as
+		start := i
+		for ; i+1 < len(optab); i++ {
+			if optab[i+1].as != r {
+				break
+			}
+		}
+		oprange[r&obj.AMask] = optab[start : i+1]
+
+		// opset() aliases optab ranges for similar instructions, to reduce the number of optabs in the array.
+		// oprange[] is used by oplook() to find the Optab entry that applies to a given Prog.
+		switch r {
+		case AADD:
+			opset(AADDC, r)
+			opset(AADDW, r)
+			opset(AADDE, r)
+			opset(AMULLD, r)
+			opset(AMULLW, r)
+		case ADIVW:
+			opset(ADIVD, r)
+			opset(ADIVDU, r)
+			opset(ADIVWU, r)
+			opset(AMODD, r)
+			opset(AMODDU, r)
+			opset(AMODW, r)
+			opset(AMODWU, r)
+		case AMULHD:
+			opset(AMULHDU, r)
+		case AMOVBZ:
+			opset(AMOVH, r)
+			opset(AMOVHZ, r)
+		case ALA:
+			opset(ALAY, r)
+		case AMVC:
+			opset(AMVCIN, r)
+			opset(ACLC, r)
+			opset(AXC, r)
+			opset(AOC, r)
+			opset(ANC, r)
+		case ASTCK:
+			opset(ASTCKC, r)
+			opset(ASTCKE, r)
+			opset(ASTCKF, r)
+		case ALAAG:
+			opset(ALAA, r)
+			opset(ALAAL, r)
+			opset(ALAALG, r)
+			opset(ALAN, r)
+			opset(ALANG, r)
+			opset(ALAX, r)
+			opset(ALAXG, r)
+			opset(ALAO, r)
+			opset(ALAOG, r)
+		case ASTMG:
+			opset(ASTMY, r)
+		case ALMG:
+			opset(ALMY, r)
+		case ABEQ:
+			opset(ABGE, r)
+			opset(ABGT, r)
+			opset(ABLE, r)
+			opset(ABLT, r)
+			opset(ABNE, r)
+			opset(ABVC, r)
+			opset(ABVS, r)
+			opset(ABLEU, r)
+			opset(ABLTU, r)
+		case ABR:
+			opset(ABL, r)
+		case ABC:
+			opset(ABCL, r)
+		case AFABS:
+			opset(AFNABS, r)
+			opset(ALPDFR, r)
+			opset(ALNDFR, r)
+			opset(AFNEG, r)
+			opset(AFNEGS, r)
+			opset(ALEDBR, r)
+			opset(ALDEBR, r)
+			opset(AFSQRT, r)
+			opset(AFSQRTS, r)
+		case AFADD:
+			opset(AFADDS, r)
+			opset(AFDIV, r)
+			opset(AFDIVS, r)
+			opset(AFSUB, r)
+			opset(AFSUBS, r)
+		case AFMADD:
+			opset(AFMADDS, r)
+			opset(AFMSUB, r)
+			opset(AFMSUBS, r)
+		case AFMUL:
+			opset(AFMULS, r)
+		case AFCMPO:
+			opset(AFCMPU, r)
+			opset(ACEBR, r)
+		case AAND:
+			opset(AOR, r)
+			opset(AXOR, r)
+		case AANDW:
+			opset(AORW, r)
+			opset(AXORW, r)
+		case ASLD:
+			opset(ASRD, r)
+			opset(ASLW, r)
+			opset(ASRW, r)
+			opset(ASRAD, r)
+			opset(ASRAW, r)
+			opset(ARLL, r)
+			opset(ARLLG, r)
+		case ARNSBG:
+			opset(ARXSBG, r)
+			opset(AROSBG, r)
+			opset(ARNSBGT, r)
+			opset(ARXSBGT, r)
+			opset(AROSBGT, r)
+			opset(ARISBG, r)
+			opset(ARISBGN, r)
+			opset(ARISBGZ, r)
+			opset(ARISBGNZ, r)
+			opset(ARISBHG, r)
+			opset(ARISBLG, r)
+			opset(ARISBHGZ, r)
+			opset(ARISBLGZ, r)
+		case ACSG:
+			opset(ACS, r)
+		case ASUB:
+			opset(ASUBC, r)
+			opset(ASUBE, r)
+			opset(ASUBW, r)
+		case ANEG:
+			opset(ANEGW, r)
+		case AFMOVD:
+			opset(AFMOVS, r)
+		case AMOVDBR:
+			opset(AMOVWBR, r)
+		case ACMP:
+			opset(ACMPW, r)
+		case ACMPU:
+			opset(ACMPWU, r)
+		case ATMHH:
+			opset(ATMHL, r)
+			opset(ATMLH, r)
+			opset(ATMLL, r)
+		case ACEFBRA:
+			opset(ACDFBRA, r)
+			opset(ACEGBRA, r)
+			opset(ACDGBRA, r)
+			opset(ACELFBR, r)
+			opset(ACDLFBR, r)
+			opset(ACELGBR, r)
+			opset(ACDLGBR, r)
+		case ACFEBRA:
+			opset(ACFDBRA, r)
+			opset(ACGEBRA, r)
+			opset(ACGDBRA, r)
+			opset(ACLFEBR, r)
+			opset(ACLFDBR, r)
+			opset(ACLGEBR, r)
+			opset(ACLGDBR, r)
+		case AFIEBR:
+			opset(AFIDBR, r)
+		case ACMPBEQ:
+			opset(ACMPBGE, r)
+			opset(ACMPBGT, r)
+			opset(ACMPBLE, r)
+			opset(ACMPBLT, r)
+			opset(ACMPBNE, r)
+		case ACMPUBEQ:
+			opset(ACMPUBGE, r)
+			opset(ACMPUBGT, r)
+			opset(ACMPUBLE, r)
+			opset(ACMPUBLT, r)
+			opset(ACMPUBNE, r)
+		case ACGRJ:
+			opset(ACRJ, r)
+		case ACLGRJ:
+			opset(ACLRJ, r)
+		case ACGIJ:
+			opset(ACIJ, r)
+		case ACLGIJ:
+			opset(ACLIJ, r)
+		case AMOVDEQ:
+			opset(AMOVDGE, r)
+			opset(AMOVDGT, r)
+			opset(AMOVDLE, r)
+			opset(AMOVDLT, r)
+			opset(AMOVDNE, r)
+		case ALOCGR:
+			opset(ALOCR, r)
+		case ALTDBR:
+			opset(ALTEBR, r)
+		case ATCDB:
+			opset(ATCEB, r)
+		case AVL:
+			opset(AVLLEZB, r)
+			opset(AVLLEZH, r)
+			opset(AVLLEZF, r)
+			opset(AVLLEZG, r)
+			opset(AVLREPB, r)
+			opset(AVLREPH, r)
+			opset(AVLREPF, r)
+			opset(AVLREPG, r)
+		case AVLEG:
+			opset(AVLBB, r)
+			opset(AVLEB, r)
+			opset(AVLEH, r)
+			opset(AVLEF, r)
+			opset(AVLEG, r)
+			opset(AVLREP, r)
+		case AVSTEG:
+			opset(AVSTEB, r)
+			opset(AVSTEH, r)
+			opset(AVSTEF, r)
+		case AVSCEG:
+			opset(AVSCEF, r)
+		case AVGEG:
+			opset(AVGEF, r)
+		case AVESLG:
+			opset(AVESLB, r)
+			opset(AVESLH, r)
+			opset(AVESLF, r)
+			opset(AVERLLB, r)
+			opset(AVERLLH, r)
+			opset(AVERLLF, r)
+			opset(AVERLLG, r)
+			opset(AVESRAB, r)
+			opset(AVESRAH, r)
+			opset(AVESRAF, r)
+			opset(AVESRAG, r)
+			opset(AVESRLB, r)
+			opset(AVESRLH, r)
+			opset(AVESRLF, r)
+			opset(AVESRLG, r)
+		case AVLGVG:
+			opset(AVLGVB, r)
+			opset(AVLGVH, r)
+			opset(AVLGVF, r)
+		case AVLVGG:
+			opset(AVLVGB, r)
+			opset(AVLVGH, r)
+			opset(AVLVGF, r)
+		case AVZERO:
+			opset(AVONE, r)
+		case AVREPIG:
+			opset(AVREPIB, r)
+			opset(AVREPIH, r)
+			opset(AVREPIF, r)
+		case AVLEIG:
+			opset(AVLEIB, r)
+			opset(AVLEIH, r)
+			opset(AVLEIF, r)
+		case AVGMG:
+			opset(AVGMB, r)
+			opset(AVGMH, r)
+			opset(AVGMF, r)
+		case AVREPG:
+			opset(AVREPB, r)
+			opset(AVREPH, r)
+			opset(AVREPF, r)
+		case AVERIMG:
+			opset(AVERIMB, r)
+			opset(AVERIMH, r)
+			opset(AVERIMF, r)
+		case AVFTCIDB:
+			opset(AWFTCIDB, r)
+		case AVLR:
+			opset(AVUPHB, r)
+			opset(AVUPHH, r)
+			opset(AVUPHF, r)
+			opset(AVUPLHB, r)
+			opset(AVUPLHH, r)
+			opset(AVUPLHF, r)
+			opset(AVUPLB, r)
+			opset(AVUPLHW, r)
+			opset(AVUPLF, r)
+			opset(AVUPLLB, r)
+			opset(AVUPLLH, r)
+			opset(AVUPLLF, r)
+			opset(AVCLZB, r)
+			opset(AVCLZH, r)
+			opset(AVCLZF, r)
+			opset(AVCLZG, r)
+			opset(AVCTZB, r)
+			opset(AVCTZH, r)
+			opset(AVCTZF, r)
+			opset(AVCTZG, r)
+			opset(AVLDEB, r)
+			opset(AWLDEB, r)
+			opset(AVFLCDB, r)
+			opset(AWFLCDB, r)
+			opset(AVFLNDB, r)
+			opset(AWFLNDB, r)
+			opset(AVFLPDB, r)
+			opset(AWFLPDB, r)
+			opset(AVFSQDB, r)
+			opset(AWFSQDB, r)
+			opset(AVISTRB, r)
+			opset(AVISTRH, r)
+			opset(AVISTRF, r)
+			opset(AVISTRBS, r)
+			opset(AVISTRHS, r)
+			opset(AVISTRFS, r)
+			opset(AVLCB, r)
+			opset(AVLCH, r)
+			opset(AVLCF, r)
+			opset(AVLCG, r)
+			opset(AVLPB, r)
+			opset(AVLPH, r)
+			opset(AVLPF, r)
+			opset(AVLPG, r)
+			opset(AVPOPCT, r)
+			opset(AVSEGB, r)
+			opset(AVSEGH, r)
+			opset(AVSEGF, r)
+		case AVECG:
+			opset(AVECB, r)
+			opset(AVECH, r)
+			opset(AVECF, r)
+			opset(AVECLB, r)
+			opset(AVECLH, r)
+			opset(AVECLF, r)
+			opset(AVECLG, r)
+			opset(AWFCDB, r)
+			opset(AWFKDB, r)
+		case AVCEQG:
+			opset(AVCEQB, r)
+			opset(AVCEQH, r)
+			opset(AVCEQF, r)
+			opset(AVCEQBS, r)
+			opset(AVCEQHS, r)
+			opset(AVCEQFS, r)
+			opset(AVCEQGS, r)
+			opset(AVCHB, r)
+			opset(AVCHH, r)
+			opset(AVCHF, r)
+			opset(AVCHG, r)
+			opset(AVCHBS, r)
+			opset(AVCHHS, r)
+			opset(AVCHFS, r)
+			opset(AVCHGS, r)
+			opset(AVCHLB, r)
+			opset(AVCHLH, r)
+			opset(AVCHLF, r)
+			opset(AVCHLG, r)
+			opset(AVCHLBS, r)
+			opset(AVCHLHS, r)
+			opset(AVCHLFS, r)
+			opset(AVCHLGS, r)
+		case AVFAEF:
+			opset(AVFAEB, r)
+			opset(AVFAEH, r)
+			opset(AVFAEBS, r)
+			opset(AVFAEHS, r)
+			opset(AVFAEFS, r)
+			opset(AVFAEZB, r)
+			opset(AVFAEZH, r)
+			opset(AVFAEZF, r)
+			opset(AVFAEZBS, r)
+			opset(AVFAEZHS, r)
+			opset(AVFAEZFS, r)
+			opset(AVFEEB, r)
+			opset(AVFEEH, r)
+			opset(AVFEEF, r)
+			opset(AVFEEBS, r)
+			opset(AVFEEHS, r)
+			opset(AVFEEFS, r)
+			opset(AVFEEZB, r)
+			opset(AVFEEZH, r)
+			opset(AVFEEZF, r)
+			opset(AVFEEZBS, r)
+			opset(AVFEEZHS, r)
+			opset(AVFEEZFS, r)
+			opset(AVFENEB, r)
+			opset(AVFENEH, r)
+			opset(AVFENEF, r)
+			opset(AVFENEBS, r)
+			opset(AVFENEHS, r)
+			opset(AVFENEFS, r)
+			opset(AVFENEZB, r)
+			opset(AVFENEZH, r)
+			opset(AVFENEZF, r)
+			opset(AVFENEZBS, r)
+			opset(AVFENEZHS, r)
+			opset(AVFENEZFS, r)
+		case AVPKSG:
+			opset(AVPKSH, r)
+			opset(AVPKSF, r)
+			opset(AVPKSHS, r)
+			opset(AVPKSFS, r)
+			opset(AVPKSGS, r)
+			opset(AVPKLSH, r)
+			opset(AVPKLSF, r)
+			opset(AVPKLSG, r)
+			opset(AVPKLSHS, r)
+			opset(AVPKLSFS, r)
+			opset(AVPKLSGS, r)
+		case AVAQ:
+			opset(AVAB, r)
+			opset(AVAH, r)
+			opset(AVAF, r)
+			opset(AVAG, r)
+			opset(AVACCB, r)
+			opset(AVACCH, r)
+			opset(AVACCF, r)
+			opset(AVACCG, r)
+			opset(AVACCQ, r)
+			opset(AVN, r)
+			opset(AVNC, r)
+			opset(AVAVGB, r)
+			opset(AVAVGH, r)
+			opset(AVAVGF, r)
+			opset(AVAVGG, r)
+			opset(AVAVGLB, r)
+			opset(AVAVGLH, r)
+			opset(AVAVGLF, r)
+			opset(AVAVGLG, r)
+			opset(AVCKSM, r)
+			opset(AVX, r)
+			opset(AVFADB, r)
+			opset(AWFADB, r)
+			opset(AVFCEDB, r)
+			opset(AVFCEDBS, r)
+			opset(AWFCEDB, r)
+			opset(AWFCEDBS, r)
+			opset(AVFCHDB, r)
+			opset(AVFCHDBS, r)
+			opset(AWFCHDB, r)
+			opset(AWFCHDBS, r)
+			opset(AVFCHEDB, r)
+			opset(AVFCHEDBS, r)
+			opset(AWFCHEDB, r)
+			opset(AWFCHEDBS, r)
+			opset(AVFMDB, r)
+			opset(AWFMDB, r)
+			opset(AVGFMB, r)
+			opset(AVGFMH, r)
+			opset(AVGFMF, r)
+			opset(AVGFMG, r)
+			opset(AVMXB, r)
+			opset(AVMXH, r)
+			opset(AVMXF, r)
+			opset(AVMXG, r)
+			opset(AVMXLB, r)
+			opset(AVMXLH, r)
+			opset(AVMXLF, r)
+			opset(AVMXLG, r)
+			opset(AVMNB, r)
+			opset(AVMNH, r)
+			opset(AVMNF, r)
+			opset(AVMNG, r)
+			opset(AVMNLB, r)
+			opset(AVMNLH, r)
+			opset(AVMNLF, r)
+			opset(AVMNLG, r)
+			opset(AVMRHB, r)
+			opset(AVMRHH, r)
+			opset(AVMRHF, r)
+			opset(AVMRHG, r)
+			opset(AVMRLB, r)
+			opset(AVMRLH, r)
+			opset(AVMRLF, r)
+			opset(AVMRLG, r)
+			opset(AVMEB, r)
+			opset(AVMEH, r)
+			opset(AVMEF, r)
+			opset(AVMLEB, r)
+			opset(AVMLEH, r)
+			opset(AVMLEF, r)
+			opset(AVMOB, r)
+			opset(AVMOH, r)
+			opset(AVMOF, r)
+			opset(AVMLOB, r)
+			opset(AVMLOH, r)
+			opset(AVMLOF, r)
+			opset(AVMHB, r)
+			opset(AVMHH, r)
+			opset(AVMHF, r)
+			opset(AVMLHB, r)
+			opset(AVMLHH, r)
+			opset(AVMLHF, r)
+			opset(AVMLH, r)
+			opset(AVMLHW, r)
+			opset(AVMLF, r)
+			opset(AVNO, r)
+			opset(AVO, r)
+			opset(AVPKH, r)
+			opset(AVPKF, r)
+			opset(AVPKG, r)
+			opset(AVSUMGH, r)
+			opset(AVSUMGF, r)
+			opset(AVSUMQF, r)
+			opset(AVSUMQG, r)
+			opset(AVSUMB, r)
+			opset(AVSUMH, r)
+		case AVERLLVG:
+			opset(AVERLLVB, r)
+			opset(AVERLLVH, r)
+			opset(AVERLLVF, r)
+			opset(AVESLVB, r)
+			opset(AVESLVH, r)
+			opset(AVESLVF, r)
+			opset(AVESLVG, r)
+			opset(AVESRAVB, r)
+			opset(AVESRAVH, r)
+			opset(AVESRAVF, r)
+			opset(AVESRAVG, r)
+			opset(AVESRLVB, r)
+			opset(AVESRLVH, r)
+			opset(AVESRLVF, r)
+			opset(AVESRLVG, r)
+			opset(AVFDDB, r)
+			opset(AWFDDB, r)
+			opset(AVFSDB, r)
+			opset(AWFSDB, r)
+			opset(AVSL, r)
+			opset(AVSLB, r)
+			opset(AVSRA, r)
+			opset(AVSRAB, r)
+			opset(AVSRL, r)
+			opset(AVSRLB, r)
+			opset(AVSB, r)
+			opset(AVSH, r)
+			opset(AVSF, r)
+			opset(AVSG, r)
+			opset(AVSQ, r)
+			opset(AVSCBIB, r)
+			opset(AVSCBIH, r)
+			opset(AVSCBIF, r)
+			opset(AVSCBIG, r)
+			opset(AVSCBIQ, r)
+		case AVACQ:
+			opset(AVACCCQ, r)
+			opset(AVGFMAB, r)
+			opset(AVGFMAH, r)
+			opset(AVGFMAF, r)
+			opset(AVGFMAG, r)
+			opset(AVMALB, r)
+			opset(AVMALHW, r)
+			opset(AVMALF, r)
+			opset(AVMAHB, r)
+			opset(AVMAHH, r)
+			opset(AVMAHF, r)
+			opset(AVMALHB, r)
+			opset(AVMALHH, r)
+			opset(AVMALHF, r)
+			opset(AVMAEB, r)
+			opset(AVMAEH, r)
+			opset(AVMAEF, r)
+			opset(AVMALEB, r)
+			opset(AVMALEH, r)
+			opset(AVMALEF, r)
+			opset(AVMAOB, r)
+			opset(AVMAOH, r)
+			opset(AVMAOF, r)
+			opset(AVMALOB, r)
+			opset(AVMALOH, r)
+			opset(AVMALOF, r)
+			opset(AVSTRCB, r)
+			opset(AVSTRCH, r)
+			opset(AVSTRCF, r)
+			opset(AVSTRCBS, r)
+			opset(AVSTRCHS, r)
+			opset(AVSTRCFS, r)
+			opset(AVSTRCZB, r)
+			opset(AVSTRCZH, r)
+			opset(AVSTRCZF, r)
+			opset(AVSTRCZBS, r)
+			opset(AVSTRCZHS, r)
+			opset(AVSTRCZFS, r)
+			opset(AVSBCBIQ, r)
+			opset(AVSBIQ, r)
+			opset(AVMSLG, r)
+			opset(AVMSLEG, r)
+			opset(AVMSLOG, r)
+			opset(AVMSLEOG, r)
+		case AVSEL:
+			opset(AVFMADB, r)
+			opset(AWFMADB, r)
+			opset(AVFMSDB, r)
+			opset(AWFMSDB, r)
+			opset(AVPERM, r)
+		}
+	}
+}
+
+const (
+	op_A       uint32 = 0x5A00 // FORMAT_RX1        ADD (32)
+	op_AD      uint32 = 0x6A00 // FORMAT_RX1        ADD NORMALIZED (long HFP)
+	op_ADB     uint32 = 0xED1A // FORMAT_RXE        ADD (long BFP)
+	op_ADBR    uint32 = 0xB31A // FORMAT_RRE        ADD (long BFP)
+	op_ADR     uint32 = 0x2A00 // FORMAT_RR         ADD NORMALIZED (long HFP)
+	op_ADTR    uint32 = 0xB3D2 // FORMAT_RRF1       ADD (long DFP)
+	op_ADTRA   uint32 = 0xB3D2 // FORMAT_RRF1       ADD (long DFP)
+	op_AE      uint32 = 0x7A00 // FORMAT_RX1        ADD NORMALIZED (short HFP)
+	op_AEB     uint32 = 0xED0A // FORMAT_RXE        ADD (short BFP)
+	op_AEBR    uint32 = 0xB30A // FORMAT_RRE        ADD (short BFP)
+	op_AER     uint32 = 0x3A00 // FORMAT_RR         ADD NORMALIZED (short HFP)
+	op_AFI     uint32 = 0xC209 // FORMAT_RIL1       ADD IMMEDIATE (32)
+	op_AG      uint32 = 0xE308 // FORMAT_RXY1       ADD (64)
+	op_AGF     uint32 = 0xE318 // FORMAT_RXY1       ADD (64<-32)
+	op_AGFI    uint32 = 0xC208 // FORMAT_RIL1       ADD IMMEDIATE (64<-32)
+	op_AGFR    uint32 = 0xB918 // FORMAT_RRE        ADD (64<-32)
+	op_AGHI    uint32 = 0xA70B // FORMAT_RI1        ADD HALFWORD IMMEDIATE (64)
+	op_AGHIK   uint32 = 0xECD9 // FORMAT_RIE4       ADD IMMEDIATE (64<-16)
+	op_AGR     uint32 = 0xB908 // FORMAT_RRE        ADD (64)
+	op_AGRK    uint32 = 0xB9E8 // FORMAT_RRF1       ADD (64)
+	op_AGSI    uint32 = 0xEB7A // FORMAT_SIY        ADD IMMEDIATE (64<-8)
+	op_AH      uint32 = 0x4A00 // FORMAT_RX1        ADD HALFWORD
+	op_AHHHR   uint32 = 0xB9C8 // FORMAT_RRF1       ADD HIGH (32)
+	op_AHHLR   uint32 = 0xB9D8 // FORMAT_RRF1       ADD HIGH (32)
+	op_AHI     uint32 = 0xA70A // FORMAT_RI1        ADD HALFWORD IMMEDIATE (32)
+	op_AHIK    uint32 = 0xECD8 // FORMAT_RIE4       ADD IMMEDIATE (32<-16)
+	op_AHY     uint32 = 0xE37A // FORMAT_RXY1       ADD HALFWORD
+	op_AIH     uint32 = 0xCC08 // FORMAT_RIL1       ADD IMMEDIATE HIGH (32)
+	op_AL      uint32 = 0x5E00 // FORMAT_RX1        ADD LOGICAL (32)
+	op_ALC     uint32 = 0xE398 // FORMAT_RXY1       ADD LOGICAL WITH CARRY (32)
+	op_ALCG    uint32 = 0xE388 // FORMAT_RXY1       ADD LOGICAL WITH CARRY (64)
+	op_ALCGR   uint32 = 0xB988 // FORMAT_RRE        ADD LOGICAL WITH CARRY (64)
+	op_ALCR    uint32 = 0xB998 // FORMAT_RRE        ADD LOGICAL WITH CARRY (32)
+	op_ALFI    uint32 = 0xC20B // FORMAT_RIL1       ADD LOGICAL IMMEDIATE (32)
+	op_ALG     uint32 = 0xE30A // FORMAT_RXY1       ADD LOGICAL (64)
+	op_ALGF    uint32 = 0xE31A // FORMAT_RXY1       ADD LOGICAL (64<-32)
+	op_ALGFI   uint32 = 0xC20A // FORMAT_RIL1       ADD LOGICAL IMMEDIATE (64<-32)
+	op_ALGFR   uint32 = 0xB91A // FORMAT_RRE        ADD LOGICAL (64<-32)
+	op_ALGHSIK uint32 = 0xECDB // FORMAT_RIE4       ADD LOGICAL WITH SIGNED IMMEDIATE (64<-16)
+	op_ALGR    uint32 = 0xB90A // FORMAT_RRE        ADD LOGICAL (64)
+	op_ALGRK   uint32 = 0xB9EA // FORMAT_RRF1       ADD LOGICAL (64)
+	op_ALGSI   uint32 = 0xEB7E // FORMAT_SIY        ADD LOGICAL WITH SIGNED IMMEDIATE (64<-8)
+	op_ALHHHR  uint32 = 0xB9CA // FORMAT_RRF1       ADD LOGICAL HIGH (32)
+	op_ALHHLR  uint32 = 0xB9DA // FORMAT_RRF1       ADD LOGICAL HIGH (32)
+	op_ALHSIK  uint32 = 0xECDA // FORMAT_RIE4       ADD LOGICAL WITH SIGNED IMMEDIATE (32<-16)
+	op_ALR     uint32 = 0x1E00 // FORMAT_RR         ADD LOGICAL (32)
+	op_ALRK    uint32 = 0xB9FA // FORMAT_RRF1       ADD LOGICAL (32)
+	op_ALSI    uint32 = 0xEB6E // FORMAT_SIY        ADD LOGICAL WITH SIGNED IMMEDIATE (32<-8)
+	op_ALSIH   uint32 = 0xCC0A // FORMAT_RIL1       ADD LOGICAL WITH SIGNED IMMEDIATE HIGH (32)
+	op_ALSIHN  uint32 = 0xCC0B // FORMAT_RIL1       ADD LOGICAL WITH SIGNED IMMEDIATE HIGH (32)
+	op_ALY     uint32 = 0xE35E // FORMAT_RXY1       ADD LOGICAL (32)
+	op_AP      uint32 = 0xFA00 // FORMAT_SS2        ADD DECIMAL
+	op_AR      uint32 = 0x1A00 // FORMAT_RR         ADD (32)
+	op_ARK     uint32 = 0xB9F8 // FORMAT_RRF1       ADD (32)
+	op_ASI     uint32 = 0xEB6A // FORMAT_SIY        ADD IMMEDIATE (32<-8)
+	op_AU      uint32 = 0x7E00 // FORMAT_RX1        ADD UNNORMALIZED (short HFP)
+	op_AUR     uint32 = 0x3E00 // FORMAT_RR         ADD UNNORMALIZED (short HFP)
+	op_AW      uint32 = 0x6E00 // FORMAT_RX1        ADD UNNORMALIZED (long HFP)
+	op_AWR     uint32 = 0x2E00 // FORMAT_RR         ADD UNNORMALIZED (long HFP)
+	op_AXBR    uint32 = 0xB34A // FORMAT_RRE        ADD (extended BFP)
+	op_AXR     uint32 = 0x3600 // FORMAT_RR         ADD NORMALIZED (extended HFP)
+	op_AXTR    uint32 = 0xB3DA // FORMAT_RRF1       ADD (extended DFP)
+	op_AXTRA   uint32 = 0xB3DA // FORMAT_RRF1       ADD (extended DFP)
+	op_AY      uint32 = 0xE35A // FORMAT_RXY1       ADD (32)
+	op_BAKR    uint32 = 0xB240 // FORMAT_RRE        BRANCH AND STACK
+	op_BAL     uint32 = 0x4500 // FORMAT_RX1        BRANCH AND LINK
+	op_BALR    uint32 = 0x0500 // FORMAT_RR         BRANCH AND LINK
+	op_BAS     uint32 = 0x4D00 // FORMAT_RX1        BRANCH AND SAVE
+	op_BASR    uint32 = 0x0D00 // FORMAT_RR         BRANCH AND SAVE
+	op_BASSM   uint32 = 0x0C00 // FORMAT_RR         BRANCH AND SAVE AND SET MODE
+	op_BC      uint32 = 0x4700 // FORMAT_RX2        BRANCH ON CONDITION
+	op_BCR     uint32 = 0x0700 // FORMAT_RR         BRANCH ON CONDITION
+	op_BCT     uint32 = 0x4600 // FORMAT_RX1        BRANCH ON COUNT (32)
+	op_BCTG    uint32 = 0xE346 // FORMAT_RXY1       BRANCH ON COUNT (64)
+	op_BCTGR   uint32 = 0xB946 // FORMAT_RRE        BRANCH ON COUNT (64)
+	op_BCTR    uint32 = 0x0600 // FORMAT_RR         BRANCH ON COUNT (32)
+	op_BPP     uint32 = 0xC700 // FORMAT_SMI        BRANCH PREDICTION PRELOAD
+	op_BPRP    uint32 = 0xC500 // FORMAT_MII        BRANCH PREDICTION RELATIVE PRELOAD
+	op_BRAS    uint32 = 0xA705 // FORMAT_RI2        BRANCH RELATIVE AND SAVE
+	op_BRASL   uint32 = 0xC005 // FORMAT_RIL2       BRANCH RELATIVE AND SAVE LONG
+	op_BRC     uint32 = 0xA704 // FORMAT_RI3        BRANCH RELATIVE ON CONDITION
+	op_BRCL    uint32 = 0xC004 // FORMAT_RIL3       BRANCH RELATIVE ON CONDITION LONG
+	op_BRCT    uint32 = 0xA706 // FORMAT_RI2        BRANCH RELATIVE ON COUNT (32)
+	op_BRCTG   uint32 = 0xA707 // FORMAT_RI2        BRANCH RELATIVE ON COUNT (64)
+	op_BRCTH   uint32 = 0xCC06 // FORMAT_RIL2       BRANCH RELATIVE ON COUNT HIGH (32)
+	op_BRXH    uint32 = 0x8400 // FORMAT_RSI        BRANCH RELATIVE ON INDEX HIGH (32)
+	op_BRXHG   uint32 = 0xEC44 // FORMAT_RIE5       BRANCH RELATIVE ON INDEX HIGH (64)
+	op_BRXLE   uint32 = 0x8500 // FORMAT_RSI        BRANCH RELATIVE ON INDEX LOW OR EQ. (32)
+	op_BRXLG   uint32 = 0xEC45 // FORMAT_RIE5       BRANCH RELATIVE ON INDEX LOW OR EQ. (64)
+	op_BSA     uint32 = 0xB25A // FORMAT_RRE        BRANCH AND SET AUTHORITY
+	op_BSG     uint32 = 0xB258 // FORMAT_RRE        BRANCH IN SUBSPACE GROUP
+	op_BSM     uint32 = 0x0B00 // FORMAT_RR         BRANCH AND SET MODE
+	op_BXH     uint32 = 0x8600 // FORMAT_RS1        BRANCH ON INDEX HIGH (32)
+	op_BXHG    uint32 = 0xEB44 // FORMAT_RSY1       BRANCH ON INDEX HIGH (64)
+	op_BXLE    uint32 = 0x8700 // FORMAT_RS1        BRANCH ON INDEX LOW OR EQUAL (32)
+	op_BXLEG   uint32 = 0xEB45 // FORMAT_RSY1       BRANCH ON INDEX LOW OR EQUAL (64)
+	op_C       uint32 = 0x5900 // FORMAT_RX1        COMPARE (32)
+	op_CD      uint32 = 0x6900 // FORMAT_RX1        COMPARE (long HFP)
+	op_CDB     uint32 = 0xED19 // FORMAT_RXE        COMPARE (long BFP)
+	op_CDBR    uint32 = 0xB319 // FORMAT_RRE        COMPARE (long BFP)
+	op_CDFBR   uint32 = 0xB395 // FORMAT_RRE        CONVERT FROM FIXED (32 to long BFP)
+	op_CDFBRA  uint32 = 0xB395 // FORMAT_RRF5       CONVERT FROM FIXED (32 to long BFP)
+	op_CDFR    uint32 = 0xB3B5 // FORMAT_RRE        CONVERT FROM FIXED (32 to long HFP)
+	op_CDFTR   uint32 = 0xB951 // FORMAT_RRE        CONVERT FROM FIXED (32 to long DFP)
+	op_CDGBR   uint32 = 0xB3A5 // FORMAT_RRE        CONVERT FROM FIXED (64 to long BFP)
+	op_CDGBRA  uint32 = 0xB3A5 // FORMAT_RRF5       CONVERT FROM FIXED (64 to long BFP)
+	op_CDGR    uint32 = 0xB3C5 // FORMAT_RRE        CONVERT FROM FIXED (64 to long HFP)
+	op_CDGTR   uint32 = 0xB3F1 // FORMAT_RRE        CONVERT FROM FIXED (64 to long DFP)
+	op_CDGTRA  uint32 = 0xB3F1 // FORMAT_RRF5       CONVERT FROM FIXED (64 to long DFP)
+	op_CDLFBR  uint32 = 0xB391 // FORMAT_RRF5       CONVERT FROM LOGICAL (32 to long BFP)
+	op_CDLFTR  uint32 = 0xB953 // FORMAT_RRF5       CONVERT FROM LOGICAL (32 to long DFP)
+	op_CDLGBR  uint32 = 0xB3A1 // FORMAT_RRF5       CONVERT FROM LOGICAL (64 to long BFP)
+	op_CDLGTR  uint32 = 0xB952 // FORMAT_RRF5       CONVERT FROM LOGICAL (64 to long DFP)
+	op_CDR     uint32 = 0x2900 // FORMAT_RR         COMPARE (long HFP)
+	op_CDS     uint32 = 0xBB00 // FORMAT_RS1        COMPARE DOUBLE AND SWAP (32)
+	op_CDSG    uint32 = 0xEB3E // FORMAT_RSY1       COMPARE DOUBLE AND SWAP (64)
+	op_CDSTR   uint32 = 0xB3F3 // FORMAT_RRE        CONVERT FROM SIGNED PACKED (64 to long DFP)
+	op_CDSY    uint32 = 0xEB31 // FORMAT_RSY1       COMPARE DOUBLE AND SWAP (32)
+	op_CDTR    uint32 = 0xB3E4 // FORMAT_RRE        COMPARE (long DFP)
+	op_CDUTR   uint32 = 0xB3F2 // FORMAT_RRE        CONVERT FROM UNSIGNED PACKED (64 to long DFP)
+	op_CDZT    uint32 = 0xEDAA // FORMAT_RSL        CONVERT FROM ZONED (to long DFP)
+	op_CE      uint32 = 0x7900 // FORMAT_RX1        COMPARE (short HFP)
+	op_CEB     uint32 = 0xED09 // FORMAT_RXE        COMPARE (short BFP)
+	op_CEBR    uint32 = 0xB309 // FORMAT_RRE        COMPARE (short BFP)
+	op_CEDTR   uint32 = 0xB3F4 // FORMAT_RRE        COMPARE BIASED EXPONENT (long DFP)
+	op_CEFBR   uint32 = 0xB394 // FORMAT_RRE        CONVERT FROM FIXED (32 to short BFP)
+	op_CEFBRA  uint32 = 0xB394 // FORMAT_RRF5       CONVERT FROM FIXED (32 to short BFP)
+	op_CEFR    uint32 = 0xB3B4 // FORMAT_RRE        CONVERT FROM FIXED (32 to short HFP)
+	op_CEGBR   uint32 = 0xB3A4 // FORMAT_RRE        CONVERT FROM FIXED (64 to short BFP)
+	op_CEGBRA  uint32 = 0xB3A4 // FORMAT_RRF5       CONVERT FROM FIXED (64 to short BFP)
+	op_CEGR    uint32 = 0xB3C4 // FORMAT_RRE        CONVERT FROM FIXED (64 to short HFP)
+	op_CELFBR  uint32 = 0xB390 // FORMAT_RRF5       CONVERT FROM LOGICAL (32 to short BFP)
+	op_CELGBR  uint32 = 0xB3A0 // FORMAT_RRF5       CONVERT FROM LOGICAL (64 to short BFP)
+	op_CER     uint32 = 0x3900 // FORMAT_RR         COMPARE (short HFP)
+	op_CEXTR   uint32 = 0xB3FC // FORMAT_RRE        COMPARE BIASED EXPONENT (extended DFP)
+	op_CFC     uint32 = 0xB21A // FORMAT_S          COMPARE AND FORM CODEWORD
+	op_CFDBR   uint32 = 0xB399 // FORMAT_RRF5       CONVERT TO FIXED (long BFP to 32)
+	op_CFDBRA  uint32 = 0xB399 // FORMAT_RRF5       CONVERT TO FIXED (long BFP to 32)
+	op_CFDR    uint32 = 0xB3B9 // FORMAT_RRF5       CONVERT TO FIXED (long HFP to 32)
+	op_CFDTR   uint32 = 0xB941 // FORMAT_RRF5       CONVERT TO FIXED (long DFP to 32)
+	op_CFEBR   uint32 = 0xB398 // FORMAT_RRF5       CONVERT TO FIXED (short BFP to 32)
+	op_CFEBRA  uint32 = 0xB398 // FORMAT_RRF5       CONVERT TO FIXED (short BFP to 32)
+	op_CFER    uint32 = 0xB3B8 // FORMAT_RRF5       CONVERT TO FIXED (short HFP to 32)
+	op_CFI     uint32 = 0xC20D // FORMAT_RIL1       COMPARE IMMEDIATE (32)
+	op_CFXBR   uint32 = 0xB39A // FORMAT_RRF5       CONVERT TO FIXED (extended BFP to 32)
+	op_CFXBRA  uint32 = 0xB39A // FORMAT_RRF5       CONVERT TO FIXED (extended BFP to 32)
+	op_CFXR    uint32 = 0xB3BA // FORMAT_RRF5       CONVERT TO FIXED (extended HFP to 32)
+	op_CFXTR   uint32 = 0xB949 // FORMAT_RRF5       CONVERT TO FIXED (extended DFP to 32)
+	op_CG      uint32 = 0xE320 // FORMAT_RXY1       COMPARE (64)
+	op_CGDBR   uint32 = 0xB3A9 // FORMAT_RRF5       CONVERT TO FIXED (long BFP to 64)
+	op_CGDBRA  uint32 = 0xB3A9 // FORMAT_RRF5       CONVERT TO FIXED (long BFP to 64)
+	op_CGDR    uint32 = 0xB3C9 // FORMAT_RRF5       CONVERT TO FIXED (long HFP to 64)
+	op_CGDTR   uint32 = 0xB3E1 // FORMAT_RRF5       CONVERT TO FIXED (long DFP to 64)
+	op_CGDTRA  uint32 = 0xB3E1 // FORMAT_RRF5       CONVERT TO FIXED (long DFP to 64)
+	op_CGEBR   uint32 = 0xB3A8 // FORMAT_RRF5       CONVERT TO FIXED (short BFP to 64)
+	op_CGEBRA  uint32 = 0xB3A8 // FORMAT_RRF5       CONVERT TO FIXED (short BFP to 64)
+	op_CGER    uint32 = 0xB3C8 // FORMAT_RRF5       CONVERT TO FIXED (short HFP to 64)
+	op_CGF     uint32 = 0xE330 // FORMAT_RXY1       COMPARE (64<-32)
+	op_CGFI    uint32 = 0xC20C // FORMAT_RIL1       COMPARE IMMEDIATE (64<-32)
+	op_CGFR    uint32 = 0xB930 // FORMAT_RRE        COMPARE (64<-32)
+	op_CGFRL   uint32 = 0xC60C // FORMAT_RIL2       COMPARE RELATIVE LONG (64<-32)
+	op_CGH     uint32 = 0xE334 // FORMAT_RXY1       COMPARE HALFWORD (64<-16)
+	op_CGHI    uint32 = 0xA70F // FORMAT_RI1        COMPARE HALFWORD IMMEDIATE (64<-16)
+	op_CGHRL   uint32 = 0xC604 // FORMAT_RIL2       COMPARE HALFWORD RELATIVE LONG (64<-16)
+	op_CGHSI   uint32 = 0xE558 // FORMAT_SIL        COMPARE HALFWORD IMMEDIATE (64<-16)
+	op_CGIB    uint32 = 0xECFC // FORMAT_RIS        COMPARE IMMEDIATE AND BRANCH (64<-8)
+	op_CGIJ    uint32 = 0xEC7C // FORMAT_RIE3       COMPARE IMMEDIATE AND BRANCH RELATIVE (64<-8)
+	op_CGIT    uint32 = 0xEC70 // FORMAT_RIE1       COMPARE IMMEDIATE AND TRAP (64<-16)
+	op_CGR     uint32 = 0xB920 // FORMAT_RRE        COMPARE (64)
+	op_CGRB    uint32 = 0xECE4 // FORMAT_RRS        COMPARE AND BRANCH (64)
+	op_CGRJ    uint32 = 0xEC64 // FORMAT_RIE2       COMPARE AND BRANCH RELATIVE (64)
+	op_CGRL    uint32 = 0xC608 // FORMAT_RIL2       COMPARE RELATIVE LONG (64)
+	op_CGRT    uint32 = 0xB960 // FORMAT_RRF3       COMPARE AND TRAP (64)
+	op_CGXBR   uint32 = 0xB3AA // FORMAT_RRF5       CONVERT TO FIXED (extended BFP to 64)
+	op_CGXBRA  uint32 = 0xB3AA // FORMAT_RRF5       CONVERT TO FIXED (extended BFP to 64)
+	op_CGXR    uint32 = 0xB3CA // FORMAT_RRF5       CONVERT TO FIXED (extended HFP to 64)
+	op_CGXTR   uint32 = 0xB3E9 // FORMAT_RRF5       CONVERT TO FIXED (extended DFP to 64)
+	op_CGXTRA  uint32 = 0xB3E9 // FORMAT_RRF5       CONVERT TO FIXED (extended DFP to 64)
+	op_CH      uint32 = 0x4900 // FORMAT_RX1        COMPARE HALFWORD (32<-16)
+	op_CHF     uint32 = 0xE3CD // FORMAT_RXY1       COMPARE HIGH (32)
+	op_CHHR    uint32 = 0xB9CD // FORMAT_RRE        COMPARE HIGH (32)
+	op_CHHSI   uint32 = 0xE554 // FORMAT_SIL        COMPARE HALFWORD IMMEDIATE (16)
+	op_CHI     uint32 = 0xA70E // FORMAT_RI1        COMPARE HALFWORD IMMEDIATE (32<-16)
+	op_CHLR    uint32 = 0xB9DD // FORMAT_RRE        COMPARE HIGH (32)
+	op_CHRL    uint32 = 0xC605 // FORMAT_RIL2       COMPARE HALFWORD RELATIVE LONG (32<-16)
+	op_CHSI    uint32 = 0xE55C // FORMAT_SIL        COMPARE HALFWORD IMMEDIATE (32<-16)
+	op_CHY     uint32 = 0xE379 // FORMAT_RXY1       COMPARE HALFWORD (32<-16)
+	op_CIB     uint32 = 0xECFE // FORMAT_RIS        COMPARE IMMEDIATE AND BRANCH (32<-8)
+	op_CIH     uint32 = 0xCC0D // FORMAT_RIL1       COMPARE IMMEDIATE HIGH (32)
+	op_CIJ     uint32 = 0xEC7E // FORMAT_RIE3       COMPARE IMMEDIATE AND BRANCH RELATIVE (32<-8)
+	op_CIT     uint32 = 0xEC72 // FORMAT_RIE1       COMPARE IMMEDIATE AND TRAP (32<-16)
+	op_CKSM    uint32 = 0xB241 // FORMAT_RRE        CHECKSUM
+	op_CL      uint32 = 0x5500 // FORMAT_RX1        COMPARE LOGICAL (32)
+	op_CLC     uint32 = 0xD500 // FORMAT_SS1        COMPARE LOGICAL (character)
+	op_CLCL    uint32 = 0x0F00 // FORMAT_RR         COMPARE LOGICAL LONG
+	op_CLCLE   uint32 = 0xA900 // FORMAT_RS1        COMPARE LOGICAL LONG EXTENDED
+	op_CLCLU   uint32 = 0xEB8F // FORMAT_RSY1       COMPARE LOGICAL LONG UNICODE
+	op_CLFDBR  uint32 = 0xB39D // FORMAT_RRF5       CONVERT TO LOGICAL (long BFP to 32)
+	op_CLFDTR  uint32 = 0xB943 // FORMAT_RRF5       CONVERT TO LOGICAL (long DFP to 32)
+	op_CLFEBR  uint32 = 0xB39C // FORMAT_RRF5       CONVERT TO LOGICAL (short BFP to 32)
+	op_CLFHSI  uint32 = 0xE55D // FORMAT_SIL        COMPARE LOGICAL IMMEDIATE (32<-16)
+	op_CLFI    uint32 = 0xC20F // FORMAT_RIL1       COMPARE LOGICAL IMMEDIATE (32)
+	op_CLFIT   uint32 = 0xEC73 // FORMAT_RIE1       COMPARE LOGICAL IMMEDIATE AND TRAP (32<-16)
+	op_CLFXBR  uint32 = 0xB39E // FORMAT_RRF5       CONVERT TO LOGICAL (extended BFP to 32)
+	op_CLFXTR  uint32 = 0xB94B // FORMAT_RRF5       CONVERT TO LOGICAL (extended DFP to 32)
+	op_CLG     uint32 = 0xE321 // FORMAT_RXY1       COMPARE LOGICAL (64)
+	op_CLGDBR  uint32 = 0xB3AD // FORMAT_RRF5       CONVERT TO LOGICAL (long BFP to 64)
+	op_CLGDTR  uint32 = 0xB942 // FORMAT_RRF5       CONVERT TO LOGICAL (long DFP to 64)
+	op_CLGEBR  uint32 = 0xB3AC // FORMAT_RRF5       CONVERT TO LOGICAL (short BFP to 64)
+	op_CLGF    uint32 = 0xE331 // FORMAT_RXY1       COMPARE LOGICAL (64<-32)
+	op_CLGFI   uint32 = 0xC20E // FORMAT_RIL1       COMPARE LOGICAL IMMEDIATE (64<-32)
+	op_CLGFR   uint32 = 0xB931 // FORMAT_RRE        COMPARE LOGICAL (64<-32)
+	op_CLGFRL  uint32 = 0xC60E // FORMAT_RIL2       COMPARE LOGICAL RELATIVE LONG (64<-32)
+	op_CLGHRL  uint32 = 0xC606 // FORMAT_RIL2       COMPARE LOGICAL RELATIVE LONG (64<-16)
+	op_CLGHSI  uint32 = 0xE559 // FORMAT_SIL        COMPARE LOGICAL IMMEDIATE (64<-16)
+	op_CLGIB   uint32 = 0xECFD // FORMAT_RIS        COMPARE LOGICAL IMMEDIATE AND BRANCH (64<-8)
+	op_CLGIJ   uint32 = 0xEC7D // FORMAT_RIE3       COMPARE LOGICAL IMMEDIATE AND BRANCH RELATIVE (64<-8)
+	op_CLGIT   uint32 = 0xEC71 // FORMAT_RIE1       COMPARE LOGICAL IMMEDIATE AND TRAP (64<-16)
+	op_CLGR    uint32 = 0xB921 // FORMAT_RRE        COMPARE LOGICAL (64)
+	op_CLGRB   uint32 = 0xECE5 // FORMAT_RRS        COMPARE LOGICAL AND BRANCH (64)
+	op_CLGRJ   uint32 = 0xEC65 // FORMAT_RIE2       COMPARE LOGICAL AND BRANCH RELATIVE (64)
+	op_CLGRL   uint32 = 0xC60A // FORMAT_RIL2       COMPARE LOGICAL RELATIVE LONG (64)
+	op_CLGRT   uint32 = 0xB961 // FORMAT_RRF3       COMPARE LOGICAL AND TRAP (64)
+	op_CLGT    uint32 = 0xEB2B // FORMAT_RSY2       COMPARE LOGICAL AND TRAP (64)
+	op_CLGXBR  uint32 = 0xB3AE // FORMAT_RRF5       CONVERT TO LOGICAL (extended BFP to 64)
+	op_CLGXTR  uint32 = 0xB94A // FORMAT_RRF5       CONVERT TO LOGICAL (extended DFP to 64)
+	op_CLHF    uint32 = 0xE3CF // FORMAT_RXY1       COMPARE LOGICAL HIGH (32)
+	op_CLHHR   uint32 = 0xB9CF // FORMAT_RRE        COMPARE LOGICAL HIGH (32)
+	op_CLHHSI  uint32 = 0xE555 // FORMAT_SIL        COMPARE LOGICAL IMMEDIATE (16)
+	op_CLHLR   uint32 = 0xB9DF // FORMAT_RRE        COMPARE LOGICAL HIGH (32)
+	op_CLHRL   uint32 = 0xC607 // FORMAT_RIL2       COMPARE LOGICAL RELATIVE LONG (32<-16)
+	op_CLI     uint32 = 0x9500 // FORMAT_SI         COMPARE LOGICAL (immediate)
+	op_CLIB    uint32 = 0xECFF // FORMAT_RIS        COMPARE LOGICAL IMMEDIATE AND BRANCH (32<-8)
+	op_CLIH    uint32 = 0xCC0F // FORMAT_RIL1       COMPARE LOGICAL IMMEDIATE HIGH (32)
+	op_CLIJ    uint32 = 0xEC7F // FORMAT_RIE3       COMPARE LOGICAL IMMEDIATE AND BRANCH RELATIVE (32<-8)
+	op_CLIY    uint32 = 0xEB55 // FORMAT_SIY        COMPARE LOGICAL (immediate)
+	op_CLM     uint32 = 0xBD00 // FORMAT_RS2        COMPARE LOGICAL CHAR. UNDER MASK (low)
+	op_CLMH    uint32 = 0xEB20 // FORMAT_RSY2       COMPARE LOGICAL CHAR. UNDER MASK (high)
+	op_CLMY    uint32 = 0xEB21 // FORMAT_RSY2       COMPARE LOGICAL CHAR. UNDER MASK (low)
+	op_CLR     uint32 = 0x1500 // FORMAT_RR         COMPARE LOGICAL (32)
+	op_CLRB    uint32 = 0xECF7 // FORMAT_RRS        COMPARE LOGICAL AND BRANCH (32)
+	op_CLRJ    uint32 = 0xEC77 // FORMAT_RIE2       COMPARE LOGICAL AND BRANCH RELATIVE (32)
+	op_CLRL    uint32 = 0xC60F // FORMAT_RIL2       COMPARE LOGICAL RELATIVE LONG (32)
+	op_CLRT    uint32 = 0xB973 // FORMAT_RRF3       COMPARE LOGICAL AND TRAP (32)
+	op_CLST    uint32 = 0xB25D // FORMAT_RRE        COMPARE LOGICAL STRING
+	op_CLT     uint32 = 0xEB23 // FORMAT_RSY2       COMPARE LOGICAL AND TRAP (32)
+	op_CLY     uint32 = 0xE355 // FORMAT_RXY1       COMPARE LOGICAL (32)
+	op_CMPSC   uint32 = 0xB263 // FORMAT_RRE        COMPRESSION CALL
+	op_CP      uint32 = 0xF900 // FORMAT_SS2        COMPARE DECIMAL
+	op_CPSDR   uint32 = 0xB372 // FORMAT_RRF2       COPY SIGN (long)
+	op_CPYA    uint32 = 0xB24D // FORMAT_RRE        COPY ACCESS
+	op_CR      uint32 = 0x1900 // FORMAT_RR         COMPARE (32)
+	op_CRB     uint32 = 0xECF6 // FORMAT_RRS        COMPARE AND BRANCH (32)
+	op_CRDTE   uint32 = 0xB98F // FORMAT_RRF2       COMPARE AND REPLACE DAT TABLE ENTRY
+	op_CRJ     uint32 = 0xEC76 // FORMAT_RIE2       COMPARE AND BRANCH RELATIVE (32)
+	op_CRL     uint32 = 0xC60D // FORMAT_RIL2       COMPARE RELATIVE LONG (32)
+	op_CRT     uint32 = 0xB972 // FORMAT_RRF3       COMPARE AND TRAP (32)
+	op_CS      uint32 = 0xBA00 // FORMAT_RS1        COMPARE AND SWAP (32)
+	op_CSCH    uint32 = 0xB230 // FORMAT_S          CLEAR SUBCHANNEL
+	op_CSDTR   uint32 = 0xB3E3 // FORMAT_RRF4       CONVERT TO SIGNED PACKED (long DFP to 64)
+	op_CSG     uint32 = 0xEB30 // FORMAT_RSY1       COMPARE AND SWAP (64)
+	op_CSP     uint32 = 0xB250 // FORMAT_RRE        COMPARE AND SWAP AND PURGE
+	op_CSPG    uint32 = 0xB98A // FORMAT_RRE        COMPARE AND SWAP AND PURGE
+	op_CSST    uint32 = 0xC802 // FORMAT_SSF        COMPARE AND SWAP AND STORE
+	op_CSXTR   uint32 = 0xB3EB // FORMAT_RRF4       CONVERT TO SIGNED PACKED (extended DFP to 128)
+	op_CSY     uint32 = 0xEB14 // FORMAT_RSY1       COMPARE AND SWAP (32)
+	op_CU12    uint32 = 0xB2A7 // FORMAT_RRF3       CONVERT UTF-8 TO UTF-16
+	op_CU14    uint32 = 0xB9B0 // FORMAT_RRF3       CONVERT UTF-8 TO UTF-32
+	op_CU21    uint32 = 0xB2A6 // FORMAT_RRF3       CONVERT UTF-16 TO UTF-8
+	op_CU24    uint32 = 0xB9B1 // FORMAT_RRF3       CONVERT UTF-16 TO UTF-32
+	op_CU41    uint32 = 0xB9B2 // FORMAT_RRE        CONVERT UTF-32 TO UTF-8
+	op_CU42    uint32 = 0xB9B3 // FORMAT_RRE        CONVERT UTF-32 TO UTF-16
+	op_CUDTR   uint32 = 0xB3E2 // FORMAT_RRE        CONVERT TO UNSIGNED PACKED (long DFP to 64)
+	op_CUSE    uint32 = 0xB257 // FORMAT_RRE        COMPARE UNTIL SUBSTRING EQUAL
+	op_CUTFU   uint32 = 0xB2A7 // FORMAT_RRF3       CONVERT UTF-8 TO UNICODE
+	op_CUUTF   uint32 = 0xB2A6 // FORMAT_RRF3       CONVERT UNICODE TO UTF-8
+	op_CUXTR   uint32 = 0xB3EA // FORMAT_RRE        CONVERT TO UNSIGNED PACKED (extended DFP to 128)
+	op_CVB     uint32 = 0x4F00 // FORMAT_RX1        CONVERT TO BINARY (32)
+	op_CVBG    uint32 = 0xE30E // FORMAT_RXY1       CONVERT TO BINARY (64)
+	op_CVBY    uint32 = 0xE306 // FORMAT_RXY1       CONVERT TO BINARY (32)
+	op_CVD     uint32 = 0x4E00 // FORMAT_RX1        CONVERT TO DECIMAL (32)
+	op_CVDG    uint32 = 0xE32E // FORMAT_RXY1       CONVERT TO DECIMAL (64)
+	op_CVDY    uint32 = 0xE326 // FORMAT_RXY1       CONVERT TO DECIMAL (32)
+	op_CXBR    uint32 = 0xB349 // FORMAT_RRE        COMPARE (extended BFP)
+	op_CXFBR   uint32 = 0xB396 // FORMAT_RRE        CONVERT FROM FIXED (32 to extended BFP)
+	op_CXFBRA  uint32 = 0xB396 // FORMAT_RRF5       CONVERT FROM FIXED (32 to extended BFP)
+	op_CXFR    uint32 = 0xB3B6 // FORMAT_RRE        CONVERT FROM FIXED (32 to extended HFP)
+	op_CXFTR   uint32 = 0xB959 // FORMAT_RRE        CONVERT FROM FIXED (32 to extended DFP)
+	op_CXGBR   uint32 = 0xB3A6 // FORMAT_RRE        CONVERT FROM FIXED (64 to extended BFP)
+	op_CXGBRA  uint32 = 0xB3A6 // FORMAT_RRF5       CONVERT FROM FIXED (64 to extended BFP)
+	op_CXGR    uint32 = 0xB3C6 // FORMAT_RRE        CONVERT FROM FIXED (64 to extended HFP)
+	op_CXGTR   uint32 = 0xB3F9 // FORMAT_RRE        CONVERT FROM FIXED (64 to extended DFP)
+	op_CXGTRA  uint32 = 0xB3F9 // FORMAT_RRF5       CONVERT FROM FIXED (64 to extended DFP)
+	op_CXLFBR  uint32 = 0xB392 // FORMAT_RRF5       CONVERT FROM LOGICAL (32 to extended BFP)
+	op_CXLFTR  uint32 = 0xB95B // FORMAT_RRF5       CONVERT FROM LOGICAL (32 to extended DFP)
+	op_CXLGBR  uint32 = 0xB3A2 // FORMAT_RRF5       CONVERT FROM LOGICAL (64 to extended BFP)
+	op_CXLGTR  uint32 = 0xB95A // FORMAT_RRF5       CONVERT FROM LOGICAL (64 to extended DFP)
+	op_CXR     uint32 = 0xB369 // FORMAT_RRE        COMPARE (extended HFP)
+	op_CXSTR   uint32 = 0xB3FB // FORMAT_RRE        CONVERT FROM SIGNED PACKED (128 to extended DFP)
+	op_CXTR    uint32 = 0xB3EC // FORMAT_RRE        COMPARE (extended DFP)
+	op_CXUTR   uint32 = 0xB3FA // FORMAT_RRE        CONVERT FROM UNSIGNED PACKED (128 to ext. DFP)
+	op_CXZT    uint32 = 0xEDAB // FORMAT_RSL        CONVERT FROM ZONED (to extended DFP)
+	op_CY      uint32 = 0xE359 // FORMAT_RXY1       COMPARE (32)
+	op_CZDT    uint32 = 0xEDA8 // FORMAT_RSL        CONVERT TO ZONED (from long DFP)
+	op_CZXT    uint32 = 0xEDA9 // FORMAT_RSL        CONVERT TO ZONED (from extended DFP)
+	op_D       uint32 = 0x5D00 // FORMAT_RX1        DIVIDE (32<-64)
+	op_DD      uint32 = 0x6D00 // FORMAT_RX1        DIVIDE (long HFP)
+	op_DDB     uint32 = 0xED1D // FORMAT_RXE        DIVIDE (long BFP)
+	op_DDBR    uint32 = 0xB31D // FORMAT_RRE        DIVIDE (long BFP)
+	op_DDR     uint32 = 0x2D00 // FORMAT_RR         DIVIDE (long HFP)
+	op_DDTR    uint32 = 0xB3D1 // FORMAT_RRF1       DIVIDE (long DFP)
+	op_DDTRA   uint32 = 0xB3D1 // FORMAT_RRF1       DIVIDE (long DFP)
+	op_DE      uint32 = 0x7D00 // FORMAT_RX1        DIVIDE (short HFP)
+	op_DEB     uint32 = 0xED0D // FORMAT_RXE        DIVIDE (short BFP)
+	op_DEBR    uint32 = 0xB30D // FORMAT_RRE        DIVIDE (short BFP)
+	op_DER     uint32 = 0x3D00 // FORMAT_RR         DIVIDE (short HFP)
+	op_DIDBR   uint32 = 0xB35B // FORMAT_RRF2       DIVIDE TO INTEGER (long BFP)
+	op_DIEBR   uint32 = 0xB353 // FORMAT_RRF2       DIVIDE TO INTEGER (short BFP)
+	op_DL      uint32 = 0xE397 // FORMAT_RXY1       DIVIDE LOGICAL (32<-64)
+	op_DLG     uint32 = 0xE387 // FORMAT_RXY1       DIVIDE LOGICAL (64<-128)
+	op_DLGR    uint32 = 0xB987 // FORMAT_RRE        DIVIDE LOGICAL (64<-128)
+	op_DLR     uint32 = 0xB997 // FORMAT_RRE        DIVIDE LOGICAL (32<-64)
+	op_DP      uint32 = 0xFD00 // FORMAT_SS2        DIVIDE DECIMAL
+	op_DR      uint32 = 0x1D00 // FORMAT_RR         DIVIDE (32<-64)
+	op_DSG     uint32 = 0xE30D // FORMAT_RXY1       DIVIDE SINGLE (64)
+	op_DSGF    uint32 = 0xE31D // FORMAT_RXY1       DIVIDE SINGLE (64<-32)
+	op_DSGFR   uint32 = 0xB91D // FORMAT_RRE        DIVIDE SINGLE (64<-32)
+	op_DSGR    uint32 = 0xB90D // FORMAT_RRE        DIVIDE SINGLE (64)
+	op_DXBR    uint32 = 0xB34D // FORMAT_RRE        DIVIDE (extended BFP)
+	op_DXR     uint32 = 0xB22D // FORMAT_RRE        DIVIDE (extended HFP)
+	op_DXTR    uint32 = 0xB3D9 // FORMAT_RRF1       DIVIDE (extended DFP)
+	op_DXTRA   uint32 = 0xB3D9 // FORMAT_RRF1       DIVIDE (extended DFP)
+	op_EAR     uint32 = 0xB24F // FORMAT_RRE        EXTRACT ACCESS
+	op_ECAG    uint32 = 0xEB4C // FORMAT_RSY1       EXTRACT CACHE ATTRIBUTE
+	op_ECTG    uint32 = 0xC801 // FORMAT_SSF        EXTRACT CPU TIME
+	op_ED      uint32 = 0xDE00 // FORMAT_SS1        EDIT
+	op_EDMK    uint32 = 0xDF00 // FORMAT_SS1        EDIT AND MARK
+	op_EEDTR   uint32 = 0xB3E5 // FORMAT_RRE        EXTRACT BIASED EXPONENT (long DFP to 64)
+	op_EEXTR   uint32 = 0xB3ED // FORMAT_RRE        EXTRACT BIASED EXPONENT (extended DFP to 64)
+	op_EFPC    uint32 = 0xB38C // FORMAT_RRE        EXTRACT FPC
+	op_EPAIR   uint32 = 0xB99A // FORMAT_RRE        EXTRACT PRIMARY ASN AND INSTANCE
+	op_EPAR    uint32 = 0xB226 // FORMAT_RRE        EXTRACT PRIMARY ASN
+	op_EPSW    uint32 = 0xB98D // FORMAT_RRE        EXTRACT PSW
+	op_EREG    uint32 = 0xB249 // FORMAT_RRE        EXTRACT STACKED REGISTERS (32)
+	op_EREGG   uint32 = 0xB90E // FORMAT_RRE        EXTRACT STACKED REGISTERS (64)
+	op_ESAIR   uint32 = 0xB99B // FORMAT_RRE        EXTRACT SECONDARY ASN AND INSTANCE
+	op_ESAR    uint32 = 0xB227 // FORMAT_RRE        EXTRACT SECONDARY ASN
+	op_ESDTR   uint32 = 0xB3E7 // FORMAT_RRE        EXTRACT SIGNIFICANCE (long DFP)
+	op_ESEA    uint32 = 0xB99D // FORMAT_RRE        EXTRACT AND SET EXTENDED AUTHORITY
+	op_ESTA    uint32 = 0xB24A // FORMAT_RRE        EXTRACT STACKED STATE
+	op_ESXTR   uint32 = 0xB3EF // FORMAT_RRE        EXTRACT SIGNIFICANCE (extended DFP)
+	op_ETND    uint32 = 0xB2EC // FORMAT_RRE        EXTRACT TRANSACTION NESTING DEPTH
+	op_EX      uint32 = 0x4400 // FORMAT_RX1        EXECUTE
+	op_EXRL    uint32 = 0xC600 // FORMAT_RIL2       EXECUTE RELATIVE LONG
+	op_FIDBR   uint32 = 0xB35F // FORMAT_RRF5       LOAD FP INTEGER (long BFP)
+	op_FIDBRA  uint32 = 0xB35F // FORMAT_RRF5       LOAD FP INTEGER (long BFP)
+	op_FIDR    uint32 = 0xB37F // FORMAT_RRE        LOAD FP INTEGER (long HFP)
+	op_FIDTR   uint32 = 0xB3D7 // FORMAT_RRF5       LOAD FP INTEGER (long DFP)
+	op_FIEBR   uint32 = 0xB357 // FORMAT_RRF5       LOAD FP INTEGER (short BFP)
+	op_FIEBRA  uint32 = 0xB357 // FORMAT_RRF5       LOAD FP INTEGER (short BFP)
+	op_FIER    uint32 = 0xB377 // FORMAT_RRE        LOAD FP INTEGER (short HFP)
+	op_FIXBR   uint32 = 0xB347 // FORMAT_RRF5       LOAD FP INTEGER (extended BFP)
+	op_FIXBRA  uint32 = 0xB347 // FORMAT_RRF5       LOAD FP INTEGER (extended BFP)
+	op_FIXR    uint32 = 0xB367 // FORMAT_RRE        LOAD FP INTEGER (extended HFP)
+	op_FIXTR   uint32 = 0xB3DF // FORMAT_RRF5       LOAD FP INTEGER (extended DFP)
+	op_FLOGR   uint32 = 0xB983 // FORMAT_RRE        FIND LEFTMOST ONE
+	op_HDR     uint32 = 0x2400 // FORMAT_RR         HALVE (long HFP)
+	op_HER     uint32 = 0x3400 // FORMAT_RR         HALVE (short HFP)
+	op_HSCH    uint32 = 0xB231 // FORMAT_S          HALT SUBCHANNEL
+	op_IAC     uint32 = 0xB224 // FORMAT_RRE        INSERT ADDRESS SPACE CONTROL
+	op_IC      uint32 = 0x4300 // FORMAT_RX1        INSERT CHARACTER
+	op_ICM     uint32 = 0xBF00 // FORMAT_RS2        INSERT CHARACTERS UNDER MASK (low)
+	op_ICMH    uint32 = 0xEB80 // FORMAT_RSY2       INSERT CHARACTERS UNDER MASK (high)
+	op_ICMY    uint32 = 0xEB81 // FORMAT_RSY2       INSERT CHARACTERS UNDER MASK (low)
+	op_ICY     uint32 = 0xE373 // FORMAT_RXY1       INSERT CHARACTER
+	op_IDTE    uint32 = 0xB98E // FORMAT_RRF2       INVALIDATE DAT TABLE ENTRY
+	op_IEDTR   uint32 = 0xB3F6 // FORMAT_RRF2       INSERT BIASED EXPONENT (64 to long DFP)
+	op_IEXTR   uint32 = 0xB3FE // FORMAT_RRF2       INSERT BIASED EXPONENT (64 to extended DFP)
+	op_IIHF    uint32 = 0xC008 // FORMAT_RIL1       INSERT IMMEDIATE (high)
+	op_IIHH    uint32 = 0xA500 // FORMAT_RI1        INSERT IMMEDIATE (high high)
+	op_IIHL    uint32 = 0xA501 // FORMAT_RI1        INSERT IMMEDIATE (high low)
+	op_IILF    uint32 = 0xC009 // FORMAT_RIL1       INSERT IMMEDIATE (low)
+	op_IILH    uint32 = 0xA502 // FORMAT_RI1        INSERT IMMEDIATE (low high)
+	op_IILL    uint32 = 0xA503 // FORMAT_RI1        INSERT IMMEDIATE (low low)
+	op_IPK     uint32 = 0xB20B // FORMAT_S          INSERT PSW KEY
+	op_IPM     uint32 = 0xB222 // FORMAT_RRE        INSERT PROGRAM MASK
+	op_IPTE    uint32 = 0xB221 // FORMAT_RRF1       INVALIDATE PAGE TABLE ENTRY
+	op_ISKE    uint32 = 0xB229 // FORMAT_RRE        INSERT STORAGE KEY EXTENDED
+	op_IVSK    uint32 = 0xB223 // FORMAT_RRE        INSERT VIRTUAL STORAGE KEY
+	op_KDB     uint32 = 0xED18 // FORMAT_RXE        COMPARE AND SIGNAL (long BFP)
+	op_KDBR    uint32 = 0xB318 // FORMAT_RRE        COMPARE AND SIGNAL (long BFP)
+	op_KDTR    uint32 = 0xB3E0 // FORMAT_RRE        COMPARE AND SIGNAL (long DFP)
+	op_KEB     uint32 = 0xED08 // FORMAT_RXE        COMPARE AND SIGNAL (short BFP)
+	op_KEBR    uint32 = 0xB308 // FORMAT_RRE        COMPARE AND SIGNAL (short BFP)
+	op_KIMD    uint32 = 0xB93E // FORMAT_RRE        COMPUTE INTERMEDIATE MESSAGE DIGEST
+	op_KLMD    uint32 = 0xB93F // FORMAT_RRE        COMPUTE LAST MESSAGE DIGEST
+	op_KM      uint32 = 0xB92E // FORMAT_RRE        CIPHER MESSAGE
+	op_KMAC    uint32 = 0xB91E // FORMAT_RRE        COMPUTE MESSAGE AUTHENTICATION CODE
+	op_KMC     uint32 = 0xB92F // FORMAT_RRE        CIPHER MESSAGE WITH CHAINING
+	op_KMCTR   uint32 = 0xB92D // FORMAT_RRF2       CIPHER MESSAGE WITH COUNTER
+	op_KMF     uint32 = 0xB92A // FORMAT_RRE        CIPHER MESSAGE WITH CFB
+	op_KMO     uint32 = 0xB92B // FORMAT_RRE        CIPHER MESSAGE WITH OFB
+	op_KXBR    uint32 = 0xB348 // FORMAT_RRE        COMPARE AND SIGNAL (extended BFP)
+	op_KXTR    uint32 = 0xB3E8 // FORMAT_RRE        COMPARE AND SIGNAL (extended DFP)
+	op_L       uint32 = 0x5800 // FORMAT_RX1        LOAD (32)
+	op_LA      uint32 = 0x4100 // FORMAT_RX1        LOAD ADDRESS
+	op_LAA     uint32 = 0xEBF8 // FORMAT_RSY1       LOAD AND ADD (32)
+	op_LAAG    uint32 = 0xEBE8 // FORMAT_RSY1       LOAD AND ADD (64)
+	op_LAAL    uint32 = 0xEBFA // FORMAT_RSY1       LOAD AND ADD LOGICAL (32)
+	op_LAALG   uint32 = 0xEBEA // FORMAT_RSY1       LOAD AND ADD LOGICAL (64)
+	op_LAE     uint32 = 0x5100 // FORMAT_RX1        LOAD ADDRESS EXTENDED
+	op_LAEY    uint32 = 0xE375 // FORMAT_RXY1       LOAD ADDRESS EXTENDED
+	op_LAM     uint32 = 0x9A00 // FORMAT_RS1        LOAD ACCESS MULTIPLE
+	op_LAMY    uint32 = 0xEB9A // FORMAT_RSY1       LOAD ACCESS MULTIPLE
+	op_LAN     uint32 = 0xEBF4 // FORMAT_RSY1       LOAD AND AND (32)
+	op_LANG    uint32 = 0xEBE4 // FORMAT_RSY1       LOAD AND AND (64)
+	op_LAO     uint32 = 0xEBF6 // FORMAT_RSY1       LOAD AND OR (32)
+	op_LAOG    uint32 = 0xEBE6 // FORMAT_RSY1       LOAD AND OR (64)
+	op_LARL    uint32 = 0xC000 // FORMAT_RIL2       LOAD ADDRESS RELATIVE LONG
+	op_LASP    uint32 = 0xE500 // FORMAT_SSE        LOAD ADDRESS SPACE PARAMETERS
+	op_LAT     uint32 = 0xE39F // FORMAT_RXY1       LOAD AND TRAP (32L<-32)
+	op_LAX     uint32 = 0xEBF7 // FORMAT_RSY1       LOAD AND EXCLUSIVE OR (32)
+	op_LAXG    uint32 = 0xEBE7 // FORMAT_RSY1       LOAD AND EXCLUSIVE OR (64)
+	op_LAY     uint32 = 0xE371 // FORMAT_RXY1       LOAD ADDRESS
+	op_LB      uint32 = 0xE376 // FORMAT_RXY1       LOAD BYTE (32)
+	op_LBH     uint32 = 0xE3C0 // FORMAT_RXY1       LOAD BYTE HIGH (32<-8)
+	op_LBR     uint32 = 0xB926 // FORMAT_RRE        LOAD BYTE (32)
+	op_LCDBR   uint32 = 0xB313 // FORMAT_RRE        LOAD COMPLEMENT (long BFP)
+	op_LCDFR   uint32 = 0xB373 // FORMAT_RRE        LOAD COMPLEMENT (long)
+	op_LCDR    uint32 = 0x2300 // FORMAT_RR         LOAD COMPLEMENT (long HFP)
+	op_LCEBR   uint32 = 0xB303 // FORMAT_RRE        LOAD COMPLEMENT (short BFP)
+	op_LCER    uint32 = 0x3300 // FORMAT_RR         LOAD COMPLEMENT (short HFP)
+	op_LCGFR   uint32 = 0xB913 // FORMAT_RRE        LOAD COMPLEMENT (64<-32)
+	op_LCGR    uint32 = 0xB903 // FORMAT_RRE        LOAD COMPLEMENT (64)
+	op_LCR     uint32 = 0x1300 // FORMAT_RR         LOAD COMPLEMENT (32)
+	op_LCTL    uint32 = 0xB700 // FORMAT_RS1        LOAD CONTROL (32)
+	op_LCTLG   uint32 = 0xEB2F // FORMAT_RSY1       LOAD CONTROL (64)
+	op_LCXBR   uint32 = 0xB343 // FORMAT_RRE        LOAD COMPLEMENT (extended BFP)
+	op_LCXR    uint32 = 0xB363 // FORMAT_RRE        LOAD COMPLEMENT (extended HFP)
+	op_LD      uint32 = 0x6800 // FORMAT_RX1        LOAD (long)
+	op_LDE     uint32 = 0xED24 // FORMAT_RXE        LOAD LENGTHENED (short to long HFP)
+	op_LDEB    uint32 = 0xED04 // FORMAT_RXE        LOAD LENGTHENED (short to long BFP)
+	op_LDEBR   uint32 = 0xB304 // FORMAT_RRE        LOAD LENGTHENED (short to long BFP)
+	op_LDER    uint32 = 0xB324 // FORMAT_RRE        LOAD LENGTHENED (short to long HFP)
+	op_LDETR   uint32 = 0xB3D4 // FORMAT_RRF4       LOAD LENGTHENED (short to long DFP)
+	op_LDGR    uint32 = 0xB3C1 // FORMAT_RRE        LOAD FPR FROM GR (64 to long)
+	op_LDR     uint32 = 0x2800 // FORMAT_RR         LOAD (long)
+	op_LDXBR   uint32 = 0xB345 // FORMAT_RRE        LOAD ROUNDED (extended to long BFP)
+	op_LDXBRA  uint32 = 0xB345 // FORMAT_RRF5       LOAD ROUNDED (extended to long BFP)
+	op_LDXR    uint32 = 0x2500 // FORMAT_RR         LOAD ROUNDED (extended to long HFP)
+	op_LDXTR   uint32 = 0xB3DD // FORMAT_RRF5       LOAD ROUNDED (extended to long DFP)
+	op_LDY     uint32 = 0xED65 // FORMAT_RXY1       LOAD (long)
+	op_LE      uint32 = 0x7800 // FORMAT_RX1        LOAD (short)
+	op_LEDBR   uint32 = 0xB344 // FORMAT_RRE        LOAD ROUNDED (long to short BFP)
+	op_LEDBRA  uint32 = 0xB344 // FORMAT_RRF5       LOAD ROUNDED (long to short BFP)
+	op_LEDR    uint32 = 0x3500 // FORMAT_RR         LOAD ROUNDED (long to short HFP)
+	op_LEDTR   uint32 = 0xB3D5 // FORMAT_RRF5       LOAD ROUNDED (long to short DFP)
+	op_LER     uint32 = 0x3800 // FORMAT_RR         LOAD (short)
+	op_LEXBR   uint32 = 0xB346 // FORMAT_RRE        LOAD ROUNDED (extended to short BFP)
+	op_LEXBRA  uint32 = 0xB346 // FORMAT_RRF5       LOAD ROUNDED (extended to short BFP)
+	op_LEXR    uint32 = 0xB366 // FORMAT_RRE        LOAD ROUNDED (extended to short HFP)
+	op_LEY     uint32 = 0xED64 // FORMAT_RXY1       LOAD (short)
+	op_LFAS    uint32 = 0xB2BD // FORMAT_S          LOAD FPC AND SIGNAL
+	op_LFH     uint32 = 0xE3CA // FORMAT_RXY1       LOAD HIGH (32)
+	op_LFHAT   uint32 = 0xE3C8 // FORMAT_RXY1       LOAD HIGH AND TRAP (32H<-32)
+	op_LFPC    uint32 = 0xB29D // FORMAT_S          LOAD FPC
+	op_LG      uint32 = 0xE304 // FORMAT_RXY1       LOAD (64)
+	op_LGAT    uint32 = 0xE385 // FORMAT_RXY1       LOAD AND TRAP (64)
+	op_LGB     uint32 = 0xE377 // FORMAT_RXY1       LOAD BYTE (64)
+	op_LGBR    uint32 = 0xB906 // FORMAT_RRE        LOAD BYTE (64)
+	op_LGDR    uint32 = 0xB3CD // FORMAT_RRE        LOAD GR FROM FPR (long to 64)
+	op_LGF     uint32 = 0xE314 // FORMAT_RXY1       LOAD (64<-32)
+	op_LGFI    uint32 = 0xC001 // FORMAT_RIL1       LOAD IMMEDIATE (64<-32)
+	op_LGFR    uint32 = 0xB914 // FORMAT_RRE        LOAD (64<-32)
+	op_LGFRL   uint32 = 0xC40C // FORMAT_RIL2       LOAD RELATIVE LONG (64<-32)
+	op_LGH     uint32 = 0xE315 // FORMAT_RXY1       LOAD HALFWORD (64)
+	op_LGHI    uint32 = 0xA709 // FORMAT_RI1        LOAD HALFWORD IMMEDIATE (64)
+	op_LGHR    uint32 = 0xB907 // FORMAT_RRE        LOAD HALFWORD (64)
+	op_LGHRL   uint32 = 0xC404 // FORMAT_RIL2       LOAD HALFWORD RELATIVE LONG (64<-16)
+	op_LGR     uint32 = 0xB904 // FORMAT_RRE        LOAD (64)
+	op_LGRL    uint32 = 0xC408 // FORMAT_RIL2       LOAD RELATIVE LONG (64)
+	op_LH      uint32 = 0x4800 // FORMAT_RX1        LOAD HALFWORD (32)
+	op_LHH     uint32 = 0xE3C4 // FORMAT_RXY1       LOAD HALFWORD HIGH (32<-16)
+	op_LHI     uint32 = 0xA708 // FORMAT_RI1        LOAD HALFWORD IMMEDIATE (32)
+	op_LHR     uint32 = 0xB927 // FORMAT_RRE        LOAD HALFWORD (32)
+	op_LHRL    uint32 = 0xC405 // FORMAT_RIL2       LOAD HALFWORD RELATIVE LONG (32<-16)
+	op_LHY     uint32 = 0xE378 // FORMAT_RXY1       LOAD HALFWORD (32)
+	op_LLC     uint32 = 0xE394 // FORMAT_RXY1       LOAD LOGICAL CHARACTER (32)
+	op_LLCH    uint32 = 0xE3C2 // FORMAT_RXY1       LOAD LOGICAL CHARACTER HIGH (32<-8)
+	op_LLCR    uint32 = 0xB994 // FORMAT_RRE        LOAD LOGICAL CHARACTER (32)
+	op_LLGC    uint32 = 0xE390 // FORMAT_RXY1       LOAD LOGICAL CHARACTER (64)
+	op_LLGCR   uint32 = 0xB984 // FORMAT_RRE        LOAD LOGICAL CHARACTER (64)
+	op_LLGF    uint32 = 0xE316 // FORMAT_RXY1       LOAD LOGICAL (64<-32)
+	op_LLGFAT  uint32 = 0xE39D // FORMAT_RXY1       LOAD LOGICAL AND TRAP (64<-32)
+	op_LLGFR   uint32 = 0xB916 // FORMAT_RRE        LOAD LOGICAL (64<-32)
+	op_LLGFRL  uint32 = 0xC40E // FORMAT_RIL2       LOAD LOGICAL RELATIVE LONG (64<-32)
+	op_LLGH    uint32 = 0xE391 // FORMAT_RXY1       LOAD LOGICAL HALFWORD (64)
+	op_LLGHR   uint32 = 0xB985 // FORMAT_RRE        LOAD LOGICAL HALFWORD (64)
+	op_LLGHRL  uint32 = 0xC406 // FORMAT_RIL2       LOAD LOGICAL HALFWORD RELATIVE LONG (64<-16)
+	op_LLGT    uint32 = 0xE317 // FORMAT_RXY1       LOAD LOGICAL THIRTY ONE BITS
+	op_LLGTAT  uint32 = 0xE39C // FORMAT_RXY1       LOAD LOGICAL THIRTY ONE BITS AND TRAP (64<-31)
+	op_LLGTR   uint32 = 0xB917 // FORMAT_RRE        LOAD LOGICAL THIRTY ONE BITS
+	op_LLH     uint32 = 0xE395 // FORMAT_RXY1       LOAD LOGICAL HALFWORD (32)
+	op_LLHH    uint32 = 0xE3C6 // FORMAT_RXY1       LOAD LOGICAL HALFWORD HIGH (32<-16)
+	op_LLHR    uint32 = 0xB995 // FORMAT_RRE        LOAD LOGICAL HALFWORD (32)
+	op_LLHRL   uint32 = 0xC402 // FORMAT_RIL2       LOAD LOGICAL HALFWORD RELATIVE LONG (32<-16)
+	op_LLIHF   uint32 = 0xC00E // FORMAT_RIL1       LOAD LOGICAL IMMEDIATE (high)
+	op_LLIHH   uint32 = 0xA50C // FORMAT_RI1        LOAD LOGICAL IMMEDIATE (high high)
+	op_LLIHL   uint32 = 0xA50D // FORMAT_RI1        LOAD LOGICAL IMMEDIATE (high low)
+	op_LLILF   uint32 = 0xC00F // FORMAT_RIL1       LOAD LOGICAL IMMEDIATE (low)
+	op_LLILH   uint32 = 0xA50E // FORMAT_RI1        LOAD LOGICAL IMMEDIATE (low high)
+	op_LLILL   uint32 = 0xA50F // FORMAT_RI1        LOAD LOGICAL IMMEDIATE (low low)
+	op_LM      uint32 = 0x9800 // FORMAT_RS1        LOAD MULTIPLE (32)
+	op_LMD     uint32 = 0xEF00 // FORMAT_SS5        LOAD MULTIPLE DISJOINT
+	op_LMG     uint32 = 0xEB04 // FORMAT_RSY1       LOAD MULTIPLE (64)
+	op_LMH     uint32 = 0xEB96 // FORMAT_RSY1       LOAD MULTIPLE HIGH
+	op_LMY     uint32 = 0xEB98 // FORMAT_RSY1       LOAD MULTIPLE (32)
+	op_LNDBR   uint32 = 0xB311 // FORMAT_RRE        LOAD NEGATIVE (long BFP)
+	op_LNDFR   uint32 = 0xB371 // FORMAT_RRE        LOAD NEGATIVE (long)
+	op_LNDR    uint32 = 0x2100 // FORMAT_RR         LOAD NEGATIVE (long HFP)
+	op_LNEBR   uint32 = 0xB301 // FORMAT_RRE        LOAD NEGATIVE (short BFP)
+	op_LNER    uint32 = 0x3100 // FORMAT_RR         LOAD NEGATIVE (short HFP)
+	op_LNGFR   uint32 = 0xB911 // FORMAT_RRE        LOAD NEGATIVE (64<-32)
+	op_LNGR    uint32 = 0xB901 // FORMAT_RRE        LOAD NEGATIVE (64)
+	op_LNR     uint32 = 0x1100 // FORMAT_RR         LOAD NEGATIVE (32)
+	op_LNXBR   uint32 = 0xB341 // FORMAT_RRE        LOAD NEGATIVE (extended BFP)
+	op_LNXR    uint32 = 0xB361 // FORMAT_RRE        LOAD NEGATIVE (extended HFP)
+	op_LOC     uint32 = 0xEBF2 // FORMAT_RSY2       LOAD ON CONDITION (32)
+	op_LOCG    uint32 = 0xEBE2 // FORMAT_RSY2       LOAD ON CONDITION (64)
+	op_LOCGR   uint32 = 0xB9E2 // FORMAT_RRF3       LOAD ON CONDITION (64)
+	op_LOCR    uint32 = 0xB9F2 // FORMAT_RRF3       LOAD ON CONDITION (32)
+	op_LPD     uint32 = 0xC804 // FORMAT_SSF        LOAD PAIR DISJOINT (32)
+	op_LPDBR   uint32 = 0xB310 // FORMAT_RRE        LOAD POSITIVE (long BFP)
+	op_LPDFR   uint32 = 0xB370 // FORMAT_RRE        LOAD POSITIVE (long)
+	op_LPDG    uint32 = 0xC805 // FORMAT_SSF        LOAD PAIR DISJOINT (64)
+	op_LPDR    uint32 = 0x2000 // FORMAT_RR         LOAD POSITIVE (long HFP)
+	op_LPEBR   uint32 = 0xB300 // FORMAT_RRE        LOAD POSITIVE (short BFP)
+	op_LPER    uint32 = 0x3000 // FORMAT_RR         LOAD POSITIVE (short HFP)
+	op_LPGFR   uint32 = 0xB910 // FORMAT_RRE        LOAD POSITIVE (64<-32)
+	op_LPGR    uint32 = 0xB900 // FORMAT_RRE        LOAD POSITIVE (64)
+	op_LPQ     uint32 = 0xE38F // FORMAT_RXY1       LOAD PAIR FROM QUADWORD
+	op_LPR     uint32 = 0x1000 // FORMAT_RR         LOAD POSITIVE (32)
+	op_LPSW    uint32 = 0x8200 // FORMAT_S          LOAD PSW
+	op_LPSWE   uint32 = 0xB2B2 // FORMAT_S          LOAD PSW EXTENDED
+	op_LPTEA   uint32 = 0xB9AA // FORMAT_RRF2       LOAD PAGE TABLE ENTRY ADDRESS
+	op_LPXBR   uint32 = 0xB340 // FORMAT_RRE        LOAD POSITIVE (extended BFP)
+	op_LPXR    uint32 = 0xB360 // FORMAT_RRE        LOAD POSITIVE (extended HFP)
+	op_LR      uint32 = 0x1800 // FORMAT_RR         LOAD (32)
+	op_LRA     uint32 = 0xB100 // FORMAT_RX1        LOAD REAL ADDRESS (32)
+	op_LRAG    uint32 = 0xE303 // FORMAT_RXY1       LOAD REAL ADDRESS (64)
+	op_LRAY    uint32 = 0xE313 // FORMAT_RXY1       LOAD REAL ADDRESS (32)
+	op_LRDR    uint32 = 0x2500 // FORMAT_RR         LOAD ROUNDED (extended to long HFP)
+	op_LRER    uint32 = 0x3500 // FORMAT_RR         LOAD ROUNDED (long to short HFP)
+	op_LRL     uint32 = 0xC40D // FORMAT_RIL2       LOAD RELATIVE LONG (32)
+	op_LRV     uint32 = 0xE31E // FORMAT_RXY1       LOAD REVERSED (32)
+	op_LRVG    uint32 = 0xE30F // FORMAT_RXY1       LOAD REVERSED (64)
+	op_LRVGR   uint32 = 0xB90F // FORMAT_RRE        LOAD REVERSED (64)
+	op_LRVH    uint32 = 0xE31F // FORMAT_RXY1       LOAD REVERSED (16)
+	op_LRVR    uint32 = 0xB91F // FORMAT_RRE        LOAD REVERSED (32)
+	op_LT      uint32 = 0xE312 // FORMAT_RXY1       LOAD AND TEST (32)
+	op_LTDBR   uint32 = 0xB312 // FORMAT_RRE        LOAD AND TEST (long BFP)
+	op_LTDR    uint32 = 0x2200 // FORMAT_RR         LOAD AND TEST (long HFP)
+	op_LTDTR   uint32 = 0xB3D6 // FORMAT_RRE        LOAD AND TEST (long DFP)
+	op_LTEBR   uint32 = 0xB302 // FORMAT_RRE        LOAD AND TEST (short BFP)
+	op_LTER    uint32 = 0x3200 // FORMAT_RR         LOAD AND TEST (short HFP)
+	op_LTG     uint32 = 0xE302 // FORMAT_RXY1       LOAD AND TEST (64)
+	op_LTGF    uint32 = 0xE332 // FORMAT_RXY1       LOAD AND TEST (64<-32)
+	op_LTGFR   uint32 = 0xB912 // FORMAT_RRE        LOAD AND TEST (64<-32)
+	op_LTGR    uint32 = 0xB902 // FORMAT_RRE        LOAD AND TEST (64)
+	op_LTR     uint32 = 0x1200 // FORMAT_RR         LOAD AND TEST (32)
+	op_LTXBR   uint32 = 0xB342 // FORMAT_RRE        LOAD AND TEST (extended BFP)
+	op_LTXR    uint32 = 0xB362 // FORMAT_RRE        LOAD AND TEST (extended HFP)
+	op_LTXTR   uint32 = 0xB3DE // FORMAT_RRE        LOAD AND TEST (extended DFP)
+	op_LURA    uint32 = 0xB24B // FORMAT_RRE        LOAD USING REAL ADDRESS (32)
+	op_LURAG   uint32 = 0xB905 // FORMAT_RRE        LOAD USING REAL ADDRESS (64)
+	op_LXD     uint32 = 0xED25 // FORMAT_RXE        LOAD LENGTHENED (long to extended HFP)
+	op_LXDB    uint32 = 0xED05 // FORMAT_RXE        LOAD LENGTHENED (long to extended BFP)
+	op_LXDBR   uint32 = 0xB305 // FORMAT_RRE        LOAD LENGTHENED (long to extended BFP)
+	op_LXDR    uint32 = 0xB325 // FORMAT_RRE        LOAD LENGTHENED (long to extended HFP)
+	op_LXDTR   uint32 = 0xB3DC // FORMAT_RRF4       LOAD LENGTHENED (long to extended DFP)
+	op_LXE     uint32 = 0xED26 // FORMAT_RXE        LOAD LENGTHENED (short to extended HFP)
+	op_LXEB    uint32 = 0xED06 // FORMAT_RXE        LOAD LENGTHENED (short to extended BFP)
+	op_LXEBR   uint32 = 0xB306 // FORMAT_RRE        LOAD LENGTHENED (short to extended BFP)
+	op_LXER    uint32 = 0xB326 // FORMAT_RRE        LOAD LENGTHENED (short to extended HFP)
+	op_LXR     uint32 = 0xB365 // FORMAT_RRE        LOAD (extended)
+	op_LY      uint32 = 0xE358 // FORMAT_RXY1       LOAD (32)
+	op_LZDR    uint32 = 0xB375 // FORMAT_RRE        LOAD ZERO (long)
+	op_LZER    uint32 = 0xB374 // FORMAT_RRE        LOAD ZERO (short)
+	op_LZXR    uint32 = 0xB376 // FORMAT_RRE        LOAD ZERO (extended)
+	op_M       uint32 = 0x5C00 // FORMAT_RX1        MULTIPLY (64<-32)
+	op_MAD     uint32 = 0xED3E // FORMAT_RXF        MULTIPLY AND ADD (long HFP)
+	op_MADB    uint32 = 0xED1E // FORMAT_RXF        MULTIPLY AND ADD (long BFP)
+	op_MADBR   uint32 = 0xB31E // FORMAT_RRD        MULTIPLY AND ADD (long BFP)
+	op_MADR    uint32 = 0xB33E // FORMAT_RRD        MULTIPLY AND ADD (long HFP)
+	op_MAE     uint32 = 0xED2E // FORMAT_RXF        MULTIPLY AND ADD (short HFP)
+	op_MAEB    uint32 = 0xED0E // FORMAT_RXF        MULTIPLY AND ADD (short BFP)
+	op_MAEBR   uint32 = 0xB30E // FORMAT_RRD        MULTIPLY AND ADD (short BFP)
+	op_MAER    uint32 = 0xB32E // FORMAT_RRD        MULTIPLY AND ADD (short HFP)
+	op_MAY     uint32 = 0xED3A // FORMAT_RXF        MULTIPLY & ADD UNNORMALIZED (long to ext. HFP)
+	op_MAYH    uint32 = 0xED3C // FORMAT_RXF        MULTIPLY AND ADD UNNRM. (long to ext. high HFP)
+	op_MAYHR   uint32 = 0xB33C // FORMAT_RRD        MULTIPLY AND ADD UNNRM. (long to ext. high HFP)
+	op_MAYL    uint32 = 0xED38 // FORMAT_RXF        MULTIPLY AND ADD UNNRM. (long to ext. low HFP)
+	op_MAYLR   uint32 = 0xB338 // FORMAT_RRD        MULTIPLY AND ADD UNNRM. (long to ext. low HFP)
+	op_MAYR    uint32 = 0xB33A // FORMAT_RRD        MULTIPLY & ADD UNNORMALIZED (long to ext. HFP)
+	op_MC      uint32 = 0xAF00 // FORMAT_SI         MONITOR CALL
+	op_MD      uint32 = 0x6C00 // FORMAT_RX1        MULTIPLY (long HFP)
+	op_MDB     uint32 = 0xED1C // FORMAT_RXE        MULTIPLY (long BFP)
+	op_MDBR    uint32 = 0xB31C // FORMAT_RRE        MULTIPLY (long BFP)
+	op_MDE     uint32 = 0x7C00 // FORMAT_RX1        MULTIPLY (short to long HFP)
+	op_MDEB    uint32 = 0xED0C // FORMAT_RXE        MULTIPLY (short to long BFP)
+	op_MDEBR   uint32 = 0xB30C // FORMAT_RRE        MULTIPLY (short to long BFP)
+	op_MDER    uint32 = 0x3C00 // FORMAT_RR         MULTIPLY (short to long HFP)
+	op_MDR     uint32 = 0x2C00 // FORMAT_RR         MULTIPLY (long HFP)
+	op_MDTR    uint32 = 0xB3D0 // FORMAT_RRF1       MULTIPLY (long DFP)
+	op_MDTRA   uint32 = 0xB3D0 // FORMAT_RRF1       MULTIPLY (long DFP)
+	op_ME      uint32 = 0x7C00 // FORMAT_RX1        MULTIPLY (short to long HFP)
+	op_MEE     uint32 = 0xED37 // FORMAT_RXE        MULTIPLY (short HFP)
+	op_MEEB    uint32 = 0xED17 // FORMAT_RXE        MULTIPLY (short BFP)
+	op_MEEBR   uint32 = 0xB317 // FORMAT_RRE        MULTIPLY (short BFP)
+	op_MEER    uint32 = 0xB337 // FORMAT_RRE        MULTIPLY (short HFP)
+	op_MER     uint32 = 0x3C00 // FORMAT_RR         MULTIPLY (short to long HFP)
+	op_MFY     uint32 = 0xE35C // FORMAT_RXY1       MULTIPLY (64<-32)
+	op_MGHI    uint32 = 0xA70D // FORMAT_RI1        MULTIPLY HALFWORD IMMEDIATE (64)
+	op_MH      uint32 = 0x4C00 // FORMAT_RX1        MULTIPLY HALFWORD (32)
+	op_MHI     uint32 = 0xA70C // FORMAT_RI1        MULTIPLY HALFWORD IMMEDIATE (32)
+	op_MHY     uint32 = 0xE37C // FORMAT_RXY1       MULTIPLY HALFWORD (32)
+	op_ML      uint32 = 0xE396 // FORMAT_RXY1       MULTIPLY LOGICAL (64<-32)
+	op_MLG     uint32 = 0xE386 // FORMAT_RXY1       MULTIPLY LOGICAL (128<-64)
+	op_MLGR    uint32 = 0xB986 // FORMAT_RRE        MULTIPLY LOGICAL (128<-64)
+	op_MLR     uint32 = 0xB996 // FORMAT_RRE        MULTIPLY LOGICAL (64<-32)
+	op_MP      uint32 = 0xFC00 // FORMAT_SS2        MULTIPLY DECIMAL
+	op_MR      uint32 = 0x1C00 // FORMAT_RR         MULTIPLY (64<-32)
+	op_MS      uint32 = 0x7100 // FORMAT_RX1        MULTIPLY SINGLE (32)
+	op_MSCH    uint32 = 0xB232 // FORMAT_S          MODIFY SUBCHANNEL
+	op_MSD     uint32 = 0xED3F // FORMAT_RXF        MULTIPLY AND SUBTRACT (long HFP)
+	op_MSDB    uint32 = 0xED1F // FORMAT_RXF        MULTIPLY AND SUBTRACT (long BFP)
+	op_MSDBR   uint32 = 0xB31F // FORMAT_RRD        MULTIPLY AND SUBTRACT (long BFP)
+	op_MSDR    uint32 = 0xB33F // FORMAT_RRD        MULTIPLY AND SUBTRACT (long HFP)
+	op_MSE     uint32 = 0xED2F // FORMAT_RXF        MULTIPLY AND SUBTRACT (short HFP)
+	op_MSEB    uint32 = 0xED0F // FORMAT_RXF        MULTIPLY AND SUBTRACT (short BFP)
+	op_MSEBR   uint32 = 0xB30F // FORMAT_RRD        MULTIPLY AND SUBTRACT (short BFP)
+	op_MSER    uint32 = 0xB32F // FORMAT_RRD        MULTIPLY AND SUBTRACT (short HFP)
+	op_MSFI    uint32 = 0xC201 // FORMAT_RIL1       MULTIPLY SINGLE IMMEDIATE (32)
+	op_MSG     uint32 = 0xE30C // FORMAT_RXY1       MULTIPLY SINGLE (64)
+	op_MSGF    uint32 = 0xE31C // FORMAT_RXY1       MULTIPLY SINGLE (64<-32)
+	op_MSGFI   uint32 = 0xC200 // FORMAT_RIL1       MULTIPLY SINGLE IMMEDIATE (64<-32)
+	op_MSGFR   uint32 = 0xB91C // FORMAT_RRE        MULTIPLY SINGLE (64<-32)
+	op_MSGR    uint32 = 0xB90C // FORMAT_RRE        MULTIPLY SINGLE (64)
+	op_MSR     uint32 = 0xB252 // FORMAT_RRE        MULTIPLY SINGLE (32)
+	op_MSTA    uint32 = 0xB247 // FORMAT_RRE        MODIFY STACKED STATE
+	op_MSY     uint32 = 0xE351 // FORMAT_RXY1       MULTIPLY SINGLE (32)
+	op_MVC     uint32 = 0xD200 // FORMAT_SS1        MOVE (character)
+	op_MVCDK   uint32 = 0xE50F // FORMAT_SSE        MOVE WITH DESTINATION KEY
+	op_MVCIN   uint32 = 0xE800 // FORMAT_SS1        MOVE INVERSE
+	op_MVCK    uint32 = 0xD900 // FORMAT_SS4        MOVE WITH KEY
+	op_MVCL    uint32 = 0x0E00 // FORMAT_RR         MOVE LONG
+	op_MVCLE   uint32 = 0xA800 // FORMAT_RS1        MOVE LONG EXTENDED
+	op_MVCLU   uint32 = 0xEB8E // FORMAT_RSY1       MOVE LONG UNICODE
+	op_MVCOS   uint32 = 0xC800 // FORMAT_SSF        MOVE WITH OPTIONAL SPECIFICATIONS
+	op_MVCP    uint32 = 0xDA00 // FORMAT_SS4        MOVE TO PRIMARY
+	op_MVCS    uint32 = 0xDB00 // FORMAT_SS4        MOVE TO SECONDARY
+	op_MVCSK   uint32 = 0xE50E // FORMAT_SSE        MOVE WITH SOURCE KEY
+	op_MVGHI   uint32 = 0xE548 // FORMAT_SIL        MOVE (64<-16)
+	op_MVHHI   uint32 = 0xE544 // FORMAT_SIL        MOVE (16<-16)
+	op_MVHI    uint32 = 0xE54C // FORMAT_SIL        MOVE (32<-16)
+	op_MVI     uint32 = 0x9200 // FORMAT_SI         MOVE (immediate)
+	op_MVIY    uint32 = 0xEB52 // FORMAT_SIY        MOVE (immediate)
+	op_MVN     uint32 = 0xD100 // FORMAT_SS1        MOVE NUMERICS
+	op_MVO     uint32 = 0xF100 // FORMAT_SS2        MOVE WITH OFFSET
+	op_MVPG    uint32 = 0xB254 // FORMAT_RRE        MOVE PAGE
+	op_MVST    uint32 = 0xB255 // FORMAT_RRE        MOVE STRING
+	op_MVZ     uint32 = 0xD300 // FORMAT_SS1        MOVE ZONES
+	op_MXBR    uint32 = 0xB34C // FORMAT_RRE        MULTIPLY (extended BFP)
+	op_MXD     uint32 = 0x6700 // FORMAT_RX1        MULTIPLY (long to extended HFP)
+	op_MXDB    uint32 = 0xED07 // FORMAT_RXE        MULTIPLY (long to extended BFP)
+	op_MXDBR   uint32 = 0xB307 // FORMAT_RRE        MULTIPLY (long to extended BFP)
+	op_MXDR    uint32 = 0x2700 // FORMAT_RR         MULTIPLY (long to extended HFP)
+	op_MXR     uint32 = 0x2600 // FORMAT_RR         MULTIPLY (extended HFP)
+	op_MXTR    uint32 = 0xB3D8 // FORMAT_RRF1       MULTIPLY (extended DFP)
+	op_MXTRA   uint32 = 0xB3D8 // FORMAT_RRF1       MULTIPLY (extended DFP)
+	op_MY      uint32 = 0xED3B // FORMAT_RXF        MULTIPLY UNNORMALIZED (long to ext. HFP)
+	op_MYH     uint32 = 0xED3D // FORMAT_RXF        MULTIPLY UNNORM. (long to ext. high HFP)
+	op_MYHR    uint32 = 0xB33D // FORMAT_RRD        MULTIPLY UNNORM. (long to ext. high HFP)
+	op_MYL     uint32 = 0xED39 // FORMAT_RXF        MULTIPLY UNNORM. (long to ext. low HFP)
+	op_MYLR    uint32 = 0xB339 // FORMAT_RRD        MULTIPLY UNNORM. (long to ext. low HFP)
+	op_MYR     uint32 = 0xB33B // FORMAT_RRD        MULTIPLY UNNORMALIZED (long to ext. HFP)
+	op_N       uint32 = 0x5400 // FORMAT_RX1        AND (32)
+	op_NC      uint32 = 0xD400 // FORMAT_SS1        AND (character)
+	op_NG      uint32 = 0xE380 // FORMAT_RXY1       AND (64)
+	op_NGR     uint32 = 0xB980 // FORMAT_RRE        AND (64)
+	op_NGRK    uint32 = 0xB9E4 // FORMAT_RRF1       AND (64)
+	op_NI      uint32 = 0x9400 // FORMAT_SI         AND (immediate)
+	op_NIAI    uint32 = 0xB2FA // FORMAT_IE         NEXT INSTRUCTION ACCESS INTENT
+	op_NIHF    uint32 = 0xC00A // FORMAT_RIL1       AND IMMEDIATE (high)
+	op_NIHH    uint32 = 0xA504 // FORMAT_RI1        AND IMMEDIATE (high high)
+	op_NIHL    uint32 = 0xA505 // FORMAT_RI1        AND IMMEDIATE (high low)
+	op_NILF    uint32 = 0xC00B // FORMAT_RIL1       AND IMMEDIATE (low)
+	op_NILH    uint32 = 0xA506 // FORMAT_RI1        AND IMMEDIATE (low high)
+	op_NILL    uint32 = 0xA507 // FORMAT_RI1        AND IMMEDIATE (low low)
+	op_NIY     uint32 = 0xEB54 // FORMAT_SIY        AND (immediate)
+	op_NR      uint32 = 0x1400 // FORMAT_RR         AND (32)
+	op_NRK     uint32 = 0xB9F4 // FORMAT_RRF1       AND (32)
+	op_NTSTG   uint32 = 0xE325 // FORMAT_RXY1       NONTRANSACTIONAL STORE
+	op_NY      uint32 = 0xE354 // FORMAT_RXY1       AND (32)
+	op_O       uint32 = 0x5600 // FORMAT_RX1        OR (32)
+	op_OC      uint32 = 0xD600 // FORMAT_SS1        OR (character)
+	op_OG      uint32 = 0xE381 // FORMAT_RXY1       OR (64)
+	op_OGR     uint32 = 0xB981 // FORMAT_RRE        OR (64)
+	op_OGRK    uint32 = 0xB9E6 // FORMAT_RRF1       OR (64)
+	op_OI      uint32 = 0x9600 // FORMAT_SI         OR (immediate)
+	op_OIHF    uint32 = 0xC00C // FORMAT_RIL1       OR IMMEDIATE (high)
+	op_OIHH    uint32 = 0xA508 // FORMAT_RI1        OR IMMEDIATE (high high)
+	op_OIHL    uint32 = 0xA509 // FORMAT_RI1        OR IMMEDIATE (high low)
+	op_OILF    uint32 = 0xC00D // FORMAT_RIL1       OR IMMEDIATE (low)
+	op_OILH    uint32 = 0xA50A // FORMAT_RI1        OR IMMEDIATE (low high)
+	op_OILL    uint32 = 0xA50B // FORMAT_RI1        OR IMMEDIATE (low low)
+	op_OIY     uint32 = 0xEB56 // FORMAT_SIY        OR (immediate)
+	op_OR      uint32 = 0x1600 // FORMAT_RR         OR (32)
+	op_ORK     uint32 = 0xB9F6 // FORMAT_RRF1       OR (32)
+	op_OY      uint32 = 0xE356 // FORMAT_RXY1       OR (32)
+	op_PACK    uint32 = 0xF200 // FORMAT_SS2        PACK
+	op_PALB    uint32 = 0xB248 // FORMAT_RRE        PURGE ALB
+	op_PC      uint32 = 0xB218 // FORMAT_S          PROGRAM CALL
+	op_PCC     uint32 = 0xB92C // FORMAT_RRE        PERFORM CRYPTOGRAPHIC COMPUTATION
+	op_PCKMO   uint32 = 0xB928 // FORMAT_RRE        PERFORM CRYPTOGRAPHIC KEY MGMT. OPERATIONS
+	op_PFD     uint32 = 0xE336 // FORMAT_RXY2       PREFETCH DATA
+	op_PFDRL   uint32 = 0xC602 // FORMAT_RIL3       PREFETCH DATA RELATIVE LONG
+	op_PFMF    uint32 = 0xB9AF // FORMAT_RRE        PERFORM FRAME MANAGEMENT FUNCTION
+	op_PFPO    uint32 = 0x010A // FORMAT_E          PERFORM FLOATING-POINT OPERATION
+	op_PGIN    uint32 = 0xB22E // FORMAT_RRE        PAGE IN
+	op_PGOUT   uint32 = 0xB22F // FORMAT_RRE        PAGE OUT
+	op_PKA     uint32 = 0xE900 // FORMAT_SS6        PACK ASCII
+	op_PKU     uint32 = 0xE100 // FORMAT_SS6        PACK UNICODE
+	op_PLO     uint32 = 0xEE00 // FORMAT_SS5        PERFORM LOCKED OPERATION
+	op_POPCNT  uint32 = 0xB9E1 // FORMAT_RRE        POPULATION COUNT
+	op_PPA     uint32 = 0xB2E8 // FORMAT_RRF3       PERFORM PROCESSOR ASSIST
+	op_PR      uint32 = 0x0101 // FORMAT_E          PROGRAM RETURN
+	op_PT      uint32 = 0xB228 // FORMAT_RRE        PROGRAM TRANSFER
+	op_PTF     uint32 = 0xB9A2 // FORMAT_RRE        PERFORM TOPOLOGY FUNCTION
+	op_PTFF    uint32 = 0x0104 // FORMAT_E          PERFORM TIMING FACILITY FUNCTION
+	op_PTI     uint32 = 0xB99E // FORMAT_RRE        PROGRAM TRANSFER WITH INSTANCE
+	op_PTLB    uint32 = 0xB20D // FORMAT_S          PURGE TLB
+	op_QADTR   uint32 = 0xB3F5 // FORMAT_RRF2       QUANTIZE (long DFP)
+	op_QAXTR   uint32 = 0xB3FD // FORMAT_RRF2       QUANTIZE (extended DFP)
+	op_RCHP    uint32 = 0xB23B // FORMAT_S          RESET CHANNEL PATH
+	op_RISBG   uint32 = 0xEC55 // FORMAT_RIE6       ROTATE THEN INSERT SELECTED BITS
+	op_RISBGN  uint32 = 0xEC59 // FORMAT_RIE6       ROTATE THEN INSERT SELECTED BITS
+	op_RISBHG  uint32 = 0xEC5D // FORMAT_RIE6       ROTATE THEN INSERT SELECTED BITS HIGH
+	op_RISBLG  uint32 = 0xEC51 // FORMAT_RIE6       ROTATE THEN INSERT SELECTED BITS LOW
+	op_RLL     uint32 = 0xEB1D // FORMAT_RSY1       ROTATE LEFT SINGLE LOGICAL (32)
+	op_RLLG    uint32 = 0xEB1C // FORMAT_RSY1       ROTATE LEFT SINGLE LOGICAL (64)
+	op_RNSBG   uint32 = 0xEC54 // FORMAT_RIE6       ROTATE THEN AND SELECTED BITS
+	op_ROSBG   uint32 = 0xEC56 // FORMAT_RIE6       ROTATE THEN OR SELECTED BITS
+	op_RP      uint32 = 0xB277 // FORMAT_S          RESUME PROGRAM
+	op_RRBE    uint32 = 0xB22A // FORMAT_RRE        RESET REFERENCE BIT EXTENDED
+	op_RRBM    uint32 = 0xB9AE // FORMAT_RRE        RESET REFERENCE BITS MULTIPLE
+	op_RRDTR   uint32 = 0xB3F7 // FORMAT_RRF2       REROUND (long DFP)
+	op_RRXTR   uint32 = 0xB3FF // FORMAT_RRF2       REROUND (extended DFP)
+	op_RSCH    uint32 = 0xB238 // FORMAT_S          RESUME SUBCHANNEL
+	op_RXSBG   uint32 = 0xEC57 // FORMAT_RIE6       ROTATE THEN EXCLUSIVE OR SELECTED BITS
+	op_S       uint32 = 0x5B00 // FORMAT_RX1        SUBTRACT (32)
+	op_SAC     uint32 = 0xB219 // FORMAT_S          SET ADDRESS SPACE CONTROL
+	op_SACF    uint32 = 0xB279 // FORMAT_S          SET ADDRESS SPACE CONTROL FAST
+	op_SAL     uint32 = 0xB237 // FORMAT_S          SET ADDRESS LIMIT
+	op_SAM24   uint32 = 0x010C // FORMAT_E          SET ADDRESSING MODE (24)
+	op_SAM31   uint32 = 0x010D // FORMAT_E          SET ADDRESSING MODE (31)
+	op_SAM64   uint32 = 0x010E // FORMAT_E          SET ADDRESSING MODE (64)
+	op_SAR     uint32 = 0xB24E // FORMAT_RRE        SET ACCESS
+	op_SCHM    uint32 = 0xB23C // FORMAT_S          SET CHANNEL MONITOR
+	op_SCK     uint32 = 0xB204 // FORMAT_S          SET CLOCK
+	op_SCKC    uint32 = 0xB206 // FORMAT_S          SET CLOCK COMPARATOR
+	op_SCKPF   uint32 = 0x0107 // FORMAT_E          SET CLOCK PROGRAMMABLE FIELD
+	op_SD      uint32 = 0x6B00 // FORMAT_RX1        SUBTRACT NORMALIZED (long HFP)
+	op_SDB     uint32 = 0xED1B // FORMAT_RXE        SUBTRACT (long BFP)
+	op_SDBR    uint32 = 0xB31B // FORMAT_RRE        SUBTRACT (long BFP)
+	op_SDR     uint32 = 0x2B00 // FORMAT_RR         SUBTRACT NORMALIZED (long HFP)
+	op_SDTR    uint32 = 0xB3D3 // FORMAT_RRF1       SUBTRACT (long DFP)
+	op_SDTRA   uint32 = 0xB3D3 // FORMAT_RRF1       SUBTRACT (long DFP)
+	op_SE      uint32 = 0x7B00 // FORMAT_RX1        SUBTRACT NORMALIZED (short HFP)
+	op_SEB     uint32 = 0xED0B // FORMAT_RXE        SUBTRACT (short BFP)
+	op_SEBR    uint32 = 0xB30B // FORMAT_RRE        SUBTRACT (short BFP)
+	op_SER     uint32 = 0x3B00 // FORMAT_RR         SUBTRACT NORMALIZED (short HFP)
+	op_SFASR   uint32 = 0xB385 // FORMAT_RRE        SET FPC AND SIGNAL
+	op_SFPC    uint32 = 0xB384 // FORMAT_RRE        SET FPC
+	op_SG      uint32 = 0xE309 // FORMAT_RXY1       SUBTRACT (64)
+	op_SGF     uint32 = 0xE319 // FORMAT_RXY1       SUBTRACT (64<-32)
+	op_SGFR    uint32 = 0xB919 // FORMAT_RRE        SUBTRACT (64<-32)
+	op_SGR     uint32 = 0xB909 // FORMAT_RRE        SUBTRACT (64)
+	op_SGRK    uint32 = 0xB9E9 // FORMAT_RRF1       SUBTRACT (64)
+	op_SH      uint32 = 0x4B00 // FORMAT_RX1        SUBTRACT HALFWORD
+	op_SHHHR   uint32 = 0xB9C9 // FORMAT_RRF1       SUBTRACT HIGH (32)
+	op_SHHLR   uint32 = 0xB9D9 // FORMAT_RRF1       SUBTRACT HIGH (32)
+	op_SHY     uint32 = 0xE37B // FORMAT_RXY1       SUBTRACT HALFWORD
+	op_SIGP    uint32 = 0xAE00 // FORMAT_RS1        SIGNAL PROCESSOR
+	op_SL      uint32 = 0x5F00 // FORMAT_RX1        SUBTRACT LOGICAL (32)
+	op_SLA     uint32 = 0x8B00 // FORMAT_RS1        SHIFT LEFT SINGLE (32)
+	op_SLAG    uint32 = 0xEB0B // FORMAT_RSY1       SHIFT LEFT SINGLE (64)
+	op_SLAK    uint32 = 0xEBDD // FORMAT_RSY1       SHIFT LEFT SINGLE (32)
+	op_SLB     uint32 = 0xE399 // FORMAT_RXY1       SUBTRACT LOGICAL WITH BORROW (32)
+	op_SLBG    uint32 = 0xE389 // FORMAT_RXY1       SUBTRACT LOGICAL WITH BORROW (64)
+	op_SLBGR   uint32 = 0xB989 // FORMAT_RRE        SUBTRACT LOGICAL WITH BORROW (64)
+	op_SLBR    uint32 = 0xB999 // FORMAT_RRE        SUBTRACT LOGICAL WITH BORROW (32)
+	op_SLDA    uint32 = 0x8F00 // FORMAT_RS1        SHIFT LEFT DOUBLE
+	op_SLDL    uint32 = 0x8D00 // FORMAT_RS1        SHIFT LEFT DOUBLE LOGICAL
+	op_SLDT    uint32 = 0xED40 // FORMAT_RXF        SHIFT SIGNIFICAND LEFT (long DFP)
+	op_SLFI    uint32 = 0xC205 // FORMAT_RIL1       SUBTRACT LOGICAL IMMEDIATE (32)
+	op_SLG     uint32 = 0xE30B // FORMAT_RXY1       SUBTRACT LOGICAL (64)
+	op_SLGF    uint32 = 0xE31B // FORMAT_RXY1       SUBTRACT LOGICAL (64<-32)
+	op_SLGFI   uint32 = 0xC204 // FORMAT_RIL1       SUBTRACT LOGICAL IMMEDIATE (64<-32)
+	op_SLGFR   uint32 = 0xB91B // FORMAT_RRE        SUBTRACT LOGICAL (64<-32)
+	op_SLGR    uint32 = 0xB90B // FORMAT_RRE        SUBTRACT LOGICAL (64)
+	op_SLGRK   uint32 = 0xB9EB // FORMAT_RRF1       SUBTRACT LOGICAL (64)
+	op_SLHHHR  uint32 = 0xB9CB // FORMAT_RRF1       SUBTRACT LOGICAL HIGH (32)
+	op_SLHHLR  uint32 = 0xB9DB // FORMAT_RRF1       SUBTRACT LOGICAL HIGH (32)
+	op_SLL     uint32 = 0x8900 // FORMAT_RS1        SHIFT LEFT SINGLE LOGICAL (32)
+	op_SLLG    uint32 = 0xEB0D // FORMAT_RSY1       SHIFT LEFT SINGLE LOGICAL (64)
+	op_SLLK    uint32 = 0xEBDF // FORMAT_RSY1       SHIFT LEFT SINGLE LOGICAL (32)
+	op_SLR     uint32 = 0x1F00 // FORMAT_RR         SUBTRACT LOGICAL (32)
+	op_SLRK    uint32 = 0xB9FB // FORMAT_RRF1       SUBTRACT LOGICAL (32)
+	op_SLXT    uint32 = 0xED48 // FORMAT_RXF        SHIFT SIGNIFICAND LEFT (extended DFP)
+	op_SLY     uint32 = 0xE35F // FORMAT_RXY1       SUBTRACT LOGICAL (32)
+	op_SP      uint32 = 0xFB00 // FORMAT_SS2        SUBTRACT DECIMAL
+	op_SPKA    uint32 = 0xB20A // FORMAT_S          SET PSW KEY FROM ADDRESS
+	op_SPM     uint32 = 0x0400 // FORMAT_RR         SET PROGRAM MASK
+	op_SPT     uint32 = 0xB208 // FORMAT_S          SET CPU TIMER
+	op_SPX     uint32 = 0xB210 // FORMAT_S          SET PREFIX
+	op_SQD     uint32 = 0xED35 // FORMAT_RXE        SQUARE ROOT (long HFP)
+	op_SQDB    uint32 = 0xED15 // FORMAT_RXE        SQUARE ROOT (long BFP)
+	op_SQDBR   uint32 = 0xB315 // FORMAT_RRE        SQUARE ROOT (long BFP)
+	op_SQDR    uint32 = 0xB244 // FORMAT_RRE        SQUARE ROOT (long HFP)
+	op_SQE     uint32 = 0xED34 // FORMAT_RXE        SQUARE ROOT (short HFP)
+	op_SQEB    uint32 = 0xED14 // FORMAT_RXE        SQUARE ROOT (short BFP)
+	op_SQEBR   uint32 = 0xB314 // FORMAT_RRE        SQUARE ROOT (short BFP)
+	op_SQER    uint32 = 0xB245 // FORMAT_RRE        SQUARE ROOT (short HFP)
+	op_SQXBR   uint32 = 0xB316 // FORMAT_RRE        SQUARE ROOT (extended BFP)
+	op_SQXR    uint32 = 0xB336 // FORMAT_RRE        SQUARE ROOT (extended HFP)
+	op_SR      uint32 = 0x1B00 // FORMAT_RR         SUBTRACT (32)
+	op_SRA     uint32 = 0x8A00 // FORMAT_RS1        SHIFT RIGHT SINGLE (32)
+	op_SRAG    uint32 = 0xEB0A // FORMAT_RSY1       SHIFT RIGHT SINGLE (64)
+	op_SRAK    uint32 = 0xEBDC // FORMAT_RSY1       SHIFT RIGHT SINGLE (32)
+	op_SRDA    uint32 = 0x8E00 // FORMAT_RS1        SHIFT RIGHT DOUBLE
+	op_SRDL    uint32 = 0x8C00 // FORMAT_RS1        SHIFT RIGHT DOUBLE LOGICAL
+	op_SRDT    uint32 = 0xED41 // FORMAT_RXF        SHIFT SIGNIFICAND RIGHT (long DFP)
+	op_SRK     uint32 = 0xB9F9 // FORMAT_RRF1       SUBTRACT (32)
+	op_SRL     uint32 = 0x8800 // FORMAT_RS1        SHIFT RIGHT SINGLE LOGICAL (32)
+	op_SRLG    uint32 = 0xEB0C // FORMAT_RSY1       SHIFT RIGHT SINGLE LOGICAL (64)
+	op_SRLK    uint32 = 0xEBDE // FORMAT_RSY1       SHIFT RIGHT SINGLE LOGICAL (32)
+	op_SRNM    uint32 = 0xB299 // FORMAT_S          SET BFP ROUNDING MODE (2 bit)
+	op_SRNMB   uint32 = 0xB2B8 // FORMAT_S          SET BFP ROUNDING MODE (3 bit)
+	op_SRNMT   uint32 = 0xB2B9 // FORMAT_S          SET DFP ROUNDING MODE
+	op_SRP     uint32 = 0xF000 // FORMAT_SS3        SHIFT AND ROUND DECIMAL
+	op_SRST    uint32 = 0xB25E // FORMAT_RRE        SEARCH STRING
+	op_SRSTU   uint32 = 0xB9BE // FORMAT_RRE        SEARCH STRING UNICODE
+	op_SRXT    uint32 = 0xED49 // FORMAT_RXF        SHIFT SIGNIFICAND RIGHT (extended DFP)
+	op_SSAIR   uint32 = 0xB99F // FORMAT_RRE        SET SECONDARY ASN WITH INSTANCE
+	op_SSAR    uint32 = 0xB225 // FORMAT_RRE        SET SECONDARY ASN
+	op_SSCH    uint32 = 0xB233 // FORMAT_S          START SUBCHANNEL
+	op_SSKE    uint32 = 0xB22B // FORMAT_RRF3       SET STORAGE KEY EXTENDED
+	op_SSM     uint32 = 0x8000 // FORMAT_S          SET SYSTEM MASK
+	op_ST      uint32 = 0x5000 // FORMAT_RX1        STORE (32)
+	op_STAM    uint32 = 0x9B00 // FORMAT_RS1        STORE ACCESS MULTIPLE
+	op_STAMY   uint32 = 0xEB9B // FORMAT_RSY1       STORE ACCESS MULTIPLE
+	op_STAP    uint32 = 0xB212 // FORMAT_S          STORE CPU ADDRESS
+	op_STC     uint32 = 0x4200 // FORMAT_RX1        STORE CHARACTER
+	op_STCH    uint32 = 0xE3C3 // FORMAT_RXY1       STORE CHARACTER HIGH (8)
+	op_STCK    uint32 = 0xB205 // FORMAT_S          STORE CLOCK
+	op_STCKC   uint32 = 0xB207 // FORMAT_S          STORE CLOCK COMPARATOR
+	op_STCKE   uint32 = 0xB278 // FORMAT_S          STORE CLOCK EXTENDED
+	op_STCKF   uint32 = 0xB27C // FORMAT_S          STORE CLOCK FAST
+	op_STCM    uint32 = 0xBE00 // FORMAT_RS2        STORE CHARACTERS UNDER MASK (low)
+	op_STCMH   uint32 = 0xEB2C // FORMAT_RSY2       STORE CHARACTERS UNDER MASK (high)
+	op_STCMY   uint32 = 0xEB2D // FORMAT_RSY2       STORE CHARACTERS UNDER MASK (low)
+	op_STCPS   uint32 = 0xB23A // FORMAT_S          STORE CHANNEL PATH STATUS
+	op_STCRW   uint32 = 0xB239 // FORMAT_S          STORE CHANNEL REPORT WORD
+	op_STCTG   uint32 = 0xEB25 // FORMAT_RSY1       STORE CONTROL (64)
+	op_STCTL   uint32 = 0xB600 // FORMAT_RS1        STORE CONTROL (32)
+	op_STCY    uint32 = 0xE372 // FORMAT_RXY1       STORE CHARACTER
+	op_STD     uint32 = 0x6000 // FORMAT_RX1        STORE (long)
+	op_STDY    uint32 = 0xED67 // FORMAT_RXY1       STORE (long)
+	op_STE     uint32 = 0x7000 // FORMAT_RX1        STORE (short)
+	op_STEY    uint32 = 0xED66 // FORMAT_RXY1       STORE (short)
+	op_STFH    uint32 = 0xE3CB // FORMAT_RXY1       STORE HIGH (32)
+	op_STFL    uint32 = 0xB2B1 // FORMAT_S          STORE FACILITY LIST
+	op_STFLE   uint32 = 0xB2B0 // FORMAT_S          STORE FACILITY LIST EXTENDED
+	op_STFPC   uint32 = 0xB29C // FORMAT_S          STORE FPC
+	op_STG     uint32 = 0xE324 // FORMAT_RXY1       STORE (64)
+	op_STGRL   uint32 = 0xC40B // FORMAT_RIL2       STORE RELATIVE LONG (64)
+	op_STH     uint32 = 0x4000 // FORMAT_RX1        STORE HALFWORD
+	op_STHH    uint32 = 0xE3C7 // FORMAT_RXY1       STORE HALFWORD HIGH (16)
+	op_STHRL   uint32 = 0xC407 // FORMAT_RIL2       STORE HALFWORD RELATIVE LONG
+	op_STHY    uint32 = 0xE370 // FORMAT_RXY1       STORE HALFWORD
+	op_STIDP   uint32 = 0xB202 // FORMAT_S          STORE CPU ID
+	op_STM     uint32 = 0x9000 // FORMAT_RS1        STORE MULTIPLE (32)
+	op_STMG    uint32 = 0xEB24 // FORMAT_RSY1       STORE MULTIPLE (64)
+	op_STMH    uint32 = 0xEB26 // FORMAT_RSY1       STORE MULTIPLE HIGH
+	op_STMY    uint32 = 0xEB90 // FORMAT_RSY1       STORE MULTIPLE (32)
+	op_STNSM   uint32 = 0xAC00 // FORMAT_SI         STORE THEN AND SYSTEM MASK
+	op_STOC    uint32 = 0xEBF3 // FORMAT_RSY2       STORE ON CONDITION (32)
+	op_STOCG   uint32 = 0xEBE3 // FORMAT_RSY2       STORE ON CONDITION (64)
+	op_STOSM   uint32 = 0xAD00 // FORMAT_SI         STORE THEN OR SYSTEM MASK
+	op_STPQ    uint32 = 0xE38E // FORMAT_RXY1       STORE PAIR TO QUADWORD
+	op_STPT    uint32 = 0xB209 // FORMAT_S          STORE CPU TIMER
+	op_STPX    uint32 = 0xB211 // FORMAT_S          STORE PREFIX
+	op_STRAG   uint32 = 0xE502 // FORMAT_SSE        STORE REAL ADDRESS
+	op_STRL    uint32 = 0xC40F // FORMAT_RIL2       STORE RELATIVE LONG (32)
+	op_STRV    uint32 = 0xE33E // FORMAT_RXY1       STORE REVERSED (32)
+	op_STRVG   uint32 = 0xE32F // FORMAT_RXY1       STORE REVERSED (64)
+	op_STRVH   uint32 = 0xE33F // FORMAT_RXY1       STORE REVERSED (16)
+	op_STSCH   uint32 = 0xB234 // FORMAT_S          STORE SUBCHANNEL
+	op_STSI    uint32 = 0xB27D // FORMAT_S          STORE SYSTEM INFORMATION
+	op_STURA   uint32 = 0xB246 // FORMAT_RRE        STORE USING REAL ADDRESS (32)
+	op_STURG   uint32 = 0xB925 // FORMAT_RRE        STORE USING REAL ADDRESS (64)
+	op_STY     uint32 = 0xE350 // FORMAT_RXY1       STORE (32)
+	op_SU      uint32 = 0x7F00 // FORMAT_RX1        SUBTRACT UNNORMALIZED (short HFP)
+	op_SUR     uint32 = 0x3F00 // FORMAT_RR         SUBTRACT UNNORMALIZED (short HFP)
+	op_SVC     uint32 = 0x0A00 // FORMAT_I          SUPERVISOR CALL
+	op_SW      uint32 = 0x6F00 // FORMAT_RX1        SUBTRACT UNNORMALIZED (long HFP)
+	op_SWR     uint32 = 0x2F00 // FORMAT_RR         SUBTRACT UNNORMALIZED (long HFP)
+	op_SXBR    uint32 = 0xB34B // FORMAT_RRE        SUBTRACT (extended BFP)
+	op_SXR     uint32 = 0x3700 // FORMAT_RR         SUBTRACT NORMALIZED (extended HFP)
+	op_SXTR    uint32 = 0xB3DB // FORMAT_RRF1       SUBTRACT (extended DFP)
+	op_SXTRA   uint32 = 0xB3DB // FORMAT_RRF1       SUBTRACT (extended DFP)
+	op_SY      uint32 = 0xE35B // FORMAT_RXY1       SUBTRACT (32)
+	op_TABORT  uint32 = 0xB2FC // FORMAT_S          TRANSACTION ABORT
+	op_TAM     uint32 = 0x010B // FORMAT_E          TEST ADDRESSING MODE
+	op_TAR     uint32 = 0xB24C // FORMAT_RRE        TEST ACCESS
+	op_TB      uint32 = 0xB22C // FORMAT_RRE        TEST BLOCK
+	op_TBDR    uint32 = 0xB351 // FORMAT_RRF5       CONVERT HFP TO BFP (long)
+	op_TBEDR   uint32 = 0xB350 // FORMAT_RRF5       CONVERT HFP TO BFP (long to short)
+	op_TBEGIN  uint32 = 0xE560 // FORMAT_SIL        TRANSACTION BEGIN
+	op_TBEGINC uint32 = 0xE561 // FORMAT_SIL        TRANSACTION BEGIN
+	op_TCDB    uint32 = 0xED11 // FORMAT_RXE        TEST DATA CLASS (long BFP)
+	op_TCEB    uint32 = 0xED10 // FORMAT_RXE        TEST DATA CLASS (short BFP)
+	op_TCXB    uint32 = 0xED12 // FORMAT_RXE        TEST DATA CLASS (extended BFP)
+	op_TDCDT   uint32 = 0xED54 // FORMAT_RXE        TEST DATA CLASS (long DFP)
+	op_TDCET   uint32 = 0xED50 // FORMAT_RXE        TEST DATA CLASS (short DFP)
+	op_TDCXT   uint32 = 0xED58 // FORMAT_RXE        TEST DATA CLASS (extended DFP)
+	op_TDGDT   uint32 = 0xED55 // FORMAT_RXE        TEST DATA GROUP (long DFP)
+	op_TDGET   uint32 = 0xED51 // FORMAT_RXE        TEST DATA GROUP (short DFP)
+	op_TDGXT   uint32 = 0xED59 // FORMAT_RXE        TEST DATA GROUP (extended DFP)
+	op_TEND    uint32 = 0xB2F8 // FORMAT_S          TRANSACTION END
+	op_THDER   uint32 = 0xB358 // FORMAT_RRE        CONVERT BFP TO HFP (short to long)
+	op_THDR    uint32 = 0xB359 // FORMAT_RRE        CONVERT BFP TO HFP (long)
+	op_TM      uint32 = 0x9100 // FORMAT_SI         TEST UNDER MASK
+	op_TMH     uint32 = 0xA700 // FORMAT_RI1        TEST UNDER MASK HIGH
+	op_TMHH    uint32 = 0xA702 // FORMAT_RI1        TEST UNDER MASK (high high)
+	op_TMHL    uint32 = 0xA703 // FORMAT_RI1        TEST UNDER MASK (high low)
+	op_TML     uint32 = 0xA701 // FORMAT_RI1        TEST UNDER MASK LOW
+	op_TMLH    uint32 = 0xA700 // FORMAT_RI1        TEST UNDER MASK (low high)
+	op_TMLL    uint32 = 0xA701 // FORMAT_RI1        TEST UNDER MASK (low low)
+	op_TMY     uint32 = 0xEB51 // FORMAT_SIY        TEST UNDER MASK
+	op_TP      uint32 = 0xEBC0 // FORMAT_RSL        TEST DECIMAL
+	op_TPI     uint32 = 0xB236 // FORMAT_S          TEST PENDING INTERRUPTION
+	op_TPROT   uint32 = 0xE501 // FORMAT_SSE        TEST PROTECTION
+	op_TR      uint32 = 0xDC00 // FORMAT_SS1        TRANSLATE
+	op_TRACE   uint32 = 0x9900 // FORMAT_RS1        TRACE (32)
+	op_TRACG   uint32 = 0xEB0F // FORMAT_RSY1       TRACE (64)
+	op_TRAP2   uint32 = 0x01FF // FORMAT_E          TRAP
+	op_TRAP4   uint32 = 0xB2FF // FORMAT_S          TRAP
+	op_TRE     uint32 = 0xB2A5 // FORMAT_RRE        TRANSLATE EXTENDED
+	op_TROO    uint32 = 0xB993 // FORMAT_RRF3       TRANSLATE ONE TO ONE
+	op_TROT    uint32 = 0xB992 // FORMAT_RRF3       TRANSLATE ONE TO TWO
+	op_TRT     uint32 = 0xDD00 // FORMAT_SS1        TRANSLATE AND TEST
+	op_TRTE    uint32 = 0xB9BF // FORMAT_RRF3       TRANSLATE AND TEST EXTENDED
+	op_TRTO    uint32 = 0xB991 // FORMAT_RRF3       TRANSLATE TWO TO ONE
+	op_TRTR    uint32 = 0xD000 // FORMAT_SS1        TRANSLATE AND TEST REVERSE
+	op_TRTRE   uint32 = 0xB9BD // FORMAT_RRF3       TRANSLATE AND TEST REVERSE EXTENDED
+	op_TRTT    uint32 = 0xB990 // FORMAT_RRF3       TRANSLATE TWO TO TWO
+	op_TS      uint32 = 0x9300 // FORMAT_S          TEST AND SET
+	op_TSCH    uint32 = 0xB235 // FORMAT_S          TEST SUBCHANNEL
+	op_UNPK    uint32 = 0xF300 // FORMAT_SS2        UNPACK
+	op_UNPKA   uint32 = 0xEA00 // FORMAT_SS1        UNPACK ASCII
+	op_UNPKU   uint32 = 0xE200 // FORMAT_SS1        UNPACK UNICODE
+	op_UPT     uint32 = 0x0102 // FORMAT_E          UPDATE TREE
+	op_X       uint32 = 0x5700 // FORMAT_RX1        EXCLUSIVE OR (32)
+	op_XC      uint32 = 0xD700 // FORMAT_SS1        EXCLUSIVE OR (character)
+	op_XG      uint32 = 0xE382 // FORMAT_RXY1       EXCLUSIVE OR (64)
+	op_XGR     uint32 = 0xB982 // FORMAT_RRE        EXCLUSIVE OR (64)
+	op_XGRK    uint32 = 0xB9E7 // FORMAT_RRF1       EXCLUSIVE OR (64)
+	op_XI      uint32 = 0x9700 // FORMAT_SI         EXCLUSIVE OR (immediate)
+	op_XIHF    uint32 = 0xC006 // FORMAT_RIL1       EXCLUSIVE OR IMMEDIATE (high)
+	op_XILF    uint32 = 0xC007 // FORMAT_RIL1       EXCLUSIVE OR IMMEDIATE (low)
+	op_XIY     uint32 = 0xEB57 // FORMAT_SIY        EXCLUSIVE OR (immediate)
+	op_XR      uint32 = 0x1700 // FORMAT_RR         EXCLUSIVE OR (32)
+	op_XRK     uint32 = 0xB9F7 // FORMAT_RRF1       EXCLUSIVE OR (32)
+	op_XSCH    uint32 = 0xB276 // FORMAT_S          CANCEL SUBCHANNEL
+	op_XY      uint32 = 0xE357 // FORMAT_RXY1       EXCLUSIVE OR (32)
+	op_ZAP     uint32 = 0xF800 // FORMAT_SS2        ZERO AND ADD
+
+	// added in z13
+	op_CXPT   uint32 = 0xEDAF // 	RSL-b	CONVERT FROM PACKED (to extended DFP)
+	op_CDPT   uint32 = 0xEDAE // 	RSL-b	CONVERT FROM PACKED (to long DFP)
+	op_CPXT   uint32 = 0xEDAD // 	RSL-b	CONVERT TO PACKED (from extended DFP)
+	op_CPDT   uint32 = 0xEDAC // 	RSL-b	CONVERT TO PACKED (from long DFP)
+	op_LZRF   uint32 = 0xE33B // 	RXY-a	LOAD AND ZERO RIGHTMOST BYTE (32)
+	op_LZRG   uint32 = 0xE32A // 	RXY-a	LOAD AND ZERO RIGHTMOST BYTE (64)
+	op_LCCB   uint32 = 0xE727 // 	RXE	LOAD COUNT TO BLOCK BOUNDARY
+	op_LOCHHI uint32 = 0xEC4E // 	RIE-g	LOAD HALFWORD HIGH IMMEDIATE ON CONDITION (32←16)
+	op_LOCHI  uint32 = 0xEC42 // 	RIE-g	LOAD HALFWORD IMMEDIATE ON CONDITION (32←16)
+	op_LOCGHI uint32 = 0xEC46 // 	RIE-g	LOAD HALFWORD IMMEDIATE ON CONDITION (64←16)
+	op_LOCFH  uint32 = 0xEBE0 // 	RSY-b	LOAD HIGH ON CONDITION (32)
+	op_LOCFHR uint32 = 0xB9E0 // 	RRF-c	LOAD HIGH ON CONDITION (32)
+	op_LLZRGF uint32 = 0xE33A // 	RXY-a	LOAD LOGICAL AND ZERO RIGHTMOST BYTE (64←32)
+	op_STOCFH uint32 = 0xEBE1 // 	RSY-b	STORE HIGH ON CONDITION
+	op_VA     uint32 = 0xE7F3 // 	VRR-c	VECTOR ADD
+	op_VACC   uint32 = 0xE7F1 // 	VRR-c	VECTOR ADD COMPUTE CARRY
+	op_VAC    uint32 = 0xE7BB // 	VRR-d	VECTOR ADD WITH CARRY
+	op_VACCC  uint32 = 0xE7B9 // 	VRR-d	VECTOR ADD WITH CARRY COMPUTE CARRY
+	op_VN     uint32 = 0xE768 // 	VRR-c	VECTOR AND
+	op_VNC    uint32 = 0xE769 // 	VRR-c	VECTOR AND WITH COMPLEMENT
+	op_VAVG   uint32 = 0xE7F2 // 	VRR-c	VECTOR AVERAGE
+	op_VAVGL  uint32 = 0xE7F0 // 	VRR-c	VECTOR AVERAGE LOGICAL
+	op_VCKSM  uint32 = 0xE766 // 	VRR-c	VECTOR CHECKSUM
+	op_VCEQ   uint32 = 0xE7F8 // 	VRR-b	VECTOR COMPARE EQUAL
+	op_VCH    uint32 = 0xE7FB // 	VRR-b	VECTOR COMPARE HIGH
+	op_VCHL   uint32 = 0xE7F9 // 	VRR-b	VECTOR COMPARE HIGH LOGICAL
+	op_VCLZ   uint32 = 0xE753 // 	VRR-a	VECTOR COUNT LEADING ZEROS
+	op_VCTZ   uint32 = 0xE752 // 	VRR-a	VECTOR COUNT TRAILING ZEROS
+	op_VEC    uint32 = 0xE7DB // 	VRR-a	VECTOR ELEMENT COMPARE
+	op_VECL   uint32 = 0xE7D9 // 	VRR-a	VECTOR ELEMENT COMPARE LOGICAL
+	op_VERIM  uint32 = 0xE772 // 	VRI-d	VECTOR ELEMENT ROTATE AND INSERT UNDER MASK
+	op_VERLL  uint32 = 0xE733 // 	VRS-a	VECTOR ELEMENT ROTATE LEFT LOGICAL
+	op_VERLLV uint32 = 0xE773 // 	VRR-c	VECTOR ELEMENT ROTATE LEFT LOGICAL
+	op_VESLV  uint32 = 0xE770 // 	VRR-c	VECTOR ELEMENT SHIFT LEFT
+	op_VESL   uint32 = 0xE730 // 	VRS-a	VECTOR ELEMENT SHIFT LEFT
+	op_VESRA  uint32 = 0xE73A // 	VRS-a	VECTOR ELEMENT SHIFT RIGHT ARITHMETIC
+	op_VESRAV uint32 = 0xE77A // 	VRR-c	VECTOR ELEMENT SHIFT RIGHT ARITHMETIC
+	op_VESRL  uint32 = 0xE738 // 	VRS-a	VECTOR ELEMENT SHIFT RIGHT LOGICAL
+	op_VESRLV uint32 = 0xE778 // 	VRR-c	VECTOR ELEMENT SHIFT RIGHT LOGICAL
+	op_VX     uint32 = 0xE76D // 	VRR-c	VECTOR EXCLUSIVE OR
+	op_VFAE   uint32 = 0xE782 // 	VRR-b	VECTOR FIND ANY ELEMENT EQUAL
+	op_VFEE   uint32 = 0xE780 // 	VRR-b	VECTOR FIND ELEMENT EQUAL
+	op_VFENE  uint32 = 0xE781 // 	VRR-b	VECTOR FIND ELEMENT NOT EQUAL
+	op_VFA    uint32 = 0xE7E3 // 	VRR-c	VECTOR FP ADD
+	op_WFK    uint32 = 0xE7CA // 	VRR-a	VECTOR FP COMPARE AND SIGNAL SCALAR
+	op_VFCE   uint32 = 0xE7E8 // 	VRR-c	VECTOR FP COMPARE EQUAL
+	op_VFCH   uint32 = 0xE7EB // 	VRR-c	VECTOR FP COMPARE HIGH
+	op_VFCHE  uint32 = 0xE7EA // 	VRR-c	VECTOR FP COMPARE HIGH OR EQUAL
+	op_WFC    uint32 = 0xE7CB // 	VRR-a	VECTOR FP COMPARE SCALAR
+	op_VCDG   uint32 = 0xE7C3 // 	VRR-a	VECTOR FP CONVERT FROM FIXED 64-BIT
+	op_VCDLG  uint32 = 0xE7C1 // 	VRR-a	VECTOR FP CONVERT FROM LOGICAL 64-BIT
+	op_VCGD   uint32 = 0xE7C2 // 	VRR-a	VECTOR FP CONVERT TO FIXED 64-BIT
+	op_VCLGD  uint32 = 0xE7C0 // 	VRR-a	VECTOR FP CONVERT TO LOGICAL 64-BIT
+	op_VFD    uint32 = 0xE7E5 // 	VRR-c	VECTOR FP DIVIDE
+	op_VLDE   uint32 = 0xE7C4 // 	VRR-a	VECTOR FP LOAD LENGTHENED
+	op_VLED   uint32 = 0xE7C5 // 	VRR-a	VECTOR FP LOAD ROUNDED
+	op_VFM    uint32 = 0xE7E7 // 	VRR-c	VECTOR FP MULTIPLY
+	op_VFMA   uint32 = 0xE78F // 	VRR-e	VECTOR FP MULTIPLY AND ADD
+	op_VFMS   uint32 = 0xE78E // 	VRR-e	VECTOR FP MULTIPLY AND SUBTRACT
+	op_VFPSO  uint32 = 0xE7CC // 	VRR-a	VECTOR FP PERFORM SIGN OPERATION
+	op_VFSQ   uint32 = 0xE7CE // 	VRR-a	VECTOR FP SQUARE ROOT
+	op_VFS    uint32 = 0xE7E2 // 	VRR-c	VECTOR FP SUBTRACT
+	op_VFTCI  uint32 = 0xE74A // 	VRI-e	VECTOR FP TEST DATA CLASS IMMEDIATE
+	op_VGFM   uint32 = 0xE7B4 // 	VRR-c	VECTOR GALOIS FIELD MULTIPLY SUM
+	op_VGFMA  uint32 = 0xE7BC // 	VRR-d	VECTOR GALOIS FIELD MULTIPLY SUM AND ACCUMULATE
+	op_VGEF   uint32 = 0xE713 // 	VRV	VECTOR GATHER ELEMENT (32)
+	op_VGEG   uint32 = 0xE712 // 	VRV	VECTOR GATHER ELEMENT (64)
+	op_VGBM   uint32 = 0xE744 // 	VRI-a	VECTOR GENERATE BYTE MASK
+	op_VGM    uint32 = 0xE746 // 	VRI-b	VECTOR GENERATE MASK
+	op_VISTR  uint32 = 0xE75C // 	VRR-a	VECTOR ISOLATE STRING
+	op_VL     uint32 = 0xE706 // 	VRX	VECTOR LOAD
+	op_VLR    uint32 = 0xE756 // 	VRR-a	VECTOR LOAD
+	op_VLREP  uint32 = 0xE705 // 	VRX	VECTOR LOAD AND REPLICATE
+	op_VLC    uint32 = 0xE7DE // 	VRR-a	VECTOR LOAD COMPLEMENT
+	op_VLEH   uint32 = 0xE701 // 	VRX	VECTOR LOAD ELEMENT (16)
+	op_VLEF   uint32 = 0xE703 // 	VRX	VECTOR LOAD ELEMENT (32)
+	op_VLEG   uint32 = 0xE702 // 	VRX	VECTOR LOAD ELEMENT (64)
+	op_VLEB   uint32 = 0xE700 // 	VRX	VECTOR LOAD ELEMENT (8)
+	op_VLEIH  uint32 = 0xE741 // 	VRI-a	VECTOR LOAD ELEMENT IMMEDIATE (16)
+	op_VLEIF  uint32 = 0xE743 // 	VRI-a	VECTOR LOAD ELEMENT IMMEDIATE (32)
+	op_VLEIG  uint32 = 0xE742 // 	VRI-a	VECTOR LOAD ELEMENT IMMEDIATE (64)
+	op_VLEIB  uint32 = 0xE740 // 	VRI-a	VECTOR LOAD ELEMENT IMMEDIATE (8)
+	op_VFI    uint32 = 0xE7C7 // 	VRR-a	VECTOR LOAD FP INTEGER
+	op_VLGV   uint32 = 0xE721 // 	VRS-c	VECTOR LOAD GR FROM VR ELEMENT
+	op_VLLEZ  uint32 = 0xE704 // 	VRX	VECTOR LOAD LOGICAL ELEMENT AND ZERO
+	op_VLM    uint32 = 0xE736 // 	VRS-a	VECTOR LOAD MULTIPLE
+	op_VLP    uint32 = 0xE7DF // 	VRR-a	VECTOR LOAD POSITIVE
+	op_VLBB   uint32 = 0xE707 // 	VRX	VECTOR LOAD TO BLOCK BOUNDARY
+	op_VLVG   uint32 = 0xE722 // 	VRS-b	VECTOR LOAD VR ELEMENT FROM GR
+	op_VLVGP  uint32 = 0xE762 // 	VRR-f	VECTOR LOAD VR FROM GRS DISJOINT
+	op_VLL    uint32 = 0xE737 // 	VRS-b	VECTOR LOAD WITH LENGTH
+	op_VMX    uint32 = 0xE7FF // 	VRR-c	VECTOR MAXIMUM
+	op_VMXL   uint32 = 0xE7FD // 	VRR-c	VECTOR MAXIMUM LOGICAL
+	op_VMRH   uint32 = 0xE761 // 	VRR-c	VECTOR MERGE HIGH
+	op_VMRL   uint32 = 0xE760 // 	VRR-c	VECTOR MERGE LOW
+	op_VMN    uint32 = 0xE7FE // 	VRR-c	VECTOR MINIMUM
+	op_VMNL   uint32 = 0xE7FC // 	VRR-c	VECTOR MINIMUM LOGICAL
+	op_VMAE   uint32 = 0xE7AE // 	VRR-d	VECTOR MULTIPLY AND ADD EVEN
+	op_VMAH   uint32 = 0xE7AB // 	VRR-d	VECTOR MULTIPLY AND ADD HIGH
+	op_VMALE  uint32 = 0xE7AC // 	VRR-d	VECTOR MULTIPLY AND ADD LOGICAL EVEN
+	op_VMALH  uint32 = 0xE7A9 // 	VRR-d	VECTOR MULTIPLY AND ADD LOGICAL HIGH
+	op_VMALO  uint32 = 0xE7AD // 	VRR-d	VECTOR MULTIPLY AND ADD LOGICAL ODD
+	op_VMAL   uint32 = 0xE7AA // 	VRR-d	VECTOR MULTIPLY AND ADD LOW
+	op_VMAO   uint32 = 0xE7AF // 	VRR-d	VECTOR MULTIPLY AND ADD ODD
+	op_VME    uint32 = 0xE7A6 // 	VRR-c	VECTOR MULTIPLY EVEN
+	op_VMH    uint32 = 0xE7A3 // 	VRR-c	VECTOR MULTIPLY HIGH
+	op_VMLE   uint32 = 0xE7A4 // 	VRR-c	VECTOR MULTIPLY EVEN LOGICAL
+	op_VMLH   uint32 = 0xE7A1 // 	VRR-c	VECTOR MULTIPLY HIGH LOGICAL
+	op_VMLO   uint32 = 0xE7A5 // 	VRR-c	VECTOR MULTIPLY ODD LOGICAL
+	op_VML    uint32 = 0xE7A2 // 	VRR-c	VECTOR MULTIPLY LOW
+	op_VMO    uint32 = 0xE7A7 // 	VRR-c	VECTOR MULTIPLY ODD
+	op_VNO    uint32 = 0xE76B // 	VRR-c	VECTOR NOR
+	op_VO     uint32 = 0xE76A // 	VRR-c	VECTOR OR
+	op_VPK    uint32 = 0xE794 // 	VRR-c	VECTOR PACK
+	op_VPKLS  uint32 = 0xE795 // 	VRR-b	VECTOR PACK LOGICAL SATURATE
+	op_VPKS   uint32 = 0xE797 // 	VRR-b	VECTOR PACK SATURATE
+	op_VPERM  uint32 = 0xE78C // 	VRR-e	VECTOR PERMUTE
+	op_VPDI   uint32 = 0xE784 // 	VRR-c	VECTOR PERMUTE DOUBLEWORD IMMEDIATE
+	op_VPOPCT uint32 = 0xE750 // 	VRR-a	VECTOR POPULATION COUNT
+	op_VREP   uint32 = 0xE74D // 	VRI-c	VECTOR REPLICATE
+	op_VREPI  uint32 = 0xE745 // 	VRI-a	VECTOR REPLICATE IMMEDIATE
+	op_VSCEF  uint32 = 0xE71B // 	VRV	VECTOR SCATTER ELEMENT (32)
+	op_VSCEG  uint32 = 0xE71A // 	VRV	VECTOR SCATTER ELEMENT (64)
+	op_VSEL   uint32 = 0xE78D // 	VRR-e	VECTOR SELECT
+	op_VSL    uint32 = 0xE774 // 	VRR-c	VECTOR SHIFT LEFT
+	op_VSLB   uint32 = 0xE775 // 	VRR-c	VECTOR SHIFT LEFT BY BYTE
+	op_VSLDB  uint32 = 0xE777 // 	VRI-d	VECTOR SHIFT LEFT DOUBLE BY BYTE
+	op_VSRA   uint32 = 0xE77E // 	VRR-c	VECTOR SHIFT RIGHT ARITHMETIC
+	op_VSRAB  uint32 = 0xE77F // 	VRR-c	VECTOR SHIFT RIGHT ARITHMETIC BY BYTE
+	op_VSRL   uint32 = 0xE77C // 	VRR-c	VECTOR SHIFT RIGHT LOGICAL
+	op_VSRLB  uint32 = 0xE77D // 	VRR-c	VECTOR SHIFT RIGHT LOGICAL BY BYTE
+	op_VSEG   uint32 = 0xE75F // 	VRR-a	VECTOR SIGN EXTEND TO DOUBLEWORD
+	op_VST    uint32 = 0xE70E // 	VRX	VECTOR STORE
+	op_VSTEH  uint32 = 0xE709 // 	VRX	VECTOR STORE ELEMENT (16)
+	op_VSTEF  uint32 = 0xE70B // 	VRX	VECTOR STORE ELEMENT (32)
+	op_VSTEG  uint32 = 0xE70A // 	VRX	VECTOR STORE ELEMENT (64)
+	op_VSTEB  uint32 = 0xE708 // 	VRX	VECTOR STORE ELEMENT (8)
+	op_VSTM   uint32 = 0xE73E // 	VRS-a	VECTOR STORE MULTIPLE
+	op_VSTL   uint32 = 0xE73F // 	VRS-b	VECTOR STORE WITH LENGTH
+	op_VSTRC  uint32 = 0xE78A // 	VRR-d	VECTOR STRING RANGE COMPARE
+	op_VS     uint32 = 0xE7F7 // 	VRR-c	VECTOR SUBTRACT
+	op_VSCBI  uint32 = 0xE7F5 // 	VRR-c	VECTOR SUBTRACT COMPUTE BORROW INDICATION
+	op_VSBCBI uint32 = 0xE7BD // 	VRR-d	VECTOR SUBTRACT WITH BORROW COMPUTE BORROW INDICATION
+	op_VSBI   uint32 = 0xE7BF // 	VRR-d	VECTOR SUBTRACT WITH BORROW INDICATION
+	op_VSUMG  uint32 = 0xE765 // 	VRR-c	VECTOR SUM ACROSS DOUBLEWORD
+	op_VSUMQ  uint32 = 0xE767 // 	VRR-c	VECTOR SUM ACROSS QUADWORD
+	op_VSUM   uint32 = 0xE764 // 	VRR-c	VECTOR SUM ACROSS WORD
+	op_VTM    uint32 = 0xE7D8 // 	VRR-a	VECTOR TEST UNDER MASK
+	op_VUPH   uint32 = 0xE7D7 // 	VRR-a	VECTOR UNPACK HIGH
+	op_VUPLH  uint32 = 0xE7D5 // 	VRR-a	VECTOR UNPACK LOGICAL HIGH
+	op_VUPLL  uint32 = 0xE7D4 // 	VRR-a	VECTOR UNPACK LOGICAL LOW
+	op_VUPL   uint32 = 0xE7D6 // 	VRR-a	VECTOR UNPACK LOW
+	op_VMSL   uint32 = 0xE7B8 // 	VRR-d	VECTOR MULTIPLY SUM LOGICAL
+)
+
+func oclass(a *obj.Addr) int {
+	return int(a.Class) - 1
+}
+
+// Add a relocation for the immediate in a RIL style instruction.
+// The addend will be adjusted as required.
+func (c *ctxtz) addrilreloc(sym *obj.LSym, add int64) *obj.Reloc {
+	if sym == nil {
+		c.ctxt.Diag("require symbol to apply relocation")
+	}
+	offset := int64(2) // relocation offset from start of instruction
+	rel := obj.Addrel(c.cursym)
+	rel.Off = int32(c.pc + offset)
+	rel.Siz = 4
+	rel.Sym = sym
+	rel.Add = add + offset + int64(rel.Siz)
+	rel.Type = objabi.R_PCRELDBL
+	return rel
+}
+
+func (c *ctxtz) addrilrelocoffset(sym *obj.LSym, add, offset int64) *obj.Reloc {
+	if sym == nil {
+		c.ctxt.Diag("require symbol to apply relocation")
+	}
+	offset += int64(2) // relocation offset from start of instruction
+	rel := obj.Addrel(c.cursym)
+	rel.Off = int32(c.pc + offset)
+	rel.Siz = 4
+	rel.Sym = sym
+	rel.Add = add + offset + int64(rel.Siz)
+	rel.Type = objabi.R_PCRELDBL
+	return rel
+}
+
+// Add a CALL relocation for the immediate in a RIL style instruction.
+// The addend will be adjusted as required.
+func (c *ctxtz) addcallreloc(sym *obj.LSym, add int64) *obj.Reloc {
+	if sym == nil {
+		c.ctxt.Diag("require symbol to apply relocation")
+	}
+	offset := int64(2) // relocation offset from start of instruction
+	rel := obj.Addrel(c.cursym)
+	rel.Off = int32(c.pc + offset)
+	rel.Siz = 4
+	rel.Sym = sym
+	rel.Add = add + offset + int64(rel.Siz)
+	rel.Type = objabi.R_CALL
+	return rel
+}
+
+func (c *ctxtz) branchMask(p *obj.Prog) CCMask {
+	switch p.As {
+	case ABRC, ALOCR, ALOCGR,
+		ACRJ, ACGRJ, ACIJ, ACGIJ,
+		ACLRJ, ACLGRJ, ACLIJ, ACLGIJ:
+		return CCMask(p.From.Offset)
+	case ABEQ, ACMPBEQ, ACMPUBEQ, AMOVDEQ:
+		return Equal
+	case ABGE, ACMPBGE, ACMPUBGE, AMOVDGE:
+		return GreaterOrEqual
+	case ABGT, ACMPBGT, ACMPUBGT, AMOVDGT:
+		return Greater
+	case ABLE, ACMPBLE, ACMPUBLE, AMOVDLE:
+		return LessOrEqual
+	case ABLT, ACMPBLT, ACMPUBLT, AMOVDLT:
+		return Less
+	case ABNE, ACMPBNE, ACMPUBNE, AMOVDNE:
+		return NotEqual
+	case ABLEU: // LE or unordered
+		return NotGreater
+	case ABLTU: // LT or unordered
+		return LessOrUnordered
+	case ABVC:
+		return Never // needs extra instruction
+	case ABVS:
+		return Unordered
+	}
+	c.ctxt.Diag("unknown conditional branch %v", p.As)
+	return Always
+}
+
+func regtmp(p *obj.Prog) uint32 {
+	p.Mark |= USETMP
+	return REGTMP
+}
+
+func (c *ctxtz) asmout(p *obj.Prog, asm *[]byte) {
+	o := c.oplook(p)
+
+	if o == nil {
+		return
+	}
+
+	// If REGTMP is used in generated code, we need to set USETMP on p.Mark.
+	// So we use regtmp(p) for REGTMP.
+
+	switch o.i {
+	default:
+		c.ctxt.Diag("unknown index %d", o.i)
+
+	case 0: // PSEUDO OPS
+		break
+
+	case 1: // mov reg reg
+		switch p.As {
+		default:
+			c.ctxt.Diag("unhandled operation: %v", p.As)
+		case AMOVD:
+			zRRE(op_LGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+		// sign extend
+		case AMOVW:
+			zRRE(op_LGFR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+		case AMOVH:
+			zRRE(op_LGHR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+		case AMOVB:
+			zRRE(op_LGBR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+		// zero extend
+		case AMOVWZ:
+			zRRE(op_LLGFR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+		case AMOVHZ:
+			zRRE(op_LLGHR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+		case AMOVBZ:
+			zRRE(op_LLGCR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+		// reverse bytes
+		case AMOVDBR:
+			zRRE(op_LRVGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+		case AMOVWBR:
+			zRRE(op_LRVR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+		// floating point
+		case AFMOVD, AFMOVS:
+			zRR(op_LDR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+		}
+
+	case 2: // arithmetic op reg [reg] reg
+		r := p.Reg
+		if r == 0 {
+			r = p.To.Reg
+		}
+
+		var opcode uint32
+
+		switch p.As {
+		default:
+			c.ctxt.Diag("invalid opcode")
+		case AADD:
+			opcode = op_AGRK
+		case AADDC:
+			opcode = op_ALGRK
+		case AADDE:
+			opcode = op_ALCGR
+		case AADDW:
+			opcode = op_ARK
+		case AMULLW:
+			opcode = op_MSGFR
+		case AMULLD:
+			opcode = op_MSGR
+		case ADIVW, AMODW:
+			opcode = op_DSGFR
+		case ADIVWU, AMODWU:
+			opcode = op_DLR
+		case ADIVD, AMODD:
+			opcode = op_DSGR
+		case ADIVDU, AMODDU:
+			opcode = op_DLGR
+		}
+
+		switch p.As {
+		default:
+
+		case AADD, AADDC, AADDW:
+			if p.As == AADDW && r == p.To.Reg {
+				zRR(op_AR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+			} else {
+				zRRF(opcode, uint32(p.From.Reg), 0, uint32(p.To.Reg), uint32(r), asm)
+			}
+
+		case AADDE, AMULLW, AMULLD:
+			if r == p.To.Reg {
+				zRRE(opcode, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+			} else if p.From.Reg == p.To.Reg {
+				zRRE(opcode, uint32(p.To.Reg), uint32(r), asm)
+			} else {
+				zRRE(op_LGR, uint32(p.To.Reg), uint32(r), asm)
+				zRRE(opcode, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+			}
+
+		case ADIVW, ADIVWU, ADIVD, ADIVDU:
+			if p.As == ADIVWU || p.As == ADIVDU {
+				zRI(op_LGHI, regtmp(p), 0, asm)
+			}
+			zRRE(op_LGR, REGTMP2, uint32(r), asm)
+			zRRE(opcode, regtmp(p), uint32(p.From.Reg), asm)
+			zRRE(op_LGR, uint32(p.To.Reg), REGTMP2, asm)
+
+		case AMODW, AMODWU, AMODD, AMODDU:
+			if p.As == AMODWU || p.As == AMODDU {
+				zRI(op_LGHI, regtmp(p), 0, asm)
+			}
+			zRRE(op_LGR, REGTMP2, uint32(r), asm)
+			zRRE(opcode, regtmp(p), uint32(p.From.Reg), asm)
+			zRRE(op_LGR, uint32(p.To.Reg), regtmp(p), asm)
+
+		}
+
+	case 3: // mov $constant reg
+		v := c.vregoff(&p.From)
+		switch p.As {
+		case AMOVBZ:
+			v = int64(uint8(v))
+		case AMOVHZ:
+			v = int64(uint16(v))
+		case AMOVWZ:
+			v = int64(uint32(v))
+		case AMOVB:
+			v = int64(int8(v))
+		case AMOVH:
+			v = int64(int16(v))
+		case AMOVW:
+			v = int64(int32(v))
+		}
+		if int64(int16(v)) == v {
+			zRI(op_LGHI, uint32(p.To.Reg), uint32(v), asm)
+		} else if v&0xffff0000 == v {
+			zRI(op_LLILH, uint32(p.To.Reg), uint32(v>>16), asm)
+		} else if v&0xffff00000000 == v {
+			zRI(op_LLIHL, uint32(p.To.Reg), uint32(v>>32), asm)
+		} else if uint64(v)&0xffff000000000000 == uint64(v) {
+			zRI(op_LLIHH, uint32(p.To.Reg), uint32(v>>48), asm)
+		} else if int64(int32(v)) == v {
+			zRIL(_a, op_LGFI, uint32(p.To.Reg), uint32(v), asm)
+		} else if int64(uint32(v)) == v {
+			zRIL(_a, op_LLILF, uint32(p.To.Reg), uint32(v), asm)
+		} else if uint64(v)&0xffffffff00000000 == uint64(v) {
+			zRIL(_a, op_LLIHF, uint32(p.To.Reg), uint32(v>>32), asm)
+		} else {
+			zRIL(_a, op_LLILF, uint32(p.To.Reg), uint32(v), asm)
+			zRIL(_a, op_IIHF, uint32(p.To.Reg), uint32(v>>32), asm)
+		}
+
+	case 4: // multiply high (a*b)>>64
+		r := p.Reg
+		if r == 0 {
+			r = p.To.Reg
+		}
+		zRRE(op_LGR, REGTMP2, uint32(r), asm)
+		zRRE(op_MLGR, regtmp(p), uint32(p.From.Reg), asm)
+		switch p.As {
+		case AMULHDU:
+			// Unsigned: move result into correct register.
+			zRRE(op_LGR, uint32(p.To.Reg), regtmp(p), asm)
+		case AMULHD:
+			// Signed: need to convert result.
+			// See Hacker's Delight 8-3.
+			zRSY(op_SRAG, REGTMP2, uint32(p.From.Reg), 0, 63, asm)
+			zRRE(op_NGR, REGTMP2, uint32(r), asm)
+			zRRE(op_SGR, regtmp(p), REGTMP2, asm)
+			zRSY(op_SRAG, REGTMP2, uint32(r), 0, 63, asm)
+			zRRE(op_NGR, REGTMP2, uint32(p.From.Reg), asm)
+			zRRF(op_SGRK, REGTMP2, 0, uint32(p.To.Reg), regtmp(p), asm)
+		}
+
+	case 5: // syscall
+		zI(op_SVC, 0, asm)
+
+	case 6: // logical op reg [reg] reg
+		var oprr, oprre, oprrf uint32
+		switch p.As {
+		case AAND:
+			oprre = op_NGR
+			oprrf = op_NGRK
+		case AANDW:
+			oprr = op_NR
+			oprrf = op_NRK
+		case AOR:
+			oprre = op_OGR
+			oprrf = op_OGRK
+		case AORW:
+			oprr = op_OR
+			oprrf = op_ORK
+		case AXOR:
+			oprre = op_XGR
+			oprrf = op_XGRK
+		case AXORW:
+			oprr = op_XR
+			oprrf = op_XRK
+		}
+		if p.Reg == 0 {
+			if oprr != 0 {
+				zRR(oprr, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+			} else {
+				zRRE(oprre, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+			}
+		} else {
+			zRRF(oprrf, uint32(p.Reg), 0, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+		}
+
+	case 7: // shift/rotate reg [reg] reg
+		d2 := c.vregoff(&p.From)
+		b2 := p.From.Reg
+		r3 := p.Reg
+		if r3 == 0 {
+			r3 = p.To.Reg
+		}
+		r1 := p.To.Reg
+		var opcode uint32
+		switch p.As {
+		default:
+		case ASLD:
+			opcode = op_SLLG
+		case ASRD:
+			opcode = op_SRLG
+		case ASLW:
+			opcode = op_SLLK
+		case ASRW:
+			opcode = op_SRLK
+		case ARLL:
+			opcode = op_RLL
+		case ARLLG:
+			opcode = op_RLLG
+		case ASRAW:
+			opcode = op_SRAK
+		case ASRAD:
+			opcode = op_SRAG
+		}
+		zRSY(opcode, uint32(r1), uint32(r3), uint32(b2), uint32(d2), asm)
+
+	case 8: // find leftmost one
+		if p.To.Reg&1 != 0 {
+			c.ctxt.Diag("target must be an even-numbered register")
+		}
+		// FLOGR also writes a mask to p.To.Reg+1.
+		zRRE(op_FLOGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+
+	case 9: // population count
+		zRRE(op_POPCNT, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+
+	case 10: // subtract reg [reg] reg
+		r := int(p.Reg)
+
+		switch p.As {
+		default:
+		case ASUB:
+			if r == 0 {
+				zRRE(op_SGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+			} else {
+				zRRF(op_SGRK, uint32(p.From.Reg), 0, uint32(p.To.Reg), uint32(r), asm)
+			}
+		case ASUBC:
+			if r == 0 {
+				zRRE(op_SLGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+			} else {
+				zRRF(op_SLGRK, uint32(p.From.Reg), 0, uint32(p.To.Reg), uint32(r), asm)
+			}
+		case ASUBE:
+			if r == 0 {
+				r = int(p.To.Reg)
+			}
+			if r == int(p.To.Reg) {
+				zRRE(op_SLBGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+			} else if p.From.Reg == p.To.Reg {
+				zRRE(op_LGR, regtmp(p), uint32(p.From.Reg), asm)
+				zRRE(op_LGR, uint32(p.To.Reg), uint32(r), asm)
+				zRRE(op_SLBGR, uint32(p.To.Reg), regtmp(p), asm)
+			} else {
+				zRRE(op_LGR, uint32(p.To.Reg), uint32(r), asm)
+				zRRE(op_SLBGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+			}
+		case ASUBW:
+			if r == 0 {
+				zRR(op_SR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+			} else {
+				zRRF(op_SRK, uint32(p.From.Reg), 0, uint32(p.To.Reg), uint32(r), asm)
+			}
+		}
+
+	case 11: // br/bl
+		v := int32(0)
+
+		if p.To.Target() != nil {
+			v = int32((p.To.Target().Pc - p.Pc) >> 1)
+		}
+
+		if p.As == ABR && p.To.Sym == nil && int32(int16(v)) == v {
+			zRI(op_BRC, 0xF, uint32(v), asm)
+		} else {
+			if p.As == ABL {
+				zRIL(_b, op_BRASL, uint32(REG_LR), uint32(v), asm)
+			} else {
+				zRIL(_c, op_BRCL, 0xF, uint32(v), asm)
+			}
+			if p.To.Sym != nil {
+				c.addcallreloc(p.To.Sym, p.To.Offset)
+			}
+		}
+
+	case 12:
+		r1 := p.To.Reg
+		d2 := c.vregoff(&p.From)
+		b2 := p.From.Reg
+		if b2 == 0 {
+			b2 = REGSP
+		}
+		x2 := p.From.Index
+		if -DISP20/2 > d2 || d2 >= DISP20/2 {
+			zRIL(_a, op_LGFI, regtmp(p), uint32(d2), asm)
+			if x2 != 0 {
+				zRX(op_LA, regtmp(p), regtmp(p), uint32(x2), 0, asm)
+			}
+			x2 = int16(regtmp(p))
+			d2 = 0
+		}
+		var opx, opxy uint32
+		switch p.As {
+		case AADD:
+			opxy = op_AG
+		case AADDC:
+			opxy = op_ALG
+		case AADDE:
+			opxy = op_ALCG
+		case AADDW:
+			opx = op_A
+			opxy = op_AY
+		case AMULLW:
+			opx = op_MS
+			opxy = op_MSY
+		case AMULLD:
+			opxy = op_MSG
+		case ASUB:
+			opxy = op_SG
+		case ASUBC:
+			opxy = op_SLG
+		case ASUBE:
+			opxy = op_SLBG
+		case ASUBW:
+			opx = op_S
+			opxy = op_SY
+		case AAND:
+			opxy = op_NG
+		case AANDW:
+			opx = op_N
+			opxy = op_NY
+		case AOR:
+			opxy = op_OG
+		case AORW:
+			opx = op_O
+			opxy = op_OY
+		case AXOR:
+			opxy = op_XG
+		case AXORW:
+			opx = op_X
+			opxy = op_XY
+		}
+		if opx != 0 && 0 <= d2 && d2 < DISP12 {
+			zRX(opx, uint32(r1), uint32(x2), uint32(b2), uint32(d2), asm)
+		} else {
+			zRXY(opxy, uint32(r1), uint32(x2), uint32(b2), uint32(d2), asm)
+		}
+
+	case 13: // rotate, followed by operation
+		r1 := p.To.Reg
+		r2 := p.RestArgs[2].Reg
+		i3 := uint8(p.From.Offset)        // start
+		i4 := uint8(p.RestArgs[0].Offset) // end
+		i5 := uint8(p.RestArgs[1].Offset) // rotate amount
+		switch p.As {
+		case ARNSBGT, ARXSBGT, AROSBGT:
+			i3 |= 0x80 // test-results
+		case ARISBGZ, ARISBGNZ, ARISBHGZ, ARISBLGZ:
+			i4 |= 0x80 // zero-remaining-bits
+		}
+		var opcode uint32
+		switch p.As {
+		case ARNSBG, ARNSBGT:
+			opcode = op_RNSBG
+		case ARXSBG, ARXSBGT:
+			opcode = op_RXSBG
+		case AROSBG, AROSBGT:
+			opcode = op_ROSBG
+		case ARISBG, ARISBGZ:
+			opcode = op_RISBG
+		case ARISBGN, ARISBGNZ:
+			opcode = op_RISBGN
+		case ARISBHG, ARISBHGZ:
+			opcode = op_RISBHG
+		case ARISBLG, ARISBLGZ:
+			opcode = op_RISBLG
+		}
+		zRIE(_f, uint32(opcode), uint32(r1), uint32(r2), 0, uint32(i3), uint32(i4), 0, uint32(i5), asm)
+
+	case 15: // br/bl (reg)
+		r := p.To.Reg
+		if p.As == ABCL || p.As == ABL {
+			zRR(op_BASR, uint32(REG_LR), uint32(r), asm)
+		} else {
+			zRR(op_BCR, uint32(Always), uint32(r), asm)
+		}
+
+	case 16: // conditional branch
+		v := int32(0)
+		if p.To.Target() != nil {
+			v = int32((p.To.Target().Pc - p.Pc) >> 1)
+		}
+		mask := uint32(c.branchMask(p))
+		if p.To.Sym == nil && int32(int16(v)) == v {
+			zRI(op_BRC, mask, uint32(v), asm)
+		} else {
+			zRIL(_c, op_BRCL, mask, uint32(v), asm)
+		}
+		if p.To.Sym != nil {
+			c.addrilreloc(p.To.Sym, p.To.Offset)
+		}
+
+	case 17: // move on condition
+		m3 := uint32(c.branchMask(p))
+		zRRF(op_LOCGR, m3, 0, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+
+	case 18: // br/bl reg
+		if p.As == ABL {
+			zRR(op_BASR, uint32(REG_LR), uint32(p.To.Reg), asm)
+		} else {
+			zRR(op_BCR, uint32(Always), uint32(p.To.Reg), asm)
+		}
+
+	case 19: // mov $sym+n(SB) reg
+		d := c.vregoff(&p.From)
+		zRIL(_b, op_LARL, uint32(p.To.Reg), 0, asm)
+		if d&1 != 0 {
+			zRX(op_LA, uint32(p.To.Reg), uint32(p.To.Reg), 0, 1, asm)
+			d -= 1
+		}
+		c.addrilreloc(p.From.Sym, d)
+
+	case 21: // subtract $constant [reg] reg
+		v := c.vregoff(&p.From)
+		r := p.Reg
+		if r == 0 {
+			r = p.To.Reg
+		}
+		switch p.As {
+		case ASUB:
+			zRIL(_a, op_LGFI, uint32(regtmp(p)), uint32(v), asm)
+			zRRF(op_SLGRK, uint32(regtmp(p)), 0, uint32(p.To.Reg), uint32(r), asm)
+		case ASUBC:
+			if r != p.To.Reg {
+				zRRE(op_LGR, uint32(p.To.Reg), uint32(r), asm)
+			}
+			zRIL(_a, op_SLGFI, uint32(p.To.Reg), uint32(v), asm)
+		case ASUBW:
+			if r != p.To.Reg {
+				zRR(op_LR, uint32(p.To.Reg), uint32(r), asm)
+			}
+			zRIL(_a, op_SLFI, uint32(p.To.Reg), uint32(v), asm)
+		}
+
+	case 22: // add/multiply $constant [reg] reg
+		v := c.vregoff(&p.From)
+		r := p.Reg
+		if r == 0 {
+			r = p.To.Reg
+		}
+		var opri, opril, oprie uint32
+		switch p.As {
+		case AADD:
+			opri = op_AGHI
+			opril = op_AGFI
+			oprie = op_AGHIK
+		case AADDC:
+			opril = op_ALGFI
+			oprie = op_ALGHSIK
+		case AADDW:
+			opri = op_AHI
+			opril = op_AFI
+			oprie = op_AHIK
+		case AMULLW:
+			opri = op_MHI
+			opril = op_MSFI
+		case AMULLD:
+			opri = op_MGHI
+			opril = op_MSGFI
+		}
+		if r != p.To.Reg && (oprie == 0 || int64(int16(v)) != v) {
+			switch p.As {
+			case AADD, AADDC, AMULLD:
+				zRRE(op_LGR, uint32(p.To.Reg), uint32(r), asm)
+			case AADDW, AMULLW:
+				zRR(op_LR, uint32(p.To.Reg), uint32(r), asm)
+			}
+			r = p.To.Reg
+		}
+		if opri != 0 && r == p.To.Reg && int64(int16(v)) == v {
+			zRI(opri, uint32(p.To.Reg), uint32(v), asm)
+		} else if oprie != 0 && int64(int16(v)) == v {
+			zRIE(_d, oprie, uint32(p.To.Reg), uint32(r), uint32(v), 0, 0, 0, 0, asm)
+		} else {
+			zRIL(_a, opril, uint32(p.To.Reg), uint32(v), asm)
+		}
+
+	case 23: // 64-bit logical op $constant reg
+		// TODO(mundaym): merge with case 24.
+		v := c.vregoff(&p.From)
+		switch p.As {
+		default:
+			c.ctxt.Diag("%v is not supported", p)
+		case AAND:
+			if v >= 0 { // needs zero extend
+				zRIL(_a, op_LGFI, regtmp(p), uint32(v), asm)
+				zRRE(op_NGR, uint32(p.To.Reg), regtmp(p), asm)
+			} else if int64(int16(v)) == v {
+				zRI(op_NILL, uint32(p.To.Reg), uint32(v), asm)
+			} else { //  r.To.Reg & 0xffffffff00000000 & uint32(v)
+				zRIL(_a, op_NILF, uint32(p.To.Reg), uint32(v), asm)
+			}
+		case AOR:
+			if int64(uint32(v)) != v { // needs sign extend
+				zRIL(_a, op_LGFI, regtmp(p), uint32(v), asm)
+				zRRE(op_OGR, uint32(p.To.Reg), regtmp(p), asm)
+			} else if int64(uint16(v)) == v {
+				zRI(op_OILL, uint32(p.To.Reg), uint32(v), asm)
+			} else {
+				zRIL(_a, op_OILF, uint32(p.To.Reg), uint32(v), asm)
+			}
+		case AXOR:
+			if int64(uint32(v)) != v { // needs sign extend
+				zRIL(_a, op_LGFI, regtmp(p), uint32(v), asm)
+				zRRE(op_XGR, uint32(p.To.Reg), regtmp(p), asm)
+			} else {
+				zRIL(_a, op_XILF, uint32(p.To.Reg), uint32(v), asm)
+			}
+		}
+
+	case 24: // 32-bit logical op $constant reg
+		v := c.vregoff(&p.From)
+		switch p.As {
+		case AANDW:
+			if uint32(v&0xffff0000) == 0xffff0000 {
+				zRI(op_NILL, uint32(p.To.Reg), uint32(v), asm)
+			} else if uint32(v&0x0000ffff) == 0x0000ffff {
+				zRI(op_NILH, uint32(p.To.Reg), uint32(v)>>16, asm)
+			} else {
+				zRIL(_a, op_NILF, uint32(p.To.Reg), uint32(v), asm)
+			}
+		case AORW:
+			if uint32(v&0xffff0000) == 0 {
+				zRI(op_OILL, uint32(p.To.Reg), uint32(v), asm)
+			} else if uint32(v&0x0000ffff) == 0 {
+				zRI(op_OILH, uint32(p.To.Reg), uint32(v)>>16, asm)
+			} else {
+				zRIL(_a, op_OILF, uint32(p.To.Reg), uint32(v), asm)
+			}
+		case AXORW:
+			zRIL(_a, op_XILF, uint32(p.To.Reg), uint32(v), asm)
+		}
+
+	case 25: // load on condition (register)
+		m3 := uint32(c.branchMask(p))
+		var opcode uint32
+		switch p.As {
+		case ALOCR:
+			opcode = op_LOCR
+		case ALOCGR:
+			opcode = op_LOCGR
+		}
+		zRRF(opcode, m3, 0, uint32(p.To.Reg), uint32(p.Reg), asm)
+
+	case 26: // MOVD $offset(base)(index), reg
+		v := c.regoff(&p.From)
+		r := p.From.Reg
+		if r == 0 {
+			r = REGSP
+		}
+		i := p.From.Index
+		if v >= 0 && v < DISP12 {
+			zRX(op_LA, uint32(p.To.Reg), uint32(r), uint32(i), uint32(v), asm)
+		} else if v >= -DISP20/2 && v < DISP20/2 {
+			zRXY(op_LAY, uint32(p.To.Reg), uint32(r), uint32(i), uint32(v), asm)
+		} else {
+			zRIL(_a, op_LGFI, regtmp(p), uint32(v), asm)
+			zRX(op_LA, uint32(p.To.Reg), uint32(r), regtmp(p), uint32(i), asm)
+		}
+
+	case 31: // dword
+		wd := uint64(c.vregoff(&p.From))
+		*asm = append(*asm,
+			uint8(wd>>56),
+			uint8(wd>>48),
+			uint8(wd>>40),
+			uint8(wd>>32),
+			uint8(wd>>24),
+			uint8(wd>>16),
+			uint8(wd>>8),
+			uint8(wd))
+
+	case 32: // float op freg freg
+		var opcode uint32
+		switch p.As {
+		default:
+			c.ctxt.Diag("invalid opcode")
+		case AFADD:
+			opcode = op_ADBR
+		case AFADDS:
+			opcode = op_AEBR
+		case AFDIV:
+			opcode = op_DDBR
+		case AFDIVS:
+			opcode = op_DEBR
+		case AFMUL:
+			opcode = op_MDBR
+		case AFMULS:
+			opcode = op_MEEBR
+		case AFSUB:
+			opcode = op_SDBR
+		case AFSUBS:
+			opcode = op_SEBR
+		}
+		zRRE(opcode, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+
+	case 33: // float op [freg] freg
+		r := p.From.Reg
+		if oclass(&p.From) == C_NONE {
+			r = p.To.Reg
+		}
+		var opcode uint32
+		switch p.As {
+		default:
+		case AFABS:
+			opcode = op_LPDBR
+		case AFNABS:
+			opcode = op_LNDBR
+		case ALPDFR:
+			opcode = op_LPDFR
+		case ALNDFR:
+			opcode = op_LNDFR
+		case AFNEG:
+			opcode = op_LCDFR
+		case AFNEGS:
+			opcode = op_LCEBR
+		case ALEDBR:
+			opcode = op_LEDBR
+		case ALDEBR:
+			opcode = op_LDEBR
+		case AFSQRT:
+			opcode = op_SQDBR
+		case AFSQRTS:
+			opcode = op_SQEBR
+		}
+		zRRE(opcode, uint32(p.To.Reg), uint32(r), asm)
+
+	case 34: // float multiply-add freg freg freg
+		var opcode uint32
+		switch p.As {
+		default:
+			c.ctxt.Diag("invalid opcode")
+		case AFMADD:
+			opcode = op_MADBR
+		case AFMADDS:
+			opcode = op_MAEBR
+		case AFMSUB:
+			opcode = op_MSDBR
+		case AFMSUBS:
+			opcode = op_MSEBR
+		}
+		zRRD(opcode, uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), asm)
+
+	case 35: // mov reg mem (no relocation)
+		d2 := c.regoff(&p.To)
+		b2 := p.To.Reg
+		if b2 == 0 {
+			b2 = REGSP
+		}
+		x2 := p.To.Index
+		if d2 < -DISP20/2 || d2 >= DISP20/2 {
+			zRIL(_a, op_LGFI, regtmp(p), uint32(d2), asm)
+			if x2 != 0 {
+				zRX(op_LA, regtmp(p), regtmp(p), uint32(x2), 0, asm)
+			}
+			x2 = int16(regtmp(p))
+			d2 = 0
+		}
+		// Emits an RX instruction if an appropriate one exists and the displacement fits in 12 bits. Otherwise use an RXY instruction.
+		if op, ok := c.zopstore12(p.As); ok && isU12(d2) {
+			zRX(op, uint32(p.From.Reg), uint32(x2), uint32(b2), uint32(d2), asm)
+		} else {
+			zRXY(c.zopstore(p.As), uint32(p.From.Reg), uint32(x2), uint32(b2), uint32(d2), asm)
+		}
+
+	case 36: // mov mem reg (no relocation)
+		d2 := c.regoff(&p.From)
+		b2 := p.From.Reg
+		if b2 == 0 {
+			b2 = REGSP
+		}
+		x2 := p.From.Index
+		if d2 < -DISP20/2 || d2 >= DISP20/2 {
+			zRIL(_a, op_LGFI, regtmp(p), uint32(d2), asm)
+			if x2 != 0 {
+				zRX(op_LA, regtmp(p), regtmp(p), uint32(x2), 0, asm)
+			}
+			x2 = int16(regtmp(p))
+			d2 = 0
+		}
+		// Emits an RX instruction if an appropriate one exists and the displacement fits in 12 bits. Otherwise use an RXY instruction.
+		if op, ok := c.zopload12(p.As); ok && isU12(d2) {
+			zRX(op, uint32(p.To.Reg), uint32(x2), uint32(b2), uint32(d2), asm)
+		} else {
+			zRXY(c.zopload(p.As), uint32(p.To.Reg), uint32(x2), uint32(b2), uint32(d2), asm)
+		}
+
+	case 40: // word/byte
+		wd := uint32(c.regoff(&p.From))
+		if p.As == AWORD { //WORD
+			*asm = append(*asm, uint8(wd>>24), uint8(wd>>16), uint8(wd>>8), uint8(wd))
+		} else { //BYTE
+			*asm = append(*asm, uint8(wd))
+		}
+
+	case 41: // branch on count
+		r1 := p.From.Reg
+		ri2 := (p.To.Target().Pc - p.Pc) >> 1
+		if int64(int16(ri2)) != ri2 {
+			c.ctxt.Diag("branch target too far away")
+		}
+		var opcode uint32
+		switch p.As {
+		case ABRCT:
+			opcode = op_BRCT
+		case ABRCTG:
+			opcode = op_BRCTG
+		}
+		zRI(opcode, uint32(r1), uint32(ri2), asm)
+
+	case 47: // negate [reg] reg
+		r := p.From.Reg
+		if r == 0 {
+			r = p.To.Reg
+		}
+		switch p.As {
+		case ANEG:
+			zRRE(op_LCGR, uint32(p.To.Reg), uint32(r), asm)
+		case ANEGW:
+			zRRE(op_LCGFR, uint32(p.To.Reg), uint32(r), asm)
+		}
+
+	case 48: // floating-point round to integer
+		m3 := c.vregoff(&p.From)
+		if 0 > m3 || m3 > 7 {
+			c.ctxt.Diag("mask (%v) must be in the range [0, 7]", m3)
+		}
+		var opcode uint32
+		switch p.As {
+		case AFIEBR:
+			opcode = op_FIEBR
+		case AFIDBR:
+			opcode = op_FIDBR
+		}
+		zRRF(opcode, uint32(m3), 0, uint32(p.To.Reg), uint32(p.Reg), asm)
+
+	case 49: // copysign
+		zRRF(op_CPSDR, uint32(p.From.Reg), 0, uint32(p.To.Reg), uint32(p.Reg), asm)
+
+	case 50: // load and test
+		var opcode uint32
+		switch p.As {
+		case ALTEBR:
+			opcode = op_LTEBR
+		case ALTDBR:
+			opcode = op_LTDBR
+		}
+		zRRE(opcode, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+
+	case 51: // test data class (immediate only)
+		var opcode uint32
+		switch p.As {
+		case ATCEB:
+			opcode = op_TCEB
+		case ATCDB:
+			opcode = op_TCDB
+		}
+		d2 := c.regoff(&p.To)
+		zRXE(opcode, uint32(p.From.Reg), 0, 0, uint32(d2), 0, asm)
+
+	case 62: // equivalent of Mul64 in math/bits
+		zRRE(op_MLGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+
+	case 66:
+		zRR(op_BCR, uint32(Never), 0, asm)
+
+	case 67: // fmov $0 freg
+		var opcode uint32
+		switch p.As {
+		case AFMOVS:
+			opcode = op_LZER
+		case AFMOVD:
+			opcode = op_LZDR
+		}
+		zRRE(opcode, uint32(p.To.Reg), 0, asm)
+
+	case 68: // movw areg reg
+		zRRE(op_EAR, uint32(p.To.Reg), uint32(p.From.Reg-REG_AR0), asm)
+
+	case 69: // movw reg areg
+		zRRE(op_SAR, uint32(p.To.Reg-REG_AR0), uint32(p.From.Reg), asm)
+
+	case 70: // cmp reg reg
+		if p.As == ACMPW || p.As == ACMPWU {
+			zRR(c.zoprr(p.As), uint32(p.From.Reg), uint32(p.To.Reg), asm)
+		} else {
+			zRRE(c.zoprre(p.As), uint32(p.From.Reg), uint32(p.To.Reg), asm)
+		}
+
+	case 71: // cmp reg $constant
+		v := c.vregoff(&p.To)
+		switch p.As {
+		case ACMP, ACMPW:
+			if int64(int32(v)) != v {
+				c.ctxt.Diag("%v overflows an int32", v)
+			}
+		case ACMPU, ACMPWU:
+			if int64(uint32(v)) != v {
+				c.ctxt.Diag("%v overflows a uint32", v)
+			}
+		}
+		if p.As == ACMP && int64(int16(v)) == v {
+			zRI(op_CGHI, uint32(p.From.Reg), uint32(v), asm)
+		} else if p.As == ACMPW && int64(int16(v)) == v {
+			zRI(op_CHI, uint32(p.From.Reg), uint32(v), asm)
+		} else {
+			zRIL(_a, c.zopril(p.As), uint32(p.From.Reg), uint32(v), asm)
+		}
+
+	case 72: // mov $constant mem
+		v := c.regoff(&p.From)
+		d := c.regoff(&p.To)
+		r := p.To.Reg
+		if p.To.Index != 0 {
+			c.ctxt.Diag("cannot use index register")
+		}
+		if r == 0 {
+			r = REGSP
+		}
+		var opcode uint32
+		switch p.As {
+		case AMOVD:
+			opcode = op_MVGHI
+		case AMOVW, AMOVWZ:
+			opcode = op_MVHI
+		case AMOVH, AMOVHZ:
+			opcode = op_MVHHI
+		case AMOVB, AMOVBZ:
+			opcode = op_MVI
+		}
+		if d < 0 || d >= DISP12 {
+			if r == int16(regtmp(p)) {
+				c.ctxt.Diag("displacement must be in range [0, 4096) to use %v", r)
+			}
+			if d >= -DISP20/2 && d < DISP20/2 {
+				if opcode == op_MVI {
+					opcode = op_MVIY
+				} else {
+					zRXY(op_LAY, uint32(regtmp(p)), 0, uint32(r), uint32(d), asm)
+					r = int16(regtmp(p))
+					d = 0
+				}
+			} else {
+				zRIL(_a, op_LGFI, regtmp(p), uint32(d), asm)
+				zRX(op_LA, regtmp(p), regtmp(p), uint32(r), 0, asm)
+				r = int16(regtmp(p))
+				d = 0
+			}
+		}
+		switch opcode {
+		case op_MVI:
+			zSI(opcode, uint32(v), uint32(r), uint32(d), asm)
+		case op_MVIY:
+			zSIY(opcode, uint32(v), uint32(r), uint32(d), asm)
+		default:
+			zSIL(opcode, uint32(r), uint32(d), uint32(v), asm)
+		}
+
+	case 74: // mov reg addr (including relocation)
+		i2 := c.regoff(&p.To)
+		switch p.As {
+		case AMOVD:
+			zRIL(_b, op_STGRL, uint32(p.From.Reg), 0, asm)
+		case AMOVW, AMOVWZ: // The zero extension doesn't affect store instructions
+			zRIL(_b, op_STRL, uint32(p.From.Reg), 0, asm)
+		case AMOVH, AMOVHZ: // The zero extension doesn't affect store instructions
+			zRIL(_b, op_STHRL, uint32(p.From.Reg), 0, asm)
+		case AMOVB, AMOVBZ: // The zero extension doesn't affect store instructions
+			zRIL(_b, op_LARL, regtmp(p), 0, asm)
+			adj := uint32(0) // adjustment needed for odd addresses
+			if i2&1 != 0 {
+				i2 -= 1
+				adj = 1
+			}
+			zRX(op_STC, uint32(p.From.Reg), 0, regtmp(p), adj, asm)
+		case AFMOVD:
+			zRIL(_b, op_LARL, regtmp(p), 0, asm)
+			zRX(op_STD, uint32(p.From.Reg), 0, regtmp(p), 0, asm)
+		case AFMOVS:
+			zRIL(_b, op_LARL, regtmp(p), 0, asm)
+			zRX(op_STE, uint32(p.From.Reg), 0, regtmp(p), 0, asm)
+		}
+		c.addrilreloc(p.To.Sym, int64(i2))
+
+	case 75: // mov addr reg (including relocation)
+		i2 := c.regoff(&p.From)
+		switch p.As {
+		case AMOVD:
+			if i2&1 != 0 {
+				zRIL(_b, op_LARL, regtmp(p), 0, asm)
+				zRXY(op_LG, uint32(p.To.Reg), regtmp(p), 0, 1, asm)
+				i2 -= 1
+			} else {
+				zRIL(_b, op_LGRL, uint32(p.To.Reg), 0, asm)
+			}
+		case AMOVW:
+			zRIL(_b, op_LGFRL, uint32(p.To.Reg), 0, asm)
+		case AMOVWZ:
+			zRIL(_b, op_LLGFRL, uint32(p.To.Reg), 0, asm)
+		case AMOVH:
+			zRIL(_b, op_LGHRL, uint32(p.To.Reg), 0, asm)
+		case AMOVHZ:
+			zRIL(_b, op_LLGHRL, uint32(p.To.Reg), 0, asm)
+		case AMOVB, AMOVBZ:
+			zRIL(_b, op_LARL, regtmp(p), 0, asm)
+			adj := uint32(0) // adjustment needed for odd addresses
+			if i2&1 != 0 {
+				i2 -= 1
+				adj = 1
+			}
+			switch p.As {
+			case AMOVB:
+				zRXY(op_LGB, uint32(p.To.Reg), 0, regtmp(p), adj, asm)
+			case AMOVBZ:
+				zRXY(op_LLGC, uint32(p.To.Reg), 0, regtmp(p), adj, asm)
+			}
+		case AFMOVD:
+			zRIL(_a, op_LARL, regtmp(p), 0, asm)
+			zRX(op_LD, uint32(p.To.Reg), 0, regtmp(p), 0, asm)
+		case AFMOVS:
+			zRIL(_a, op_LARL, regtmp(p), 0, asm)
+			zRX(op_LE, uint32(p.To.Reg), 0, regtmp(p), 0, asm)
+		}
+		c.addrilreloc(p.From.Sym, int64(i2))
+
+	case 76: // set program mask
+		zRR(op_SPM, uint32(p.From.Reg), 0, asm)
+
+	case 77: // syscall $constant
+		if p.From.Offset > 255 || p.From.Offset < 1 {
+			c.ctxt.Diag("illegal system call; system call number out of range: %v", p)
+			zE(op_TRAP2, asm) // trap always
+		} else {
+			zI(op_SVC, uint32(p.From.Offset), asm)
+		}
+
+	case 78: // undef
+		// "An instruction consisting entirely of binary 0s is guaranteed
+		// always to be an illegal instruction."
+		*asm = append(*asm, 0, 0, 0, 0)
+
+	case 79: // compare and swap reg reg reg
+		v := c.regoff(&p.To)
+		if v < 0 {
+			v = 0
+		}
+		if p.As == ACS {
+			zRS(op_CS, uint32(p.From.Reg), uint32(p.Reg), uint32(p.To.Reg), uint32(v), asm)
+		} else if p.As == ACSG {
+			zRSY(op_CSG, uint32(p.From.Reg), uint32(p.Reg), uint32(p.To.Reg), uint32(v), asm)
+		}
+
+	case 80: // sync
+		zRR(op_BCR, uint32(NotEqual), 0, asm)
+
+	case 81: // float to fixed and fixed to float moves (no conversion)
+		switch p.As {
+		case ALDGR:
+			zRRE(op_LDGR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+		case ALGDR:
+			zRRE(op_LGDR, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+		}
+
+	case 82: // fixed to float conversion
+		var opcode uint32
+		switch p.As {
+		default:
+			log.Fatalf("unexpected opcode %v", p.As)
+		case ACEFBRA:
+			opcode = op_CEFBRA
+		case ACDFBRA:
+			opcode = op_CDFBRA
+		case ACEGBRA:
+			opcode = op_CEGBRA
+		case ACDGBRA:
+			opcode = op_CDGBRA
+		case ACELFBR:
+			opcode = op_CELFBR
+		case ACDLFBR:
+			opcode = op_CDLFBR
+		case ACELGBR:
+			opcode = op_CELGBR
+		case ACDLGBR:
+			opcode = op_CDLGBR
+		}
+		// set immediate operand M3 to 0 to use the default BFP rounding mode
+		// (usually round to nearest, ties to even)
+		// TODO(mundaym): should this be fixed at round to nearest, ties to even?
+		// M4 is reserved and must be 0
+		zRRF(opcode, 0, 0, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+
+	case 83: // float to fixed conversion
+		var opcode uint32
+		switch p.As {
+		default:
+			log.Fatalf("unexpected opcode %v", p.As)
+		case ACFEBRA:
+			opcode = op_CFEBRA
+		case ACFDBRA:
+			opcode = op_CFDBRA
+		case ACGEBRA:
+			opcode = op_CGEBRA
+		case ACGDBRA:
+			opcode = op_CGDBRA
+		case ACLFEBR:
+			opcode = op_CLFEBR
+		case ACLFDBR:
+			opcode = op_CLFDBR
+		case ACLGEBR:
+			opcode = op_CLGEBR
+		case ACLGDBR:
+			opcode = op_CLGDBR
+		}
+		// set immediate operand M3 to 5 for rounding toward zero (required by Go spec)
+		// M4 is reserved and must be 0
+		zRRF(opcode, 5, 0, uint32(p.To.Reg), uint32(p.From.Reg), asm)
+
+	case 84: // storage-and-storage operations $length mem mem
+		l := c.regoff(&p.From)
+		if l < 1 || l > 256 {
+			c.ctxt.Diag("number of bytes (%v) not in range [1,256]", l)
+		}
+		if p.GetFrom3().Index != 0 || p.To.Index != 0 {
+			c.ctxt.Diag("cannot use index reg")
+		}
+		b1 := p.To.Reg
+		b2 := p.GetFrom3().Reg
+		if b1 == 0 {
+			b1 = REGSP
+		}
+		if b2 == 0 {
+			b2 = REGSP
+		}
+		d1 := c.regoff(&p.To)
+		d2 := c.regoff(p.GetFrom3())
+		if d1 < 0 || d1 >= DISP12 {
+			if b2 == int16(regtmp(p)) {
+				c.ctxt.Diag("regtmp(p) conflict")
+			}
+			if b1 != int16(regtmp(p)) {
+				zRRE(op_LGR, regtmp(p), uint32(b1), asm)
+			}
+			zRIL(_a, op_AGFI, regtmp(p), uint32(d1), asm)
+			if d1 == d2 && b1 == b2 {
+				d2 = 0
+				b2 = int16(regtmp(p))
+			}
+			d1 = 0
+			b1 = int16(regtmp(p))
+		}
+		if d2 < 0 || d2 >= DISP12 {
+			if b1 == REGTMP2 {
+				c.ctxt.Diag("REGTMP2 conflict")
+			}
+			if b2 != REGTMP2 {
+				zRRE(op_LGR, REGTMP2, uint32(b2), asm)
+			}
+			zRIL(_a, op_AGFI, REGTMP2, uint32(d2), asm)
+			d2 = 0
+			b2 = REGTMP2
+		}
+		var opcode uint32
+		switch p.As {
+		default:
+			c.ctxt.Diag("unexpected opcode %v", p.As)
+		case AMVC:
+			opcode = op_MVC
+		case AMVCIN:
+			opcode = op_MVCIN
+		case ACLC:
+			opcode = op_CLC
+			// swap operand order for CLC so that it matches CMP
+			b1, b2 = b2, b1
+			d1, d2 = d2, d1
+		case AXC:
+			opcode = op_XC
+		case AOC:
+			opcode = op_OC
+		case ANC:
+			opcode = op_NC
+		}
+		zSS(_a, opcode, uint32(l-1), 0, uint32(b1), uint32(d1), uint32(b2), uint32(d2), asm)
+
+	case 85: // load address relative long
+		v := c.regoff(&p.From)
+		if p.From.Sym == nil {
+			if (v & 1) != 0 {
+				c.ctxt.Diag("cannot use LARL with odd offset: %v", v)
+			}
+		} else {
+			c.addrilreloc(p.From.Sym, int64(v))
+			v = 0
+		}
+		zRIL(_b, op_LARL, uint32(p.To.Reg), uint32(v>>1), asm)
+
+	case 86: // load address
+		d := c.vregoff(&p.From)
+		x := p.From.Index
+		b := p.From.Reg
+		if b == 0 {
+			b = REGSP
+		}
+		switch p.As {
+		case ALA:
+			zRX(op_LA, uint32(p.To.Reg), uint32(x), uint32(b), uint32(d), asm)
+		case ALAY:
+			zRXY(op_LAY, uint32(p.To.Reg), uint32(x), uint32(b), uint32(d), asm)
+		}
+
+	case 87: // execute relative long
+		v := c.vregoff(&p.From)
+		if p.From.Sym == nil {
+			if v&1 != 0 {
+				c.ctxt.Diag("cannot use EXRL with odd offset: %v", v)
+			}
+		} else {
+			c.addrilreloc(p.From.Sym, v)
+			v = 0
+		}
+		zRIL(_b, op_EXRL, uint32(p.To.Reg), uint32(v>>1), asm)
+
+	case 88: // store clock
+		var opcode uint32
+		switch p.As {
+		case ASTCK:
+			opcode = op_STCK
+		case ASTCKC:
+			opcode = op_STCKC
+		case ASTCKE:
+			opcode = op_STCKE
+		case ASTCKF:
+			opcode = op_STCKF
+		}
+		v := c.vregoff(&p.To)
+		r := p.To.Reg
+		if r == 0 {
+			r = REGSP
+		}
+		zS(opcode, uint32(r), uint32(v), asm)
+
+	case 89: // compare and branch reg reg
+		var v int32
+		if p.To.Target() != nil {
+			v = int32((p.To.Target().Pc - p.Pc) >> 1)
+		}
+
+		// Some instructions take a mask as the first argument.
+		r1, r2 := p.From.Reg, p.Reg
+		if p.From.Type == obj.TYPE_CONST {
+			r1, r2 = p.Reg, p.RestArgs[0].Reg
+		}
+		m3 := uint32(c.branchMask(p))
+
+		var opcode uint32
+		switch p.As {
+		case ACRJ:
+			// COMPARE AND BRANCH RELATIVE (32)
+			opcode = op_CRJ
+		case ACGRJ, ACMPBEQ, ACMPBGE, ACMPBGT, ACMPBLE, ACMPBLT, ACMPBNE:
+			// COMPARE AND BRANCH RELATIVE (64)
+			opcode = op_CGRJ
+		case ACLRJ:
+			// COMPARE LOGICAL AND BRANCH RELATIVE (32)
+			opcode = op_CLRJ
+		case ACLGRJ, ACMPUBEQ, ACMPUBGE, ACMPUBGT, ACMPUBLE, ACMPUBLT, ACMPUBNE:
+			// COMPARE LOGICAL AND BRANCH RELATIVE (64)
+			opcode = op_CLGRJ
+		}
+
+		if int32(int16(v)) != v {
+			// The branch is too far for one instruction so crack
+			// `CMPBEQ x, y, target` into:
+			//
+			//     CMPBNE x, y, 2(PC)
+			//     BR     target
+			//
+			// Note that the instruction sequence MUST NOT clobber
+			// the condition code.
+			m3 ^= 0xe // invert 3-bit mask
+			zRIE(_b, opcode, uint32(r1), uint32(r2), uint32(sizeRIE+sizeRIL)/2, 0, 0, m3, 0, asm)
+			zRIL(_c, op_BRCL, uint32(Always), uint32(v-sizeRIE/2), asm)
+		} else {
+			zRIE(_b, opcode, uint32(r1), uint32(r2), uint32(v), 0, 0, m3, 0, asm)
+		}
+
+	case 90: // compare and branch reg $constant
+		var v int32
+		if p.To.Target() != nil {
+			v = int32((p.To.Target().Pc - p.Pc) >> 1)
+		}
+
+		// Some instructions take a mask as the first argument.
+		r1, i2 := p.From.Reg, p.RestArgs[0].Offset
+		if p.From.Type == obj.TYPE_CONST {
+			r1 = p.Reg
+		}
+		m3 := uint32(c.branchMask(p))
+
+		var opcode uint32
+		switch p.As {
+		case ACIJ:
+			opcode = op_CIJ
+		case ACGIJ, ACMPBEQ, ACMPBGE, ACMPBGT, ACMPBLE, ACMPBLT, ACMPBNE:
+			opcode = op_CGIJ
+		case ACLIJ:
+			opcode = op_CLIJ
+		case ACLGIJ, ACMPUBEQ, ACMPUBGE, ACMPUBGT, ACMPUBLE, ACMPUBLT, ACMPUBNE:
+			opcode = op_CLGIJ
+		}
+		if int32(int16(v)) != v {
+			// The branch is too far for one instruction so crack
+			// `CMPBEQ x, $0, target` into:
+			//
+			//     CMPBNE x, $0, 2(PC)
+			//     BR     target
+			//
+			// Note that the instruction sequence MUST NOT clobber
+			// the condition code.
+			m3 ^= 0xe // invert 3-bit mask
+			zRIE(_c, opcode, uint32(r1), m3, uint32(sizeRIE+sizeRIL)/2, 0, 0, 0, uint32(i2), asm)
+			zRIL(_c, op_BRCL, uint32(Always), uint32(v-sizeRIE/2), asm)
+		} else {
+			zRIE(_c, opcode, uint32(r1), m3, uint32(v), 0, 0, 0, uint32(i2), asm)
+		}
+
+	case 91: // test under mask (immediate)
+		var opcode uint32
+		switch p.As {
+		case ATMHH:
+			opcode = op_TMHH
+		case ATMHL:
+			opcode = op_TMHL
+		case ATMLH:
+			opcode = op_TMLH
+		case ATMLL:
+			opcode = op_TMLL
+		}
+		zRI(opcode, uint32(p.From.Reg), uint32(c.vregoff(&p.To)), asm)
+
+	case 92: // insert program mask
+		zRRE(op_IPM, uint32(p.From.Reg), 0, asm)
+
+	case 93: // GOT lookup
+		v := c.vregoff(&p.To)
+		if v != 0 {
+			c.ctxt.Diag("invalid offset against GOT slot %v", p)
+		}
+		zRIL(_b, op_LGRL, uint32(p.To.Reg), 0, asm)
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc + 2)
+		rel.Siz = 4
+		rel.Sym = p.From.Sym
+		rel.Type = objabi.R_GOTPCREL
+		rel.Add = 2 + int64(rel.Siz)
+
+	case 94: // TLS local exec model
+		zRIL(_b, op_LARL, regtmp(p), (sizeRIL+sizeRXY+sizeRI)>>1, asm)
+		zRXY(op_LG, uint32(p.To.Reg), regtmp(p), 0, 0, asm)
+		zRI(op_BRC, 0xF, (sizeRI+8)>>1, asm)
+		*asm = append(*asm, 0, 0, 0, 0, 0, 0, 0, 0)
+		rel := obj.Addrel(c.cursym)
+		rel.Off = int32(c.pc + sizeRIL + sizeRXY + sizeRI)
+		rel.Siz = 8
+		rel.Sym = p.From.Sym
+		rel.Type = objabi.R_TLS_LE
+		rel.Add = 0
+
+	case 95: // TLS initial exec model
+		// Assembly                   | Relocation symbol    | Done Here?
+		// --------------------------------------------------------------
+		// ear  %r11, %a0             |                      |
+		// sllg %r11, %r11, 32        |                      |
+		// ear  %r11, %a1             |                      |
+		// larl %r10, <var>@indntpoff | R_390_TLS_IEENT      | Y
+		// lg   %r10, 0(%r10)         | R_390_TLS_LOAD (tag) | Y
+		// la   %r10, 0(%r10, %r11)   |                      |
+		// --------------------------------------------------------------
+
+		// R_390_TLS_IEENT
+		zRIL(_b, op_LARL, regtmp(p), 0, asm)
+		ieent := obj.Addrel(c.cursym)
+		ieent.Off = int32(c.pc + 2)
+		ieent.Siz = 4
+		ieent.Sym = p.From.Sym
+		ieent.Type = objabi.R_TLS_IE
+		ieent.Add = 2 + int64(ieent.Siz)
+
+		// R_390_TLS_LOAD
+		zRXY(op_LGF, uint32(p.To.Reg), regtmp(p), 0, 0, asm)
+		// TODO(mundaym): add R_390_TLS_LOAD relocation here
+		// not strictly required but might allow the linker to optimize
+
+	case 96: // clear macro
+		length := c.vregoff(&p.From)
+		offset := c.vregoff(&p.To)
+		reg := p.To.Reg
+		if reg == 0 {
+			reg = REGSP
+		}
+		if length <= 0 {
+			c.ctxt.Diag("cannot CLEAR %d bytes, must be greater than 0", length)
+		}
+		for length > 0 {
+			if offset < 0 || offset >= DISP12 {
+				if offset >= -DISP20/2 && offset < DISP20/2 {
+					zRXY(op_LAY, regtmp(p), uint32(reg), 0, uint32(offset), asm)
+				} else {
+					if reg != int16(regtmp(p)) {
+						zRRE(op_LGR, regtmp(p), uint32(reg), asm)
+					}
+					zRIL(_a, op_AGFI, regtmp(p), uint32(offset), asm)
+				}
+				reg = int16(regtmp(p))
+				offset = 0
+			}
+			size := length
+			if size > 256 {
+				size = 256
+			}
+
+			switch size {
+			case 1:
+				zSI(op_MVI, 0, uint32(reg), uint32(offset), asm)
+			case 2:
+				zSIL(op_MVHHI, uint32(reg), uint32(offset), 0, asm)
+			case 4:
+				zSIL(op_MVHI, uint32(reg), uint32(offset), 0, asm)
+			case 8:
+				zSIL(op_MVGHI, uint32(reg), uint32(offset), 0, asm)
+			default:
+				zSS(_a, op_XC, uint32(size-1), 0, uint32(reg), uint32(offset), uint32(reg), uint32(offset), asm)
+			}
+
+			length -= size
+			offset += size
+		}
+
+	case 97: // store multiple
+		rstart := p.From.Reg
+		rend := p.Reg
+		offset := c.regoff(&p.To)
+		reg := p.To.Reg
+		if reg == 0 {
+			reg = REGSP
+		}
+		if offset < -DISP20/2 || offset >= DISP20/2 {
+			if reg != int16(regtmp(p)) {
+				zRRE(op_LGR, regtmp(p), uint32(reg), asm)
+			}
+			zRIL(_a, op_AGFI, regtmp(p), uint32(offset), asm)
+			reg = int16(regtmp(p))
+			offset = 0
+		}
+		switch p.As {
+		case ASTMY:
+			if offset >= 0 && offset < DISP12 {
+				zRS(op_STM, uint32(rstart), uint32(rend), uint32(reg), uint32(offset), asm)
+			} else {
+				zRSY(op_STMY, uint32(rstart), uint32(rend), uint32(reg), uint32(offset), asm)
+			}
+		case ASTMG:
+			zRSY(op_STMG, uint32(rstart), uint32(rend), uint32(reg), uint32(offset), asm)
+		}
+
+	case 98: // load multiple
+		rstart := p.Reg
+		rend := p.To.Reg
+		offset := c.regoff(&p.From)
+		reg := p.From.Reg
+		if reg == 0 {
+			reg = REGSP
+		}
+		if offset < -DISP20/2 || offset >= DISP20/2 {
+			if reg != int16(regtmp(p)) {
+				zRRE(op_LGR, regtmp(p), uint32(reg), asm)
+			}
+			zRIL(_a, op_AGFI, regtmp(p), uint32(offset), asm)
+			reg = int16(regtmp(p))
+			offset = 0
+		}
+		switch p.As {
+		case ALMY:
+			if offset >= 0 && offset < DISP12 {
+				zRS(op_LM, uint32(rstart), uint32(rend), uint32(reg), uint32(offset), asm)
+			} else {
+				zRSY(op_LMY, uint32(rstart), uint32(rend), uint32(reg), uint32(offset), asm)
+			}
+		case ALMG:
+			zRSY(op_LMG, uint32(rstart), uint32(rend), uint32(reg), uint32(offset), asm)
+		}
+
+	case 99: // interlocked load and op
+		if p.To.Index != 0 {
+			c.ctxt.Diag("cannot use indexed address")
+		}
+		offset := c.regoff(&p.To)
+		if offset < -DISP20/2 || offset >= DISP20/2 {
+			c.ctxt.Diag("%v does not fit into 20-bit signed integer", offset)
+		}
+		var opcode uint32
+		switch p.As {
+		case ALAA:
+			opcode = op_LAA
+		case ALAAG:
+			opcode = op_LAAG
+		case ALAAL:
+			opcode = op_LAAL
+		case ALAALG:
+			opcode = op_LAALG
+		case ALAN:
+			opcode = op_LAN
+		case ALANG:
+			opcode = op_LANG
+		case ALAX:
+			opcode = op_LAX
+		case ALAXG:
+			opcode = op_LAXG
+		case ALAO:
+			opcode = op_LAO
+		case ALAOG:
+			opcode = op_LAOG
+		}
+		zRSY(opcode, uint32(p.Reg), uint32(p.From.Reg), uint32(p.To.Reg), uint32(offset), asm)
+
+	case 100: // VRX STORE
+		op, m3, _ := vop(p.As)
+		v1 := p.From.Reg
+		if p.Reg != 0 {
+			m3 = uint32(c.vregoff(&p.From))
+			v1 = p.Reg
+		}
+		b2 := p.To.Reg
+		if b2 == 0 {
+			b2 = REGSP
+		}
+		d2 := uint32(c.vregoff(&p.To))
+		zVRX(op, uint32(v1), uint32(p.To.Index), uint32(b2), d2, m3, asm)
+
+	case 101: // VRX LOAD
+		op, m3, _ := vop(p.As)
+		src := &p.From
+		if p.GetFrom3() != nil {
+			m3 = uint32(c.vregoff(&p.From))
+			src = p.GetFrom3()
+		}
+		b2 := src.Reg
+		if b2 == 0 {
+			b2 = REGSP
+		}
+		d2 := uint32(c.vregoff(src))
+		zVRX(op, uint32(p.To.Reg), uint32(src.Index), uint32(b2), d2, m3, asm)
+
+	case 102: // VRV SCATTER
+		op, _, _ := vop(p.As)
+		m3 := uint32(c.vregoff(&p.From))
+		b2 := p.To.Reg
+		if b2 == 0 {
+			b2 = REGSP
+		}
+		d2 := uint32(c.vregoff(&p.To))
+		zVRV(op, uint32(p.Reg), uint32(p.To.Index), uint32(b2), d2, m3, asm)
+
+	case 103: // VRV GATHER
+		op, _, _ := vop(p.As)
+		m3 := uint32(c.vregoff(&p.From))
+		b2 := p.GetFrom3().Reg
+		if b2 == 0 {
+			b2 = REGSP
+		}
+		d2 := uint32(c.vregoff(p.GetFrom3()))
+		zVRV(op, uint32(p.To.Reg), uint32(p.GetFrom3().Index), uint32(b2), d2, m3, asm)
+
+	case 104: // VRS SHIFT/ROTATE and LOAD GR FROM VR ELEMENT
+		op, m4, _ := vop(p.As)
+		fr := p.Reg
+		if fr == 0 {
+			fr = p.To.Reg
+		}
+		bits := uint32(c.vregoff(&p.From))
+		zVRS(op, uint32(p.To.Reg), uint32(fr), uint32(p.From.Reg), bits, m4, asm)
+
+	case 105: // VRS STORE MULTIPLE
+		op, _, _ := vop(p.As)
+		offset := uint32(c.vregoff(&p.To))
+		reg := p.To.Reg
+		if reg == 0 {
+			reg = REGSP
+		}
+		zVRS(op, uint32(p.From.Reg), uint32(p.Reg), uint32(reg), offset, 0, asm)
+
+	case 106: // VRS LOAD MULTIPLE
+		op, _, _ := vop(p.As)
+		offset := uint32(c.vregoff(&p.From))
+		reg := p.From.Reg
+		if reg == 0 {
+			reg = REGSP
+		}
+		zVRS(op, uint32(p.Reg), uint32(p.To.Reg), uint32(reg), offset, 0, asm)
+
+	case 107: // VRS STORE WITH LENGTH
+		op, _, _ := vop(p.As)
+		offset := uint32(c.vregoff(&p.To))
+		reg := p.To.Reg
+		if reg == 0 {
+			reg = REGSP
+		}
+		zVRS(op, uint32(p.Reg), uint32(p.From.Reg), uint32(reg), offset, 0, asm)
+
+	case 108: // VRS LOAD WITH LENGTH
+		op, _, _ := vop(p.As)
+		offset := uint32(c.vregoff(p.GetFrom3()))
+		reg := p.GetFrom3().Reg
+		if reg == 0 {
+			reg = REGSP
+		}
+		zVRS(op, uint32(p.To.Reg), uint32(p.From.Reg), uint32(reg), offset, 0, asm)
+
+	case 109: // VRI-a
+		op, m3, _ := vop(p.As)
+		i2 := uint32(c.vregoff(&p.From))
+		if p.GetFrom3() != nil {
+			m3 = uint32(c.vregoff(&p.From))
+			i2 = uint32(c.vregoff(p.GetFrom3()))
+		}
+		switch p.As {
+		case AVZERO:
+			i2 = 0
+		case AVONE:
+			i2 = 0xffff
+		}
+		zVRIa(op, uint32(p.To.Reg), i2, m3, asm)
+
+	case 110:
+		op, m4, _ := vop(p.As)
+		i2 := uint32(c.vregoff(&p.From))
+		i3 := uint32(c.vregoff(p.GetFrom3()))
+		zVRIb(op, uint32(p.To.Reg), i2, i3, m4, asm)
+
+	case 111:
+		op, m4, _ := vop(p.As)
+		i2 := uint32(c.vregoff(&p.From))
+		zVRIc(op, uint32(p.To.Reg), uint32(p.Reg), i2, m4, asm)
+
+	case 112:
+		op, m5, _ := vop(p.As)
+		i4 := uint32(c.vregoff(&p.From))
+		zVRId(op, uint32(p.To.Reg), uint32(p.Reg), uint32(p.GetFrom3().Reg), i4, m5, asm)
+
+	case 113:
+		op, m4, _ := vop(p.As)
+		m5 := singleElementMask(p.As)
+		i3 := uint32(c.vregoff(&p.From))
+		zVRIe(op, uint32(p.To.Reg), uint32(p.Reg), i3, m5, m4, asm)
+
+	case 114: // VRR-a
+		op, m3, m5 := vop(p.As)
+		m4 := singleElementMask(p.As)
+		zVRRa(op, uint32(p.To.Reg), uint32(p.From.Reg), m5, m4, m3, asm)
+
+	case 115: // VRR-a COMPARE
+		op, m3, m5 := vop(p.As)
+		m4 := singleElementMask(p.As)
+		zVRRa(op, uint32(p.From.Reg), uint32(p.To.Reg), m5, m4, m3, asm)
+
+	case 117: // VRR-b
+		op, m4, m5 := vop(p.As)
+		zVRRb(op, uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), m5, m4, asm)
+
+	case 118: // VRR-c
+		op, m4, m6 := vop(p.As)
+		m5 := singleElementMask(p.As)
+		v3 := p.Reg
+		if v3 == 0 {
+			v3 = p.To.Reg
+		}
+		zVRRc(op, uint32(p.To.Reg), uint32(p.From.Reg), uint32(v3), m6, m5, m4, asm)
+
+	case 119: // VRR-c SHIFT/ROTATE/DIVIDE/SUB (rhs value on the left, like SLD, DIV etc.)
+		op, m4, m6 := vop(p.As)
+		m5 := singleElementMask(p.As)
+		v2 := p.Reg
+		if v2 == 0 {
+			v2 = p.To.Reg
+		}
+		zVRRc(op, uint32(p.To.Reg), uint32(v2), uint32(p.From.Reg), m6, m5, m4, asm)
+
+	case 120: // VRR-d
+		op, m6, _ := vop(p.As)
+		m5 := singleElementMask(p.As)
+		v1 := uint32(p.To.Reg)
+		v2 := uint32(p.From.Reg)
+		v3 := uint32(p.Reg)
+		v4 := uint32(p.GetFrom3().Reg)
+		zVRRd(op, v1, v2, v3, m6, m5, v4, asm)
+
+	case 121: // VRR-e
+		op, m6, _ := vop(p.As)
+		m5 := singleElementMask(p.As)
+		v1 := uint32(p.To.Reg)
+		v2 := uint32(p.From.Reg)
+		v3 := uint32(p.Reg)
+		v4 := uint32(p.GetFrom3().Reg)
+		zVRRe(op, v1, v2, v3, m6, m5, v4, asm)
+
+	case 122: // VRR-f LOAD VRS FROM GRS DISJOINT
+		op, _, _ := vop(p.As)
+		zVRRf(op, uint32(p.To.Reg), uint32(p.From.Reg), uint32(p.Reg), asm)
+
+	case 123: // VPDI $m4, V2, V3, V1
+		op, _, _ := vop(p.As)
+		m4 := c.regoff(&p.From)
+		zVRRc(op, uint32(p.To.Reg), uint32(p.Reg), uint32(p.GetFrom3().Reg), 0, 0, uint32(m4), asm)
+	}
+}
+
+func (c *ctxtz) vregoff(a *obj.Addr) int64 {
+	c.instoffset = 0
+	if a != nil {
+		c.aclass(a)
+	}
+	return c.instoffset
+}
+
+func (c *ctxtz) regoff(a *obj.Addr) int32 {
+	return int32(c.vregoff(a))
+}
+
+// find if the displacement is within 12 bit
+func isU12(displacement int32) bool {
+	return displacement >= 0 && displacement < DISP12
+}
+
+// zopload12 returns the RX op with 12 bit displacement for the given load
+func (c *ctxtz) zopload12(a obj.As) (uint32, bool) {
+	switch a {
+	case AFMOVD:
+		return op_LD, true
+	case AFMOVS:
+		return op_LE, true
+	}
+	return 0, false
+}
+
+// zopload returns the RXY op for the given load
+func (c *ctxtz) zopload(a obj.As) uint32 {
+	switch a {
+	// fixed point load
+	case AMOVD:
+		return op_LG
+	case AMOVW:
+		return op_LGF
+	case AMOVWZ:
+		return op_LLGF
+	case AMOVH:
+		return op_LGH
+	case AMOVHZ:
+		return op_LLGH
+	case AMOVB:
+		return op_LGB
+	case AMOVBZ:
+		return op_LLGC
+
+	// floating point load
+	case AFMOVD:
+		return op_LDY
+	case AFMOVS:
+		return op_LEY
+
+	// byte reversed load
+	case AMOVDBR:
+		return op_LRVG
+	case AMOVWBR:
+		return op_LRV
+	case AMOVHBR:
+		return op_LRVH
+	}
+
+	c.ctxt.Diag("unknown store opcode %v", a)
+	return 0
+}
+
+// zopstore12 returns the RX op with 12 bit displacement for the given store
+func (c *ctxtz) zopstore12(a obj.As) (uint32, bool) {
+	switch a {
+	case AFMOVD:
+		return op_STD, true
+	case AFMOVS:
+		return op_STE, true
+	case AMOVW, AMOVWZ:
+		return op_ST, true
+	case AMOVH, AMOVHZ:
+		return op_STH, true
+	case AMOVB, AMOVBZ:
+		return op_STC, true
+	}
+	return 0, false
+}
+
+// zopstore returns the RXY op for the given store
+func (c *ctxtz) zopstore(a obj.As) uint32 {
+	switch a {
+	// fixed point store
+	case AMOVD:
+		return op_STG
+	case AMOVW, AMOVWZ:
+		return op_STY
+	case AMOVH, AMOVHZ:
+		return op_STHY
+	case AMOVB, AMOVBZ:
+		return op_STCY
+
+	// floating point store
+	case AFMOVD:
+		return op_STDY
+	case AFMOVS:
+		return op_STEY
+
+	// byte reversed store
+	case AMOVDBR:
+		return op_STRVG
+	case AMOVWBR:
+		return op_STRV
+	case AMOVHBR:
+		return op_STRVH
+	}
+
+	c.ctxt.Diag("unknown store opcode %v", a)
+	return 0
+}
+
+// zoprre returns the RRE op for the given a
+func (c *ctxtz) zoprre(a obj.As) uint32 {
+	switch a {
+	case ACMP:
+		return op_CGR
+	case ACMPU:
+		return op_CLGR
+	case AFCMPO: //ordered
+		return op_KDBR
+	case AFCMPU: //unordered
+		return op_CDBR
+	case ACEBR:
+		return op_CEBR
+	}
+	c.ctxt.Diag("unknown rre opcode %v", a)
+	return 0
+}
+
+// zoprr returns the RR op for the given a
+func (c *ctxtz) zoprr(a obj.As) uint32 {
+	switch a {
+	case ACMPW:
+		return op_CR
+	case ACMPWU:
+		return op_CLR
+	}
+	c.ctxt.Diag("unknown rr opcode %v", a)
+	return 0
+}
+
+// zopril returns the RIL op for the given a
+func (c *ctxtz) zopril(a obj.As) uint32 {
+	switch a {
+	case ACMP:
+		return op_CGFI
+	case ACMPU:
+		return op_CLGFI
+	case ACMPW:
+		return op_CFI
+	case ACMPWU:
+		return op_CLFI
+	}
+	c.ctxt.Diag("unknown ril opcode %v", a)
+	return 0
+}
+
+// z instructions sizes
+const (
+	sizeE    = 2
+	sizeI    = 2
+	sizeIE   = 4
+	sizeMII  = 6
+	sizeRI   = 4
+	sizeRI1  = 4
+	sizeRI2  = 4
+	sizeRI3  = 4
+	sizeRIE  = 6
+	sizeRIE1 = 6
+	sizeRIE2 = 6
+	sizeRIE3 = 6
+	sizeRIE4 = 6
+	sizeRIE5 = 6
+	sizeRIE6 = 6
+	sizeRIL  = 6
+	sizeRIL1 = 6
+	sizeRIL2 = 6
+	sizeRIL3 = 6
+	sizeRIS  = 6
+	sizeRR   = 2
+	sizeRRD  = 4
+	sizeRRE  = 4
+	sizeRRF  = 4
+	sizeRRF1 = 4
+	sizeRRF2 = 4
+	sizeRRF3 = 4
+	sizeRRF4 = 4
+	sizeRRF5 = 4
+	sizeRRR  = 2
+	sizeRRS  = 6
+	sizeRS   = 4
+	sizeRS1  = 4
+	sizeRS2  = 4
+	sizeRSI  = 4
+	sizeRSL  = 6
+	sizeRSY  = 6
+	sizeRSY1 = 6
+	sizeRSY2 = 6
+	sizeRX   = 4
+	sizeRX1  = 4
+	sizeRX2  = 4
+	sizeRXE  = 6
+	sizeRXF  = 6
+	sizeRXY  = 6
+	sizeRXY1 = 6
+	sizeRXY2 = 6
+	sizeS    = 4
+	sizeSI   = 4
+	sizeSIL  = 6
+	sizeSIY  = 6
+	sizeSMI  = 6
+	sizeSS   = 6
+	sizeSS1  = 6
+	sizeSS2  = 6
+	sizeSS3  = 6
+	sizeSS4  = 6
+	sizeSS5  = 6
+	sizeSS6  = 6
+	sizeSSE  = 6
+	sizeSSF  = 6
+)
+
+// instruction format variations
+type form int
+
+const (
+	_a form = iota
+	_b
+	_c
+	_d
+	_e
+	_f
+)
+
+func zE(op uint32, asm *[]byte) {
+	*asm = append(*asm, uint8(op>>8), uint8(op))
+}
+
+func zI(op, i1 uint32, asm *[]byte) {
+	*asm = append(*asm, uint8(op>>8), uint8(i1))
+}
+
+func zMII(op, m1, ri2, ri3 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(m1)<<4)|uint8((ri2>>8)&0x0F),
+		uint8(ri2),
+		uint8(ri3>>16),
+		uint8(ri3>>8),
+		uint8(ri3))
+}
+
+func zRI(op, r1_m1, i2_ri2 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(r1_m1)<<4)|(uint8(op)&0x0F),
+		uint8(i2_ri2>>8),
+		uint8(i2_ri2))
+}
+
+// Expected argument values for the instruction formats.
+//
+// Format    a1  a2   a3  a4  a5  a6  a7
+// ------------------------------------
+// a         r1,  0,  i2,  0,  0, m3,  0
+// b         r1, r2, ri4,  0,  0, m3,  0
+// c         r1, m3, ri4,  0,  0,  0, i2
+// d         r1, r3,  i2,  0,  0,  0,  0
+// e         r1, r3, ri2,  0,  0,  0,  0
+// f         r1, r2,   0, i3, i4,  0, i5
+// g         r1, m3,  i2,  0,  0,  0,  0
+func zRIE(f form, op, r1, r2_m3_r3, i2_ri4_ri2, i3, i4, m3, i2_i5 uint32, asm *[]byte) {
+	*asm = append(*asm, uint8(op>>8), uint8(r1)<<4|uint8(r2_m3_r3&0x0F))
+
+	switch f {
+	default:
+		*asm = append(*asm, uint8(i2_ri4_ri2>>8), uint8(i2_ri4_ri2))
+	case _f:
+		*asm = append(*asm, uint8(i3), uint8(i4))
+	}
+
+	switch f {
+	case _a, _b:
+		*asm = append(*asm, uint8(m3)<<4)
+	default:
+		*asm = append(*asm, uint8(i2_i5))
+	}
+
+	*asm = append(*asm, uint8(op))
+}
+
+func zRIL(f form, op, r1_m1, i2_ri2 uint32, asm *[]byte) {
+	if f == _a || f == _b {
+		r1_m1 = r1_m1 - obj.RBaseS390X // this is a register base
+	}
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(r1_m1)<<4)|(uint8(op)&0x0F),
+		uint8(i2_ri2>>24),
+		uint8(i2_ri2>>16),
+		uint8(i2_ri2>>8),
+		uint8(i2_ri2))
+}
+
+func zRIS(op, r1, m3, b4, d4, i2 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(r1)<<4)|uint8(m3&0x0F),
+		(uint8(b4)<<4)|(uint8(d4>>8)&0x0F),
+		uint8(d4),
+		uint8(i2),
+		uint8(op))
+}
+
+func zRR(op, r1, r2 uint32, asm *[]byte) {
+	*asm = append(*asm, uint8(op>>8), (uint8(r1)<<4)|uint8(r2&0x0F))
+}
+
+func zRRD(op, r1, r3, r2 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		uint8(op),
+		uint8(r1)<<4,
+		(uint8(r3)<<4)|uint8(r2&0x0F))
+}
+
+func zRRE(op, r1, r2 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		uint8(op),
+		0,
+		(uint8(r1)<<4)|uint8(r2&0x0F))
+}
+
+func zRRF(op, r3_m3, m4, r1, r2 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		uint8(op),
+		(uint8(r3_m3)<<4)|uint8(m4&0x0F),
+		(uint8(r1)<<4)|uint8(r2&0x0F))
+}
+
+func zRRS(op, r1, r2, b4, d4, m3 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(r1)<<4)|uint8(r2&0x0F),
+		(uint8(b4)<<4)|uint8((d4>>8)&0x0F),
+		uint8(d4),
+		uint8(m3)<<4,
+		uint8(op))
+}
+
+func zRS(op, r1, r3_m3, b2, d2 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(r1)<<4)|uint8(r3_m3&0x0F),
+		(uint8(b2)<<4)|uint8((d2>>8)&0x0F),
+		uint8(d2))
+}
+
+func zRSI(op, r1, r3, ri2 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(r1)<<4)|uint8(r3&0x0F),
+		uint8(ri2>>8),
+		uint8(ri2))
+}
+
+func zRSL(op, l1, b2, d2 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		uint8(l1),
+		(uint8(b2)<<4)|uint8((d2>>8)&0x0F),
+		uint8(d2),
+		uint8(op))
+}
+
+func zRSY(op, r1, r3_m3, b2, d2 uint32, asm *[]byte) {
+	dl2 := uint16(d2) & 0x0FFF
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(r1)<<4)|uint8(r3_m3&0x0F),
+		(uint8(b2)<<4)|(uint8(dl2>>8)&0x0F),
+		uint8(dl2),
+		uint8(d2>>12),
+		uint8(op))
+}
+
+func zRX(op, r1_m1, x2, b2, d2 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(r1_m1)<<4)|uint8(x2&0x0F),
+		(uint8(b2)<<4)|uint8((d2>>8)&0x0F),
+		uint8(d2))
+}
+
+func zRXE(op, r1, x2, b2, d2, m3 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(r1)<<4)|uint8(x2&0x0F),
+		(uint8(b2)<<4)|uint8((d2>>8)&0x0F),
+		uint8(d2),
+		uint8(m3)<<4,
+		uint8(op))
+}
+
+func zRXF(op, r3, x2, b2, d2, m1 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(r3)<<4)|uint8(x2&0x0F),
+		(uint8(b2)<<4)|uint8((d2>>8)&0x0F),
+		uint8(d2),
+		uint8(m1)<<4,
+		uint8(op))
+}
+
+func zRXY(op, r1_m1, x2, b2, d2 uint32, asm *[]byte) {
+	dl2 := uint16(d2) & 0x0FFF
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(r1_m1)<<4)|uint8(x2&0x0F),
+		(uint8(b2)<<4)|(uint8(dl2>>8)&0x0F),
+		uint8(dl2),
+		uint8(d2>>12),
+		uint8(op))
+}
+
+func zS(op, b2, d2 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		uint8(op),
+		(uint8(b2)<<4)|uint8((d2>>8)&0x0F),
+		uint8(d2))
+}
+
+func zSI(op, i2, b1, d1 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		uint8(i2),
+		(uint8(b1)<<4)|uint8((d1>>8)&0x0F),
+		uint8(d1))
+}
+
+func zSIL(op, b1, d1, i2 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		uint8(op),
+		(uint8(b1)<<4)|uint8((d1>>8)&0x0F),
+		uint8(d1),
+		uint8(i2>>8),
+		uint8(i2))
+}
+
+func zSIY(op, i2, b1, d1 uint32, asm *[]byte) {
+	dl1 := uint16(d1) & 0x0FFF
+	*asm = append(*asm,
+		uint8(op>>8),
+		uint8(i2),
+		(uint8(b1)<<4)|(uint8(dl1>>8)&0x0F),
+		uint8(dl1),
+		uint8(d1>>12),
+		uint8(op))
+}
+
+func zSMI(op, m1, b3, d3, ri2 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		uint8(m1)<<4,
+		(uint8(b3)<<4)|uint8((d3>>8)&0x0F),
+		uint8(d3),
+		uint8(ri2>>8),
+		uint8(ri2))
+}
+
+// Expected argument values for the instruction formats.
+//
+// Format    a1  a2  a3  a4  a5  a6
+// -------------------------------
+// a         l1,  0, b1, d1, b2, d2
+// b         l1, l2, b1, d1, b2, d2
+// c         l1, i3, b1, d1, b2, d2
+// d         r1, r3, b1, d1, b2, d2
+// e         r1, r3, b2, d2, b4, d4
+// f          0, l2, b1, d1, b2, d2
+func zSS(f form, op, l1_r1, l2_i3_r3, b1_b2, d1_d2, b2_b4, d2_d4 uint32, asm *[]byte) {
+	*asm = append(*asm, uint8(op>>8))
+
+	switch f {
+	case _a:
+		*asm = append(*asm, uint8(l1_r1))
+	case _b, _c, _d, _e:
+		*asm = append(*asm, (uint8(l1_r1)<<4)|uint8(l2_i3_r3&0x0F))
+	case _f:
+		*asm = append(*asm, uint8(l2_i3_r3))
+	}
+
+	*asm = append(*asm,
+		(uint8(b1_b2)<<4)|uint8((d1_d2>>8)&0x0F),
+		uint8(d1_d2),
+		(uint8(b2_b4)<<4)|uint8((d2_d4>>8)&0x0F),
+		uint8(d2_d4))
+}
+
+func zSSE(op, b1, d1, b2, d2 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		uint8(op),
+		(uint8(b1)<<4)|uint8((d1>>8)&0x0F),
+		uint8(d1),
+		(uint8(b2)<<4)|uint8((d2>>8)&0x0F),
+		uint8(d2))
+}
+
+func zSSF(op, r3, b1, d1, b2, d2 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(r3)<<4)|(uint8(op)&0x0F),
+		(uint8(b1)<<4)|uint8((d1>>8)&0x0F),
+		uint8(d1),
+		(uint8(b2)<<4)|uint8((d2>>8)&0x0F),
+		uint8(d2))
+}
+
+func rxb(va, vb, vc, vd uint32) uint8 {
+	mask := uint8(0)
+	if va >= REG_V16 && va <= REG_V31 {
+		mask |= 0x8
+	}
+	if vb >= REG_V16 && vb <= REG_V31 {
+		mask |= 0x4
+	}
+	if vc >= REG_V16 && vc <= REG_V31 {
+		mask |= 0x2
+	}
+	if vd >= REG_V16 && vd <= REG_V31 {
+		mask |= 0x1
+	}
+	return mask
+}
+
+func zVRX(op, v1, x2, b2, d2, m3 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(v1)<<4)|(uint8(x2)&0xf),
+		(uint8(b2)<<4)|(uint8(d2>>8)&0xf),
+		uint8(d2),
+		(uint8(m3)<<4)|rxb(v1, 0, 0, 0),
+		uint8(op))
+}
+
+func zVRV(op, v1, v2, b2, d2, m3 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(v1)<<4)|(uint8(v2)&0xf),
+		(uint8(b2)<<4)|(uint8(d2>>8)&0xf),
+		uint8(d2),
+		(uint8(m3)<<4)|rxb(v1, v2, 0, 0),
+		uint8(op))
+}
+
+func zVRS(op, v1, v3_r3, b2, d2, m4 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(v1)<<4)|(uint8(v3_r3)&0xf),
+		(uint8(b2)<<4)|(uint8(d2>>8)&0xf),
+		uint8(d2),
+		(uint8(m4)<<4)|rxb(v1, v3_r3, 0, 0),
+		uint8(op))
+}
+
+func zVRRa(op, v1, v2, m5, m4, m3 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(v1)<<4)|(uint8(v2)&0xf),
+		0,
+		(uint8(m5)<<4)|(uint8(m4)&0xf),
+		(uint8(m3)<<4)|rxb(v1, v2, 0, 0),
+		uint8(op))
+}
+
+func zVRRb(op, v1, v2, v3, m5, m4 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(v1)<<4)|(uint8(v2)&0xf),
+		uint8(v3)<<4,
+		uint8(m5)<<4,
+		(uint8(m4)<<4)|rxb(v1, v2, v3, 0),
+		uint8(op))
+}
+
+func zVRRc(op, v1, v2, v3, m6, m5, m4 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(v1)<<4)|(uint8(v2)&0xf),
+		uint8(v3)<<4,
+		(uint8(m6)<<4)|(uint8(m5)&0xf),
+		(uint8(m4)<<4)|rxb(v1, v2, v3, 0),
+		uint8(op))
+}
+
+func zVRRd(op, v1, v2, v3, m5, m6, v4 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(v1)<<4)|(uint8(v2)&0xf),
+		(uint8(v3)<<4)|(uint8(m5)&0xf),
+		uint8(m6)<<4,
+		(uint8(v4)<<4)|rxb(v1, v2, v3, v4),
+		uint8(op))
+}
+
+func zVRRe(op, v1, v2, v3, m6, m5, v4 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(v1)<<4)|(uint8(v2)&0xf),
+		(uint8(v3)<<4)|(uint8(m6)&0xf),
+		uint8(m5),
+		(uint8(v4)<<4)|rxb(v1, v2, v3, v4),
+		uint8(op))
+}
+
+func zVRRf(op, v1, r2, r3 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(v1)<<4)|(uint8(r2)&0xf),
+		uint8(r3)<<4,
+		0,
+		rxb(v1, 0, 0, 0),
+		uint8(op))
+}
+
+func zVRIa(op, v1, i2, m3 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		uint8(v1)<<4,
+		uint8(i2>>8),
+		uint8(i2),
+		(uint8(m3)<<4)|rxb(v1, 0, 0, 0),
+		uint8(op))
+}
+
+func zVRIb(op, v1, i2, i3, m4 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		uint8(v1)<<4,
+		uint8(i2),
+		uint8(i3),
+		(uint8(m4)<<4)|rxb(v1, 0, 0, 0),
+		uint8(op))
+}
+
+func zVRIc(op, v1, v3, i2, m4 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(v1)<<4)|(uint8(v3)&0xf),
+		uint8(i2>>8),
+		uint8(i2),
+		(uint8(m4)<<4)|rxb(v1, v3, 0, 0),
+		uint8(op))
+}
+
+func zVRId(op, v1, v2, v3, i4, m5 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(v1)<<4)|(uint8(v2)&0xf),
+		uint8(v3)<<4,
+		uint8(i4),
+		(uint8(m5)<<4)|rxb(v1, v2, v3, 0),
+		uint8(op))
+}
+
+func zVRIe(op, v1, v2, i3, m5, m4 uint32, asm *[]byte) {
+	*asm = append(*asm,
+		uint8(op>>8),
+		(uint8(v1)<<4)|(uint8(v2)&0xf),
+		uint8(i3>>4),
+		(uint8(i3)<<4)|(uint8(m5)&0xf),
+		(uint8(m4)<<4)|rxb(v1, v2, 0, 0),
+		uint8(op))
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/condition_code.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/condition_code.go
new file mode 100644
index 000000000..764fc5bc6
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/condition_code.go
@@ -0,0 +1,126 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package s390x
+
+import (
+	"fmt"
+)
+
+// CCMask represents a 4-bit condition code mask. Bits that
+// are not part of the mask should be 0.
+//
+// Condition code masks represent the 4 possible values of
+// the 2-bit condition code as individual bits. Since IBM Z
+// is a big-endian platform bits are numbered from left to
+// right. The lowest value, 0, is represented by 8 (0b1000)
+// and the highest value, 3, is represented by 1 (0b0001).
+//
+// Note that condition code values have different semantics
+// depending on the instruction that set the condition code.
+// The names given here assume that the condition code was
+// set by an integer or floating point comparison. Other
+// instructions may use these same codes to indicate
+// different results such as a carry or overflow.
+type CCMask uint8
+
+const (
+	Never CCMask = 0 // no-op
+
+	// 1-bit masks
+	Equal     CCMask = 1 << 3
+	Less      CCMask = 1 << 2
+	Greater   CCMask = 1 << 1
+	Unordered CCMask = 1 << 0
+
+	// 2-bit masks
+	EqualOrUnordered   CCMask = Equal | Unordered   // not less and not greater
+	LessOrEqual        CCMask = Less | Equal        // ordered and not greater
+	LessOrGreater      CCMask = Less | Greater      // ordered and not equal
+	LessOrUnordered    CCMask = Less | Unordered    // not greater and not equal
+	GreaterOrEqual     CCMask = Greater | Equal     // ordered and not less
+	GreaterOrUnordered CCMask = Greater | Unordered // not less and not equal
+
+	// 3-bit masks
+	NotEqual     CCMask = Always ^ Equal
+	NotLess      CCMask = Always ^ Less
+	NotGreater   CCMask = Always ^ Greater
+	NotUnordered CCMask = Always ^ Unordered
+
+	// 4-bit mask
+	Always CCMask = Equal | Less | Greater | Unordered
+
+	// useful aliases
+	Carry    CCMask = GreaterOrUnordered
+	NoCarry  CCMask = LessOrEqual
+	Borrow   CCMask = NoCarry
+	NoBorrow CCMask = Carry
+)
+
+// Inverse returns the complement of the condition code mask.
+func (c CCMask) Inverse() CCMask {
+	return c ^ Always
+}
+
+// ReverseComparison swaps the bits at 0b0100 and 0b0010 in the mask,
+// reversing the behavior of greater than and less than conditions.
+func (c CCMask) ReverseComparison() CCMask {
+	r := c & EqualOrUnordered
+	if c&Less != 0 {
+		r |= Greater
+	}
+	if c&Greater != 0 {
+		r |= Less
+	}
+	return r
+}
+
+func (c CCMask) String() string {
+	switch c {
+	// 0-bit mask
+	case Never:
+		return "Never"
+
+	// 1-bit masks
+	case Equal:
+		return "Equal"
+	case Less:
+		return "Less"
+	case Greater:
+		return "Greater"
+	case Unordered:
+		return "Unordered"
+
+	// 2-bit masks
+	case EqualOrUnordered:
+		return "EqualOrUnordered"
+	case LessOrEqual:
+		return "LessOrEqual"
+	case LessOrGreater:
+		return "LessOrGreater"
+	case LessOrUnordered:
+		return "LessOrUnordered"
+	case GreaterOrEqual:
+		return "GreaterOrEqual"
+	case GreaterOrUnordered:
+		return "GreaterOrUnordered"
+
+	// 3-bit masks
+	case NotEqual:
+		return "NotEqual"
+	case NotLess:
+		return "NotLess"
+	case NotGreater:
+		return "NotGreater"
+	case NotUnordered:
+		return "NotUnordered"
+
+	// 4-bit mask
+	case Always:
+		return "Always"
+	}
+
+	// invalid
+	return fmt.Sprintf("Invalid (%#x)", c)
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/listz.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/listz.go
new file mode 100644
index 000000000..21ff0f56e
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/listz.go
@@ -0,0 +1,73 @@
+// Based on cmd/internal/obj/ppc64/list9.go.
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2008 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package s390x
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"fmt"
+)
+
+func init() {
+	obj.RegisterRegister(obj.RBaseS390X, REG_R0+1024, rconv)
+	obj.RegisterOpcode(obj.ABaseS390X, Anames)
+}
+
+func rconv(r int) string {
+	if r == 0 {
+		return "NONE"
+	}
+	if r == REGG {
+		// Special case.
+		return "g"
+	}
+	if REG_R0 <= r && r <= REG_R15 {
+		return fmt.Sprintf("R%d", r-REG_R0)
+	}
+	if REG_F0 <= r && r <= REG_F15 {
+		return fmt.Sprintf("F%d", r-REG_F0)
+	}
+	if REG_AR0 <= r && r <= REG_AR15 {
+		return fmt.Sprintf("AR%d", r-REG_AR0)
+	}
+	if REG_V0 <= r && r <= REG_V31 {
+		return fmt.Sprintf("V%d", r-REG_V0)
+	}
+	return fmt.Sprintf("Rgok(%d)", r-obj.RBaseS390X)
+}
+
+func DRconv(a int) string {
+	s := "C_??"
+	if a >= C_NONE && a <= C_NCLASS {
+		s = cnamesz[a]
+	}
+	var fp string
+	fp += s
+	return fp
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/objz.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/objz.go
new file mode 100644
index 000000000..a9bd32aef
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/objz.go
@@ -0,0 +1,735 @@
+// Based on cmd/internal/obj/ppc64/obj9.go.
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2008 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package s390x
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"github.com/twitchyliquid64/golang-asm/sys"
+	"math"
+)
+
+func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
+	p.From.Class = 0
+	p.To.Class = 0
+
+	c := ctxtz{ctxt: ctxt, newprog: newprog}
+
+	// Rewrite BR/BL to symbol as TYPE_BRANCH.
+	switch p.As {
+	case ABR, ABL, obj.ARET, obj.ADUFFZERO, obj.ADUFFCOPY:
+		if p.To.Sym != nil {
+			p.To.Type = obj.TYPE_BRANCH
+		}
+	}
+
+	// Rewrite float constants to values stored in memory unless they are +0.
+	switch p.As {
+	case AFMOVS:
+		if p.From.Type == obj.TYPE_FCONST {
+			f32 := float32(p.From.Val.(float64))
+			if math.Float32bits(f32) == 0 { // +0
+				break
+			}
+			p.From.Type = obj.TYPE_MEM
+			p.From.Sym = ctxt.Float32Sym(f32)
+			p.From.Name = obj.NAME_EXTERN
+			p.From.Offset = 0
+		}
+
+	case AFMOVD:
+		if p.From.Type == obj.TYPE_FCONST {
+			f64 := p.From.Val.(float64)
+			if math.Float64bits(f64) == 0 { // +0
+				break
+			}
+			p.From.Type = obj.TYPE_MEM
+			p.From.Sym = ctxt.Float64Sym(f64)
+			p.From.Name = obj.NAME_EXTERN
+			p.From.Offset = 0
+		}
+
+		// put constants not loadable by LOAD IMMEDIATE into memory
+	case AMOVD:
+		if p.From.Type == obj.TYPE_CONST {
+			val := p.From.Offset
+			if int64(int32(val)) != val &&
+				int64(uint32(val)) != val &&
+				int64(uint64(val)&(0xffffffff<<32)) != val {
+				p.From.Type = obj.TYPE_MEM
+				p.From.Sym = ctxt.Int64Sym(p.From.Offset)
+				p.From.Name = obj.NAME_EXTERN
+				p.From.Offset = 0
+			}
+		}
+	}
+
+	// Rewrite SUB constants into ADD.
+	switch p.As {
+	case ASUBC:
+		if p.From.Type == obj.TYPE_CONST && isint32(-p.From.Offset) {
+			p.From.Offset = -p.From.Offset
+			p.As = AADDC
+		}
+
+	case ASUB:
+		if p.From.Type == obj.TYPE_CONST && isint32(-p.From.Offset) {
+			p.From.Offset = -p.From.Offset
+			p.As = AADD
+		}
+	}
+
+	if c.ctxt.Flag_dynlink {
+		c.rewriteToUseGot(p)
+	}
+}
+
+// Rewrite p, if necessary, to access global data via the global offset table.
+func (c *ctxtz) rewriteToUseGot(p *obj.Prog) {
+	// At the moment EXRL instructions are not emitted by the compiler and only reference local symbols in
+	// assembly code.
+	if p.As == AEXRL {
+		return
+	}
+
+	// We only care about global data: NAME_EXTERN means a global
+	// symbol in the Go sense, and p.Sym.Local is true for a few
+	// internally defined symbols.
+	// Rewrites must not clobber flags and therefore cannot use the
+	// ADD instruction.
+	if p.From.Type == obj.TYPE_ADDR && p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
+		// MOVD $sym, Rx becomes MOVD sym@GOT, Rx
+		// MOVD $sym+<off>, Rx becomes MOVD sym@GOT, Rx or REGTMP2; MOVD $<off>(Rx or REGTMP2), Rx
+		if p.To.Type != obj.TYPE_REG || p.As != AMOVD {
+			c.ctxt.Diag("do not know how to handle LEA-type insn to non-register in %v with -dynlink", p)
+		}
+		p.From.Type = obj.TYPE_MEM
+		p.From.Name = obj.NAME_GOTREF
+		q := p
+		if p.From.Offset != 0 {
+			target := p.To.Reg
+			if target == REG_R0 {
+				// Cannot use R0 as input to address calculation.
+				// REGTMP might be used by the assembler.
+				p.To.Reg = REGTMP2
+			}
+			q = obj.Appendp(q, c.newprog)
+			q.As = AMOVD
+			q.From.Type = obj.TYPE_ADDR
+			q.From.Offset = p.From.Offset
+			q.From.Reg = p.To.Reg
+			q.To.Type = obj.TYPE_REG
+			q.To.Reg = target
+			p.From.Offset = 0
+		}
+	}
+	if p.GetFrom3() != nil && p.GetFrom3().Name == obj.NAME_EXTERN {
+		c.ctxt.Diag("don't know how to handle %v with -dynlink", p)
+	}
+	var source *obj.Addr
+	// MOVD sym, Ry becomes MOVD sym@GOT, REGTMP2; MOVD (REGTMP2), Ry
+	// MOVD Ry, sym becomes MOVD sym@GOT, REGTMP2; MOVD Ry, (REGTMP2)
+	// An addition may be inserted between the two MOVs if there is an offset.
+	if p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
+		if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
+			c.ctxt.Diag("cannot handle NAME_EXTERN on both sides in %v with -dynlink", p)
+		}
+		source = &p.From
+	} else if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
+		source = &p.To
+	} else {
+		return
+	}
+	if p.As == obj.ATEXT || p.As == obj.AFUNCDATA || p.As == obj.ACALL || p.As == obj.ARET || p.As == obj.AJMP {
+		return
+	}
+	if source.Sym.Type == objabi.STLSBSS {
+		return
+	}
+	if source.Type != obj.TYPE_MEM {
+		c.ctxt.Diag("don't know how to handle %v with -dynlink", p)
+	}
+	p1 := obj.Appendp(p, c.newprog)
+	p2 := obj.Appendp(p1, c.newprog)
+
+	p1.As = AMOVD
+	p1.From.Type = obj.TYPE_MEM
+	p1.From.Sym = source.Sym
+	p1.From.Name = obj.NAME_GOTREF
+	p1.To.Type = obj.TYPE_REG
+	p1.To.Reg = REGTMP2
+
+	p2.As = p.As
+	p2.From = p.From
+	p2.To = p.To
+	if p.From.Name == obj.NAME_EXTERN {
+		p2.From.Reg = REGTMP2
+		p2.From.Name = obj.NAME_NONE
+		p2.From.Sym = nil
+	} else if p.To.Name == obj.NAME_EXTERN {
+		p2.To.Reg = REGTMP2
+		p2.To.Name = obj.NAME_NONE
+		p2.To.Sym = nil
+	} else {
+		return
+	}
+	obj.Nopout(p)
+}
+
+func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
+	// TODO(minux): add morestack short-cuts with small fixed frame-size.
+	if cursym.Func.Text == nil || cursym.Func.Text.Link == nil {
+		return
+	}
+
+	c := ctxtz{ctxt: ctxt, cursym: cursym, newprog: newprog}
+
+	p := c.cursym.Func.Text
+	textstksiz := p.To.Offset
+	if textstksiz == -8 {
+		// Compatibility hack.
+		p.From.Sym.Set(obj.AttrNoFrame, true)
+		textstksiz = 0
+	}
+	if textstksiz%8 != 0 {
+		c.ctxt.Diag("frame size %d not a multiple of 8", textstksiz)
+	}
+	if p.From.Sym.NoFrame() {
+		if textstksiz != 0 {
+			c.ctxt.Diag("NOFRAME functions must have a frame size of 0, not %d", textstksiz)
+		}
+	}
+
+	c.cursym.Func.Args = p.To.Val.(int32)
+	c.cursym.Func.Locals = int32(textstksiz)
+
+	/*
+	 * find leaf subroutines
+	 * strip NOPs
+	 * expand RET
+	 */
+
+	var q *obj.Prog
+	for p := c.cursym.Func.Text; p != nil; p = p.Link {
+		switch p.As {
+		case obj.ATEXT:
+			q = p
+			p.Mark |= LEAF
+
+		case ABL, ABCL:
+			q = p
+			c.cursym.Func.Text.Mark &^= LEAF
+			fallthrough
+
+		case ABC,
+			ABRC,
+			ABEQ,
+			ABGE,
+			ABGT,
+			ABLE,
+			ABLT,
+			ABLEU,
+			ABLTU,
+			ABNE,
+			ABR,
+			ABVC,
+			ABVS,
+			ACRJ,
+			ACGRJ,
+			ACLRJ,
+			ACLGRJ,
+			ACIJ,
+			ACGIJ,
+			ACLIJ,
+			ACLGIJ,
+			ACMPBEQ,
+			ACMPBGE,
+			ACMPBGT,
+			ACMPBLE,
+			ACMPBLT,
+			ACMPBNE,
+			ACMPUBEQ,
+			ACMPUBGE,
+			ACMPUBGT,
+			ACMPUBLE,
+			ACMPUBLT,
+			ACMPUBNE:
+			q = p
+			p.Mark |= BRANCH
+
+		default:
+			q = p
+		}
+	}
+
+	autosize := int32(0)
+	var pLast *obj.Prog
+	var pPre *obj.Prog
+	var pPreempt *obj.Prog
+	wasSplit := false
+	for p := c.cursym.Func.Text; p != nil; p = p.Link {
+		pLast = p
+		switch p.As {
+		case obj.ATEXT:
+			autosize = int32(textstksiz)
+
+			if p.Mark&LEAF != 0 && autosize == 0 {
+				// A leaf function with no locals has no frame.
+				p.From.Sym.Set(obj.AttrNoFrame, true)
+			}
+
+			if !p.From.Sym.NoFrame() {
+				// If there is a stack frame at all, it includes
+				// space to save the LR.
+				autosize += int32(c.ctxt.FixedFrameSize())
+			}
+
+			if p.Mark&LEAF != 0 && autosize < objabi.StackSmall {
+				// A leaf function with a small stack can be marked
+				// NOSPLIT, avoiding a stack check.
+				p.From.Sym.Set(obj.AttrNoSplit, true)
+			}
+
+			p.To.Offset = int64(autosize)
+
+			q := p
+
+			if !p.From.Sym.NoSplit() {
+				p, pPreempt = c.stacksplitPre(p, autosize) // emit pre part of split check
+				pPre = p
+				p = c.ctxt.EndUnsafePoint(p, c.newprog, -1)
+				wasSplit = true //need post part of split
+			}
+
+			if autosize != 0 {
+				// Make sure to save link register for non-empty frame, even if
+				// it is a leaf function, so that traceback works.
+				// Store link register before decrementing SP, so if a signal comes
+				// during the execution of the function prologue, the traceback
+				// code will not see a half-updated stack frame.
+				// This sequence is not async preemptible, as if we open a frame
+				// at the current SP, it will clobber the saved LR.
+				q = c.ctxt.StartUnsafePoint(p, c.newprog)
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = AMOVD
+				q.From.Type = obj.TYPE_REG
+				q.From.Reg = REG_LR
+				q.To.Type = obj.TYPE_MEM
+				q.To.Reg = REGSP
+				q.To.Offset = int64(-autosize)
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = AMOVD
+				q.From.Type = obj.TYPE_ADDR
+				q.From.Offset = int64(-autosize)
+				q.From.Reg = REGSP // not actually needed - REGSP is assumed if no reg is provided
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REGSP
+				q.Spadj = autosize
+
+				q = c.ctxt.EndUnsafePoint(q, c.newprog, -1)
+			} else if c.cursym.Func.Text.Mark&LEAF == 0 {
+				// A very few functions that do not return to their caller
+				// (e.g. gogo) are not identified as leaves but still have
+				// no frame.
+				c.cursym.Func.Text.Mark |= LEAF
+			}
+
+			if c.cursym.Func.Text.Mark&LEAF != 0 {
+				c.cursym.Set(obj.AttrLeaf, true)
+				break
+			}
+
+			if c.cursym.Func.Text.From.Sym.Wrapper() {
+				// if(g->panic != nil && g->panic->argp == FP) g->panic->argp = bottom-of-frame
+				//
+				//	MOVD g_panic(g), R3
+				//	CMP R3, $0
+				//	BEQ end
+				//	MOVD panic_argp(R3), R4
+				//	ADD $(autosize+8), R1, R5
+				//	CMP R4, R5
+				//	BNE end
+				//	ADD $8, R1, R6
+				//	MOVD R6, panic_argp(R3)
+				// end:
+				//	NOP
+				//
+				// The NOP is needed to give the jumps somewhere to land.
+				// It is a liblink NOP, not a s390x NOP: it encodes to 0 instruction bytes.
+
+				q = obj.Appendp(q, c.newprog)
+
+				q.As = AMOVD
+				q.From.Type = obj.TYPE_MEM
+				q.From.Reg = REGG
+				q.From.Offset = 4 * int64(c.ctxt.Arch.PtrSize) // G.panic
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R3
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = ACMP
+				q.From.Type = obj.TYPE_REG
+				q.From.Reg = REG_R3
+				q.To.Type = obj.TYPE_CONST
+				q.To.Offset = 0
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = ABEQ
+				q.To.Type = obj.TYPE_BRANCH
+				p1 := q
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = AMOVD
+				q.From.Type = obj.TYPE_MEM
+				q.From.Reg = REG_R3
+				q.From.Offset = 0 // Panic.argp
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R4
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = AADD
+				q.From.Type = obj.TYPE_CONST
+				q.From.Offset = int64(autosize) + c.ctxt.FixedFrameSize()
+				q.Reg = REGSP
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R5
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = ACMP
+				q.From.Type = obj.TYPE_REG
+				q.From.Reg = REG_R4
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R5
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = ABNE
+				q.To.Type = obj.TYPE_BRANCH
+				p2 := q
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = AADD
+				q.From.Type = obj.TYPE_CONST
+				q.From.Offset = c.ctxt.FixedFrameSize()
+				q.Reg = REGSP
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_R6
+
+				q = obj.Appendp(q, c.newprog)
+				q.As = AMOVD
+				q.From.Type = obj.TYPE_REG
+				q.From.Reg = REG_R6
+				q.To.Type = obj.TYPE_MEM
+				q.To.Reg = REG_R3
+				q.To.Offset = 0 // Panic.argp
+
+				q = obj.Appendp(q, c.newprog)
+
+				q.As = obj.ANOP
+				p1.To.SetTarget(q)
+				p2.To.SetTarget(q)
+			}
+
+		case obj.ARET:
+			retTarget := p.To.Sym
+
+			if c.cursym.Func.Text.Mark&LEAF != 0 {
+				if autosize == 0 {
+					p.As = ABR
+					p.From = obj.Addr{}
+					if retTarget == nil {
+						p.To.Type = obj.TYPE_REG
+						p.To.Reg = REG_LR
+					} else {
+						p.To.Type = obj.TYPE_BRANCH
+						p.To.Sym = retTarget
+					}
+					p.Mark |= BRANCH
+					break
+				}
+
+				p.As = AADD
+				p.From.Type = obj.TYPE_CONST
+				p.From.Offset = int64(autosize)
+				p.To.Type = obj.TYPE_REG
+				p.To.Reg = REGSP
+				p.Spadj = -autosize
+
+				q = obj.Appendp(p, c.newprog)
+				q.As = ABR
+				q.From = obj.Addr{}
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_LR
+				q.Mark |= BRANCH
+				q.Spadj = autosize
+				break
+			}
+
+			p.As = AMOVD
+			p.From.Type = obj.TYPE_MEM
+			p.From.Reg = REGSP
+			p.From.Offset = 0
+			p.To.Type = obj.TYPE_REG
+			p.To.Reg = REG_LR
+
+			q = p
+
+			if autosize != 0 {
+				q = obj.Appendp(q, c.newprog)
+				q.As = AADD
+				q.From.Type = obj.TYPE_CONST
+				q.From.Offset = int64(autosize)
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REGSP
+				q.Spadj = -autosize
+			}
+
+			q = obj.Appendp(q, c.newprog)
+			q.As = ABR
+			q.From = obj.Addr{}
+			if retTarget == nil {
+				q.To.Type = obj.TYPE_REG
+				q.To.Reg = REG_LR
+			} else {
+				q.To.Type = obj.TYPE_BRANCH
+				q.To.Sym = retTarget
+			}
+			q.Mark |= BRANCH
+			q.Spadj = autosize
+
+		case AADD:
+			if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.From.Type == obj.TYPE_CONST {
+				p.Spadj = int32(-p.From.Offset)
+			}
+
+		case obj.AGETCALLERPC:
+			if cursym.Leaf() {
+				/* MOVD LR, Rd */
+				p.As = AMOVD
+				p.From.Type = obj.TYPE_REG
+				p.From.Reg = REG_LR
+			} else {
+				/* MOVD (RSP), Rd */
+				p.As = AMOVD
+				p.From.Type = obj.TYPE_MEM
+				p.From.Reg = REGSP
+			}
+		}
+	}
+	if wasSplit {
+		c.stacksplitPost(pLast, pPre, pPreempt, autosize) // emit post part of split check
+	}
+}
+
+func (c *ctxtz) stacksplitPre(p *obj.Prog, framesize int32) (*obj.Prog, *obj.Prog) {
+	var q *obj.Prog
+
+	// MOVD	g_stackguard(g), R3
+	p = obj.Appendp(p, c.newprog)
+
+	p.As = AMOVD
+	p.From.Type = obj.TYPE_MEM
+	p.From.Reg = REGG
+	p.From.Offset = 2 * int64(c.ctxt.Arch.PtrSize) // G.stackguard0
+	if c.cursym.CFunc() {
+		p.From.Offset = 3 * int64(c.ctxt.Arch.PtrSize) // G.stackguard1
+	}
+	p.To.Type = obj.TYPE_REG
+	p.To.Reg = REG_R3
+
+	// Mark the stack bound check and morestack call async nonpreemptible.
+	// If we get preempted here, when resumed the preemption request is
+	// cleared, but we'll still call morestack, which will double the stack
+	// unnecessarily. See issue #35470.
+	p = c.ctxt.StartUnsafePoint(p, c.newprog)
+
+	q = nil
+	if framesize <= objabi.StackSmall {
+		// small stack: SP < stackguard
+		//	CMPUBGE	stackguard, SP, label-of-call-to-morestack
+
+		p = obj.Appendp(p, c.newprog)
+		//q1 = p
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R3
+		p.Reg = REGSP
+		p.As = ACMPUBGE
+		p.To.Type = obj.TYPE_BRANCH
+
+	} else if framesize <= objabi.StackBig {
+		// large stack: SP-framesize < stackguard-StackSmall
+		//	ADD $-(framesize-StackSmall), SP, R4
+		//	CMPUBGE stackguard, R4, label-of-call-to-morestack
+		p = obj.Appendp(p, c.newprog)
+
+		p.As = AADD
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = -(int64(framesize) - objabi.StackSmall)
+		p.Reg = REGSP
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R4
+
+		p = obj.Appendp(p, c.newprog)
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R3
+		p.Reg = REG_R4
+		p.As = ACMPUBGE
+		p.To.Type = obj.TYPE_BRANCH
+
+	} else {
+		// Such a large stack we need to protect against wraparound.
+		// If SP is close to zero:
+		//	SP-stackguard+StackGuard <= framesize + (StackGuard-StackSmall)
+		// The +StackGuard on both sides is required to keep the left side positive:
+		// SP is allowed to be slightly below stackguard. See stack.h.
+		//
+		// Preemption sets stackguard to StackPreempt, a very large value.
+		// That breaks the math above, so we have to check for that explicitly.
+		//	// stackguard is R3
+		//	CMP	R3, $StackPreempt
+		//	BEQ	label-of-call-to-morestack
+		//	ADD	$StackGuard, SP, R4
+		//	SUB	R3, R4
+		//	MOVD	$(framesize+(StackGuard-StackSmall)), TEMP
+		//	CMPUBGE	TEMP, R4, label-of-call-to-morestack
+		p = obj.Appendp(p, c.newprog)
+
+		p.As = ACMP
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R3
+		p.To.Type = obj.TYPE_CONST
+		p.To.Offset = objabi.StackPreempt
+
+		p = obj.Appendp(p, c.newprog)
+		q = p
+		p.As = ABEQ
+		p.To.Type = obj.TYPE_BRANCH
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = AADD
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = int64(objabi.StackGuard)
+		p.Reg = REGSP
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R4
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = ASUB
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_R3
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_R4
+
+		p = obj.Appendp(p, c.newprog)
+		p.As = AMOVD
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = int64(framesize) + int64(objabi.StackGuard) - objabi.StackSmall
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REGTMP
+
+		p = obj.Appendp(p, c.newprog)
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REGTMP
+		p.Reg = REG_R4
+		p.As = ACMPUBGE
+		p.To.Type = obj.TYPE_BRANCH
+	}
+
+	return p, q
+}
+
+func (c *ctxtz) stacksplitPost(p *obj.Prog, pPre *obj.Prog, pPreempt *obj.Prog, framesize int32) *obj.Prog {
+	// Now we are at the end of the function, but logically
+	// we are still in function prologue. We need to fix the
+	// SP data and PCDATA.
+	spfix := obj.Appendp(p, c.newprog)
+	spfix.As = obj.ANOP
+	spfix.Spadj = -framesize
+
+	pcdata := c.ctxt.EmitEntryStackMap(c.cursym, spfix, c.newprog)
+	pcdata = c.ctxt.StartUnsafePoint(pcdata, c.newprog)
+
+	// MOVD	LR, R5
+	p = obj.Appendp(pcdata, c.newprog)
+	pPre.To.SetTarget(p)
+	p.As = AMOVD
+	p.From.Type = obj.TYPE_REG
+	p.From.Reg = REG_LR
+	p.To.Type = obj.TYPE_REG
+	p.To.Reg = REG_R5
+	if pPreempt != nil {
+		pPreempt.To.SetTarget(p)
+	}
+
+	// BL	runtime.morestack(SB)
+	p = obj.Appendp(p, c.newprog)
+
+	p.As = ABL
+	p.To.Type = obj.TYPE_BRANCH
+	if c.cursym.CFunc() {
+		p.To.Sym = c.ctxt.Lookup("runtime.morestackc")
+	} else if !c.cursym.Func.Text.From.Sym.NeedCtxt() {
+		p.To.Sym = c.ctxt.Lookup("runtime.morestack_noctxt")
+	} else {
+		p.To.Sym = c.ctxt.Lookup("runtime.morestack")
+	}
+
+	p = c.ctxt.EndUnsafePoint(p, c.newprog, -1)
+
+	// BR	start
+	p = obj.Appendp(p, c.newprog)
+
+	p.As = ABR
+	p.To.Type = obj.TYPE_BRANCH
+	p.To.SetTarget(c.cursym.Func.Text.Link)
+	return p
+}
+
+var unaryDst = map[obj.As]bool{
+	ASTCK:  true,
+	ASTCKC: true,
+	ASTCKE: true,
+	ASTCKF: true,
+	ANEG:   true,
+	ANEGW:  true,
+	AVONE:  true,
+	AVZERO: true,
+}
+
+var Links390x = obj.LinkArch{
+	Arch:           sys.ArchS390X,
+	Init:           buildop,
+	Preprocess:     preprocess,
+	Assemble:       spanz,
+	Progedit:       progedit,
+	UnaryDst:       unaryDst,
+	DWARFRegisters: S390XDWARFRegisters,
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/rotate.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/rotate.go
new file mode 100644
index 000000000..fd2d5482d
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/rotate.go
@@ -0,0 +1,47 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package s390x
+
+// RotateParams represents the immediates required for a "rotate
+// then ... selected bits instruction".
+//
+// The Start and End values are the indexes that represent
+// the masked region. They are inclusive and are in big-
+// endian order (bit 0 is the MSB, bit 63 is the LSB). They
+// may wrap around.
+//
+// Some examples:
+//
+// Masked region             | Start | End
+// --------------------------+-------+----
+// 0x00_00_00_00_00_00_00_0f | 60    | 63
+// 0xf0_00_00_00_00_00_00_00 | 0     | 3
+// 0xf0_00_00_00_00_00_00_0f | 60    | 3
+//
+// The Amount value represents the amount to rotate the
+// input left by. Note that this rotation is performed
+// before the masked region is used.
+type RotateParams struct {
+	Start  uint8 // big-endian start bit index [0..63]
+	End    uint8 // big-endian end bit index [0..63]
+	Amount uint8 // amount to rotate left
+}
+
+func NewRotateParams(start, end, amount int64) RotateParams {
+	if start&^63 != 0 {
+		panic("start out of bounds")
+	}
+	if end&^63 != 0 {
+		panic("end out of bounds")
+	}
+	if amount&^63 != 0 {
+		panic("amount out of bounds")
+	}
+	return RotateParams{
+		Start:  uint8(start),
+		End:    uint8(end),
+		Amount: uint8(amount),
+	}
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/vector.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/vector.go
new file mode 100644
index 000000000..44b303f60
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/s390x/vector.go
@@ -0,0 +1,1069 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package s390x
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+)
+
+// This file contains utility functions for use when
+// assembling vector instructions.
+
+// vop returns the opcode, element size and condition
+// setting for the given (possibly extended) mnemonic.
+func vop(as obj.As) (opcode, es, cs uint32) {
+	switch as {
+	default:
+		return 0, 0, 0
+	case AVA:
+		return op_VA, 0, 0
+	case AVAB:
+		return op_VA, 0, 0
+	case AVAH:
+		return op_VA, 1, 0
+	case AVAF:
+		return op_VA, 2, 0
+	case AVAG:
+		return op_VA, 3, 0
+	case AVAQ:
+		return op_VA, 4, 0
+	case AVACC:
+		return op_VACC, 0, 0
+	case AVACCB:
+		return op_VACC, 0, 0
+	case AVACCH:
+		return op_VACC, 1, 0
+	case AVACCF:
+		return op_VACC, 2, 0
+	case AVACCG:
+		return op_VACC, 3, 0
+	case AVACCQ:
+		return op_VACC, 4, 0
+	case AVAC:
+		return op_VAC, 0, 0
+	case AVACQ:
+		return op_VAC, 4, 0
+	case AVMSLG, AVMSLEG, AVMSLOG, AVMSLEOG:
+		return op_VMSL, 3, 0
+	case AVACCC:
+		return op_VACCC, 0, 0
+	case AVACCCQ:
+		return op_VACCC, 4, 0
+	case AVN:
+		return op_VN, 0, 0
+	case AVNC:
+		return op_VNC, 0, 0
+	case AVAVG:
+		return op_VAVG, 0, 0
+	case AVAVGB:
+		return op_VAVG, 0, 0
+	case AVAVGH:
+		return op_VAVG, 1, 0
+	case AVAVGF:
+		return op_VAVG, 2, 0
+	case AVAVGG:
+		return op_VAVG, 3, 0
+	case AVAVGL:
+		return op_VAVGL, 0, 0
+	case AVAVGLB:
+		return op_VAVGL, 0, 0
+	case AVAVGLH:
+		return op_VAVGL, 1, 0
+	case AVAVGLF:
+		return op_VAVGL, 2, 0
+	case AVAVGLG:
+		return op_VAVGL, 3, 0
+	case AVCKSM:
+		return op_VCKSM, 0, 0
+	case AVCEQ:
+		return op_VCEQ, 0, 0
+	case AVCEQB:
+		return op_VCEQ, 0, 0
+	case AVCEQH:
+		return op_VCEQ, 1, 0
+	case AVCEQF:
+		return op_VCEQ, 2, 0
+	case AVCEQG:
+		return op_VCEQ, 3, 0
+	case AVCEQBS:
+		return op_VCEQ, 0, 1
+	case AVCEQHS:
+		return op_VCEQ, 1, 1
+	case AVCEQFS:
+		return op_VCEQ, 2, 1
+	case AVCEQGS:
+		return op_VCEQ, 3, 1
+	case AVCH:
+		return op_VCH, 0, 0
+	case AVCHB:
+		return op_VCH, 0, 0
+	case AVCHH:
+		return op_VCH, 1, 0
+	case AVCHF:
+		return op_VCH, 2, 0
+	case AVCHG:
+		return op_VCH, 3, 0
+	case AVCHBS:
+		return op_VCH, 0, 1
+	case AVCHHS:
+		return op_VCH, 1, 1
+	case AVCHFS:
+		return op_VCH, 2, 1
+	case AVCHGS:
+		return op_VCH, 3, 1
+	case AVCHL:
+		return op_VCHL, 0, 0
+	case AVCHLB:
+		return op_VCHL, 0, 0
+	case AVCHLH:
+		return op_VCHL, 1, 0
+	case AVCHLF:
+		return op_VCHL, 2, 0
+	case AVCHLG:
+		return op_VCHL, 3, 0
+	case AVCHLBS:
+		return op_VCHL, 0, 1
+	case AVCHLHS:
+		return op_VCHL, 1, 1
+	case AVCHLFS:
+		return op_VCHL, 2, 1
+	case AVCHLGS:
+		return op_VCHL, 3, 1
+	case AVCLZ:
+		return op_VCLZ, 0, 0
+	case AVCLZB:
+		return op_VCLZ, 0, 0
+	case AVCLZH:
+		return op_VCLZ, 1, 0
+	case AVCLZF:
+		return op_VCLZ, 2, 0
+	case AVCLZG:
+		return op_VCLZ, 3, 0
+	case AVCTZ:
+		return op_VCTZ, 0, 0
+	case AVCTZB:
+		return op_VCTZ, 0, 0
+	case AVCTZH:
+		return op_VCTZ, 1, 0
+	case AVCTZF:
+		return op_VCTZ, 2, 0
+	case AVCTZG:
+		return op_VCTZ, 3, 0
+	case AVEC:
+		return op_VEC, 0, 0
+	case AVECB:
+		return op_VEC, 0, 0
+	case AVECH:
+		return op_VEC, 1, 0
+	case AVECF:
+		return op_VEC, 2, 0
+	case AVECG:
+		return op_VEC, 3, 0
+	case AVECL:
+		return op_VECL, 0, 0
+	case AVECLB:
+		return op_VECL, 0, 0
+	case AVECLH:
+		return op_VECL, 1, 0
+	case AVECLF:
+		return op_VECL, 2, 0
+	case AVECLG:
+		return op_VECL, 3, 0
+	case AVERIM:
+		return op_VERIM, 0, 0
+	case AVERIMB:
+		return op_VERIM, 0, 0
+	case AVERIMH:
+		return op_VERIM, 1, 0
+	case AVERIMF:
+		return op_VERIM, 2, 0
+	case AVERIMG:
+		return op_VERIM, 3, 0
+	case AVERLL:
+		return op_VERLL, 0, 0
+	case AVERLLB:
+		return op_VERLL, 0, 0
+	case AVERLLH:
+		return op_VERLL, 1, 0
+	case AVERLLF:
+		return op_VERLL, 2, 0
+	case AVERLLG:
+		return op_VERLL, 3, 0
+	case AVERLLV:
+		return op_VERLLV, 0, 0
+	case AVERLLVB:
+		return op_VERLLV, 0, 0
+	case AVERLLVH:
+		return op_VERLLV, 1, 0
+	case AVERLLVF:
+		return op_VERLLV, 2, 0
+	case AVERLLVG:
+		return op_VERLLV, 3, 0
+	case AVESLV:
+		return op_VESLV, 0, 0
+	case AVESLVB:
+		return op_VESLV, 0, 0
+	case AVESLVH:
+		return op_VESLV, 1, 0
+	case AVESLVF:
+		return op_VESLV, 2, 0
+	case AVESLVG:
+		return op_VESLV, 3, 0
+	case AVESL:
+		return op_VESL, 0, 0
+	case AVESLB:
+		return op_VESL, 0, 0
+	case AVESLH:
+		return op_VESL, 1, 0
+	case AVESLF:
+		return op_VESL, 2, 0
+	case AVESLG:
+		return op_VESL, 3, 0
+	case AVESRA:
+		return op_VESRA, 0, 0
+	case AVESRAB:
+		return op_VESRA, 0, 0
+	case AVESRAH:
+		return op_VESRA, 1, 0
+	case AVESRAF:
+		return op_VESRA, 2, 0
+	case AVESRAG:
+		return op_VESRA, 3, 0
+	case AVESRAV:
+		return op_VESRAV, 0, 0
+	case AVESRAVB:
+		return op_VESRAV, 0, 0
+	case AVESRAVH:
+		return op_VESRAV, 1, 0
+	case AVESRAVF:
+		return op_VESRAV, 2, 0
+	case AVESRAVG:
+		return op_VESRAV, 3, 0
+	case AVESRL:
+		return op_VESRL, 0, 0
+	case AVESRLB:
+		return op_VESRL, 0, 0
+	case AVESRLH:
+		return op_VESRL, 1, 0
+	case AVESRLF:
+		return op_VESRL, 2, 0
+	case AVESRLG:
+		return op_VESRL, 3, 0
+	case AVESRLV:
+		return op_VESRLV, 0, 0
+	case AVESRLVB:
+		return op_VESRLV, 0, 0
+	case AVESRLVH:
+		return op_VESRLV, 1, 0
+	case AVESRLVF:
+		return op_VESRLV, 2, 0
+	case AVESRLVG:
+		return op_VESRLV, 3, 0
+	case AVX:
+		return op_VX, 0, 0
+	case AVFAE:
+		return op_VFAE, 0, 0
+	case AVFAEB:
+		return op_VFAE, 0, 0
+	case AVFAEH:
+		return op_VFAE, 1, 0
+	case AVFAEF:
+		return op_VFAE, 2, 0
+	case AVFAEBS:
+		return op_VFAE, 0, 1
+	case AVFAEHS:
+		return op_VFAE, 1, 1
+	case AVFAEFS:
+		return op_VFAE, 2, 1
+	case AVFAEZB:
+		return op_VFAE, 0, 2
+	case AVFAEZH:
+		return op_VFAE, 1, 2
+	case AVFAEZF:
+		return op_VFAE, 2, 2
+	case AVFAEZBS:
+		return op_VFAE, 0, 3
+	case AVFAEZHS:
+		return op_VFAE, 1, 3
+	case AVFAEZFS:
+		return op_VFAE, 2, 3
+	case AVFEE:
+		return op_VFEE, 0, 0
+	case AVFEEB:
+		return op_VFEE, 0, 0
+	case AVFEEH:
+		return op_VFEE, 1, 0
+	case AVFEEF:
+		return op_VFEE, 2, 0
+	case AVFEEBS:
+		return op_VFEE, 0, 1
+	case AVFEEHS:
+		return op_VFEE, 1, 1
+	case AVFEEFS:
+		return op_VFEE, 2, 1
+	case AVFEEZB:
+		return op_VFEE, 0, 2
+	case AVFEEZH:
+		return op_VFEE, 1, 2
+	case AVFEEZF:
+		return op_VFEE, 2, 2
+	case AVFEEZBS:
+		return op_VFEE, 0, 3
+	case AVFEEZHS:
+		return op_VFEE, 1, 3
+	case AVFEEZFS:
+		return op_VFEE, 2, 3
+	case AVFENE:
+		return op_VFENE, 0, 0
+	case AVFENEB:
+		return op_VFENE, 0, 0
+	case AVFENEH:
+		return op_VFENE, 1, 0
+	case AVFENEF:
+		return op_VFENE, 2, 0
+	case AVFENEBS:
+		return op_VFENE, 0, 1
+	case AVFENEHS:
+		return op_VFENE, 1, 1
+	case AVFENEFS:
+		return op_VFENE, 2, 1
+	case AVFENEZB:
+		return op_VFENE, 0, 2
+	case AVFENEZH:
+		return op_VFENE, 1, 2
+	case AVFENEZF:
+		return op_VFENE, 2, 2
+	case AVFENEZBS:
+		return op_VFENE, 0, 3
+	case AVFENEZHS:
+		return op_VFENE, 1, 3
+	case AVFENEZFS:
+		return op_VFENE, 2, 3
+	case AVFA:
+		return op_VFA, 0, 0
+	case AVFADB:
+		return op_VFA, 3, 0
+	case AWFADB:
+		return op_VFA, 3, 0
+	case AWFK:
+		return op_WFK, 0, 0
+	case AWFKDB:
+		return op_WFK, 3, 0
+	case AVFCE:
+		return op_VFCE, 0, 0
+	case AVFCEDB:
+		return op_VFCE, 3, 0
+	case AVFCEDBS:
+		return op_VFCE, 3, 1
+	case AWFCEDB:
+		return op_VFCE, 3, 0
+	case AWFCEDBS:
+		return op_VFCE, 3, 1
+	case AVFCH:
+		return op_VFCH, 0, 0
+	case AVFCHDB:
+		return op_VFCH, 3, 0
+	case AVFCHDBS:
+		return op_VFCH, 3, 1
+	case AWFCHDB:
+		return op_VFCH, 3, 0
+	case AWFCHDBS:
+		return op_VFCH, 3, 1
+	case AVFCHE:
+		return op_VFCHE, 0, 0
+	case AVFCHEDB:
+		return op_VFCHE, 3, 0
+	case AVFCHEDBS:
+		return op_VFCHE, 3, 1
+	case AWFCHEDB:
+		return op_VFCHE, 3, 0
+	case AWFCHEDBS:
+		return op_VFCHE, 3, 1
+	case AWFC:
+		return op_WFC, 0, 0
+	case AWFCDB:
+		return op_WFC, 3, 0
+	case AVCDG:
+		return op_VCDG, 0, 0
+	case AVCDGB:
+		return op_VCDG, 3, 0
+	case AWCDGB:
+		return op_VCDG, 3, 0
+	case AVCDLG:
+		return op_VCDLG, 0, 0
+	case AVCDLGB:
+		return op_VCDLG, 3, 0
+	case AWCDLGB:
+		return op_VCDLG, 3, 0
+	case AVCGD:
+		return op_VCGD, 0, 0
+	case AVCGDB:
+		return op_VCGD, 3, 0
+	case AWCGDB:
+		return op_VCGD, 3, 0
+	case AVCLGD:
+		return op_VCLGD, 0, 0
+	case AVCLGDB:
+		return op_VCLGD, 3, 0
+	case AWCLGDB:
+		return op_VCLGD, 3, 0
+	case AVFD:
+		return op_VFD, 0, 0
+	case AVFDDB:
+		return op_VFD, 3, 0
+	case AWFDDB:
+		return op_VFD, 3, 0
+	case AVLDE:
+		return op_VLDE, 0, 0
+	case AVLDEB:
+		return op_VLDE, 2, 0
+	case AWLDEB:
+		return op_VLDE, 2, 0
+	case AVLED:
+		return op_VLED, 0, 0
+	case AVLEDB:
+		return op_VLED, 3, 0
+	case AWLEDB:
+		return op_VLED, 3, 0
+	case AVFM:
+		return op_VFM, 0, 0
+	case AVFMDB:
+		return op_VFM, 3, 0
+	case AWFMDB:
+		return op_VFM, 3, 0
+	case AVFMA:
+		return op_VFMA, 0, 0
+	case AVFMADB:
+		return op_VFMA, 3, 0
+	case AWFMADB:
+		return op_VFMA, 3, 0
+	case AVFMS:
+		return op_VFMS, 0, 0
+	case AVFMSDB:
+		return op_VFMS, 3, 0
+	case AWFMSDB:
+		return op_VFMS, 3, 0
+	case AVFPSO:
+		return op_VFPSO, 0, 0
+	case AVFPSODB:
+		return op_VFPSO, 3, 0
+	case AWFPSODB:
+		return op_VFPSO, 3, 0
+	case AVFLCDB:
+		return op_VFPSO, 3, 0
+	case AWFLCDB:
+		return op_VFPSO, 3, 0
+	case AVFLNDB:
+		return op_VFPSO, 3, 1
+	case AWFLNDB:
+		return op_VFPSO, 3, 1
+	case AVFLPDB:
+		return op_VFPSO, 3, 2
+	case AWFLPDB:
+		return op_VFPSO, 3, 2
+	case AVFSQ:
+		return op_VFSQ, 0, 0
+	case AVFSQDB:
+		return op_VFSQ, 3, 0
+	case AWFSQDB:
+		return op_VFSQ, 3, 0
+	case AVFS:
+		return op_VFS, 0, 0
+	case AVFSDB:
+		return op_VFS, 3, 0
+	case AWFSDB:
+		return op_VFS, 3, 0
+	case AVFTCI:
+		return op_VFTCI, 0, 0
+	case AVFTCIDB:
+		return op_VFTCI, 3, 0
+	case AWFTCIDB:
+		return op_VFTCI, 3, 0
+	case AVGFM:
+		return op_VGFM, 0, 0
+	case AVGFMB:
+		return op_VGFM, 0, 0
+	case AVGFMH:
+		return op_VGFM, 1, 0
+	case AVGFMF:
+		return op_VGFM, 2, 0
+	case AVGFMG:
+		return op_VGFM, 3, 0
+	case AVGFMA:
+		return op_VGFMA, 0, 0
+	case AVGFMAB:
+		return op_VGFMA, 0, 0
+	case AVGFMAH:
+		return op_VGFMA, 1, 0
+	case AVGFMAF:
+		return op_VGFMA, 2, 0
+	case AVGFMAG:
+		return op_VGFMA, 3, 0
+	case AVGEF:
+		return op_VGEF, 0, 0
+	case AVGEG:
+		return op_VGEG, 0, 0
+	case AVGBM:
+		return op_VGBM, 0, 0
+	case AVZERO:
+		return op_VGBM, 0, 0
+	case AVONE:
+		return op_VGBM, 0, 0
+	case AVGM:
+		return op_VGM, 0, 0
+	case AVGMB:
+		return op_VGM, 0, 0
+	case AVGMH:
+		return op_VGM, 1, 0
+	case AVGMF:
+		return op_VGM, 2, 0
+	case AVGMG:
+		return op_VGM, 3, 0
+	case AVISTR:
+		return op_VISTR, 0, 0
+	case AVISTRB:
+		return op_VISTR, 0, 0
+	case AVISTRH:
+		return op_VISTR, 1, 0
+	case AVISTRF:
+		return op_VISTR, 2, 0
+	case AVISTRBS:
+		return op_VISTR, 0, 1
+	case AVISTRHS:
+		return op_VISTR, 1, 1
+	case AVISTRFS:
+		return op_VISTR, 2, 1
+	case AVL:
+		return op_VL, 0, 0
+	case AVLR:
+		return op_VLR, 0, 0
+	case AVLREP:
+		return op_VLREP, 0, 0
+	case AVLREPB:
+		return op_VLREP, 0, 0
+	case AVLREPH:
+		return op_VLREP, 1, 0
+	case AVLREPF:
+		return op_VLREP, 2, 0
+	case AVLREPG:
+		return op_VLREP, 3, 0
+	case AVLC:
+		return op_VLC, 0, 0
+	case AVLCB:
+		return op_VLC, 0, 0
+	case AVLCH:
+		return op_VLC, 1, 0
+	case AVLCF:
+		return op_VLC, 2, 0
+	case AVLCG:
+		return op_VLC, 3, 0
+	case AVLEH:
+		return op_VLEH, 0, 0
+	case AVLEF:
+		return op_VLEF, 0, 0
+	case AVLEG:
+		return op_VLEG, 0, 0
+	case AVLEB:
+		return op_VLEB, 0, 0
+	case AVLEIH:
+		return op_VLEIH, 0, 0
+	case AVLEIF:
+		return op_VLEIF, 0, 0
+	case AVLEIG:
+		return op_VLEIG, 0, 0
+	case AVLEIB:
+		return op_VLEIB, 0, 0
+	case AVFI:
+		return op_VFI, 0, 0
+	case AVFIDB:
+		return op_VFI, 3, 0
+	case AWFIDB:
+		return op_VFI, 3, 0
+	case AVLGV:
+		return op_VLGV, 0, 0
+	case AVLGVB:
+		return op_VLGV, 0, 0
+	case AVLGVH:
+		return op_VLGV, 1, 0
+	case AVLGVF:
+		return op_VLGV, 2, 0
+	case AVLGVG:
+		return op_VLGV, 3, 0
+	case AVLLEZ:
+		return op_VLLEZ, 0, 0
+	case AVLLEZB:
+		return op_VLLEZ, 0, 0
+	case AVLLEZH:
+		return op_VLLEZ, 1, 0
+	case AVLLEZF:
+		return op_VLLEZ, 2, 0
+	case AVLLEZG:
+		return op_VLLEZ, 3, 0
+	case AVLM:
+		return op_VLM, 0, 0
+	case AVLP:
+		return op_VLP, 0, 0
+	case AVLPB:
+		return op_VLP, 0, 0
+	case AVLPH:
+		return op_VLP, 1, 0
+	case AVLPF:
+		return op_VLP, 2, 0
+	case AVLPG:
+		return op_VLP, 3, 0
+	case AVLBB:
+		return op_VLBB, 0, 0
+	case AVLVG:
+		return op_VLVG, 0, 0
+	case AVLVGB:
+		return op_VLVG, 0, 0
+	case AVLVGH:
+		return op_VLVG, 1, 0
+	case AVLVGF:
+		return op_VLVG, 2, 0
+	case AVLVGG:
+		return op_VLVG, 3, 0
+	case AVLVGP:
+		return op_VLVGP, 0, 0
+	case AVLL:
+		return op_VLL, 0, 0
+	case AVMX:
+		return op_VMX, 0, 0
+	case AVMXB:
+		return op_VMX, 0, 0
+	case AVMXH:
+		return op_VMX, 1, 0
+	case AVMXF:
+		return op_VMX, 2, 0
+	case AVMXG:
+		return op_VMX, 3, 0
+	case AVMXL:
+		return op_VMXL, 0, 0
+	case AVMXLB:
+		return op_VMXL, 0, 0
+	case AVMXLH:
+		return op_VMXL, 1, 0
+	case AVMXLF:
+		return op_VMXL, 2, 0
+	case AVMXLG:
+		return op_VMXL, 3, 0
+	case AVMRH:
+		return op_VMRH, 0, 0
+	case AVMRHB:
+		return op_VMRH, 0, 0
+	case AVMRHH:
+		return op_VMRH, 1, 0
+	case AVMRHF:
+		return op_VMRH, 2, 0
+	case AVMRHG:
+		return op_VMRH, 3, 0
+	case AVMRL:
+		return op_VMRL, 0, 0
+	case AVMRLB:
+		return op_VMRL, 0, 0
+	case AVMRLH:
+		return op_VMRL, 1, 0
+	case AVMRLF:
+		return op_VMRL, 2, 0
+	case AVMRLG:
+		return op_VMRL, 3, 0
+	case AVMN:
+		return op_VMN, 0, 0
+	case AVMNB:
+		return op_VMN, 0, 0
+	case AVMNH:
+		return op_VMN, 1, 0
+	case AVMNF:
+		return op_VMN, 2, 0
+	case AVMNG:
+		return op_VMN, 3, 0
+	case AVMNL:
+		return op_VMNL, 0, 0
+	case AVMNLB:
+		return op_VMNL, 0, 0
+	case AVMNLH:
+		return op_VMNL, 1, 0
+	case AVMNLF:
+		return op_VMNL, 2, 0
+	case AVMNLG:
+		return op_VMNL, 3, 0
+	case AVMAE:
+		return op_VMAE, 0, 0
+	case AVMAEB:
+		return op_VMAE, 0, 0
+	case AVMAEH:
+		return op_VMAE, 1, 0
+	case AVMAEF:
+		return op_VMAE, 2, 0
+	case AVMAH:
+		return op_VMAH, 0, 0
+	case AVMAHB:
+		return op_VMAH, 0, 0
+	case AVMAHH:
+		return op_VMAH, 1, 0
+	case AVMAHF:
+		return op_VMAH, 2, 0
+	case AVMALE:
+		return op_VMALE, 0, 0
+	case AVMALEB:
+		return op_VMALE, 0, 0
+	case AVMALEH:
+		return op_VMALE, 1, 0
+	case AVMALEF:
+		return op_VMALE, 2, 0
+	case AVMALH:
+		return op_VMALH, 0, 0
+	case AVMALHB:
+		return op_VMALH, 0, 0
+	case AVMALHH:
+		return op_VMALH, 1, 0
+	case AVMALHF:
+		return op_VMALH, 2, 0
+	case AVMALO:
+		return op_VMALO, 0, 0
+	case AVMALOB:
+		return op_VMALO, 0, 0
+	case AVMALOH:
+		return op_VMALO, 1, 0
+	case AVMALOF:
+		return op_VMALO, 2, 0
+	case AVMAL:
+		return op_VMAL, 0, 0
+	case AVMALB:
+		return op_VMAL, 0, 0
+	case AVMALHW:
+		return op_VMAL, 1, 0
+	case AVMALF:
+		return op_VMAL, 2, 0
+	case AVMAO:
+		return op_VMAO, 0, 0
+	case AVMAOB:
+		return op_VMAO, 0, 0
+	case AVMAOH:
+		return op_VMAO, 1, 0
+	case AVMAOF:
+		return op_VMAO, 2, 0
+	case AVME:
+		return op_VME, 0, 0
+	case AVMEB:
+		return op_VME, 0, 0
+	case AVMEH:
+		return op_VME, 1, 0
+	case AVMEF:
+		return op_VME, 2, 0
+	case AVMH:
+		return op_VMH, 0, 0
+	case AVMHB:
+		return op_VMH, 0, 0
+	case AVMHH:
+		return op_VMH, 1, 0
+	case AVMHF:
+		return op_VMH, 2, 0
+	case AVMLE:
+		return op_VMLE, 0, 0
+	case AVMLEB:
+		return op_VMLE, 0, 0
+	case AVMLEH:
+		return op_VMLE, 1, 0
+	case AVMLEF:
+		return op_VMLE, 2, 0
+	case AVMLH:
+		return op_VMLH, 0, 0
+	case AVMLHB:
+		return op_VMLH, 0, 0
+	case AVMLHH:
+		return op_VMLH, 1, 0
+	case AVMLHF:
+		return op_VMLH, 2, 0
+	case AVMLO:
+		return op_VMLO, 0, 0
+	case AVMLOB:
+		return op_VMLO, 0, 0
+	case AVMLOH:
+		return op_VMLO, 1, 0
+	case AVMLOF:
+		return op_VMLO, 2, 0
+	case AVML:
+		return op_VML, 0, 0
+	case AVMLB:
+		return op_VML, 0, 0
+	case AVMLHW:
+		return op_VML, 1, 0
+	case AVMLF:
+		return op_VML, 2, 0
+	case AVMO:
+		return op_VMO, 0, 0
+	case AVMOB:
+		return op_VMO, 0, 0
+	case AVMOH:
+		return op_VMO, 1, 0
+	case AVMOF:
+		return op_VMO, 2, 0
+	case AVNO:
+		return op_VNO, 0, 0
+	case AVNOT:
+		return op_VNO, 0, 0
+	case AVO:
+		return op_VO, 0, 0
+	case AVPK:
+		return op_VPK, 0, 0
+	case AVPKH:
+		return op_VPK, 1, 0
+	case AVPKF:
+		return op_VPK, 2, 0
+	case AVPKG:
+		return op_VPK, 3, 0
+	case AVPKLS:
+		return op_VPKLS, 0, 0
+	case AVPKLSH:
+		return op_VPKLS, 1, 0
+	case AVPKLSF:
+		return op_VPKLS, 2, 0
+	case AVPKLSG:
+		return op_VPKLS, 3, 0
+	case AVPKLSHS:
+		return op_VPKLS, 1, 1
+	case AVPKLSFS:
+		return op_VPKLS, 2, 1
+	case AVPKLSGS:
+		return op_VPKLS, 3, 1
+	case AVPKS:
+		return op_VPKS, 0, 0
+	case AVPKSH:
+		return op_VPKS, 1, 0
+	case AVPKSF:
+		return op_VPKS, 2, 0
+	case AVPKSG:
+		return op_VPKS, 3, 0
+	case AVPKSHS:
+		return op_VPKS, 1, 1
+	case AVPKSFS:
+		return op_VPKS, 2, 1
+	case AVPKSGS:
+		return op_VPKS, 3, 1
+	case AVPERM:
+		return op_VPERM, 0, 0
+	case AVPDI:
+		return op_VPDI, 0, 0
+	case AVPOPCT:
+		return op_VPOPCT, 0, 0
+	case AVREP:
+		return op_VREP, 0, 0
+	case AVREPB:
+		return op_VREP, 0, 0
+	case AVREPH:
+		return op_VREP, 1, 0
+	case AVREPF:
+		return op_VREP, 2, 0
+	case AVREPG:
+		return op_VREP, 3, 0
+	case AVREPI:
+		return op_VREPI, 0, 0
+	case AVREPIB:
+		return op_VREPI, 0, 0
+	case AVREPIH:
+		return op_VREPI, 1, 0
+	case AVREPIF:
+		return op_VREPI, 2, 0
+	case AVREPIG:
+		return op_VREPI, 3, 0
+	case AVSCEF:
+		return op_VSCEF, 0, 0
+	case AVSCEG:
+		return op_VSCEG, 0, 0
+	case AVSEL:
+		return op_VSEL, 0, 0
+	case AVSL:
+		return op_VSL, 0, 0
+	case AVSLB:
+		return op_VSLB, 0, 0
+	case AVSLDB:
+		return op_VSLDB, 0, 0
+	case AVSRA:
+		return op_VSRA, 0, 0
+	case AVSRAB:
+		return op_VSRAB, 0, 0
+	case AVSRL:
+		return op_VSRL, 0, 0
+	case AVSRLB:
+		return op_VSRLB, 0, 0
+	case AVSEG:
+		return op_VSEG, 0, 0
+	case AVSEGB:
+		return op_VSEG, 0, 0
+	case AVSEGH:
+		return op_VSEG, 1, 0
+	case AVSEGF:
+		return op_VSEG, 2, 0
+	case AVST:
+		return op_VST, 0, 0
+	case AVSTEH:
+		return op_VSTEH, 0, 0
+	case AVSTEF:
+		return op_VSTEF, 0, 0
+	case AVSTEG:
+		return op_VSTEG, 0, 0
+	case AVSTEB:
+		return op_VSTEB, 0, 0
+	case AVSTM:
+		return op_VSTM, 0, 0
+	case AVSTL:
+		return op_VSTL, 0, 0
+	case AVSTRC:
+		return op_VSTRC, 0, 0
+	case AVSTRCB:
+		return op_VSTRC, 0, 0
+	case AVSTRCH:
+		return op_VSTRC, 1, 0
+	case AVSTRCF:
+		return op_VSTRC, 2, 0
+	case AVSTRCBS:
+		return op_VSTRC, 0, 1
+	case AVSTRCHS:
+		return op_VSTRC, 1, 1
+	case AVSTRCFS:
+		return op_VSTRC, 2, 1
+	case AVSTRCZB:
+		return op_VSTRC, 0, 2
+	case AVSTRCZH:
+		return op_VSTRC, 1, 2
+	case AVSTRCZF:
+		return op_VSTRC, 2, 2
+	case AVSTRCZBS:
+		return op_VSTRC, 0, 3
+	case AVSTRCZHS:
+		return op_VSTRC, 1, 3
+	case AVSTRCZFS:
+		return op_VSTRC, 2, 3
+	case AVS:
+		return op_VS, 0, 0
+	case AVSB:
+		return op_VS, 0, 0
+	case AVSH:
+		return op_VS, 1, 0
+	case AVSF:
+		return op_VS, 2, 0
+	case AVSG:
+		return op_VS, 3, 0
+	case AVSQ:
+		return op_VS, 4, 0
+	case AVSCBI:
+		return op_VSCBI, 0, 0
+	case AVSCBIB:
+		return op_VSCBI, 0, 0
+	case AVSCBIH:
+		return op_VSCBI, 1, 0
+	case AVSCBIF:
+		return op_VSCBI, 2, 0
+	case AVSCBIG:
+		return op_VSCBI, 3, 0
+	case AVSCBIQ:
+		return op_VSCBI, 4, 0
+	case AVSBCBI:
+		return op_VSBCBI, 0, 0
+	case AVSBCBIQ:
+		return op_VSBCBI, 4, 0
+	case AVSBI:
+		return op_VSBI, 0, 0
+	case AVSBIQ:
+		return op_VSBI, 4, 0
+	case AVSUMG:
+		return op_VSUMG, 0, 0
+	case AVSUMGH:
+		return op_VSUMG, 1, 0
+	case AVSUMGF:
+		return op_VSUMG, 2, 0
+	case AVSUMQ:
+		return op_VSUMQ, 0, 0
+	case AVSUMQF:
+		return op_VSUMQ, 2, 0
+	case AVSUMQG:
+		return op_VSUMQ, 3, 0
+	case AVSUM:
+		return op_VSUM, 0, 0
+	case AVSUMB:
+		return op_VSUM, 0, 0
+	case AVSUMH:
+		return op_VSUM, 1, 0
+	case AVTM:
+		return op_VTM, 0, 0
+	case AVUPH:
+		return op_VUPH, 0, 0
+	case AVUPHB:
+		return op_VUPH, 0, 0
+	case AVUPHH:
+		return op_VUPH, 1, 0
+	case AVUPHF:
+		return op_VUPH, 2, 0
+	case AVUPLH:
+		return op_VUPLH, 0, 0
+	case AVUPLHB:
+		return op_VUPLH, 0, 0
+	case AVUPLHH:
+		return op_VUPLH, 1, 0
+	case AVUPLHF:
+		return op_VUPLH, 2, 0
+	case AVUPLL:
+		return op_VUPLL, 0, 0
+	case AVUPLLB:
+		return op_VUPLL, 0, 0
+	case AVUPLLH:
+		return op_VUPLL, 1, 0
+	case AVUPLLF:
+		return op_VUPLL, 2, 0
+	case AVUPL:
+		return op_VUPL, 0, 0
+	case AVUPLB:
+		return op_VUPL, 0, 0
+	case AVUPLHW:
+		return op_VUPL, 1, 0
+	case AVUPLF:
+		return op_VUPL, 2, 0
+	}
+}
+
+// singleElementMask returns the single element mask bits required for the
+// given instruction.
+func singleElementMask(as obj.As) uint32 {
+	switch as {
+	case AWFADB,
+		AWFK,
+		AWFKDB,
+		AWFCEDB,
+		AWFCEDBS,
+		AWFCHDB,
+		AWFCHDBS,
+		AWFCHEDB,
+		AWFCHEDBS,
+		AWFC,
+		AWFCDB,
+		AWCDGB,
+		AWCDLGB,
+		AWCGDB,
+		AWCLGDB,
+		AWFDDB,
+		AWLDEB,
+		AWLEDB,
+		AWFMDB,
+		AWFMADB,
+		AWFMSDB,
+		AWFPSODB,
+		AWFLCDB,
+		AWFLNDB,
+		AWFLPDB,
+		AWFSQDB,
+		AWFSDB,
+		AWFTCIDB,
+		AWFIDB:
+		return 8
+	case AVMSLEG:
+		return 8
+	case AVMSLOG:
+		return 4
+	case AVMSLEOG:
+		return 12
+	}
+	return 0
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/sym.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/sym.go
new file mode 100644
index 000000000..f0bcce58c
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/sym.go
@@ -0,0 +1,421 @@
+// Derived from Inferno utils/6l/obj.c and utils/6l/span.c
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/obj.c
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/span.c
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package obj
+
+import (
+	"github.com/twitchyliquid64/golang-asm/goobj"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"fmt"
+	"log"
+	"math"
+	"sort"
+)
+
+func Linknew(arch *LinkArch) *Link {
+	ctxt := new(Link)
+	ctxt.hash = make(map[string]*LSym)
+	ctxt.funchash = make(map[string]*LSym)
+	ctxt.statichash = make(map[string]*LSym)
+	ctxt.Arch = arch
+	ctxt.Pathname = objabi.WorkingDir()
+
+	if err := ctxt.Headtype.Set(objabi.GOOS); err != nil {
+		log.Fatalf("unknown goos %s", objabi.GOOS)
+	}
+
+	ctxt.Flag_optimize = true
+	return ctxt
+}
+
+// LookupDerived looks up or creates the symbol with name name derived from symbol s.
+// The resulting symbol will be static iff s is.
+func (ctxt *Link) LookupDerived(s *LSym, name string) *LSym {
+	if s.Static() {
+		return ctxt.LookupStatic(name)
+	}
+	return ctxt.Lookup(name)
+}
+
+// LookupStatic looks up the static symbol with name name.
+// If it does not exist, it creates it.
+func (ctxt *Link) LookupStatic(name string) *LSym {
+	s := ctxt.statichash[name]
+	if s == nil {
+		s = &LSym{Name: name, Attribute: AttrStatic}
+		ctxt.statichash[name] = s
+	}
+	return s
+}
+
+// LookupABI looks up a symbol with the given ABI.
+// If it does not exist, it creates it.
+func (ctxt *Link) LookupABI(name string, abi ABI) *LSym {
+	return ctxt.LookupABIInit(name, abi, nil)
+}
+
+// LookupABI looks up a symbol with the given ABI.
+// If it does not exist, it creates it and
+// passes it to init for one-time initialization.
+func (ctxt *Link) LookupABIInit(name string, abi ABI, init func(s *LSym)) *LSym {
+	var hash map[string]*LSym
+	switch abi {
+	case ABI0:
+		hash = ctxt.hash
+	case ABIInternal:
+		hash = ctxt.funchash
+	default:
+		panic("unknown ABI")
+	}
+
+	ctxt.hashmu.Lock()
+	s := hash[name]
+	if s == nil {
+		s = &LSym{Name: name}
+		s.SetABI(abi)
+		hash[name] = s
+		if init != nil {
+			init(s)
+		}
+	}
+	ctxt.hashmu.Unlock()
+	return s
+}
+
+// Lookup looks up the symbol with name name.
+// If it does not exist, it creates it.
+func (ctxt *Link) Lookup(name string) *LSym {
+	return ctxt.LookupInit(name, nil)
+}
+
+// LookupInit looks up the symbol with name name.
+// If it does not exist, it creates it and
+// passes it to init for one-time initialization.
+func (ctxt *Link) LookupInit(name string, init func(s *LSym)) *LSym {
+	ctxt.hashmu.Lock()
+	s := ctxt.hash[name]
+	if s == nil {
+		s = &LSym{Name: name}
+		ctxt.hash[name] = s
+		if init != nil {
+			init(s)
+		}
+	}
+	ctxt.hashmu.Unlock()
+	return s
+}
+
+func (ctxt *Link) Float32Sym(f float32) *LSym {
+	i := math.Float32bits(f)
+	name := fmt.Sprintf("$f32.%08x", i)
+	return ctxt.LookupInit(name, func(s *LSym) {
+		s.Size = 4
+		s.WriteFloat32(ctxt, 0, f)
+		s.Type = objabi.SRODATA
+		s.Set(AttrLocal, true)
+		s.Set(AttrContentAddressable, true)
+		ctxt.constSyms = append(ctxt.constSyms, s)
+	})
+}
+
+func (ctxt *Link) Float64Sym(f float64) *LSym {
+	i := math.Float64bits(f)
+	name := fmt.Sprintf("$f64.%016x", i)
+	return ctxt.LookupInit(name, func(s *LSym) {
+		s.Size = 8
+		s.WriteFloat64(ctxt, 0, f)
+		s.Type = objabi.SRODATA
+		s.Set(AttrLocal, true)
+		s.Set(AttrContentAddressable, true)
+		ctxt.constSyms = append(ctxt.constSyms, s)
+	})
+}
+
+func (ctxt *Link) Int64Sym(i int64) *LSym {
+	name := fmt.Sprintf("$i64.%016x", uint64(i))
+	return ctxt.LookupInit(name, func(s *LSym) {
+		s.Size = 8
+		s.WriteInt(ctxt, 0, 8, i)
+		s.Type = objabi.SRODATA
+		s.Set(AttrLocal, true)
+		s.Set(AttrContentAddressable, true)
+		ctxt.constSyms = append(ctxt.constSyms, s)
+	})
+}
+
+// Assign index to symbols.
+// asm is set to true if this is called by the assembler (i.e. not the compiler),
+// in which case all the symbols are non-package (for now).
+func (ctxt *Link) NumberSyms() {
+	if ctxt.Headtype == objabi.Haix {
+		// Data must be sorted to keep a constant order in TOC symbols.
+		// As they are created during Progedit, two symbols can be switched between
+		// two different compilations. Therefore, BuildID will be different.
+		// TODO: find a better place and optimize to only sort TOC symbols
+		sort.Slice(ctxt.Data, func(i, j int) bool {
+			return ctxt.Data[i].Name < ctxt.Data[j].Name
+		})
+	}
+
+	// Constant symbols are created late in the concurrent phase. Sort them
+	// to ensure a deterministic order.
+	sort.Slice(ctxt.constSyms, func(i, j int) bool {
+		return ctxt.constSyms[i].Name < ctxt.constSyms[j].Name
+	})
+	ctxt.Data = append(ctxt.Data, ctxt.constSyms...)
+	ctxt.constSyms = nil
+
+	ctxt.pkgIdx = make(map[string]int32)
+	ctxt.defs = []*LSym{}
+	ctxt.hashed64defs = []*LSym{}
+	ctxt.hasheddefs = []*LSym{}
+	ctxt.nonpkgdefs = []*LSym{}
+
+	var idx, hashedidx, hashed64idx, nonpkgidx int32
+	ctxt.traverseSyms(traverseDefs, func(s *LSym) {
+		// if Pkgpath is unknown, cannot hash symbols with relocations, as it
+		// may reference named symbols whose names are not fully expanded.
+		if s.ContentAddressable() && (ctxt.Pkgpath != "" || len(s.R) == 0) {
+			if len(s.P) <= 8 && len(s.R) == 0 { // we can use short hash only for symbols without relocations
+				s.PkgIdx = goobj.PkgIdxHashed64
+				s.SymIdx = hashed64idx
+				if hashed64idx != int32(len(ctxt.hashed64defs)) {
+					panic("bad index")
+				}
+				ctxt.hashed64defs = append(ctxt.hashed64defs, s)
+				hashed64idx++
+			} else {
+				s.PkgIdx = goobj.PkgIdxHashed
+				s.SymIdx = hashedidx
+				if hashedidx != int32(len(ctxt.hasheddefs)) {
+					panic("bad index")
+				}
+				ctxt.hasheddefs = append(ctxt.hasheddefs, s)
+				hashedidx++
+			}
+		} else if isNonPkgSym(ctxt, s) {
+			s.PkgIdx = goobj.PkgIdxNone
+			s.SymIdx = nonpkgidx
+			if nonpkgidx != int32(len(ctxt.nonpkgdefs)) {
+				panic("bad index")
+			}
+			ctxt.nonpkgdefs = append(ctxt.nonpkgdefs, s)
+			nonpkgidx++
+		} else {
+			s.PkgIdx = goobj.PkgIdxSelf
+			s.SymIdx = idx
+			if idx != int32(len(ctxt.defs)) {
+				panic("bad index")
+			}
+			ctxt.defs = append(ctxt.defs, s)
+			idx++
+		}
+		s.Set(AttrIndexed, true)
+	})
+
+	ipkg := int32(1) // 0 is invalid index
+	nonpkgdef := nonpkgidx
+	ctxt.traverseSyms(traverseRefs|traverseAux, func(rs *LSym) {
+		if rs.PkgIdx != goobj.PkgIdxInvalid {
+			return
+		}
+		if !ctxt.Flag_linkshared {
+			// Assign special index for builtin symbols.
+			// Don't do it when linking against shared libraries, as the runtime
+			// may be in a different library.
+			if i := goobj.BuiltinIdx(rs.Name, int(rs.ABI())); i != -1 {
+				rs.PkgIdx = goobj.PkgIdxBuiltin
+				rs.SymIdx = int32(i)
+				rs.Set(AttrIndexed, true)
+				return
+			}
+		}
+		pkg := rs.Pkg
+		if rs.ContentAddressable() {
+			// for now, only support content-addressable symbols that are always locally defined.
+			panic("hashed refs unsupported for now")
+		}
+		if pkg == "" || pkg == "\"\"" || pkg == "_" || !rs.Indexed() {
+			rs.PkgIdx = goobj.PkgIdxNone
+			rs.SymIdx = nonpkgidx
+			rs.Set(AttrIndexed, true)
+			if nonpkgidx != nonpkgdef+int32(len(ctxt.nonpkgrefs)) {
+				panic("bad index")
+			}
+			ctxt.nonpkgrefs = append(ctxt.nonpkgrefs, rs)
+			nonpkgidx++
+			return
+		}
+		if k, ok := ctxt.pkgIdx[pkg]; ok {
+			rs.PkgIdx = k
+			return
+		}
+		rs.PkgIdx = ipkg
+		ctxt.pkgIdx[pkg] = ipkg
+		ipkg++
+	})
+}
+
+// Returns whether s is a non-package symbol, which needs to be referenced
+// by name instead of by index.
+func isNonPkgSym(ctxt *Link, s *LSym) bool {
+	if ctxt.IsAsm && !s.Static() {
+		// asm symbols are referenced by name only, except static symbols
+		// which are file-local and can be referenced by index.
+		return true
+	}
+	if ctxt.Flag_linkshared {
+		// The referenced symbol may be in a different shared library so
+		// the linker cannot see its index.
+		return true
+	}
+	if s.Pkg == "_" {
+		// The frontend uses package "_" to mark symbols that should not
+		// be referenced by index, e.g. linkname'd symbols.
+		return true
+	}
+	if s.DuplicateOK() {
+		// Dupok symbol needs to be dedup'd by name.
+		return true
+	}
+	return false
+}
+
+// StaticNamePref is the prefix the front end applies to static temporary
+// variables. When turned into LSyms, these can be tagged as static so
+// as to avoid inserting them into the linker's name lookup tables.
+const StaticNamePref = ".stmp_"
+
+type traverseFlag uint32
+
+const (
+	traverseDefs traverseFlag = 1 << iota
+	traverseRefs
+	traverseAux
+
+	traverseAll = traverseDefs | traverseRefs | traverseAux
+)
+
+// Traverse symbols based on flag, call fn for each symbol.
+func (ctxt *Link) traverseSyms(flag traverseFlag, fn func(*LSym)) {
+	lists := [][]*LSym{ctxt.Text, ctxt.Data, ctxt.ABIAliases}
+	for _, list := range lists {
+		for _, s := range list {
+			if flag&traverseDefs != 0 {
+				fn(s)
+			}
+			if flag&traverseRefs != 0 {
+				for _, r := range s.R {
+					if r.Sym != nil {
+						fn(r.Sym)
+					}
+				}
+			}
+			if flag&traverseAux != 0 {
+				if s.Gotype != nil {
+					fn(s.Gotype)
+				}
+				if s.Type == objabi.STEXT {
+					f := func(parent *LSym, aux *LSym) {
+						fn(aux)
+					}
+					ctxt.traverseFuncAux(flag, s, f)
+				}
+			}
+		}
+	}
+}
+
+func (ctxt *Link) traverseFuncAux(flag traverseFlag, fsym *LSym, fn func(parent *LSym, aux *LSym)) {
+	pc := &fsym.Func.Pcln
+	if flag&traverseAux == 0 {
+		// NB: should it become necessary to walk aux sym reloc references
+		// without walking the aux syms themselves, this can be changed.
+		panic("should not be here")
+	}
+	for _, d := range pc.Funcdata {
+		if d != nil {
+			fn(fsym, d)
+		}
+	}
+	files := ctxt.PosTable.FileTable()
+	usedFiles := make([]goobj.CUFileIndex, 0, len(pc.UsedFiles))
+	for f := range pc.UsedFiles {
+		usedFiles = append(usedFiles, f)
+	}
+	sort.Slice(usedFiles, func(i, j int) bool { return usedFiles[i] < usedFiles[j] })
+	for _, f := range usedFiles {
+		if filesym := ctxt.Lookup(files[f]); filesym != nil {
+			fn(fsym, filesym)
+		}
+	}
+	for _, call := range pc.InlTree.nodes {
+		if call.Func != nil {
+			fn(fsym, call.Func)
+		}
+		f, _ := linkgetlineFromPos(ctxt, call.Pos)
+		if filesym := ctxt.Lookup(f); filesym != nil {
+			fn(fsym, filesym)
+		}
+	}
+	dwsyms := []*LSym{fsym.Func.dwarfRangesSym, fsym.Func.dwarfLocSym, fsym.Func.dwarfDebugLinesSym, fsym.Func.dwarfInfoSym}
+	for _, dws := range dwsyms {
+		if dws == nil || dws.Size == 0 {
+			continue
+		}
+		fn(fsym, dws)
+		if flag&traverseRefs != 0 {
+			for _, r := range dws.R {
+				if r.Sym != nil {
+					fn(dws, r.Sym)
+				}
+			}
+		}
+	}
+}
+
+// Traverse aux symbols, calling fn for each sym/aux pair.
+func (ctxt *Link) traverseAuxSyms(flag traverseFlag, fn func(parent *LSym, aux *LSym)) {
+	lists := [][]*LSym{ctxt.Text, ctxt.Data, ctxt.ABIAliases}
+	for _, list := range lists {
+		for _, s := range list {
+			if s.Gotype != nil {
+				if flag&traverseDefs != 0 {
+					fn(s, s.Gotype)
+				}
+			}
+			if s.Type != objabi.STEXT {
+				continue
+			}
+			ctxt.traverseFuncAux(flag, s, fn)
+		}
+	}
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/textflag.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/textflag.go
new file mode 100644
index 000000000..d2cec734b
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/textflag.go
@@ -0,0 +1,54 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file defines flags attached to various functions
+// and data objects. The compilers, assemblers, and linker must
+// all agree on these values.
+
+package obj
+
+const (
+	// Don't profile the marked routine.
+	//
+	// Deprecated: Not implemented, do not use.
+	NOPROF = 1
+
+	// It is ok for the linker to get multiple of these symbols. It will
+	// pick one of the duplicates to use.
+	DUPOK = 2
+
+	// Don't insert stack check preamble.
+	NOSPLIT = 4
+
+	// Put this data in a read-only section.
+	RODATA = 8
+
+	// This data contains no pointers.
+	NOPTR = 16
+
+	// This is a wrapper function and should not count as disabling 'recover'.
+	WRAPPER = 32
+
+	// This function uses its incoming context register.
+	NEEDCTXT = 64
+
+	// When passed to ggloblsym, causes Local to be set to true on the LSym it creates.
+	LOCAL = 128
+
+	// Allocate a word of thread local storage and store the offset from the
+	// thread local base to the thread local storage in this variable.
+	TLSBSS = 256
+
+	// Do not insert instructions to allocate a stack frame for this function.
+	// Only valid on functions that declare a frame size of 0.
+	// TODO(mwhudson): only implemented for ppc64x at present.
+	NOFRAME = 512
+
+	// Function can call reflect.Type.Method or reflect.Type.MethodByName.
+	REFLECTMETHOD = 1024
+
+	// Function is the top of the call stack. Call stack unwinders should stop
+	// at this function.
+	TOPFRAME = 2048
+)
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/util.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/util.go
new file mode 100644
index 000000000..9d3030a68
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/util.go
@@ -0,0 +1,598 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package obj
+
+import (
+	"bytes"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"fmt"
+	"io"
+	"strings"
+)
+
+const REG_NONE = 0
+
+// Line returns a string containing the filename and line number for p
+func (p *Prog) Line() string {
+	return p.Ctxt.OutermostPos(p.Pos).Format(false, true)
+}
+func (p *Prog) InnermostLine(w io.Writer) {
+	p.Ctxt.InnermostPos(p.Pos).WriteTo(w, false, true)
+}
+
+// InnermostLineNumber returns a string containing the line number for the
+// innermost inlined function (if any inlining) at p's position
+func (p *Prog) InnermostLineNumber() string {
+	return p.Ctxt.InnermostPos(p.Pos).LineNumber()
+}
+
+// InnermostLineNumberHTML returns a string containing the line number for the
+// innermost inlined function (if any inlining) at p's position
+func (p *Prog) InnermostLineNumberHTML() string {
+	return p.Ctxt.InnermostPos(p.Pos).LineNumberHTML()
+}
+
+// InnermostFilename returns a string containing the innermost
+// (in inlining) filename at p's position
+func (p *Prog) InnermostFilename() string {
+	// TODO For now, this is only used for debugging output, and if we need more/better information, it might change.
+	// An example of what we might want to see is the full stack of positions for inlined code, so we get some visibility into what is recorded there.
+	pos := p.Ctxt.InnermostPos(p.Pos)
+	if !pos.IsKnown() {
+		return "<unknown file name>"
+	}
+	return pos.Filename()
+}
+
+var armCondCode = []string{
+	".EQ",
+	".NE",
+	".CS",
+	".CC",
+	".MI",
+	".PL",
+	".VS",
+	".VC",
+	".HI",
+	".LS",
+	".GE",
+	".LT",
+	".GT",
+	".LE",
+	"",
+	".NV",
+}
+
+/* ARM scond byte */
+const (
+	C_SCOND     = (1 << 4) - 1
+	C_SBIT      = 1 << 4
+	C_PBIT      = 1 << 5
+	C_WBIT      = 1 << 6
+	C_FBIT      = 1 << 7
+	C_UBIT      = 1 << 7
+	C_SCOND_XOR = 14
+)
+
+// CConv formats opcode suffix bits (Prog.Scond).
+func CConv(s uint8) string {
+	if s == 0 {
+		return ""
+	}
+	for i := range opSuffixSpace {
+		sset := &opSuffixSpace[i]
+		if sset.arch == objabi.GOARCH {
+			return sset.cconv(s)
+		}
+	}
+	return fmt.Sprintf("SC???%d", s)
+}
+
+// CConvARM formats ARM opcode suffix bits (mostly condition codes).
+func CConvARM(s uint8) string {
+	// TODO: could be great to move suffix-related things into
+	// ARM asm backends some day.
+	// obj/x86 can be used as an example.
+
+	sc := armCondCode[(s&C_SCOND)^C_SCOND_XOR]
+	if s&C_SBIT != 0 {
+		sc += ".S"
+	}
+	if s&C_PBIT != 0 {
+		sc += ".P"
+	}
+	if s&C_WBIT != 0 {
+		sc += ".W"
+	}
+	if s&C_UBIT != 0 { /* ambiguous with FBIT */
+		sc += ".U"
+	}
+	return sc
+}
+
+func (p *Prog) String() string {
+	if p == nil {
+		return "<nil Prog>"
+	}
+	if p.Ctxt == nil {
+		return "<Prog without ctxt>"
+	}
+	return fmt.Sprintf("%.5d (%v)\t%s", p.Pc, p.Line(), p.InstructionString())
+}
+
+func (p *Prog) InnermostString(w io.Writer) {
+	if p == nil {
+		io.WriteString(w, "<nil Prog>")
+		return
+	}
+	if p.Ctxt == nil {
+		io.WriteString(w, "<Prog without ctxt>")
+		return
+	}
+	fmt.Fprintf(w, "%.5d (", p.Pc)
+	p.InnermostLine(w)
+	io.WriteString(w, ")\t")
+	p.WriteInstructionString(w)
+}
+
+// InstructionString returns a string representation of the instruction without preceding
+// program counter or file and line number.
+func (p *Prog) InstructionString() string {
+	buf := new(bytes.Buffer)
+	p.WriteInstructionString(buf)
+	return buf.String()
+}
+
+// WriteInstructionString writes a string representation of the instruction without preceding
+// program counter or file and line number.
+func (p *Prog) WriteInstructionString(w io.Writer) {
+	if p == nil {
+		io.WriteString(w, "<nil Prog>")
+		return
+	}
+
+	if p.Ctxt == nil {
+		io.WriteString(w, "<Prog without ctxt>")
+		return
+	}
+
+	sc := CConv(p.Scond)
+
+	io.WriteString(w, p.As.String())
+	io.WriteString(w, sc)
+	sep := "\t"
+
+	if p.From.Type != TYPE_NONE {
+		io.WriteString(w, sep)
+		WriteDconv(w, p, &p.From)
+		sep = ", "
+	}
+	if p.Reg != REG_NONE {
+		// Should not happen but might as well show it if it does.
+		fmt.Fprintf(w, "%s%v", sep, Rconv(int(p.Reg)))
+		sep = ", "
+	}
+	for i := range p.RestArgs {
+		io.WriteString(w, sep)
+		WriteDconv(w, p, &p.RestArgs[i])
+		sep = ", "
+	}
+
+	if p.As == ATEXT {
+		// If there are attributes, print them. Otherwise, skip the comma.
+		// In short, print one of these two:
+		// TEXT	foo(SB), DUPOK|NOSPLIT, $0
+		// TEXT	foo(SB), $0
+		s := p.From.Sym.Attribute.TextAttrString()
+		if s != "" {
+			fmt.Fprintf(w, "%s%s", sep, s)
+			sep = ", "
+		}
+	}
+	if p.To.Type != TYPE_NONE {
+		io.WriteString(w, sep)
+		WriteDconv(w, p, &p.To)
+	}
+	if p.RegTo2 != REG_NONE {
+		fmt.Fprintf(w, "%s%v", sep, Rconv(int(p.RegTo2)))
+	}
+}
+
+func (ctxt *Link) NewProg() *Prog {
+	p := new(Prog)
+	p.Ctxt = ctxt
+	return p
+}
+
+func (ctxt *Link) CanReuseProgs() bool {
+	return ctxt.Debugasm == 0
+}
+
+func Dconv(p *Prog, a *Addr) string {
+	buf := new(bytes.Buffer)
+	WriteDconv(buf, p, a)
+	return buf.String()
+}
+
+func WriteDconv(w io.Writer, p *Prog, a *Addr) {
+	switch a.Type {
+	default:
+		fmt.Fprintf(w, "type=%d", a.Type)
+
+	case TYPE_NONE:
+		if a.Name != NAME_NONE || a.Reg != 0 || a.Sym != nil {
+			a.WriteNameTo(w)
+			fmt.Fprintf(w, "(%v)(NONE)", Rconv(int(a.Reg)))
+		}
+
+	case TYPE_REG:
+		// TODO(rsc): This special case is for x86 instructions like
+		//	PINSRQ	CX,$1,X6
+		// where the $1 is included in the p->to Addr.
+		// Move into a new field.
+		if a.Offset != 0 && (a.Reg < RBaseARM64 || a.Reg >= RBaseMIPS) {
+			fmt.Fprintf(w, "$%d,%v", a.Offset, Rconv(int(a.Reg)))
+			return
+		}
+
+		if a.Name != NAME_NONE || a.Sym != nil {
+			a.WriteNameTo(w)
+			fmt.Fprintf(w, "(%v)(REG)", Rconv(int(a.Reg)))
+		} else {
+			io.WriteString(w, Rconv(int(a.Reg)))
+		}
+		if (RBaseARM64+1<<10+1<<9) /* arm64.REG_ELEM */ <= a.Reg &&
+			a.Reg < (RBaseARM64+1<<11) /* arm64.REG_ELEM_END */ {
+			fmt.Fprintf(w, "[%d]", a.Index)
+		}
+
+	case TYPE_BRANCH:
+		if a.Sym != nil {
+			fmt.Fprintf(w, "%s(SB)", a.Sym.Name)
+		} else if a.Target() != nil {
+			fmt.Fprint(w, a.Target().Pc)
+		} else {
+			fmt.Fprintf(w, "%d(PC)", a.Offset)
+		}
+
+	case TYPE_INDIR:
+		io.WriteString(w, "*")
+		a.WriteNameTo(w)
+
+	case TYPE_MEM:
+		a.WriteNameTo(w)
+		if a.Index != REG_NONE {
+			if a.Scale == 0 {
+				// arm64 shifted or extended register offset, scale = 0.
+				fmt.Fprintf(w, "(%v)", Rconv(int(a.Index)))
+			} else {
+				fmt.Fprintf(w, "(%v*%d)", Rconv(int(a.Index)), int(a.Scale))
+			}
+		}
+
+	case TYPE_CONST:
+		io.WriteString(w, "$")
+		a.WriteNameTo(w)
+		if a.Reg != 0 {
+			fmt.Fprintf(w, "(%v)", Rconv(int(a.Reg)))
+		}
+
+	case TYPE_TEXTSIZE:
+		if a.Val.(int32) == objabi.ArgsSizeUnknown {
+			fmt.Fprintf(w, "$%d", a.Offset)
+		} else {
+			fmt.Fprintf(w, "$%d-%d", a.Offset, a.Val.(int32))
+		}
+
+	case TYPE_FCONST:
+		str := fmt.Sprintf("%.17g", a.Val.(float64))
+		// Make sure 1 prints as 1.0
+		if !strings.ContainsAny(str, ".e") {
+			str += ".0"
+		}
+		fmt.Fprintf(w, "$(%s)", str)
+
+	case TYPE_SCONST:
+		fmt.Fprintf(w, "$%q", a.Val.(string))
+
+	case TYPE_ADDR:
+		io.WriteString(w, "$")
+		a.WriteNameTo(w)
+
+	case TYPE_SHIFT:
+		v := int(a.Offset)
+		ops := "<<>>->@>"
+		switch objabi.GOARCH {
+		case "arm":
+			op := ops[((v>>5)&3)<<1:]
+			if v&(1<<4) != 0 {
+				fmt.Fprintf(w, "R%d%c%cR%d", v&15, op[0], op[1], (v>>8)&15)
+			} else {
+				fmt.Fprintf(w, "R%d%c%c%d", v&15, op[0], op[1], (v>>7)&31)
+			}
+			if a.Reg != 0 {
+				fmt.Fprintf(w, "(%v)", Rconv(int(a.Reg)))
+			}
+		case "arm64":
+			op := ops[((v>>22)&3)<<1:]
+			r := (v >> 16) & 31
+			fmt.Fprintf(w, "%s%c%c%d", Rconv(r+RBaseARM64), op[0], op[1], (v>>10)&63)
+		default:
+			panic("TYPE_SHIFT is not supported on " + objabi.GOARCH)
+		}
+
+	case TYPE_REGREG:
+		fmt.Fprintf(w, "(%v, %v)", Rconv(int(a.Reg)), Rconv(int(a.Offset)))
+
+	case TYPE_REGREG2:
+		fmt.Fprintf(w, "%v, %v", Rconv(int(a.Offset)), Rconv(int(a.Reg)))
+
+	case TYPE_REGLIST:
+		io.WriteString(w, RLconv(a.Offset))
+	}
+}
+
+func (a *Addr) WriteNameTo(w io.Writer) {
+	switch a.Name {
+	default:
+		fmt.Fprintf(w, "name=%d", a.Name)
+
+	case NAME_NONE:
+		switch {
+		case a.Reg == REG_NONE:
+			fmt.Fprint(w, a.Offset)
+		case a.Offset == 0:
+			fmt.Fprintf(w, "(%v)", Rconv(int(a.Reg)))
+		case a.Offset != 0:
+			fmt.Fprintf(w, "%d(%v)", a.Offset, Rconv(int(a.Reg)))
+		}
+
+		// Note: a.Reg == REG_NONE encodes the default base register for the NAME_ type.
+	case NAME_EXTERN:
+		reg := "SB"
+		if a.Reg != REG_NONE {
+			reg = Rconv(int(a.Reg))
+		}
+		if a.Sym != nil {
+			fmt.Fprintf(w, "%s%s(%s)", a.Sym.Name, offConv(a.Offset), reg)
+		} else {
+			fmt.Fprintf(w, "%s(%s)", offConv(a.Offset), reg)
+		}
+
+	case NAME_GOTREF:
+		reg := "SB"
+		if a.Reg != REG_NONE {
+			reg = Rconv(int(a.Reg))
+		}
+		if a.Sym != nil {
+			fmt.Fprintf(w, "%s%s@GOT(%s)", a.Sym.Name, offConv(a.Offset), reg)
+		} else {
+			fmt.Fprintf(w, "%s@GOT(%s)", offConv(a.Offset), reg)
+		}
+
+	case NAME_STATIC:
+		reg := "SB"
+		if a.Reg != REG_NONE {
+			reg = Rconv(int(a.Reg))
+		}
+		if a.Sym != nil {
+			fmt.Fprintf(w, "%s<>%s(%s)", a.Sym.Name, offConv(a.Offset), reg)
+		} else {
+			fmt.Fprintf(w, "<>%s(%s)", offConv(a.Offset), reg)
+		}
+
+	case NAME_AUTO:
+		reg := "SP"
+		if a.Reg != REG_NONE {
+			reg = Rconv(int(a.Reg))
+		}
+		if a.Sym != nil {
+			fmt.Fprintf(w, "%s%s(%s)", a.Sym.Name, offConv(a.Offset), reg)
+		} else {
+			fmt.Fprintf(w, "%s(%s)", offConv(a.Offset), reg)
+		}
+
+	case NAME_PARAM:
+		reg := "FP"
+		if a.Reg != REG_NONE {
+			reg = Rconv(int(a.Reg))
+		}
+		if a.Sym != nil {
+			fmt.Fprintf(w, "%s%s(%s)", a.Sym.Name, offConv(a.Offset), reg)
+		} else {
+			fmt.Fprintf(w, "%s(%s)", offConv(a.Offset), reg)
+		}
+	case NAME_TOCREF:
+		reg := "SB"
+		if a.Reg != REG_NONE {
+			reg = Rconv(int(a.Reg))
+		}
+		if a.Sym != nil {
+			fmt.Fprintf(w, "%s%s(%s)", a.Sym.Name, offConv(a.Offset), reg)
+		} else {
+			fmt.Fprintf(w, "%s(%s)", offConv(a.Offset), reg)
+		}
+	}
+}
+
+func offConv(off int64) string {
+	if off == 0 {
+		return ""
+	}
+	return fmt.Sprintf("%+d", off)
+}
+
+// opSuffixSet is like regListSet, but for opcode suffixes.
+//
+// Unlike some other similar structures, uint8 space is not
+// divided by its own values set (because there are only 256 of them).
+// Instead, every arch may interpret/format all 8 bits as they like,
+// as long as they register proper cconv function for it.
+type opSuffixSet struct {
+	arch  string
+	cconv func(suffix uint8) string
+}
+
+var opSuffixSpace []opSuffixSet
+
+// RegisterOpSuffix assigns cconv function for formatting opcode suffixes
+// when compiling for GOARCH=arch.
+//
+// cconv is never called with 0 argument.
+func RegisterOpSuffix(arch string, cconv func(uint8) string) {
+	opSuffixSpace = append(opSuffixSpace, opSuffixSet{
+		arch:  arch,
+		cconv: cconv,
+	})
+}
+
+type regSet struct {
+	lo    int
+	hi    int
+	Rconv func(int) string
+}
+
+// Few enough architectures that a linear scan is fastest.
+// Not even worth sorting.
+var regSpace []regSet
+
+/*
+	Each architecture defines a register space as a unique
+	integer range.
+	Here is the list of architectures and the base of their register spaces.
+*/
+
+const (
+	// Because of masking operations in the encodings, each register
+	// space should start at 0 modulo some power of 2.
+	RBase386   = 1 * 1024
+	RBaseAMD64 = 2 * 1024
+	RBaseARM   = 3 * 1024
+	RBasePPC64 = 4 * 1024  // range [4k, 8k)
+	RBaseARM64 = 8 * 1024  // range [8k, 13k)
+	RBaseMIPS  = 13 * 1024 // range [13k, 14k)
+	RBaseS390X = 14 * 1024 // range [14k, 15k)
+	RBaseRISCV = 15 * 1024 // range [15k, 16k)
+	RBaseWasm  = 16 * 1024
+)
+
+// RegisterRegister binds a pretty-printer (Rconv) for register
+// numbers to a given register number range. Lo is inclusive,
+// hi exclusive (valid registers are lo through hi-1).
+func RegisterRegister(lo, hi int, Rconv func(int) string) {
+	regSpace = append(regSpace, regSet{lo, hi, Rconv})
+}
+
+func Rconv(reg int) string {
+	if reg == REG_NONE {
+		return "NONE"
+	}
+	for i := range regSpace {
+		rs := &regSpace[i]
+		if rs.lo <= reg && reg < rs.hi {
+			return rs.Rconv(reg)
+		}
+	}
+	return fmt.Sprintf("R???%d", reg)
+}
+
+type regListSet struct {
+	lo     int64
+	hi     int64
+	RLconv func(int64) string
+}
+
+var regListSpace []regListSet
+
+// Each architecture is allotted a distinct subspace: [Lo, Hi) for declaring its
+// arch-specific register list numbers.
+const (
+	RegListARMLo = 0
+	RegListARMHi = 1 << 16
+
+	// arm64 uses the 60th bit to differentiate from other archs
+	RegListARM64Lo = 1 << 60
+	RegListARM64Hi = 1<<61 - 1
+
+	// x86 uses the 61th bit to differentiate from other archs
+	RegListX86Lo = 1 << 61
+	RegListX86Hi = 1<<62 - 1
+)
+
+// RegisterRegisterList binds a pretty-printer (RLconv) for register list
+// numbers to a given register list number range. Lo is inclusive,
+// hi exclusive (valid register list are lo through hi-1).
+func RegisterRegisterList(lo, hi int64, rlconv func(int64) string) {
+	regListSpace = append(regListSpace, regListSet{lo, hi, rlconv})
+}
+
+func RLconv(list int64) string {
+	for i := range regListSpace {
+		rls := &regListSpace[i]
+		if rls.lo <= list && list < rls.hi {
+			return rls.RLconv(list)
+		}
+	}
+	return fmt.Sprintf("RL???%d", list)
+}
+
+type opSet struct {
+	lo    As
+	names []string
+}
+
+// Not even worth sorting
+var aSpace []opSet
+
+// RegisterOpcode binds a list of instruction names
+// to a given instruction number range.
+func RegisterOpcode(lo As, Anames []string) {
+	if len(Anames) > AllowedOpCodes {
+		panic(fmt.Sprintf("too many instructions, have %d max %d", len(Anames), AllowedOpCodes))
+	}
+	aSpace = append(aSpace, opSet{lo, Anames})
+}
+
+func (a As) String() string {
+	if 0 <= a && int(a) < len(Anames) {
+		return Anames[a]
+	}
+	for i := range aSpace {
+		as := &aSpace[i]
+		if as.lo <= a && int(a-as.lo) < len(as.names) {
+			return as.names[a-as.lo]
+		}
+	}
+	return fmt.Sprintf("A???%d", a)
+}
+
+var Anames = []string{
+	"XXX",
+	"CALL",
+	"DUFFCOPY",
+	"DUFFZERO",
+	"END",
+	"FUNCDATA",
+	"JMP",
+	"NOP",
+	"PCALIGN",
+	"PCDATA",
+	"RET",
+	"GETCALLERPC",
+	"TEXT",
+	"UNDEF",
+}
+
+func Bool2int(b bool) int {
+	// The compiler currently only optimizes this form.
+	// See issue 6011.
+	var i int
+	if b {
+		i = 1
+	} else {
+		i = 0
+	}
+	return i
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/wasm/a.out.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/wasm/a.out.go
new file mode 100644
index 000000000..43a79db71
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/wasm/a.out.go
@@ -0,0 +1,331 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package wasm
+
+import "github.com/twitchyliquid64/golang-asm/obj"
+
+//go:generate go run ../stringer.go -i $GOFILE -o anames.go -p wasm
+
+const (
+	/* mark flags */
+	DONE          = 1 << iota
+	PRESERVEFLAGS // not allowed to clobber flags
+)
+
+/*
+ *	wasm
+ */
+const (
+	ACallImport = obj.ABaseWasm + obj.A_ARCHSPECIFIC + iota
+	AGet
+	ASet
+	ATee
+	ANot // alias for I32Eqz
+
+	// The following are low-level WebAssembly instructions.
+	// Their order matters, since it matches the opcode encoding.
+	// Gaps in the encoding are indicated by comments.
+
+	AUnreachable // opcode 0x00
+	ANop
+	ABlock
+	ALoop
+	AIf
+	AElse
+
+	AEnd // opcode 0x0B
+	ABr
+	ABrIf
+	ABrTable
+	// ACall and AReturn are WebAssembly instructions. obj.ACALL and obj.ARET are higher level instructions
+	// with Go semantics, e.g. they manipulate the Go stack on the linear memory.
+	AReturn
+	ACall
+	ACallIndirect
+
+	ADrop // opcode 0x1A
+	ASelect
+
+	ALocalGet // opcode 0x20
+	ALocalSet
+	ALocalTee
+	AGlobalGet
+	AGlobalSet
+
+	AI32Load // opcode 0x28
+	AI64Load
+	AF32Load
+	AF64Load
+	AI32Load8S
+	AI32Load8U
+	AI32Load16S
+	AI32Load16U
+	AI64Load8S
+	AI64Load8U
+	AI64Load16S
+	AI64Load16U
+	AI64Load32S
+	AI64Load32U
+	AI32Store
+	AI64Store
+	AF32Store
+	AF64Store
+	AI32Store8
+	AI32Store16
+	AI64Store8
+	AI64Store16
+	AI64Store32
+	ACurrentMemory
+	AGrowMemory
+
+	AI32Const
+	AI64Const
+	AF32Const
+	AF64Const
+
+	AI32Eqz
+	AI32Eq
+	AI32Ne
+	AI32LtS
+	AI32LtU
+	AI32GtS
+	AI32GtU
+	AI32LeS
+	AI32LeU
+	AI32GeS
+	AI32GeU
+
+	AI64Eqz
+	AI64Eq
+	AI64Ne
+	AI64LtS
+	AI64LtU
+	AI64GtS
+	AI64GtU
+	AI64LeS
+	AI64LeU
+	AI64GeS
+	AI64GeU
+
+	AF32Eq
+	AF32Ne
+	AF32Lt
+	AF32Gt
+	AF32Le
+	AF32Ge
+
+	AF64Eq
+	AF64Ne
+	AF64Lt
+	AF64Gt
+	AF64Le
+	AF64Ge
+
+	AI32Clz
+	AI32Ctz
+	AI32Popcnt
+	AI32Add
+	AI32Sub
+	AI32Mul
+	AI32DivS
+	AI32DivU
+	AI32RemS
+	AI32RemU
+	AI32And
+	AI32Or
+	AI32Xor
+	AI32Shl
+	AI32ShrS
+	AI32ShrU
+	AI32Rotl
+	AI32Rotr
+
+	AI64Clz
+	AI64Ctz
+	AI64Popcnt
+	AI64Add
+	AI64Sub
+	AI64Mul
+	AI64DivS
+	AI64DivU
+	AI64RemS
+	AI64RemU
+	AI64And
+	AI64Or
+	AI64Xor
+	AI64Shl
+	AI64ShrS
+	AI64ShrU
+	AI64Rotl
+	AI64Rotr
+
+	AF32Abs
+	AF32Neg
+	AF32Ceil
+	AF32Floor
+	AF32Trunc
+	AF32Nearest
+	AF32Sqrt
+	AF32Add
+	AF32Sub
+	AF32Mul
+	AF32Div
+	AF32Min
+	AF32Max
+	AF32Copysign
+
+	AF64Abs
+	AF64Neg
+	AF64Ceil
+	AF64Floor
+	AF64Trunc
+	AF64Nearest
+	AF64Sqrt
+	AF64Add
+	AF64Sub
+	AF64Mul
+	AF64Div
+	AF64Min
+	AF64Max
+	AF64Copysign
+
+	AI32WrapI64
+	AI32TruncF32S
+	AI32TruncF32U
+	AI32TruncF64S
+	AI32TruncF64U
+	AI64ExtendI32S
+	AI64ExtendI32U
+	AI64TruncF32S
+	AI64TruncF32U
+	AI64TruncF64S
+	AI64TruncF64U
+	AF32ConvertI32S
+	AF32ConvertI32U
+	AF32ConvertI64S
+	AF32ConvertI64U
+	AF32DemoteF64
+	AF64ConvertI32S
+	AF64ConvertI32U
+	AF64ConvertI64S
+	AF64ConvertI64U
+	AF64PromoteF32
+	AI32ReinterpretF32
+	AI64ReinterpretF64
+	AF32ReinterpretI32
+	AF64ReinterpretI64
+	AI32Extend8S
+	AI32Extend16S
+	AI64Extend8S
+	AI64Extend16S
+	AI64Extend32S
+
+	AI32TruncSatF32S // opcode 0xFC 0x00
+	AI32TruncSatF32U
+	AI32TruncSatF64S
+	AI32TruncSatF64U
+	AI64TruncSatF32S
+	AI64TruncSatF32U
+	AI64TruncSatF64S
+	AI64TruncSatF64U
+
+	ALast // Sentinel: End of low-level WebAssembly instructions.
+
+	ARESUMEPOINT
+	// ACALLNORESUME is a call which is not followed by a resume point.
+	// It is allowed inside of WebAssembly blocks, whereas obj.ACALL is not.
+	// However, it is not allowed to switch goroutines while inside of an ACALLNORESUME call.
+	ACALLNORESUME
+
+	ARETUNWIND
+
+	AMOVB
+	AMOVH
+	AMOVW
+	AMOVD
+
+	AWORD
+	ALAST
+)
+
+const (
+	REG_NONE = 0
+)
+
+const (
+	// globals
+	REG_SP = obj.RBaseWasm + iota // SP is currently 32-bit, until 64-bit memory operations are available
+	REG_CTXT
+	REG_g
+	// RET* are used by runtime.return0 and runtime.reflectcall. These functions pass return values in registers.
+	REG_RET0
+	REG_RET1
+	REG_RET2
+	REG_RET3
+	REG_PAUSE
+
+	// i32 locals
+	REG_R0
+	REG_R1
+	REG_R2
+	REG_R3
+	REG_R4
+	REG_R5
+	REG_R6
+	REG_R7
+	REG_R8
+	REG_R9
+	REG_R10
+	REG_R11
+	REG_R12
+	REG_R13
+	REG_R14
+	REG_R15
+
+	// f32 locals
+	REG_F0
+	REG_F1
+	REG_F2
+	REG_F3
+	REG_F4
+	REG_F5
+	REG_F6
+	REG_F7
+	REG_F8
+	REG_F9
+	REG_F10
+	REG_F11
+	REG_F12
+	REG_F13
+	REG_F14
+	REG_F15
+
+	// f64 locals
+	REG_F16
+	REG_F17
+	REG_F18
+	REG_F19
+	REG_F20
+	REG_F21
+	REG_F22
+	REG_F23
+	REG_F24
+	REG_F25
+	REG_F26
+	REG_F27
+	REG_F28
+	REG_F29
+	REG_F30
+	REG_F31
+
+	REG_PC_B // also first parameter, i32
+
+	MAXREG
+
+	MINREG  = REG_SP
+	REGSP   = REG_SP
+	REGCTXT = REG_CTXT
+	REGG    = REG_g
+)
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/wasm/anames.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/wasm/anames.go
new file mode 100644
index 000000000..1906810e3
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/wasm/anames.go
@@ -0,0 +1,208 @@
+// Code generated by stringer -i a.out.go -o anames.go -p wasm; DO NOT EDIT.
+
+package wasm
+
+import "github.com/twitchyliquid64/golang-asm/obj"
+
+var Anames = []string{
+	obj.A_ARCHSPECIFIC: "CallImport",
+	"Get",
+	"Set",
+	"Tee",
+	"Not",
+	"Unreachable",
+	"Nop",
+	"Block",
+	"Loop",
+	"If",
+	"Else",
+	"End",
+	"Br",
+	"BrIf",
+	"BrTable",
+	"Return",
+	"Call",
+	"CallIndirect",
+	"Drop",
+	"Select",
+	"LocalGet",
+	"LocalSet",
+	"LocalTee",
+	"GlobalGet",
+	"GlobalSet",
+	"I32Load",
+	"I64Load",
+	"F32Load",
+	"F64Load",
+	"I32Load8S",
+	"I32Load8U",
+	"I32Load16S",
+	"I32Load16U",
+	"I64Load8S",
+	"I64Load8U",
+	"I64Load16S",
+	"I64Load16U",
+	"I64Load32S",
+	"I64Load32U",
+	"I32Store",
+	"I64Store",
+	"F32Store",
+	"F64Store",
+	"I32Store8",
+	"I32Store16",
+	"I64Store8",
+	"I64Store16",
+	"I64Store32",
+	"CurrentMemory",
+	"GrowMemory",
+	"I32Const",
+	"I64Const",
+	"F32Const",
+	"F64Const",
+	"I32Eqz",
+	"I32Eq",
+	"I32Ne",
+	"I32LtS",
+	"I32LtU",
+	"I32GtS",
+	"I32GtU",
+	"I32LeS",
+	"I32LeU",
+	"I32GeS",
+	"I32GeU",
+	"I64Eqz",
+	"I64Eq",
+	"I64Ne",
+	"I64LtS",
+	"I64LtU",
+	"I64GtS",
+	"I64GtU",
+	"I64LeS",
+	"I64LeU",
+	"I64GeS",
+	"I64GeU",
+	"F32Eq",
+	"F32Ne",
+	"F32Lt",
+	"F32Gt",
+	"F32Le",
+	"F32Ge",
+	"F64Eq",
+	"F64Ne",
+	"F64Lt",
+	"F64Gt",
+	"F64Le",
+	"F64Ge",
+	"I32Clz",
+	"I32Ctz",
+	"I32Popcnt",
+	"I32Add",
+	"I32Sub",
+	"I32Mul",
+	"I32DivS",
+	"I32DivU",
+	"I32RemS",
+	"I32RemU",
+	"I32And",
+	"I32Or",
+	"I32Xor",
+	"I32Shl",
+	"I32ShrS",
+	"I32ShrU",
+	"I32Rotl",
+	"I32Rotr",
+	"I64Clz",
+	"I64Ctz",
+	"I64Popcnt",
+	"I64Add",
+	"I64Sub",
+	"I64Mul",
+	"I64DivS",
+	"I64DivU",
+	"I64RemS",
+	"I64RemU",
+	"I64And",
+	"I64Or",
+	"I64Xor",
+	"I64Shl",
+	"I64ShrS",
+	"I64ShrU",
+	"I64Rotl",
+	"I64Rotr",
+	"F32Abs",
+	"F32Neg",
+	"F32Ceil",
+	"F32Floor",
+	"F32Trunc",
+	"F32Nearest",
+	"F32Sqrt",
+	"F32Add",
+	"F32Sub",
+	"F32Mul",
+	"F32Div",
+	"F32Min",
+	"F32Max",
+	"F32Copysign",
+	"F64Abs",
+	"F64Neg",
+	"F64Ceil",
+	"F64Floor",
+	"F64Trunc",
+	"F64Nearest",
+	"F64Sqrt",
+	"F64Add",
+	"F64Sub",
+	"F64Mul",
+	"F64Div",
+	"F64Min",
+	"F64Max",
+	"F64Copysign",
+	"I32WrapI64",
+	"I32TruncF32S",
+	"I32TruncF32U",
+	"I32TruncF64S",
+	"I32TruncF64U",
+	"I64ExtendI32S",
+	"I64ExtendI32U",
+	"I64TruncF32S",
+	"I64TruncF32U",
+	"I64TruncF64S",
+	"I64TruncF64U",
+	"F32ConvertI32S",
+	"F32ConvertI32U",
+	"F32ConvertI64S",
+	"F32ConvertI64U",
+	"F32DemoteF64",
+	"F64ConvertI32S",
+	"F64ConvertI32U",
+	"F64ConvertI64S",
+	"F64ConvertI64U",
+	"F64PromoteF32",
+	"I32ReinterpretF32",
+	"I64ReinterpretF64",
+	"F32ReinterpretI32",
+	"F64ReinterpretI64",
+	"I32Extend8S",
+	"I32Extend16S",
+	"I64Extend8S",
+	"I64Extend16S",
+	"I64Extend32S",
+	"I32TruncSatF32S",
+	"I32TruncSatF32U",
+	"I32TruncSatF64S",
+	"I32TruncSatF64U",
+	"I64TruncSatF32S",
+	"I64TruncSatF32U",
+	"I64TruncSatF64S",
+	"I64TruncSatF64U",
+	"Last",
+	"RESUMEPOINT",
+	"CALLNORESUME",
+	"RETUNWIND",
+	"MOVB",
+	"MOVH",
+	"MOVW",
+	"MOVD",
+	"WORD",
+	"LAST",
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/wasm/wasmobj.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/wasm/wasmobj.go
new file mode 100644
index 000000000..f7e4e33a7
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/wasm/wasmobj.go
@@ -0,0 +1,1185 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package wasm
+
+import (
+	"bytes"
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"github.com/twitchyliquid64/golang-asm/sys"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"math"
+)
+
+var Register = map[string]int16{
+	"SP":    REG_SP,
+	"CTXT":  REG_CTXT,
+	"g":     REG_g,
+	"RET0":  REG_RET0,
+	"RET1":  REG_RET1,
+	"RET2":  REG_RET2,
+	"RET3":  REG_RET3,
+	"PAUSE": REG_PAUSE,
+
+	"R0":  REG_R0,
+	"R1":  REG_R1,
+	"R2":  REG_R2,
+	"R3":  REG_R3,
+	"R4":  REG_R4,
+	"R5":  REG_R5,
+	"R6":  REG_R6,
+	"R7":  REG_R7,
+	"R8":  REG_R8,
+	"R9":  REG_R9,
+	"R10": REG_R10,
+	"R11": REG_R11,
+	"R12": REG_R12,
+	"R13": REG_R13,
+	"R14": REG_R14,
+	"R15": REG_R15,
+
+	"F0":  REG_F0,
+	"F1":  REG_F1,
+	"F2":  REG_F2,
+	"F3":  REG_F3,
+	"F4":  REG_F4,
+	"F5":  REG_F5,
+	"F6":  REG_F6,
+	"F7":  REG_F7,
+	"F8":  REG_F8,
+	"F9":  REG_F9,
+	"F10": REG_F10,
+	"F11": REG_F11,
+	"F12": REG_F12,
+	"F13": REG_F13,
+	"F14": REG_F14,
+	"F15": REG_F15,
+
+	"F16": REG_F16,
+	"F17": REG_F17,
+	"F18": REG_F18,
+	"F19": REG_F19,
+	"F20": REG_F20,
+	"F21": REG_F21,
+	"F22": REG_F22,
+	"F23": REG_F23,
+	"F24": REG_F24,
+	"F25": REG_F25,
+	"F26": REG_F26,
+	"F27": REG_F27,
+	"F28": REG_F28,
+	"F29": REG_F29,
+	"F30": REG_F30,
+	"F31": REG_F31,
+
+	"PC_B": REG_PC_B,
+}
+
+var registerNames []string
+
+func init() {
+	obj.RegisterRegister(MINREG, MAXREG, rconv)
+	obj.RegisterOpcode(obj.ABaseWasm, Anames)
+
+	registerNames = make([]string, MAXREG-MINREG)
+	for name, reg := range Register {
+		registerNames[reg-MINREG] = name
+	}
+}
+
+func rconv(r int) string {
+	return registerNames[r-MINREG]
+}
+
+var unaryDst = map[obj.As]bool{
+	ASet:          true,
+	ATee:          true,
+	ACall:         true,
+	ACallIndirect: true,
+	ACallImport:   true,
+	ABr:           true,
+	ABrIf:         true,
+	ABrTable:      true,
+	AI32Store:     true,
+	AI64Store:     true,
+	AF32Store:     true,
+	AF64Store:     true,
+	AI32Store8:    true,
+	AI32Store16:   true,
+	AI64Store8:    true,
+	AI64Store16:   true,
+	AI64Store32:   true,
+	ACALLNORESUME: true,
+}
+
+var Linkwasm = obj.LinkArch{
+	Arch:       sys.ArchWasm,
+	Init:       instinit,
+	Preprocess: preprocess,
+	Assemble:   assemble,
+	UnaryDst:   unaryDst,
+}
+
+var (
+	morestack       *obj.LSym
+	morestackNoCtxt *obj.LSym
+	gcWriteBarrier  *obj.LSym
+	sigpanic        *obj.LSym
+	sigpanic0       *obj.LSym
+	deferreturn     *obj.LSym
+	jmpdefer        *obj.LSym
+)
+
+const (
+	/* mark flags */
+	WasmImport = 1 << 0
+)
+
+func instinit(ctxt *obj.Link) {
+	morestack = ctxt.Lookup("runtime.morestack")
+	morestackNoCtxt = ctxt.Lookup("runtime.morestack_noctxt")
+	gcWriteBarrier = ctxt.Lookup("runtime.gcWriteBarrier")
+	sigpanic = ctxt.LookupABI("runtime.sigpanic", obj.ABIInternal)
+	sigpanic0 = ctxt.LookupABI("runtime.sigpanic", 0) // sigpanic called from assembly, which has ABI0
+	deferreturn = ctxt.LookupABI("runtime.deferreturn", obj.ABIInternal)
+	// jmpdefer is defined in assembly as ABI0, but what we're
+	// looking for is the *call* to jmpdefer from the Go function
+	// deferreturn, so we're looking for the ABIInternal version
+	// of jmpdefer that's called by Go.
+	jmpdefer = ctxt.LookupABI(`"".jmpdefer`, obj.ABIInternal)
+}
+
+func preprocess(ctxt *obj.Link, s *obj.LSym, newprog obj.ProgAlloc) {
+	appendp := func(p *obj.Prog, as obj.As, args ...obj.Addr) *obj.Prog {
+		if p.As != obj.ANOP {
+			p2 := obj.Appendp(p, newprog)
+			p2.Pc = p.Pc
+			p = p2
+		}
+		p.As = as
+		switch len(args) {
+		case 0:
+			p.From = obj.Addr{}
+			p.To = obj.Addr{}
+		case 1:
+			if unaryDst[as] {
+				p.From = obj.Addr{}
+				p.To = args[0]
+			} else {
+				p.From = args[0]
+				p.To = obj.Addr{}
+			}
+		case 2:
+			p.From = args[0]
+			p.To = args[1]
+		default:
+			panic("bad args")
+		}
+		return p
+	}
+
+	framesize := s.Func.Text.To.Offset
+	if framesize < 0 {
+		panic("bad framesize")
+	}
+	s.Func.Args = s.Func.Text.To.Val.(int32)
+	s.Func.Locals = int32(framesize)
+
+	if s.Func.Text.From.Sym.Wrapper() {
+		// if g._panic != nil && g._panic.argp == FP {
+		//   g._panic.argp = bottom-of-frame
+		// }
+		//
+		// MOVD g_panic(g), R0
+		// Get R0
+		// I64Eqz
+		// Not
+		// If
+		//   Get SP
+		//   I64ExtendI32U
+		//   I64Const $framesize+8
+		//   I64Add
+		//   I64Load panic_argp(R0)
+		//   I64Eq
+		//   If
+		//     MOVD SP, panic_argp(R0)
+		//   End
+		// End
+
+		gpanic := obj.Addr{
+			Type:   obj.TYPE_MEM,
+			Reg:    REGG,
+			Offset: 4 * 8, // g_panic
+		}
+
+		panicargp := obj.Addr{
+			Type:   obj.TYPE_MEM,
+			Reg:    REG_R0,
+			Offset: 0, // panic.argp
+		}
+
+		p := s.Func.Text
+		p = appendp(p, AMOVD, gpanic, regAddr(REG_R0))
+
+		p = appendp(p, AGet, regAddr(REG_R0))
+		p = appendp(p, AI64Eqz)
+		p = appendp(p, ANot)
+		p = appendp(p, AIf)
+
+		p = appendp(p, AGet, regAddr(REG_SP))
+		p = appendp(p, AI64ExtendI32U)
+		p = appendp(p, AI64Const, constAddr(framesize+8))
+		p = appendp(p, AI64Add)
+		p = appendp(p, AI64Load, panicargp)
+
+		p = appendp(p, AI64Eq)
+		p = appendp(p, AIf)
+		p = appendp(p, AMOVD, regAddr(REG_SP), panicargp)
+		p = appendp(p, AEnd)
+
+		p = appendp(p, AEnd)
+	}
+
+	if framesize > 0 {
+		p := s.Func.Text
+		p = appendp(p, AGet, regAddr(REG_SP))
+		p = appendp(p, AI32Const, constAddr(framesize))
+		p = appendp(p, AI32Sub)
+		p = appendp(p, ASet, regAddr(REG_SP))
+		p.Spadj = int32(framesize)
+	}
+
+	// Introduce resume points for CALL instructions
+	// and collect other explicit resume points.
+	numResumePoints := 0
+	explicitBlockDepth := 0
+	pc := int64(0) // pc is only incremented when necessary, this avoids bloat of the BrTable instruction
+	var tableIdxs []uint64
+	tablePC := int64(0)
+	base := ctxt.PosTable.Pos(s.Func.Text.Pos).Base()
+	for p := s.Func.Text; p != nil; p = p.Link {
+		prevBase := base
+		base = ctxt.PosTable.Pos(p.Pos).Base()
+		switch p.As {
+		case ABlock, ALoop, AIf:
+			explicitBlockDepth++
+
+		case AEnd:
+			if explicitBlockDepth == 0 {
+				panic("End without block")
+			}
+			explicitBlockDepth--
+
+		case ARESUMEPOINT:
+			if explicitBlockDepth != 0 {
+				panic("RESUME can only be used on toplevel")
+			}
+			p.As = AEnd
+			for tablePC <= pc {
+				tableIdxs = append(tableIdxs, uint64(numResumePoints))
+				tablePC++
+			}
+			numResumePoints++
+			pc++
+
+		case obj.ACALL:
+			if explicitBlockDepth != 0 {
+				panic("CALL can only be used on toplevel, try CALLNORESUME instead")
+			}
+			appendp(p, ARESUMEPOINT)
+		}
+
+		p.Pc = pc
+
+		// Increase pc whenever some pc-value table needs a new entry. Don't increase it
+		// more often to avoid bloat of the BrTable instruction.
+		// The "base != prevBase" condition detects inlined instructions. They are an
+		// implicit call, so entering and leaving this section affects the stack trace.
+		if p.As == ACALLNORESUME || p.As == obj.ANOP || p.As == ANop || p.Spadj != 0 || base != prevBase {
+			pc++
+			if p.To.Sym == sigpanic {
+				// The panic stack trace expects the PC at the call of sigpanic,
+				// not the next one. However, runtime.Caller subtracts 1 from the
+				// PC. To make both PC and PC-1 work (have the same line number),
+				// we advance the PC by 2 at sigpanic.
+				pc++
+			}
+		}
+	}
+	tableIdxs = append(tableIdxs, uint64(numResumePoints))
+	s.Size = pc + 1
+
+	if !s.Func.Text.From.Sym.NoSplit() {
+		p := s.Func.Text
+
+		if framesize <= objabi.StackSmall {
+			// small stack: SP <= stackguard
+			// Get SP
+			// Get g
+			// I32WrapI64
+			// I32Load $stackguard0
+			// I32GtU
+
+			p = appendp(p, AGet, regAddr(REG_SP))
+			p = appendp(p, AGet, regAddr(REGG))
+			p = appendp(p, AI32WrapI64)
+			p = appendp(p, AI32Load, constAddr(2*int64(ctxt.Arch.PtrSize))) // G.stackguard0
+			p = appendp(p, AI32LeU)
+		} else {
+			// large stack: SP-framesize <= stackguard-StackSmall
+			//              SP <= stackguard+(framesize-StackSmall)
+			// Get SP
+			// Get g
+			// I32WrapI64
+			// I32Load $stackguard0
+			// I32Const $(framesize-StackSmall)
+			// I32Add
+			// I32GtU
+
+			p = appendp(p, AGet, regAddr(REG_SP))
+			p = appendp(p, AGet, regAddr(REGG))
+			p = appendp(p, AI32WrapI64)
+			p = appendp(p, AI32Load, constAddr(2*int64(ctxt.Arch.PtrSize))) // G.stackguard0
+			p = appendp(p, AI32Const, constAddr(int64(framesize)-objabi.StackSmall))
+			p = appendp(p, AI32Add)
+			p = appendp(p, AI32LeU)
+		}
+		// TODO(neelance): handle wraparound case
+
+		p = appendp(p, AIf)
+		p = appendp(p, obj.ACALL, constAddr(0))
+		if s.Func.Text.From.Sym.NeedCtxt() {
+			p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: morestack}
+		} else {
+			p.To = obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: morestackNoCtxt}
+		}
+		p = appendp(p, AEnd)
+	}
+
+	// record the branches targeting the entry loop and the unwind exit,
+	// their targets with be filled in later
+	var entryPointLoopBranches []*obj.Prog
+	var unwindExitBranches []*obj.Prog
+	currentDepth := 0
+	for p := s.Func.Text; p != nil; p = p.Link {
+		switch p.As {
+		case ABlock, ALoop, AIf:
+			currentDepth++
+		case AEnd:
+			currentDepth--
+		}
+
+		switch p.As {
+		case obj.AJMP:
+			jmp := *p
+			p.As = obj.ANOP
+
+			if jmp.To.Type == obj.TYPE_BRANCH {
+				// jump to basic block
+				p = appendp(p, AI32Const, constAddr(jmp.To.Val.(*obj.Prog).Pc))
+				p = appendp(p, ASet, regAddr(REG_PC_B)) // write next basic block to PC_B
+				p = appendp(p, ABr)                     // jump to beginning of entryPointLoop
+				entryPointLoopBranches = append(entryPointLoopBranches, p)
+				break
+			}
+
+			// low-level WebAssembly call to function
+			switch jmp.To.Type {
+			case obj.TYPE_MEM:
+				if !notUsePC_B[jmp.To.Sym.Name] {
+					// Set PC_B parameter to function entry.
+					p = appendp(p, AI32Const, constAddr(0))
+				}
+				p = appendp(p, ACall, jmp.To)
+
+			case obj.TYPE_NONE:
+				// (target PC is on stack)
+				p = appendp(p, AI32WrapI64)
+				p = appendp(p, AI32Const, constAddr(16)) // only needs PC_F bits (16-31), PC_B bits (0-15) are zero
+				p = appendp(p, AI32ShrU)
+
+				// Set PC_B parameter to function entry.
+				// We need to push this before pushing the target PC_F,
+				// so temporarily pop PC_F, using our REG_PC_B as a
+				// scratch register, and push it back after pushing 0.
+				p = appendp(p, ASet, regAddr(REG_PC_B))
+				p = appendp(p, AI32Const, constAddr(0))
+				p = appendp(p, AGet, regAddr(REG_PC_B))
+
+				p = appendp(p, ACallIndirect)
+
+			default:
+				panic("bad target for JMP")
+			}
+
+			p = appendp(p, AReturn)
+
+		case obj.ACALL, ACALLNORESUME:
+			call := *p
+			p.As = obj.ANOP
+
+			pcAfterCall := call.Link.Pc
+			if call.To.Sym == sigpanic {
+				pcAfterCall-- // sigpanic expects to be called without advancing the pc
+			}
+
+			// jmpdefer manipulates the return address on the stack so deferreturn gets called repeatedly.
+			// Model this in WebAssembly with a loop.
+			if call.To.Sym == deferreturn {
+				p = appendp(p, ALoop)
+			}
+
+			// SP -= 8
+			p = appendp(p, AGet, regAddr(REG_SP))
+			p = appendp(p, AI32Const, constAddr(8))
+			p = appendp(p, AI32Sub)
+			p = appendp(p, ASet, regAddr(REG_SP))
+
+			// write return address to Go stack
+			p = appendp(p, AGet, regAddr(REG_SP))
+			p = appendp(p, AI64Const, obj.Addr{
+				Type:   obj.TYPE_ADDR,
+				Name:   obj.NAME_EXTERN,
+				Sym:    s,           // PC_F
+				Offset: pcAfterCall, // PC_B
+			})
+			p = appendp(p, AI64Store, constAddr(0))
+
+			// low-level WebAssembly call to function
+			switch call.To.Type {
+			case obj.TYPE_MEM:
+				if !notUsePC_B[call.To.Sym.Name] {
+					// Set PC_B parameter to function entry.
+					p = appendp(p, AI32Const, constAddr(0))
+				}
+				p = appendp(p, ACall, call.To)
+
+			case obj.TYPE_NONE:
+				// (target PC is on stack)
+				p = appendp(p, AI32WrapI64)
+				p = appendp(p, AI32Const, constAddr(16)) // only needs PC_F bits (16-31), PC_B bits (0-15) are zero
+				p = appendp(p, AI32ShrU)
+
+				// Set PC_B parameter to function entry.
+				// We need to push this before pushing the target PC_F,
+				// so temporarily pop PC_F, using our PC_B as a
+				// scratch register, and push it back after pushing 0.
+				p = appendp(p, ASet, regAddr(REG_PC_B))
+				p = appendp(p, AI32Const, constAddr(0))
+				p = appendp(p, AGet, regAddr(REG_PC_B))
+
+				p = appendp(p, ACallIndirect)
+
+			default:
+				panic("bad target for CALL")
+			}
+
+			// gcWriteBarrier has no return value, it never unwinds the stack
+			if call.To.Sym == gcWriteBarrier {
+				break
+			}
+
+			// jmpdefer removes the frame of deferreturn from the Go stack.
+			// However, its WebAssembly function still returns normally,
+			// so we need to return from deferreturn without removing its
+			// stack frame (no RET), because the frame is already gone.
+			if call.To.Sym == jmpdefer {
+				p = appendp(p, AReturn)
+				break
+			}
+
+			// return value of call is on the top of the stack, indicating whether to unwind the WebAssembly stack
+			if call.As == ACALLNORESUME && call.To.Sym != sigpanic && call.To.Sym != sigpanic0 { // sigpanic unwinds the stack, but it never resumes
+				// trying to unwind WebAssembly stack but call has no resume point, terminate with error
+				p = appendp(p, AIf)
+				p = appendp(p, obj.AUNDEF)
+				p = appendp(p, AEnd)
+			} else {
+				// unwinding WebAssembly stack to switch goroutine, return 1
+				p = appendp(p, ABrIf)
+				unwindExitBranches = append(unwindExitBranches, p)
+			}
+
+			// jump to before the call if jmpdefer has reset the return address to the call's PC
+			if call.To.Sym == deferreturn {
+				// get PC_B from -8(SP)
+				p = appendp(p, AGet, regAddr(REG_SP))
+				p = appendp(p, AI32Const, constAddr(8))
+				p = appendp(p, AI32Sub)
+				p = appendp(p, AI32Load16U, constAddr(0))
+				p = appendp(p, ATee, regAddr(REG_PC_B))
+
+				p = appendp(p, AI32Const, constAddr(call.Pc))
+				p = appendp(p, AI32Eq)
+				p = appendp(p, ABrIf, constAddr(0))
+				p = appendp(p, AEnd) // end of Loop
+			}
+
+		case obj.ARET, ARETUNWIND:
+			ret := *p
+			p.As = obj.ANOP
+
+			if framesize > 0 {
+				// SP += framesize
+				p = appendp(p, AGet, regAddr(REG_SP))
+				p = appendp(p, AI32Const, constAddr(framesize))
+				p = appendp(p, AI32Add)
+				p = appendp(p, ASet, regAddr(REG_SP))
+				// TODO(neelance): This should theoretically set Spadj, but it only works without.
+				// p.Spadj = int32(-framesize)
+			}
+
+			if ret.To.Type == obj.TYPE_MEM {
+				// Set PC_B parameter to function entry.
+				p = appendp(p, AI32Const, constAddr(0))
+
+				// low-level WebAssembly call to function
+				p = appendp(p, ACall, ret.To)
+				p = appendp(p, AReturn)
+				break
+			}
+
+			// SP += 8
+			p = appendp(p, AGet, regAddr(REG_SP))
+			p = appendp(p, AI32Const, constAddr(8))
+			p = appendp(p, AI32Add)
+			p = appendp(p, ASet, regAddr(REG_SP))
+
+			if ret.As == ARETUNWIND {
+				// function needs to unwind the WebAssembly stack, return 1
+				p = appendp(p, AI32Const, constAddr(1))
+				p = appendp(p, AReturn)
+				break
+			}
+
+			// not unwinding the WebAssembly stack, return 0
+			p = appendp(p, AI32Const, constAddr(0))
+			p = appendp(p, AReturn)
+		}
+	}
+
+	for p := s.Func.Text; p != nil; p = p.Link {
+		switch p.From.Name {
+		case obj.NAME_AUTO:
+			p.From.Offset += int64(framesize)
+		case obj.NAME_PARAM:
+			p.From.Reg = REG_SP
+			p.From.Offset += int64(framesize) + 8 // parameters are after the frame and the 8-byte return address
+		}
+
+		switch p.To.Name {
+		case obj.NAME_AUTO:
+			p.To.Offset += int64(framesize)
+		case obj.NAME_PARAM:
+			p.To.Reg = REG_SP
+			p.To.Offset += int64(framesize) + 8 // parameters are after the frame and the 8-byte return address
+		}
+
+		switch p.As {
+		case AGet:
+			if p.From.Type == obj.TYPE_ADDR {
+				get := *p
+				p.As = obj.ANOP
+
+				switch get.From.Name {
+				case obj.NAME_EXTERN:
+					p = appendp(p, AI64Const, get.From)
+				case obj.NAME_AUTO, obj.NAME_PARAM:
+					p = appendp(p, AGet, regAddr(get.From.Reg))
+					if get.From.Reg == REG_SP {
+						p = appendp(p, AI64ExtendI32U)
+					}
+					if get.From.Offset != 0 {
+						p = appendp(p, AI64Const, constAddr(get.From.Offset))
+						p = appendp(p, AI64Add)
+					}
+				default:
+					panic("bad Get: invalid name")
+				}
+			}
+
+		case AI32Load, AI64Load, AF32Load, AF64Load, AI32Load8S, AI32Load8U, AI32Load16S, AI32Load16U, AI64Load8S, AI64Load8U, AI64Load16S, AI64Load16U, AI64Load32S, AI64Load32U:
+			if p.From.Type == obj.TYPE_MEM {
+				as := p.As
+				from := p.From
+
+				p.As = AGet
+				p.From = regAddr(from.Reg)
+
+				if from.Reg != REG_SP {
+					p = appendp(p, AI32WrapI64)
+				}
+
+				p = appendp(p, as, constAddr(from.Offset))
+			}
+
+		case AMOVB, AMOVH, AMOVW, AMOVD:
+			mov := *p
+			p.As = obj.ANOP
+
+			var loadAs obj.As
+			var storeAs obj.As
+			switch mov.As {
+			case AMOVB:
+				loadAs = AI64Load8U
+				storeAs = AI64Store8
+			case AMOVH:
+				loadAs = AI64Load16U
+				storeAs = AI64Store16
+			case AMOVW:
+				loadAs = AI64Load32U
+				storeAs = AI64Store32
+			case AMOVD:
+				loadAs = AI64Load
+				storeAs = AI64Store
+			}
+
+			appendValue := func() {
+				switch mov.From.Type {
+				case obj.TYPE_CONST:
+					p = appendp(p, AI64Const, constAddr(mov.From.Offset))
+
+				case obj.TYPE_ADDR:
+					switch mov.From.Name {
+					case obj.NAME_NONE, obj.NAME_PARAM, obj.NAME_AUTO:
+						p = appendp(p, AGet, regAddr(mov.From.Reg))
+						if mov.From.Reg == REG_SP {
+							p = appendp(p, AI64ExtendI32U)
+						}
+						p = appendp(p, AI64Const, constAddr(mov.From.Offset))
+						p = appendp(p, AI64Add)
+					case obj.NAME_EXTERN:
+						p = appendp(p, AI64Const, mov.From)
+					default:
+						panic("bad name for MOV")
+					}
+
+				case obj.TYPE_REG:
+					p = appendp(p, AGet, mov.From)
+					if mov.From.Reg == REG_SP {
+						p = appendp(p, AI64ExtendI32U)
+					}
+
+				case obj.TYPE_MEM:
+					p = appendp(p, AGet, regAddr(mov.From.Reg))
+					if mov.From.Reg != REG_SP {
+						p = appendp(p, AI32WrapI64)
+					}
+					p = appendp(p, loadAs, constAddr(mov.From.Offset))
+
+				default:
+					panic("bad MOV type")
+				}
+			}
+
+			switch mov.To.Type {
+			case obj.TYPE_REG:
+				appendValue()
+				if mov.To.Reg == REG_SP {
+					p = appendp(p, AI32WrapI64)
+				}
+				p = appendp(p, ASet, mov.To)
+
+			case obj.TYPE_MEM:
+				switch mov.To.Name {
+				case obj.NAME_NONE, obj.NAME_PARAM:
+					p = appendp(p, AGet, regAddr(mov.To.Reg))
+					if mov.To.Reg != REG_SP {
+						p = appendp(p, AI32WrapI64)
+					}
+				case obj.NAME_EXTERN:
+					p = appendp(p, AI32Const, obj.Addr{Type: obj.TYPE_ADDR, Name: obj.NAME_EXTERN, Sym: mov.To.Sym})
+				default:
+					panic("bad MOV name")
+				}
+				appendValue()
+				p = appendp(p, storeAs, constAddr(mov.To.Offset))
+
+			default:
+				panic("bad MOV type")
+			}
+
+		case ACallImport:
+			p.As = obj.ANOP
+			p = appendp(p, AGet, regAddr(REG_SP))
+			p = appendp(p, ACall, obj.Addr{Type: obj.TYPE_MEM, Name: obj.NAME_EXTERN, Sym: s})
+			p.Mark = WasmImport
+		}
+	}
+
+	{
+		p := s.Func.Text
+		if len(unwindExitBranches) > 0 {
+			p = appendp(p, ABlock) // unwindExit, used to return 1 when unwinding the stack
+			for _, b := range unwindExitBranches {
+				b.To = obj.Addr{Type: obj.TYPE_BRANCH, Val: p}
+			}
+		}
+		if len(entryPointLoopBranches) > 0 {
+			p = appendp(p, ALoop) // entryPointLoop, used to jump between basic blocks
+			for _, b := range entryPointLoopBranches {
+				b.To = obj.Addr{Type: obj.TYPE_BRANCH, Val: p}
+			}
+		}
+		if numResumePoints > 0 {
+			// Add Block instructions for resume points and BrTable to jump to selected resume point.
+			for i := 0; i < numResumePoints+1; i++ {
+				p = appendp(p, ABlock)
+			}
+			p = appendp(p, AGet, regAddr(REG_PC_B)) // read next basic block from PC_B
+			p = appendp(p, ABrTable, obj.Addr{Val: tableIdxs})
+			p = appendp(p, AEnd) // end of Block
+		}
+		for p.Link != nil {
+			p = p.Link // function instructions
+		}
+		if len(entryPointLoopBranches) > 0 {
+			p = appendp(p, AEnd) // end of entryPointLoop
+		}
+		p = appendp(p, obj.AUNDEF)
+		if len(unwindExitBranches) > 0 {
+			p = appendp(p, AEnd) // end of unwindExit
+			p = appendp(p, AI32Const, constAddr(1))
+		}
+	}
+
+	currentDepth = 0
+	blockDepths := make(map[*obj.Prog]int)
+	for p := s.Func.Text; p != nil; p = p.Link {
+		switch p.As {
+		case ABlock, ALoop, AIf:
+			currentDepth++
+			blockDepths[p] = currentDepth
+		case AEnd:
+			currentDepth--
+		}
+
+		switch p.As {
+		case ABr, ABrIf:
+			if p.To.Type == obj.TYPE_BRANCH {
+				blockDepth, ok := blockDepths[p.To.Val.(*obj.Prog)]
+				if !ok {
+					panic("label not at block")
+				}
+				p.To = constAddr(int64(currentDepth - blockDepth))
+			}
+		}
+	}
+}
+
+func constAddr(value int64) obj.Addr {
+	return obj.Addr{Type: obj.TYPE_CONST, Offset: value}
+}
+
+func regAddr(reg int16) obj.Addr {
+	return obj.Addr{Type: obj.TYPE_REG, Reg: reg}
+}
+
+// Most of the Go functions has a single parameter (PC_B) in
+// Wasm ABI. This is a list of exceptions.
+var notUsePC_B = map[string]bool{
+	"_rt0_wasm_js":           true,
+	"wasm_export_run":        true,
+	"wasm_export_resume":     true,
+	"wasm_export_getsp":      true,
+	"wasm_pc_f_loop":         true,
+	"runtime.wasmMove":       true,
+	"runtime.wasmZero":       true,
+	"runtime.wasmDiv":        true,
+	"runtime.wasmTruncS":     true,
+	"runtime.wasmTruncU":     true,
+	"runtime.gcWriteBarrier": true,
+	"cmpbody":                true,
+	"memeqbody":              true,
+	"memcmp":                 true,
+	"memchr":                 true,
+}
+
+func assemble(ctxt *obj.Link, s *obj.LSym, newprog obj.ProgAlloc) {
+	type regVar struct {
+		global bool
+		index  uint64
+	}
+
+	type varDecl struct {
+		count uint64
+		typ   valueType
+	}
+
+	hasLocalSP := false
+	regVars := [MAXREG - MINREG]*regVar{
+		REG_SP - MINREG:    {true, 0},
+		REG_CTXT - MINREG:  {true, 1},
+		REG_g - MINREG:     {true, 2},
+		REG_RET0 - MINREG:  {true, 3},
+		REG_RET1 - MINREG:  {true, 4},
+		REG_RET2 - MINREG:  {true, 5},
+		REG_RET3 - MINREG:  {true, 6},
+		REG_PAUSE - MINREG: {true, 7},
+	}
+	var varDecls []*varDecl
+	useAssemblyRegMap := func() {
+		for i := int16(0); i < 16; i++ {
+			regVars[REG_R0+i-MINREG] = &regVar{false, uint64(i)}
+		}
+	}
+
+	// Function starts with declaration of locals: numbers and types.
+	// Some functions use a special calling convention.
+	switch s.Name {
+	case "_rt0_wasm_js", "wasm_export_run", "wasm_export_resume", "wasm_export_getsp", "wasm_pc_f_loop",
+		"runtime.wasmMove", "runtime.wasmZero", "runtime.wasmDiv", "runtime.wasmTruncS", "runtime.wasmTruncU", "memeqbody":
+		varDecls = []*varDecl{}
+		useAssemblyRegMap()
+	case "memchr", "memcmp":
+		varDecls = []*varDecl{{count: 2, typ: i32}}
+		useAssemblyRegMap()
+	case "cmpbody":
+		varDecls = []*varDecl{{count: 2, typ: i64}}
+		useAssemblyRegMap()
+	case "runtime.gcWriteBarrier":
+		varDecls = []*varDecl{{count: 4, typ: i64}}
+		useAssemblyRegMap()
+	default:
+		// Normal calling convention: PC_B as WebAssembly parameter. First local variable is local SP cache.
+		regVars[REG_PC_B-MINREG] = &regVar{false, 0}
+		hasLocalSP = true
+
+		var regUsed [MAXREG - MINREG]bool
+		for p := s.Func.Text; p != nil; p = p.Link {
+			if p.From.Reg != 0 {
+				regUsed[p.From.Reg-MINREG] = true
+			}
+			if p.To.Reg != 0 {
+				regUsed[p.To.Reg-MINREG] = true
+			}
+		}
+
+		regs := []int16{REG_SP}
+		for reg := int16(REG_R0); reg <= REG_F31; reg++ {
+			if regUsed[reg-MINREG] {
+				regs = append(regs, reg)
+			}
+		}
+
+		var lastDecl *varDecl
+		for i, reg := range regs {
+			t := regType(reg)
+			if lastDecl == nil || lastDecl.typ != t {
+				lastDecl = &varDecl{
+					count: 0,
+					typ:   t,
+				}
+				varDecls = append(varDecls, lastDecl)
+			}
+			lastDecl.count++
+			if reg != REG_SP {
+				regVars[reg-MINREG] = &regVar{false, 1 + uint64(i)}
+			}
+		}
+	}
+
+	w := new(bytes.Buffer)
+
+	writeUleb128(w, uint64(len(varDecls)))
+	for _, decl := range varDecls {
+		writeUleb128(w, decl.count)
+		w.WriteByte(byte(decl.typ))
+	}
+
+	if hasLocalSP {
+		// Copy SP from its global variable into a local variable. Accessing a local variable is more efficient.
+		updateLocalSP(w)
+	}
+
+	for p := s.Func.Text; p != nil; p = p.Link {
+		switch p.As {
+		case AGet:
+			if p.From.Type != obj.TYPE_REG {
+				panic("bad Get: argument is not a register")
+			}
+			reg := p.From.Reg
+			v := regVars[reg-MINREG]
+			if v == nil {
+				panic("bad Get: invalid register")
+			}
+			if reg == REG_SP && hasLocalSP {
+				writeOpcode(w, ALocalGet)
+				writeUleb128(w, 1) // local SP
+				continue
+			}
+			if v.global {
+				writeOpcode(w, AGlobalGet)
+			} else {
+				writeOpcode(w, ALocalGet)
+			}
+			writeUleb128(w, v.index)
+			continue
+
+		case ASet:
+			if p.To.Type != obj.TYPE_REG {
+				panic("bad Set: argument is not a register")
+			}
+			reg := p.To.Reg
+			v := regVars[reg-MINREG]
+			if v == nil {
+				panic("bad Set: invalid register")
+			}
+			if reg == REG_SP && hasLocalSP {
+				writeOpcode(w, ALocalTee)
+				writeUleb128(w, 1) // local SP
+			}
+			if v.global {
+				writeOpcode(w, AGlobalSet)
+			} else {
+				if p.Link.As == AGet && p.Link.From.Reg == reg {
+					writeOpcode(w, ALocalTee)
+					p = p.Link
+				} else {
+					writeOpcode(w, ALocalSet)
+				}
+			}
+			writeUleb128(w, v.index)
+			continue
+
+		case ATee:
+			if p.To.Type != obj.TYPE_REG {
+				panic("bad Tee: argument is not a register")
+			}
+			reg := p.To.Reg
+			v := regVars[reg-MINREG]
+			if v == nil {
+				panic("bad Tee: invalid register")
+			}
+			writeOpcode(w, ALocalTee)
+			writeUleb128(w, v.index)
+			continue
+
+		case ANot:
+			writeOpcode(w, AI32Eqz)
+			continue
+
+		case obj.AUNDEF:
+			writeOpcode(w, AUnreachable)
+			continue
+
+		case obj.ANOP, obj.ATEXT, obj.AFUNCDATA, obj.APCDATA:
+			// ignore
+			continue
+		}
+
+		writeOpcode(w, p.As)
+
+		switch p.As {
+		case ABlock, ALoop, AIf:
+			if p.From.Offset != 0 {
+				// block type, rarely used, e.g. for code compiled with emscripten
+				w.WriteByte(0x80 - byte(p.From.Offset))
+				continue
+			}
+			w.WriteByte(0x40)
+
+		case ABr, ABrIf:
+			if p.To.Type != obj.TYPE_CONST {
+				panic("bad Br/BrIf")
+			}
+			writeUleb128(w, uint64(p.To.Offset))
+
+		case ABrTable:
+			idxs := p.To.Val.([]uint64)
+			writeUleb128(w, uint64(len(idxs)-1))
+			for _, idx := range idxs {
+				writeUleb128(w, idx)
+			}
+
+		case ACall:
+			switch p.To.Type {
+			case obj.TYPE_CONST:
+				writeUleb128(w, uint64(p.To.Offset))
+
+			case obj.TYPE_MEM:
+				if p.To.Name != obj.NAME_EXTERN && p.To.Name != obj.NAME_STATIC {
+					fmt.Println(p.To)
+					panic("bad name for Call")
+				}
+				r := obj.Addrel(s)
+				r.Off = int32(w.Len())
+				r.Type = objabi.R_CALL
+				if p.Mark&WasmImport != 0 {
+					r.Type = objabi.R_WASMIMPORT
+				}
+				r.Sym = p.To.Sym
+				if hasLocalSP {
+					// The stack may have moved, which changes SP. Update the local SP variable.
+					updateLocalSP(w)
+				}
+
+			default:
+				panic("bad type for Call")
+			}
+
+		case ACallIndirect:
+			writeUleb128(w, uint64(p.To.Offset))
+			w.WriteByte(0x00) // reserved value
+			if hasLocalSP {
+				// The stack may have moved, which changes SP. Update the local SP variable.
+				updateLocalSP(w)
+			}
+
+		case AI32Const, AI64Const:
+			if p.From.Name == obj.NAME_EXTERN {
+				r := obj.Addrel(s)
+				r.Off = int32(w.Len())
+				r.Type = objabi.R_ADDR
+				r.Sym = p.From.Sym
+				r.Add = p.From.Offset
+				break
+			}
+			writeSleb128(w, p.From.Offset)
+
+		case AF32Const:
+			b := make([]byte, 4)
+			binary.LittleEndian.PutUint32(b, math.Float32bits(float32(p.From.Val.(float64))))
+			w.Write(b)
+
+		case AF64Const:
+			b := make([]byte, 8)
+			binary.LittleEndian.PutUint64(b, math.Float64bits(p.From.Val.(float64)))
+			w.Write(b)
+
+		case AI32Load, AI64Load, AF32Load, AF64Load, AI32Load8S, AI32Load8U, AI32Load16S, AI32Load16U, AI64Load8S, AI64Load8U, AI64Load16S, AI64Load16U, AI64Load32S, AI64Load32U:
+			if p.From.Offset < 0 {
+				panic("negative offset for *Load")
+			}
+			if p.From.Type != obj.TYPE_CONST {
+				panic("bad type for *Load")
+			}
+			if p.From.Offset > math.MaxUint32 {
+				ctxt.Diag("bad offset in %v", p)
+			}
+			writeUleb128(w, align(p.As))
+			writeUleb128(w, uint64(p.From.Offset))
+
+		case AI32Store, AI64Store, AF32Store, AF64Store, AI32Store8, AI32Store16, AI64Store8, AI64Store16, AI64Store32:
+			if p.To.Offset < 0 {
+				panic("negative offset")
+			}
+			if p.From.Offset > math.MaxUint32 {
+				ctxt.Diag("bad offset in %v", p)
+			}
+			writeUleb128(w, align(p.As))
+			writeUleb128(w, uint64(p.To.Offset))
+
+		case ACurrentMemory, AGrowMemory:
+			w.WriteByte(0x00)
+
+		}
+	}
+
+	w.WriteByte(0x0b) // end
+
+	s.P = w.Bytes()
+}
+
+func updateLocalSP(w *bytes.Buffer) {
+	writeOpcode(w, AGlobalGet)
+	writeUleb128(w, 0) // global SP
+	writeOpcode(w, ALocalSet)
+	writeUleb128(w, 1) // local SP
+}
+
+func writeOpcode(w *bytes.Buffer, as obj.As) {
+	switch {
+	case as < AUnreachable:
+		panic(fmt.Sprintf("unexpected assembler op: %s", as))
+	case as < AEnd:
+		w.WriteByte(byte(as - AUnreachable + 0x00))
+	case as < ADrop:
+		w.WriteByte(byte(as - AEnd + 0x0B))
+	case as < ALocalGet:
+		w.WriteByte(byte(as - ADrop + 0x1A))
+	case as < AI32Load:
+		w.WriteByte(byte(as - ALocalGet + 0x20))
+	case as < AI32TruncSatF32S:
+		w.WriteByte(byte(as - AI32Load + 0x28))
+	case as < ALast:
+		w.WriteByte(0xFC)
+		w.WriteByte(byte(as - AI32TruncSatF32S + 0x00))
+	default:
+		panic(fmt.Sprintf("unexpected assembler op: %s", as))
+	}
+}
+
+type valueType byte
+
+const (
+	i32 valueType = 0x7F
+	i64 valueType = 0x7E
+	f32 valueType = 0x7D
+	f64 valueType = 0x7C
+)
+
+func regType(reg int16) valueType {
+	switch {
+	case reg == REG_SP:
+		return i32
+	case reg >= REG_R0 && reg <= REG_R15:
+		return i64
+	case reg >= REG_F0 && reg <= REG_F15:
+		return f32
+	case reg >= REG_F16 && reg <= REG_F31:
+		return f64
+	default:
+		panic("invalid register")
+	}
+}
+
+func align(as obj.As) uint64 {
+	switch as {
+	case AI32Load8S, AI32Load8U, AI64Load8S, AI64Load8U, AI32Store8, AI64Store8:
+		return 0
+	case AI32Load16S, AI32Load16U, AI64Load16S, AI64Load16U, AI32Store16, AI64Store16:
+		return 1
+	case AI32Load, AF32Load, AI64Load32S, AI64Load32U, AI32Store, AF32Store, AI64Store32:
+		return 2
+	case AI64Load, AF64Load, AI64Store, AF64Store:
+		return 3
+	default:
+		panic("align: bad op")
+	}
+}
+
+func writeUleb128(w io.ByteWriter, v uint64) {
+	if v < 128 {
+		w.WriteByte(uint8(v))
+		return
+	}
+	more := true
+	for more {
+		c := uint8(v & 0x7f)
+		v >>= 7
+		more = v != 0
+		if more {
+			c |= 0x80
+		}
+		w.WriteByte(c)
+	}
+}
+
+func writeSleb128(w io.ByteWriter, v int64) {
+	more := true
+	for more {
+		c := uint8(v & 0x7f)
+		s := uint8(v & 0x40)
+		v >>= 7
+		more = !((v == 0 && s == 0) || (v == -1 && s != 0))
+		if more {
+			c |= 0x80
+		}
+		w.WriteByte(c)
+	}
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/a.out.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/a.out.go
new file mode 100644
index 000000000..4624973cc
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/a.out.go
@@ -0,0 +1,423 @@
+// Inferno utils/6c/6.out.h
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6c/6.out.h
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package x86
+
+import "github.com/twitchyliquid64/golang-asm/obj"
+
+const (
+	REG_NONE = 0
+)
+
+const (
+	REG_AL = obj.RBaseAMD64 + iota
+	REG_CL
+	REG_DL
+	REG_BL
+	REG_SPB
+	REG_BPB
+	REG_SIB
+	REG_DIB
+	REG_R8B
+	REG_R9B
+	REG_R10B
+	REG_R11B
+	REG_R12B
+	REG_R13B
+	REG_R14B
+	REG_R15B
+
+	REG_AX
+	REG_CX
+	REG_DX
+	REG_BX
+	REG_SP
+	REG_BP
+	REG_SI
+	REG_DI
+	REG_R8
+	REG_R9
+	REG_R10
+	REG_R11
+	REG_R12
+	REG_R13
+	REG_R14
+	REG_R15
+
+	REG_AH
+	REG_CH
+	REG_DH
+	REG_BH
+
+	REG_F0
+	REG_F1
+	REG_F2
+	REG_F3
+	REG_F4
+	REG_F5
+	REG_F6
+	REG_F7
+
+	REG_M0
+	REG_M1
+	REG_M2
+	REG_M3
+	REG_M4
+	REG_M5
+	REG_M6
+	REG_M7
+
+	REG_K0
+	REG_K1
+	REG_K2
+	REG_K3
+	REG_K4
+	REG_K5
+	REG_K6
+	REG_K7
+
+	REG_X0
+	REG_X1
+	REG_X2
+	REG_X3
+	REG_X4
+	REG_X5
+	REG_X6
+	REG_X7
+	REG_X8
+	REG_X9
+	REG_X10
+	REG_X11
+	REG_X12
+	REG_X13
+	REG_X14
+	REG_X15
+	REG_X16
+	REG_X17
+	REG_X18
+	REG_X19
+	REG_X20
+	REG_X21
+	REG_X22
+	REG_X23
+	REG_X24
+	REG_X25
+	REG_X26
+	REG_X27
+	REG_X28
+	REG_X29
+	REG_X30
+	REG_X31
+
+	REG_Y0
+	REG_Y1
+	REG_Y2
+	REG_Y3
+	REG_Y4
+	REG_Y5
+	REG_Y6
+	REG_Y7
+	REG_Y8
+	REG_Y9
+	REG_Y10
+	REG_Y11
+	REG_Y12
+	REG_Y13
+	REG_Y14
+	REG_Y15
+	REG_Y16
+	REG_Y17
+	REG_Y18
+	REG_Y19
+	REG_Y20
+	REG_Y21
+	REG_Y22
+	REG_Y23
+	REG_Y24
+	REG_Y25
+	REG_Y26
+	REG_Y27
+	REG_Y28
+	REG_Y29
+	REG_Y30
+	REG_Y31
+
+	REG_Z0
+	REG_Z1
+	REG_Z2
+	REG_Z3
+	REG_Z4
+	REG_Z5
+	REG_Z6
+	REG_Z7
+	REG_Z8
+	REG_Z9
+	REG_Z10
+	REG_Z11
+	REG_Z12
+	REG_Z13
+	REG_Z14
+	REG_Z15
+	REG_Z16
+	REG_Z17
+	REG_Z18
+	REG_Z19
+	REG_Z20
+	REG_Z21
+	REG_Z22
+	REG_Z23
+	REG_Z24
+	REG_Z25
+	REG_Z26
+	REG_Z27
+	REG_Z28
+	REG_Z29
+	REG_Z30
+	REG_Z31
+
+	REG_CS
+	REG_SS
+	REG_DS
+	REG_ES
+	REG_FS
+	REG_GS
+
+	REG_GDTR // global descriptor table register
+	REG_IDTR // interrupt descriptor table register
+	REG_LDTR // local descriptor table register
+	REG_MSW  // machine status word
+	REG_TASK // task register
+
+	REG_CR0
+	REG_CR1
+	REG_CR2
+	REG_CR3
+	REG_CR4
+	REG_CR5
+	REG_CR6
+	REG_CR7
+	REG_CR8
+	REG_CR9
+	REG_CR10
+	REG_CR11
+	REG_CR12
+	REG_CR13
+	REG_CR14
+	REG_CR15
+
+	REG_DR0
+	REG_DR1
+	REG_DR2
+	REG_DR3
+	REG_DR4
+	REG_DR5
+	REG_DR6
+	REG_DR7
+
+	REG_TR0
+	REG_TR1
+	REG_TR2
+	REG_TR3
+	REG_TR4
+	REG_TR5
+	REG_TR6
+	REG_TR7
+
+	REG_TLS
+
+	MAXREG
+
+	REG_CR = REG_CR0
+	REG_DR = REG_DR0
+	REG_TR = REG_TR0
+
+	REGARG   = -1
+	REGRET   = REG_AX
+	FREGRET  = REG_X0
+	REGSP    = REG_SP
+	REGCTXT  = REG_DX
+	REGEXT   = REG_R15     // compiler allocates external registers R15 down
+	FREGMIN  = REG_X0 + 5  // first register variable
+	FREGEXT  = REG_X0 + 15 // first external register
+	T_TYPE   = 1 << 0
+	T_INDEX  = 1 << 1
+	T_OFFSET = 1 << 2
+	T_FCONST = 1 << 3
+	T_SYM    = 1 << 4
+	T_SCONST = 1 << 5
+	T_64     = 1 << 6
+	T_GOTYPE = 1 << 7
+)
+
+// https://www.uclibc.org/docs/psABI-x86_64.pdf, figure 3.36
+var AMD64DWARFRegisters = map[int16]int16{
+	REG_AX:  0,
+	REG_DX:  1,
+	REG_CX:  2,
+	REG_BX:  3,
+	REG_SI:  4,
+	REG_DI:  5,
+	REG_BP:  6,
+	REG_SP:  7,
+	REG_R8:  8,
+	REG_R9:  9,
+	REG_R10: 10,
+	REG_R11: 11,
+	REG_R12: 12,
+	REG_R13: 13,
+	REG_R14: 14,
+	REG_R15: 15,
+	// 16 is "Return Address RA", whatever that is.
+	// 17-24 vector registers (X/Y/Z).
+	REG_X0: 17,
+	REG_X1: 18,
+	REG_X2: 19,
+	REG_X3: 20,
+	REG_X4: 21,
+	REG_X5: 22,
+	REG_X6: 23,
+	REG_X7: 24,
+	// 25-32 extended vector registers (X/Y/Z).
+	REG_X8:  25,
+	REG_X9:  26,
+	REG_X10: 27,
+	REG_X11: 28,
+	REG_X12: 29,
+	REG_X13: 30,
+	REG_X14: 31,
+	REG_X15: 32,
+	// ST registers. %stN => FN.
+	REG_F0: 33,
+	REG_F1: 34,
+	REG_F2: 35,
+	REG_F3: 36,
+	REG_F4: 37,
+	REG_F5: 38,
+	REG_F6: 39,
+	REG_F7: 40,
+	// MMX registers. %mmN => MN.
+	REG_M0: 41,
+	REG_M1: 42,
+	REG_M2: 43,
+	REG_M3: 44,
+	REG_M4: 45,
+	REG_M5: 46,
+	REG_M6: 47,
+	REG_M7: 48,
+	// 48 is flags, which doesn't have a name.
+	REG_ES: 50,
+	REG_CS: 51,
+	REG_SS: 52,
+	REG_DS: 53,
+	REG_FS: 54,
+	REG_GS: 55,
+	// 58 and 59 are {fs,gs}base, which don't have names.
+	REG_TR:   62,
+	REG_LDTR: 63,
+	// 64-66 are mxcsr, fcw, fsw, which don't have names.
+
+	// 67-82 upper vector registers (X/Y/Z).
+	REG_X16: 67,
+	REG_X17: 68,
+	REG_X18: 69,
+	REG_X19: 70,
+	REG_X20: 71,
+	REG_X21: 72,
+	REG_X22: 73,
+	REG_X23: 74,
+	REG_X24: 75,
+	REG_X25: 76,
+	REG_X26: 77,
+	REG_X27: 78,
+	REG_X28: 79,
+	REG_X29: 80,
+	REG_X30: 81,
+	REG_X31: 82,
+
+	// 118-125 vector mask registers. %kN => KN.
+	REG_K0: 118,
+	REG_K1: 119,
+	REG_K2: 120,
+	REG_K3: 121,
+	REG_K4: 122,
+	REG_K5: 123,
+	REG_K6: 124,
+	REG_K7: 125,
+}
+
+// https://www.uclibc.org/docs/psABI-i386.pdf, table 2.14
+var X86DWARFRegisters = map[int16]int16{
+	REG_AX: 0,
+	REG_CX: 1,
+	REG_DX: 2,
+	REG_BX: 3,
+	REG_SP: 4,
+	REG_BP: 5,
+	REG_SI: 6,
+	REG_DI: 7,
+	// 8 is "Return Address RA", whatever that is.
+	// 9 is flags, which doesn't have a name.
+	// ST registers. %stN => FN.
+	REG_F0: 11,
+	REG_F1: 12,
+	REG_F2: 13,
+	REG_F3: 14,
+	REG_F4: 15,
+	REG_F5: 16,
+	REG_F6: 17,
+	REG_F7: 18,
+	// XMM registers. %xmmN => XN.
+	REG_X0: 21,
+	REG_X1: 22,
+	REG_X2: 23,
+	REG_X3: 24,
+	REG_X4: 25,
+	REG_X5: 26,
+	REG_X6: 27,
+	REG_X7: 28,
+	// MMX registers. %mmN => MN.
+	REG_M0: 29,
+	REG_M1: 30,
+	REG_M2: 31,
+	REG_M3: 32,
+	REG_M4: 33,
+	REG_M5: 34,
+	REG_M6: 35,
+	REG_M7: 36,
+	// 39 is mxcsr, which doesn't have a name.
+	REG_ES:   40,
+	REG_CS:   41,
+	REG_SS:   42,
+	REG_DS:   43,
+	REG_FS:   44,
+	REG_GS:   45,
+	REG_TR:   48,
+	REG_LDTR: 49,
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/aenum.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/aenum.go
new file mode 100644
index 000000000..9b5997fee
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/aenum.go
@@ -0,0 +1,1609 @@
+// Code generated by x86avxgen. DO NOT EDIT.
+
+package x86
+
+import "github.com/twitchyliquid64/golang-asm/obj"
+
+//go:generate go run ../stringer.go -i $GOFILE -o anames.go -p x86
+
+const (
+	AAAA = obj.ABaseAMD64 + obj.A_ARCHSPECIFIC + iota
+	AAAD
+	AAAM
+	AAAS
+	AADCB
+	AADCL
+	AADCQ
+	AADCW
+	AADCXL
+	AADCXQ
+	AADDB
+	AADDL
+	AADDPD
+	AADDPS
+	AADDQ
+	AADDSD
+	AADDSS
+	AADDSUBPD
+	AADDSUBPS
+	AADDW
+	AADJSP
+	AADOXL
+	AADOXQ
+	AAESDEC
+	AAESDECLAST
+	AAESENC
+	AAESENCLAST
+	AAESIMC
+	AAESKEYGENASSIST
+	AANDB
+	AANDL
+	AANDNL
+	AANDNPD
+	AANDNPS
+	AANDNQ
+	AANDPD
+	AANDPS
+	AANDQ
+	AANDW
+	AARPL
+	ABEXTRL
+	ABEXTRQ
+	ABLENDPD
+	ABLENDPS
+	ABLENDVPD
+	ABLENDVPS
+	ABLSIL
+	ABLSIQ
+	ABLSMSKL
+	ABLSMSKQ
+	ABLSRL
+	ABLSRQ
+	ABOUNDL
+	ABOUNDW
+	ABSFL
+	ABSFQ
+	ABSFW
+	ABSRL
+	ABSRQ
+	ABSRW
+	ABSWAPL
+	ABSWAPQ
+	ABTCL
+	ABTCQ
+	ABTCW
+	ABTL
+	ABTQ
+	ABTRL
+	ABTRQ
+	ABTRW
+	ABTSL
+	ABTSQ
+	ABTSW
+	ABTW
+	ABYTE
+	ABZHIL
+	ABZHIQ
+	ACBW
+	ACDQ
+	ACDQE
+	ACLAC
+	ACLC
+	ACLD
+	ACLDEMOTE
+	ACLFLUSH
+	ACLFLUSHOPT
+	ACLI
+	ACLTS
+	ACLWB
+	ACMC
+	ACMOVLCC
+	ACMOVLCS
+	ACMOVLEQ
+	ACMOVLGE
+	ACMOVLGT
+	ACMOVLHI
+	ACMOVLLE
+	ACMOVLLS
+	ACMOVLLT
+	ACMOVLMI
+	ACMOVLNE
+	ACMOVLOC
+	ACMOVLOS
+	ACMOVLPC
+	ACMOVLPL
+	ACMOVLPS
+	ACMOVQCC
+	ACMOVQCS
+	ACMOVQEQ
+	ACMOVQGE
+	ACMOVQGT
+	ACMOVQHI
+	ACMOVQLE
+	ACMOVQLS
+	ACMOVQLT
+	ACMOVQMI
+	ACMOVQNE
+	ACMOVQOC
+	ACMOVQOS
+	ACMOVQPC
+	ACMOVQPL
+	ACMOVQPS
+	ACMOVWCC
+	ACMOVWCS
+	ACMOVWEQ
+	ACMOVWGE
+	ACMOVWGT
+	ACMOVWHI
+	ACMOVWLE
+	ACMOVWLS
+	ACMOVWLT
+	ACMOVWMI
+	ACMOVWNE
+	ACMOVWOC
+	ACMOVWOS
+	ACMOVWPC
+	ACMOVWPL
+	ACMOVWPS
+	ACMPB
+	ACMPL
+	ACMPPD
+	ACMPPS
+	ACMPQ
+	ACMPSB
+	ACMPSD
+	ACMPSL
+	ACMPSQ
+	ACMPSS
+	ACMPSW
+	ACMPW
+	ACMPXCHG16B
+	ACMPXCHG8B
+	ACMPXCHGB
+	ACMPXCHGL
+	ACMPXCHGQ
+	ACMPXCHGW
+	ACOMISD
+	ACOMISS
+	ACPUID
+	ACQO
+	ACRC32B
+	ACRC32L
+	ACRC32Q
+	ACRC32W
+	ACVTPD2PL
+	ACVTPD2PS
+	ACVTPL2PD
+	ACVTPL2PS
+	ACVTPS2PD
+	ACVTPS2PL
+	ACVTSD2SL
+	ACVTSD2SQ
+	ACVTSD2SS
+	ACVTSL2SD
+	ACVTSL2SS
+	ACVTSQ2SD
+	ACVTSQ2SS
+	ACVTSS2SD
+	ACVTSS2SL
+	ACVTSS2SQ
+	ACVTTPD2PL
+	ACVTTPS2PL
+	ACVTTSD2SL
+	ACVTTSD2SQ
+	ACVTTSS2SL
+	ACVTTSS2SQ
+	ACWD
+	ACWDE
+	ADAA
+	ADAS
+	ADECB
+	ADECL
+	ADECQ
+	ADECW
+	ADIVB
+	ADIVL
+	ADIVPD
+	ADIVPS
+	ADIVQ
+	ADIVSD
+	ADIVSS
+	ADIVW
+	ADPPD
+	ADPPS
+	AEMMS
+	AENTER
+	AEXTRACTPS
+	AF2XM1
+	AFABS
+	AFADDD
+	AFADDDP
+	AFADDF
+	AFADDL
+	AFADDW
+	AFBLD
+	AFBSTP
+	AFCHS
+	AFCLEX
+	AFCMOVB
+	AFCMOVBE
+	AFCMOVCC
+	AFCMOVCS
+	AFCMOVE
+	AFCMOVEQ
+	AFCMOVHI
+	AFCMOVLS
+	AFCMOVNB
+	AFCMOVNBE
+	AFCMOVNE
+	AFCMOVNU
+	AFCMOVU
+	AFCMOVUN
+	AFCOMD
+	AFCOMDP
+	AFCOMDPP
+	AFCOMF
+	AFCOMFP
+	AFCOMI
+	AFCOMIP
+	AFCOML
+	AFCOMLP
+	AFCOMW
+	AFCOMWP
+	AFCOS
+	AFDECSTP
+	AFDIVD
+	AFDIVDP
+	AFDIVF
+	AFDIVL
+	AFDIVRD
+	AFDIVRDP
+	AFDIVRF
+	AFDIVRL
+	AFDIVRW
+	AFDIVW
+	AFFREE
+	AFINCSTP
+	AFINIT
+	AFLD1
+	AFLDCW
+	AFLDENV
+	AFLDL2E
+	AFLDL2T
+	AFLDLG2
+	AFLDLN2
+	AFLDPI
+	AFLDZ
+	AFMOVB
+	AFMOVBP
+	AFMOVD
+	AFMOVDP
+	AFMOVF
+	AFMOVFP
+	AFMOVL
+	AFMOVLP
+	AFMOVV
+	AFMOVVP
+	AFMOVW
+	AFMOVWP
+	AFMOVX
+	AFMOVXP
+	AFMULD
+	AFMULDP
+	AFMULF
+	AFMULL
+	AFMULW
+	AFNOP
+	AFPATAN
+	AFPREM
+	AFPREM1
+	AFPTAN
+	AFRNDINT
+	AFRSTOR
+	AFSAVE
+	AFSCALE
+	AFSIN
+	AFSINCOS
+	AFSQRT
+	AFSTCW
+	AFSTENV
+	AFSTSW
+	AFSUBD
+	AFSUBDP
+	AFSUBF
+	AFSUBL
+	AFSUBRD
+	AFSUBRDP
+	AFSUBRF
+	AFSUBRL
+	AFSUBRW
+	AFSUBW
+	AFTST
+	AFUCOM
+	AFUCOMI
+	AFUCOMIP
+	AFUCOMP
+	AFUCOMPP
+	AFXAM
+	AFXCHD
+	AFXRSTOR
+	AFXRSTOR64
+	AFXSAVE
+	AFXSAVE64
+	AFXTRACT
+	AFYL2X
+	AFYL2XP1
+	AHADDPD
+	AHADDPS
+	AHLT
+	AHSUBPD
+	AHSUBPS
+	AICEBP
+	AIDIVB
+	AIDIVL
+	AIDIVQ
+	AIDIVW
+	AIMUL3L
+	AIMUL3Q
+	AIMUL3W
+	AIMULB
+	AIMULL
+	AIMULQ
+	AIMULW
+	AINB
+	AINCB
+	AINCL
+	AINCQ
+	AINCW
+	AINL
+	AINSB
+	AINSERTPS
+	AINSL
+	AINSW
+	AINT
+	AINTO
+	AINVD
+	AINVLPG
+	AINVPCID
+	AINW
+	AIRETL
+	AIRETQ
+	AIRETW
+	AJCC // >= unsigned
+	AJCS // < unsigned
+	AJCXZL
+	AJCXZQ
+	AJCXZW
+	AJEQ // == (zero)
+	AJGE // >= signed
+	AJGT // > signed
+	AJHI // > unsigned
+	AJLE // <= signed
+	AJLS // <= unsigned
+	AJLT // < signed
+	AJMI // sign bit set (negative)
+	AJNE // != (nonzero)
+	AJOC // overflow clear
+	AJOS // overflow set
+	AJPC // parity clear
+	AJPL // sign bit clear (positive)
+	AJPS // parity set
+	AKADDB
+	AKADDD
+	AKADDQ
+	AKADDW
+	AKANDB
+	AKANDD
+	AKANDNB
+	AKANDND
+	AKANDNQ
+	AKANDNW
+	AKANDQ
+	AKANDW
+	AKMOVB
+	AKMOVD
+	AKMOVQ
+	AKMOVW
+	AKNOTB
+	AKNOTD
+	AKNOTQ
+	AKNOTW
+	AKORB
+	AKORD
+	AKORQ
+	AKORTESTB
+	AKORTESTD
+	AKORTESTQ
+	AKORTESTW
+	AKORW
+	AKSHIFTLB
+	AKSHIFTLD
+	AKSHIFTLQ
+	AKSHIFTLW
+	AKSHIFTRB
+	AKSHIFTRD
+	AKSHIFTRQ
+	AKSHIFTRW
+	AKTESTB
+	AKTESTD
+	AKTESTQ
+	AKTESTW
+	AKUNPCKBW
+	AKUNPCKDQ
+	AKUNPCKWD
+	AKXNORB
+	AKXNORD
+	AKXNORQ
+	AKXNORW
+	AKXORB
+	AKXORD
+	AKXORQ
+	AKXORW
+	ALAHF
+	ALARL
+	ALARQ
+	ALARW
+	ALDDQU
+	ALDMXCSR
+	ALEAL
+	ALEAQ
+	ALEAVEL
+	ALEAVEQ
+	ALEAVEW
+	ALEAW
+	ALFENCE
+	ALFSL
+	ALFSQ
+	ALFSW
+	ALGDT
+	ALGSL
+	ALGSQ
+	ALGSW
+	ALIDT
+	ALLDT
+	ALMSW
+	ALOCK
+	ALODSB
+	ALODSL
+	ALODSQ
+	ALODSW
+	ALONG
+	ALOOP
+	ALOOPEQ
+	ALOOPNE
+	ALSLL
+	ALSLQ
+	ALSLW
+	ALSSL
+	ALSSQ
+	ALSSW
+	ALTR
+	ALZCNTL
+	ALZCNTQ
+	ALZCNTW
+	AMASKMOVOU
+	AMASKMOVQ
+	AMAXPD
+	AMAXPS
+	AMAXSD
+	AMAXSS
+	AMFENCE
+	AMINPD
+	AMINPS
+	AMINSD
+	AMINSS
+	AMONITOR
+	AMOVAPD
+	AMOVAPS
+	AMOVB
+	AMOVBELL
+	AMOVBEQQ
+	AMOVBEWW
+	AMOVBLSX
+	AMOVBLZX
+	AMOVBQSX
+	AMOVBQZX
+	AMOVBWSX
+	AMOVBWZX
+	AMOVDDUP
+	AMOVHLPS
+	AMOVHPD
+	AMOVHPS
+	AMOVL
+	AMOVLHPS
+	AMOVLPD
+	AMOVLPS
+	AMOVLQSX
+	AMOVLQZX
+	AMOVMSKPD
+	AMOVMSKPS
+	AMOVNTDQA
+	AMOVNTIL
+	AMOVNTIQ
+	AMOVNTO
+	AMOVNTPD
+	AMOVNTPS
+	AMOVNTQ
+	AMOVO
+	AMOVOU
+	AMOVQ
+	AMOVQL
+	AMOVQOZX
+	AMOVSB
+	AMOVSD
+	AMOVSHDUP
+	AMOVSL
+	AMOVSLDUP
+	AMOVSQ
+	AMOVSS
+	AMOVSW
+	AMOVSWW
+	AMOVUPD
+	AMOVUPS
+	AMOVW
+	AMOVWLSX
+	AMOVWLZX
+	AMOVWQSX
+	AMOVWQZX
+	AMOVZWW
+	AMPSADBW
+	AMULB
+	AMULL
+	AMULPD
+	AMULPS
+	AMULQ
+	AMULSD
+	AMULSS
+	AMULW
+	AMULXL
+	AMULXQ
+	AMWAIT
+	ANEGB
+	ANEGL
+	ANEGQ
+	ANEGW
+	ANOPL
+	ANOPW
+	ANOTB
+	ANOTL
+	ANOTQ
+	ANOTW
+	AORB
+	AORL
+	AORPD
+	AORPS
+	AORQ
+	AORW
+	AOUTB
+	AOUTL
+	AOUTSB
+	AOUTSL
+	AOUTSW
+	AOUTW
+	APABSB
+	APABSD
+	APABSW
+	APACKSSLW
+	APACKSSWB
+	APACKUSDW
+	APACKUSWB
+	APADDB
+	APADDL
+	APADDQ
+	APADDSB
+	APADDSW
+	APADDUSB
+	APADDUSW
+	APADDW
+	APALIGNR
+	APAND
+	APANDN
+	APAUSE
+	APAVGB
+	APAVGW
+	APBLENDVB
+	APBLENDW
+	APCLMULQDQ
+	APCMPEQB
+	APCMPEQL
+	APCMPEQQ
+	APCMPEQW
+	APCMPESTRI
+	APCMPESTRM
+	APCMPGTB
+	APCMPGTL
+	APCMPGTQ
+	APCMPGTW
+	APCMPISTRI
+	APCMPISTRM
+	APDEPL
+	APDEPQ
+	APEXTL
+	APEXTQ
+	APEXTRB
+	APEXTRD
+	APEXTRQ
+	APEXTRW
+	APHADDD
+	APHADDSW
+	APHADDW
+	APHMINPOSUW
+	APHSUBD
+	APHSUBSW
+	APHSUBW
+	APINSRB
+	APINSRD
+	APINSRQ
+	APINSRW
+	APMADDUBSW
+	APMADDWL
+	APMAXSB
+	APMAXSD
+	APMAXSW
+	APMAXUB
+	APMAXUD
+	APMAXUW
+	APMINSB
+	APMINSD
+	APMINSW
+	APMINUB
+	APMINUD
+	APMINUW
+	APMOVMSKB
+	APMOVSXBD
+	APMOVSXBQ
+	APMOVSXBW
+	APMOVSXDQ
+	APMOVSXWD
+	APMOVSXWQ
+	APMOVZXBD
+	APMOVZXBQ
+	APMOVZXBW
+	APMOVZXDQ
+	APMOVZXWD
+	APMOVZXWQ
+	APMULDQ
+	APMULHRSW
+	APMULHUW
+	APMULHW
+	APMULLD
+	APMULLW
+	APMULULQ
+	APOPAL
+	APOPAW
+	APOPCNTL
+	APOPCNTQ
+	APOPCNTW
+	APOPFL
+	APOPFQ
+	APOPFW
+	APOPL
+	APOPQ
+	APOPW
+	APOR
+	APREFETCHNTA
+	APREFETCHT0
+	APREFETCHT1
+	APREFETCHT2
+	APSADBW
+	APSHUFB
+	APSHUFD
+	APSHUFHW
+	APSHUFL
+	APSHUFLW
+	APSHUFW
+	APSIGNB
+	APSIGND
+	APSIGNW
+	APSLLL
+	APSLLO
+	APSLLQ
+	APSLLW
+	APSRAL
+	APSRAW
+	APSRLL
+	APSRLO
+	APSRLQ
+	APSRLW
+	APSUBB
+	APSUBL
+	APSUBQ
+	APSUBSB
+	APSUBSW
+	APSUBUSB
+	APSUBUSW
+	APSUBW
+	APTEST
+	APUNPCKHBW
+	APUNPCKHLQ
+	APUNPCKHQDQ
+	APUNPCKHWL
+	APUNPCKLBW
+	APUNPCKLLQ
+	APUNPCKLQDQ
+	APUNPCKLWL
+	APUSHAL
+	APUSHAW
+	APUSHFL
+	APUSHFQ
+	APUSHFW
+	APUSHL
+	APUSHQ
+	APUSHW
+	APXOR
+	AQUAD
+	ARCLB
+	ARCLL
+	ARCLQ
+	ARCLW
+	ARCPPS
+	ARCPSS
+	ARCRB
+	ARCRL
+	ARCRQ
+	ARCRW
+	ARDFSBASEL
+	ARDFSBASEQ
+	ARDGSBASEL
+	ARDGSBASEQ
+	ARDMSR
+	ARDPKRU
+	ARDPMC
+	ARDRANDL
+	ARDRANDQ
+	ARDRANDW
+	ARDSEEDL
+	ARDSEEDQ
+	ARDSEEDW
+	ARDTSC
+	ARDTSCP
+	AREP
+	AREPN
+	ARETFL
+	ARETFQ
+	ARETFW
+	AROLB
+	AROLL
+	AROLQ
+	AROLW
+	ARORB
+	ARORL
+	ARORQ
+	ARORW
+	ARORXL
+	ARORXQ
+	AROUNDPD
+	AROUNDPS
+	AROUNDSD
+	AROUNDSS
+	ARSM
+	ARSQRTPS
+	ARSQRTSS
+	ASAHF
+	ASALB
+	ASALL
+	ASALQ
+	ASALW
+	ASARB
+	ASARL
+	ASARQ
+	ASARW
+	ASARXL
+	ASARXQ
+	ASBBB
+	ASBBL
+	ASBBQ
+	ASBBW
+	ASCASB
+	ASCASL
+	ASCASQ
+	ASCASW
+	ASETCC
+	ASETCS
+	ASETEQ
+	ASETGE
+	ASETGT
+	ASETHI
+	ASETLE
+	ASETLS
+	ASETLT
+	ASETMI
+	ASETNE
+	ASETOC
+	ASETOS
+	ASETPC
+	ASETPL
+	ASETPS
+	ASFENCE
+	ASGDT
+	ASHA1MSG1
+	ASHA1MSG2
+	ASHA1NEXTE
+	ASHA1RNDS4
+	ASHA256MSG1
+	ASHA256MSG2
+	ASHA256RNDS2
+	ASHLB
+	ASHLL
+	ASHLQ
+	ASHLW
+	ASHLXL
+	ASHLXQ
+	ASHRB
+	ASHRL
+	ASHRQ
+	ASHRW
+	ASHRXL
+	ASHRXQ
+	ASHUFPD
+	ASHUFPS
+	ASIDT
+	ASLDTL
+	ASLDTQ
+	ASLDTW
+	ASMSWL
+	ASMSWQ
+	ASMSWW
+	ASQRTPD
+	ASQRTPS
+	ASQRTSD
+	ASQRTSS
+	ASTAC
+	ASTC
+	ASTD
+	ASTI
+	ASTMXCSR
+	ASTOSB
+	ASTOSL
+	ASTOSQ
+	ASTOSW
+	ASTRL
+	ASTRQ
+	ASTRW
+	ASUBB
+	ASUBL
+	ASUBPD
+	ASUBPS
+	ASUBQ
+	ASUBSD
+	ASUBSS
+	ASUBW
+	ASWAPGS
+	ASYSCALL
+	ASYSENTER
+	ASYSENTER64
+	ASYSEXIT
+	ASYSEXIT64
+	ASYSRET
+	ATESTB
+	ATESTL
+	ATESTQ
+	ATESTW
+	ATPAUSE
+	ATZCNTL
+	ATZCNTQ
+	ATZCNTW
+	AUCOMISD
+	AUCOMISS
+	AUD1
+	AUD2
+	AUMWAIT
+	AUNPCKHPD
+	AUNPCKHPS
+	AUNPCKLPD
+	AUNPCKLPS
+	AUMONITOR
+	AV4FMADDPS
+	AV4FMADDSS
+	AV4FNMADDPS
+	AV4FNMADDSS
+	AVADDPD
+	AVADDPS
+	AVADDSD
+	AVADDSS
+	AVADDSUBPD
+	AVADDSUBPS
+	AVAESDEC
+	AVAESDECLAST
+	AVAESENC
+	AVAESENCLAST
+	AVAESIMC
+	AVAESKEYGENASSIST
+	AVALIGND
+	AVALIGNQ
+	AVANDNPD
+	AVANDNPS
+	AVANDPD
+	AVANDPS
+	AVBLENDMPD
+	AVBLENDMPS
+	AVBLENDPD
+	AVBLENDPS
+	AVBLENDVPD
+	AVBLENDVPS
+	AVBROADCASTF128
+	AVBROADCASTF32X2
+	AVBROADCASTF32X4
+	AVBROADCASTF32X8
+	AVBROADCASTF64X2
+	AVBROADCASTF64X4
+	AVBROADCASTI128
+	AVBROADCASTI32X2
+	AVBROADCASTI32X4
+	AVBROADCASTI32X8
+	AVBROADCASTI64X2
+	AVBROADCASTI64X4
+	AVBROADCASTSD
+	AVBROADCASTSS
+	AVCMPPD
+	AVCMPPS
+	AVCMPSD
+	AVCMPSS
+	AVCOMISD
+	AVCOMISS
+	AVCOMPRESSPD
+	AVCOMPRESSPS
+	AVCVTDQ2PD
+	AVCVTDQ2PS
+	AVCVTPD2DQ
+	AVCVTPD2DQX
+	AVCVTPD2DQY
+	AVCVTPD2PS
+	AVCVTPD2PSX
+	AVCVTPD2PSY
+	AVCVTPD2QQ
+	AVCVTPD2UDQ
+	AVCVTPD2UDQX
+	AVCVTPD2UDQY
+	AVCVTPD2UQQ
+	AVCVTPH2PS
+	AVCVTPS2DQ
+	AVCVTPS2PD
+	AVCVTPS2PH
+	AVCVTPS2QQ
+	AVCVTPS2UDQ
+	AVCVTPS2UQQ
+	AVCVTQQ2PD
+	AVCVTQQ2PS
+	AVCVTQQ2PSX
+	AVCVTQQ2PSY
+	AVCVTSD2SI
+	AVCVTSD2SIQ
+	AVCVTSD2SS
+	AVCVTSD2USI
+	AVCVTSD2USIL
+	AVCVTSD2USIQ
+	AVCVTSI2SDL
+	AVCVTSI2SDQ
+	AVCVTSI2SSL
+	AVCVTSI2SSQ
+	AVCVTSS2SD
+	AVCVTSS2SI
+	AVCVTSS2SIQ
+	AVCVTSS2USI
+	AVCVTSS2USIL
+	AVCVTSS2USIQ
+	AVCVTTPD2DQ
+	AVCVTTPD2DQX
+	AVCVTTPD2DQY
+	AVCVTTPD2QQ
+	AVCVTTPD2UDQ
+	AVCVTTPD2UDQX
+	AVCVTTPD2UDQY
+	AVCVTTPD2UQQ
+	AVCVTTPS2DQ
+	AVCVTTPS2QQ
+	AVCVTTPS2UDQ
+	AVCVTTPS2UQQ
+	AVCVTTSD2SI
+	AVCVTTSD2SIQ
+	AVCVTTSD2USI
+	AVCVTTSD2USIL
+	AVCVTTSD2USIQ
+	AVCVTTSS2SI
+	AVCVTTSS2SIQ
+	AVCVTTSS2USI
+	AVCVTTSS2USIL
+	AVCVTTSS2USIQ
+	AVCVTUDQ2PD
+	AVCVTUDQ2PS
+	AVCVTUQQ2PD
+	AVCVTUQQ2PS
+	AVCVTUQQ2PSX
+	AVCVTUQQ2PSY
+	AVCVTUSI2SD
+	AVCVTUSI2SDL
+	AVCVTUSI2SDQ
+	AVCVTUSI2SS
+	AVCVTUSI2SSL
+	AVCVTUSI2SSQ
+	AVDBPSADBW
+	AVDIVPD
+	AVDIVPS
+	AVDIVSD
+	AVDIVSS
+	AVDPPD
+	AVDPPS
+	AVERR
+	AVERW
+	AVEXP2PD
+	AVEXP2PS
+	AVEXPANDPD
+	AVEXPANDPS
+	AVEXTRACTF128
+	AVEXTRACTF32X4
+	AVEXTRACTF32X8
+	AVEXTRACTF64X2
+	AVEXTRACTF64X4
+	AVEXTRACTI128
+	AVEXTRACTI32X4
+	AVEXTRACTI32X8
+	AVEXTRACTI64X2
+	AVEXTRACTI64X4
+	AVEXTRACTPS
+	AVFIXUPIMMPD
+	AVFIXUPIMMPS
+	AVFIXUPIMMSD
+	AVFIXUPIMMSS
+	AVFMADD132PD
+	AVFMADD132PS
+	AVFMADD132SD
+	AVFMADD132SS
+	AVFMADD213PD
+	AVFMADD213PS
+	AVFMADD213SD
+	AVFMADD213SS
+	AVFMADD231PD
+	AVFMADD231PS
+	AVFMADD231SD
+	AVFMADD231SS
+	AVFMADDSUB132PD
+	AVFMADDSUB132PS
+	AVFMADDSUB213PD
+	AVFMADDSUB213PS
+	AVFMADDSUB231PD
+	AVFMADDSUB231PS
+	AVFMSUB132PD
+	AVFMSUB132PS
+	AVFMSUB132SD
+	AVFMSUB132SS
+	AVFMSUB213PD
+	AVFMSUB213PS
+	AVFMSUB213SD
+	AVFMSUB213SS
+	AVFMSUB231PD
+	AVFMSUB231PS
+	AVFMSUB231SD
+	AVFMSUB231SS
+	AVFMSUBADD132PD
+	AVFMSUBADD132PS
+	AVFMSUBADD213PD
+	AVFMSUBADD213PS
+	AVFMSUBADD231PD
+	AVFMSUBADD231PS
+	AVFNMADD132PD
+	AVFNMADD132PS
+	AVFNMADD132SD
+	AVFNMADD132SS
+	AVFNMADD213PD
+	AVFNMADD213PS
+	AVFNMADD213SD
+	AVFNMADD213SS
+	AVFNMADD231PD
+	AVFNMADD231PS
+	AVFNMADD231SD
+	AVFNMADD231SS
+	AVFNMSUB132PD
+	AVFNMSUB132PS
+	AVFNMSUB132SD
+	AVFNMSUB132SS
+	AVFNMSUB213PD
+	AVFNMSUB213PS
+	AVFNMSUB213SD
+	AVFNMSUB213SS
+	AVFNMSUB231PD
+	AVFNMSUB231PS
+	AVFNMSUB231SD
+	AVFNMSUB231SS
+	AVFPCLASSPD
+	AVFPCLASSPDX
+	AVFPCLASSPDY
+	AVFPCLASSPDZ
+	AVFPCLASSPS
+	AVFPCLASSPSX
+	AVFPCLASSPSY
+	AVFPCLASSPSZ
+	AVFPCLASSSD
+	AVFPCLASSSS
+	AVGATHERDPD
+	AVGATHERDPS
+	AVGATHERPF0DPD
+	AVGATHERPF0DPS
+	AVGATHERPF0QPD
+	AVGATHERPF0QPS
+	AVGATHERPF1DPD
+	AVGATHERPF1DPS
+	AVGATHERPF1QPD
+	AVGATHERPF1QPS
+	AVGATHERQPD
+	AVGATHERQPS
+	AVGETEXPPD
+	AVGETEXPPS
+	AVGETEXPSD
+	AVGETEXPSS
+	AVGETMANTPD
+	AVGETMANTPS
+	AVGETMANTSD
+	AVGETMANTSS
+	AVGF2P8AFFINEINVQB
+	AVGF2P8AFFINEQB
+	AVGF2P8MULB
+	AVHADDPD
+	AVHADDPS
+	AVHSUBPD
+	AVHSUBPS
+	AVINSERTF128
+	AVINSERTF32X4
+	AVINSERTF32X8
+	AVINSERTF64X2
+	AVINSERTF64X4
+	AVINSERTI128
+	AVINSERTI32X4
+	AVINSERTI32X8
+	AVINSERTI64X2
+	AVINSERTI64X4
+	AVINSERTPS
+	AVLDDQU
+	AVLDMXCSR
+	AVMASKMOVDQU
+	AVMASKMOVPD
+	AVMASKMOVPS
+	AVMAXPD
+	AVMAXPS
+	AVMAXSD
+	AVMAXSS
+	AVMINPD
+	AVMINPS
+	AVMINSD
+	AVMINSS
+	AVMOVAPD
+	AVMOVAPS
+	AVMOVD
+	AVMOVDDUP
+	AVMOVDQA
+	AVMOVDQA32
+	AVMOVDQA64
+	AVMOVDQU
+	AVMOVDQU16
+	AVMOVDQU32
+	AVMOVDQU64
+	AVMOVDQU8
+	AVMOVHLPS
+	AVMOVHPD
+	AVMOVHPS
+	AVMOVLHPS
+	AVMOVLPD
+	AVMOVLPS
+	AVMOVMSKPD
+	AVMOVMSKPS
+	AVMOVNTDQ
+	AVMOVNTDQA
+	AVMOVNTPD
+	AVMOVNTPS
+	AVMOVQ
+	AVMOVSD
+	AVMOVSHDUP
+	AVMOVSLDUP
+	AVMOVSS
+	AVMOVUPD
+	AVMOVUPS
+	AVMPSADBW
+	AVMULPD
+	AVMULPS
+	AVMULSD
+	AVMULSS
+	AVORPD
+	AVORPS
+	AVP4DPWSSD
+	AVP4DPWSSDS
+	AVPABSB
+	AVPABSD
+	AVPABSQ
+	AVPABSW
+	AVPACKSSDW
+	AVPACKSSWB
+	AVPACKUSDW
+	AVPACKUSWB
+	AVPADDB
+	AVPADDD
+	AVPADDQ
+	AVPADDSB
+	AVPADDSW
+	AVPADDUSB
+	AVPADDUSW
+	AVPADDW
+	AVPALIGNR
+	AVPAND
+	AVPANDD
+	AVPANDN
+	AVPANDND
+	AVPANDNQ
+	AVPANDQ
+	AVPAVGB
+	AVPAVGW
+	AVPBLENDD
+	AVPBLENDMB
+	AVPBLENDMD
+	AVPBLENDMQ
+	AVPBLENDMW
+	AVPBLENDVB
+	AVPBLENDW
+	AVPBROADCASTB
+	AVPBROADCASTD
+	AVPBROADCASTMB2Q
+	AVPBROADCASTMW2D
+	AVPBROADCASTQ
+	AVPBROADCASTW
+	AVPCLMULQDQ
+	AVPCMPB
+	AVPCMPD
+	AVPCMPEQB
+	AVPCMPEQD
+	AVPCMPEQQ
+	AVPCMPEQW
+	AVPCMPESTRI
+	AVPCMPESTRM
+	AVPCMPGTB
+	AVPCMPGTD
+	AVPCMPGTQ
+	AVPCMPGTW
+	AVPCMPISTRI
+	AVPCMPISTRM
+	AVPCMPQ
+	AVPCMPUB
+	AVPCMPUD
+	AVPCMPUQ
+	AVPCMPUW
+	AVPCMPW
+	AVPCOMPRESSB
+	AVPCOMPRESSD
+	AVPCOMPRESSQ
+	AVPCOMPRESSW
+	AVPCONFLICTD
+	AVPCONFLICTQ
+	AVPDPBUSD
+	AVPDPBUSDS
+	AVPDPWSSD
+	AVPDPWSSDS
+	AVPERM2F128
+	AVPERM2I128
+	AVPERMB
+	AVPERMD
+	AVPERMI2B
+	AVPERMI2D
+	AVPERMI2PD
+	AVPERMI2PS
+	AVPERMI2Q
+	AVPERMI2W
+	AVPERMILPD
+	AVPERMILPS
+	AVPERMPD
+	AVPERMPS
+	AVPERMQ
+	AVPERMT2B
+	AVPERMT2D
+	AVPERMT2PD
+	AVPERMT2PS
+	AVPERMT2Q
+	AVPERMT2W
+	AVPERMW
+	AVPEXPANDB
+	AVPEXPANDD
+	AVPEXPANDQ
+	AVPEXPANDW
+	AVPEXTRB
+	AVPEXTRD
+	AVPEXTRQ
+	AVPEXTRW
+	AVPGATHERDD
+	AVPGATHERDQ
+	AVPGATHERQD
+	AVPGATHERQQ
+	AVPHADDD
+	AVPHADDSW
+	AVPHADDW
+	AVPHMINPOSUW
+	AVPHSUBD
+	AVPHSUBSW
+	AVPHSUBW
+	AVPINSRB
+	AVPINSRD
+	AVPINSRQ
+	AVPINSRW
+	AVPLZCNTD
+	AVPLZCNTQ
+	AVPMADD52HUQ
+	AVPMADD52LUQ
+	AVPMADDUBSW
+	AVPMADDWD
+	AVPMASKMOVD
+	AVPMASKMOVQ
+	AVPMAXSB
+	AVPMAXSD
+	AVPMAXSQ
+	AVPMAXSW
+	AVPMAXUB
+	AVPMAXUD
+	AVPMAXUQ
+	AVPMAXUW
+	AVPMINSB
+	AVPMINSD
+	AVPMINSQ
+	AVPMINSW
+	AVPMINUB
+	AVPMINUD
+	AVPMINUQ
+	AVPMINUW
+	AVPMOVB2M
+	AVPMOVD2M
+	AVPMOVDB
+	AVPMOVDW
+	AVPMOVM2B
+	AVPMOVM2D
+	AVPMOVM2Q
+	AVPMOVM2W
+	AVPMOVMSKB
+	AVPMOVQ2M
+	AVPMOVQB
+	AVPMOVQD
+	AVPMOVQW
+	AVPMOVSDB
+	AVPMOVSDW
+	AVPMOVSQB
+	AVPMOVSQD
+	AVPMOVSQW
+	AVPMOVSWB
+	AVPMOVSXBD
+	AVPMOVSXBQ
+	AVPMOVSXBW
+	AVPMOVSXDQ
+	AVPMOVSXWD
+	AVPMOVSXWQ
+	AVPMOVUSDB
+	AVPMOVUSDW
+	AVPMOVUSQB
+	AVPMOVUSQD
+	AVPMOVUSQW
+	AVPMOVUSWB
+	AVPMOVW2M
+	AVPMOVWB
+	AVPMOVZXBD
+	AVPMOVZXBQ
+	AVPMOVZXBW
+	AVPMOVZXDQ
+	AVPMOVZXWD
+	AVPMOVZXWQ
+	AVPMULDQ
+	AVPMULHRSW
+	AVPMULHUW
+	AVPMULHW
+	AVPMULLD
+	AVPMULLQ
+	AVPMULLW
+	AVPMULTISHIFTQB
+	AVPMULUDQ
+	AVPOPCNTB
+	AVPOPCNTD
+	AVPOPCNTQ
+	AVPOPCNTW
+	AVPOR
+	AVPORD
+	AVPORQ
+	AVPROLD
+	AVPROLQ
+	AVPROLVD
+	AVPROLVQ
+	AVPRORD
+	AVPRORQ
+	AVPRORVD
+	AVPRORVQ
+	AVPSADBW
+	AVPSCATTERDD
+	AVPSCATTERDQ
+	AVPSCATTERQD
+	AVPSCATTERQQ
+	AVPSHLDD
+	AVPSHLDQ
+	AVPSHLDVD
+	AVPSHLDVQ
+	AVPSHLDVW
+	AVPSHLDW
+	AVPSHRDD
+	AVPSHRDQ
+	AVPSHRDVD
+	AVPSHRDVQ
+	AVPSHRDVW
+	AVPSHRDW
+	AVPSHUFB
+	AVPSHUFBITQMB
+	AVPSHUFD
+	AVPSHUFHW
+	AVPSHUFLW
+	AVPSIGNB
+	AVPSIGND
+	AVPSIGNW
+	AVPSLLD
+	AVPSLLDQ
+	AVPSLLQ
+	AVPSLLVD
+	AVPSLLVQ
+	AVPSLLVW
+	AVPSLLW
+	AVPSRAD
+	AVPSRAQ
+	AVPSRAVD
+	AVPSRAVQ
+	AVPSRAVW
+	AVPSRAW
+	AVPSRLD
+	AVPSRLDQ
+	AVPSRLQ
+	AVPSRLVD
+	AVPSRLVQ
+	AVPSRLVW
+	AVPSRLW
+	AVPSUBB
+	AVPSUBD
+	AVPSUBQ
+	AVPSUBSB
+	AVPSUBSW
+	AVPSUBUSB
+	AVPSUBUSW
+	AVPSUBW
+	AVPTERNLOGD
+	AVPTERNLOGQ
+	AVPTEST
+	AVPTESTMB
+	AVPTESTMD
+	AVPTESTMQ
+	AVPTESTMW
+	AVPTESTNMB
+	AVPTESTNMD
+	AVPTESTNMQ
+	AVPTESTNMW
+	AVPUNPCKHBW
+	AVPUNPCKHDQ
+	AVPUNPCKHQDQ
+	AVPUNPCKHWD
+	AVPUNPCKLBW
+	AVPUNPCKLDQ
+	AVPUNPCKLQDQ
+	AVPUNPCKLWD
+	AVPXOR
+	AVPXORD
+	AVPXORQ
+	AVRANGEPD
+	AVRANGEPS
+	AVRANGESD
+	AVRANGESS
+	AVRCP14PD
+	AVRCP14PS
+	AVRCP14SD
+	AVRCP14SS
+	AVRCP28PD
+	AVRCP28PS
+	AVRCP28SD
+	AVRCP28SS
+	AVRCPPS
+	AVRCPSS
+	AVREDUCEPD
+	AVREDUCEPS
+	AVREDUCESD
+	AVREDUCESS
+	AVRNDSCALEPD
+	AVRNDSCALEPS
+	AVRNDSCALESD
+	AVRNDSCALESS
+	AVROUNDPD
+	AVROUNDPS
+	AVROUNDSD
+	AVROUNDSS
+	AVRSQRT14PD
+	AVRSQRT14PS
+	AVRSQRT14SD
+	AVRSQRT14SS
+	AVRSQRT28PD
+	AVRSQRT28PS
+	AVRSQRT28SD
+	AVRSQRT28SS
+	AVRSQRTPS
+	AVRSQRTSS
+	AVSCALEFPD
+	AVSCALEFPS
+	AVSCALEFSD
+	AVSCALEFSS
+	AVSCATTERDPD
+	AVSCATTERDPS
+	AVSCATTERPF0DPD
+	AVSCATTERPF0DPS
+	AVSCATTERPF0QPD
+	AVSCATTERPF0QPS
+	AVSCATTERPF1DPD
+	AVSCATTERPF1DPS
+	AVSCATTERPF1QPD
+	AVSCATTERPF1QPS
+	AVSCATTERQPD
+	AVSCATTERQPS
+	AVSHUFF32X4
+	AVSHUFF64X2
+	AVSHUFI32X4
+	AVSHUFI64X2
+	AVSHUFPD
+	AVSHUFPS
+	AVSQRTPD
+	AVSQRTPS
+	AVSQRTSD
+	AVSQRTSS
+	AVSTMXCSR
+	AVSUBPD
+	AVSUBPS
+	AVSUBSD
+	AVSUBSS
+	AVTESTPD
+	AVTESTPS
+	AVUCOMISD
+	AVUCOMISS
+	AVUNPCKHPD
+	AVUNPCKHPS
+	AVUNPCKLPD
+	AVUNPCKLPS
+	AVXORPD
+	AVXORPS
+	AVZEROALL
+	AVZEROUPPER
+	AWAIT
+	AWBINVD
+	AWORD
+	AWRFSBASEL
+	AWRFSBASEQ
+	AWRGSBASEL
+	AWRGSBASEQ
+	AWRMSR
+	AWRPKRU
+	AXABORT
+	AXACQUIRE
+	AXADDB
+	AXADDL
+	AXADDQ
+	AXADDW
+	AXBEGIN
+	AXCHGB
+	AXCHGL
+	AXCHGQ
+	AXCHGW
+	AXEND
+	AXGETBV
+	AXLAT
+	AXORB
+	AXORL
+	AXORPD
+	AXORPS
+	AXORQ
+	AXORW
+	AXRELEASE
+	AXRSTOR
+	AXRSTOR64
+	AXRSTORS
+	AXRSTORS64
+	AXSAVE
+	AXSAVE64
+	AXSAVEC
+	AXSAVEC64
+	AXSAVEOPT
+	AXSAVEOPT64
+	AXSAVES
+	AXSAVES64
+	AXSETBV
+	AXTEST
+	ALAST
+)
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/anames.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/anames.go
new file mode 100644
index 000000000..ac9da3211
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/anames.go
@@ -0,0 +1,1607 @@
+// Code generated by stringer -i aenum.go -o anames.go -p x86; DO NOT EDIT.
+
+package x86
+
+import "github.com/twitchyliquid64/golang-asm/obj"
+
+var Anames = []string{
+	obj.A_ARCHSPECIFIC: "AAA",
+	"AAD",
+	"AAM",
+	"AAS",
+	"ADCB",
+	"ADCL",
+	"ADCQ",
+	"ADCW",
+	"ADCXL",
+	"ADCXQ",
+	"ADDB",
+	"ADDL",
+	"ADDPD",
+	"ADDPS",
+	"ADDQ",
+	"ADDSD",
+	"ADDSS",
+	"ADDSUBPD",
+	"ADDSUBPS",
+	"ADDW",
+	"ADJSP",
+	"ADOXL",
+	"ADOXQ",
+	"AESDEC",
+	"AESDECLAST",
+	"AESENC",
+	"AESENCLAST",
+	"AESIMC",
+	"AESKEYGENASSIST",
+	"ANDB",
+	"ANDL",
+	"ANDNL",
+	"ANDNPD",
+	"ANDNPS",
+	"ANDNQ",
+	"ANDPD",
+	"ANDPS",
+	"ANDQ",
+	"ANDW",
+	"ARPL",
+	"BEXTRL",
+	"BEXTRQ",
+	"BLENDPD",
+	"BLENDPS",
+	"BLENDVPD",
+	"BLENDVPS",
+	"BLSIL",
+	"BLSIQ",
+	"BLSMSKL",
+	"BLSMSKQ",
+	"BLSRL",
+	"BLSRQ",
+	"BOUNDL",
+	"BOUNDW",
+	"BSFL",
+	"BSFQ",
+	"BSFW",
+	"BSRL",
+	"BSRQ",
+	"BSRW",
+	"BSWAPL",
+	"BSWAPQ",
+	"BTCL",
+	"BTCQ",
+	"BTCW",
+	"BTL",
+	"BTQ",
+	"BTRL",
+	"BTRQ",
+	"BTRW",
+	"BTSL",
+	"BTSQ",
+	"BTSW",
+	"BTW",
+	"BYTE",
+	"BZHIL",
+	"BZHIQ",
+	"CBW",
+	"CDQ",
+	"CDQE",
+	"CLAC",
+	"CLC",
+	"CLD",
+	"CLDEMOTE",
+	"CLFLUSH",
+	"CLFLUSHOPT",
+	"CLI",
+	"CLTS",
+	"CLWB",
+	"CMC",
+	"CMOVLCC",
+	"CMOVLCS",
+	"CMOVLEQ",
+	"CMOVLGE",
+	"CMOVLGT",
+	"CMOVLHI",
+	"CMOVLLE",
+	"CMOVLLS",
+	"CMOVLLT",
+	"CMOVLMI",
+	"CMOVLNE",
+	"CMOVLOC",
+	"CMOVLOS",
+	"CMOVLPC",
+	"CMOVLPL",
+	"CMOVLPS",
+	"CMOVQCC",
+	"CMOVQCS",
+	"CMOVQEQ",
+	"CMOVQGE",
+	"CMOVQGT",
+	"CMOVQHI",
+	"CMOVQLE",
+	"CMOVQLS",
+	"CMOVQLT",
+	"CMOVQMI",
+	"CMOVQNE",
+	"CMOVQOC",
+	"CMOVQOS",
+	"CMOVQPC",
+	"CMOVQPL",
+	"CMOVQPS",
+	"CMOVWCC",
+	"CMOVWCS",
+	"CMOVWEQ",
+	"CMOVWGE",
+	"CMOVWGT",
+	"CMOVWHI",
+	"CMOVWLE",
+	"CMOVWLS",
+	"CMOVWLT",
+	"CMOVWMI",
+	"CMOVWNE",
+	"CMOVWOC",
+	"CMOVWOS",
+	"CMOVWPC",
+	"CMOVWPL",
+	"CMOVWPS",
+	"CMPB",
+	"CMPL",
+	"CMPPD",
+	"CMPPS",
+	"CMPQ",
+	"CMPSB",
+	"CMPSD",
+	"CMPSL",
+	"CMPSQ",
+	"CMPSS",
+	"CMPSW",
+	"CMPW",
+	"CMPXCHG16B",
+	"CMPXCHG8B",
+	"CMPXCHGB",
+	"CMPXCHGL",
+	"CMPXCHGQ",
+	"CMPXCHGW",
+	"COMISD",
+	"COMISS",
+	"CPUID",
+	"CQO",
+	"CRC32B",
+	"CRC32L",
+	"CRC32Q",
+	"CRC32W",
+	"CVTPD2PL",
+	"CVTPD2PS",
+	"CVTPL2PD",
+	"CVTPL2PS",
+	"CVTPS2PD",
+	"CVTPS2PL",
+	"CVTSD2SL",
+	"CVTSD2SQ",
+	"CVTSD2SS",
+	"CVTSL2SD",
+	"CVTSL2SS",
+	"CVTSQ2SD",
+	"CVTSQ2SS",
+	"CVTSS2SD",
+	"CVTSS2SL",
+	"CVTSS2SQ",
+	"CVTTPD2PL",
+	"CVTTPS2PL",
+	"CVTTSD2SL",
+	"CVTTSD2SQ",
+	"CVTTSS2SL",
+	"CVTTSS2SQ",
+	"CWD",
+	"CWDE",
+	"DAA",
+	"DAS",
+	"DECB",
+	"DECL",
+	"DECQ",
+	"DECW",
+	"DIVB",
+	"DIVL",
+	"DIVPD",
+	"DIVPS",
+	"DIVQ",
+	"DIVSD",
+	"DIVSS",
+	"DIVW",
+	"DPPD",
+	"DPPS",
+	"EMMS",
+	"ENTER",
+	"EXTRACTPS",
+	"F2XM1",
+	"FABS",
+	"FADDD",
+	"FADDDP",
+	"FADDF",
+	"FADDL",
+	"FADDW",
+	"FBLD",
+	"FBSTP",
+	"FCHS",
+	"FCLEX",
+	"FCMOVB",
+	"FCMOVBE",
+	"FCMOVCC",
+	"FCMOVCS",
+	"FCMOVE",
+	"FCMOVEQ",
+	"FCMOVHI",
+	"FCMOVLS",
+	"FCMOVNB",
+	"FCMOVNBE",
+	"FCMOVNE",
+	"FCMOVNU",
+	"FCMOVU",
+	"FCMOVUN",
+	"FCOMD",
+	"FCOMDP",
+	"FCOMDPP",
+	"FCOMF",
+	"FCOMFP",
+	"FCOMI",
+	"FCOMIP",
+	"FCOML",
+	"FCOMLP",
+	"FCOMW",
+	"FCOMWP",
+	"FCOS",
+	"FDECSTP",
+	"FDIVD",
+	"FDIVDP",
+	"FDIVF",
+	"FDIVL",
+	"FDIVRD",
+	"FDIVRDP",
+	"FDIVRF",
+	"FDIVRL",
+	"FDIVRW",
+	"FDIVW",
+	"FFREE",
+	"FINCSTP",
+	"FINIT",
+	"FLD1",
+	"FLDCW",
+	"FLDENV",
+	"FLDL2E",
+	"FLDL2T",
+	"FLDLG2",
+	"FLDLN2",
+	"FLDPI",
+	"FLDZ",
+	"FMOVB",
+	"FMOVBP",
+	"FMOVD",
+	"FMOVDP",
+	"FMOVF",
+	"FMOVFP",
+	"FMOVL",
+	"FMOVLP",
+	"FMOVV",
+	"FMOVVP",
+	"FMOVW",
+	"FMOVWP",
+	"FMOVX",
+	"FMOVXP",
+	"FMULD",
+	"FMULDP",
+	"FMULF",
+	"FMULL",
+	"FMULW",
+	"FNOP",
+	"FPATAN",
+	"FPREM",
+	"FPREM1",
+	"FPTAN",
+	"FRNDINT",
+	"FRSTOR",
+	"FSAVE",
+	"FSCALE",
+	"FSIN",
+	"FSINCOS",
+	"FSQRT",
+	"FSTCW",
+	"FSTENV",
+	"FSTSW",
+	"FSUBD",
+	"FSUBDP",
+	"FSUBF",
+	"FSUBL",
+	"FSUBRD",
+	"FSUBRDP",
+	"FSUBRF",
+	"FSUBRL",
+	"FSUBRW",
+	"FSUBW",
+	"FTST",
+	"FUCOM",
+	"FUCOMI",
+	"FUCOMIP",
+	"FUCOMP",
+	"FUCOMPP",
+	"FXAM",
+	"FXCHD",
+	"FXRSTOR",
+	"FXRSTOR64",
+	"FXSAVE",
+	"FXSAVE64",
+	"FXTRACT",
+	"FYL2X",
+	"FYL2XP1",
+	"HADDPD",
+	"HADDPS",
+	"HLT",
+	"HSUBPD",
+	"HSUBPS",
+	"ICEBP",
+	"IDIVB",
+	"IDIVL",
+	"IDIVQ",
+	"IDIVW",
+	"IMUL3L",
+	"IMUL3Q",
+	"IMUL3W",
+	"IMULB",
+	"IMULL",
+	"IMULQ",
+	"IMULW",
+	"INB",
+	"INCB",
+	"INCL",
+	"INCQ",
+	"INCW",
+	"INL",
+	"INSB",
+	"INSERTPS",
+	"INSL",
+	"INSW",
+	"INT",
+	"INTO",
+	"INVD",
+	"INVLPG",
+	"INVPCID",
+	"INW",
+	"IRETL",
+	"IRETQ",
+	"IRETW",
+	"JCC",
+	"JCS",
+	"JCXZL",
+	"JCXZQ",
+	"JCXZW",
+	"JEQ",
+	"JGE",
+	"JGT",
+	"JHI",
+	"JLE",
+	"JLS",
+	"JLT",
+	"JMI",
+	"JNE",
+	"JOC",
+	"JOS",
+	"JPC",
+	"JPL",
+	"JPS",
+	"KADDB",
+	"KADDD",
+	"KADDQ",
+	"KADDW",
+	"KANDB",
+	"KANDD",
+	"KANDNB",
+	"KANDND",
+	"KANDNQ",
+	"KANDNW",
+	"KANDQ",
+	"KANDW",
+	"KMOVB",
+	"KMOVD",
+	"KMOVQ",
+	"KMOVW",
+	"KNOTB",
+	"KNOTD",
+	"KNOTQ",
+	"KNOTW",
+	"KORB",
+	"KORD",
+	"KORQ",
+	"KORTESTB",
+	"KORTESTD",
+	"KORTESTQ",
+	"KORTESTW",
+	"KORW",
+	"KSHIFTLB",
+	"KSHIFTLD",
+	"KSHIFTLQ",
+	"KSHIFTLW",
+	"KSHIFTRB",
+	"KSHIFTRD",
+	"KSHIFTRQ",
+	"KSHIFTRW",
+	"KTESTB",
+	"KTESTD",
+	"KTESTQ",
+	"KTESTW",
+	"KUNPCKBW",
+	"KUNPCKDQ",
+	"KUNPCKWD",
+	"KXNORB",
+	"KXNORD",
+	"KXNORQ",
+	"KXNORW",
+	"KXORB",
+	"KXORD",
+	"KXORQ",
+	"KXORW",
+	"LAHF",
+	"LARL",
+	"LARQ",
+	"LARW",
+	"LDDQU",
+	"LDMXCSR",
+	"LEAL",
+	"LEAQ",
+	"LEAVEL",
+	"LEAVEQ",
+	"LEAVEW",
+	"LEAW",
+	"LFENCE",
+	"LFSL",
+	"LFSQ",
+	"LFSW",
+	"LGDT",
+	"LGSL",
+	"LGSQ",
+	"LGSW",
+	"LIDT",
+	"LLDT",
+	"LMSW",
+	"LOCK",
+	"LODSB",
+	"LODSL",
+	"LODSQ",
+	"LODSW",
+	"LONG",
+	"LOOP",
+	"LOOPEQ",
+	"LOOPNE",
+	"LSLL",
+	"LSLQ",
+	"LSLW",
+	"LSSL",
+	"LSSQ",
+	"LSSW",
+	"LTR",
+	"LZCNTL",
+	"LZCNTQ",
+	"LZCNTW",
+	"MASKMOVOU",
+	"MASKMOVQ",
+	"MAXPD",
+	"MAXPS",
+	"MAXSD",
+	"MAXSS",
+	"MFENCE",
+	"MINPD",
+	"MINPS",
+	"MINSD",
+	"MINSS",
+	"MONITOR",
+	"MOVAPD",
+	"MOVAPS",
+	"MOVB",
+	"MOVBELL",
+	"MOVBEQQ",
+	"MOVBEWW",
+	"MOVBLSX",
+	"MOVBLZX",
+	"MOVBQSX",
+	"MOVBQZX",
+	"MOVBWSX",
+	"MOVBWZX",
+	"MOVDDUP",
+	"MOVHLPS",
+	"MOVHPD",
+	"MOVHPS",
+	"MOVL",
+	"MOVLHPS",
+	"MOVLPD",
+	"MOVLPS",
+	"MOVLQSX",
+	"MOVLQZX",
+	"MOVMSKPD",
+	"MOVMSKPS",
+	"MOVNTDQA",
+	"MOVNTIL",
+	"MOVNTIQ",
+	"MOVNTO",
+	"MOVNTPD",
+	"MOVNTPS",
+	"MOVNTQ",
+	"MOVO",
+	"MOVOU",
+	"MOVQ",
+	"MOVQL",
+	"MOVQOZX",
+	"MOVSB",
+	"MOVSD",
+	"MOVSHDUP",
+	"MOVSL",
+	"MOVSLDUP",
+	"MOVSQ",
+	"MOVSS",
+	"MOVSW",
+	"MOVSWW",
+	"MOVUPD",
+	"MOVUPS",
+	"MOVW",
+	"MOVWLSX",
+	"MOVWLZX",
+	"MOVWQSX",
+	"MOVWQZX",
+	"MOVZWW",
+	"MPSADBW",
+	"MULB",
+	"MULL",
+	"MULPD",
+	"MULPS",
+	"MULQ",
+	"MULSD",
+	"MULSS",
+	"MULW",
+	"MULXL",
+	"MULXQ",
+	"MWAIT",
+	"NEGB",
+	"NEGL",
+	"NEGQ",
+	"NEGW",
+	"NOPL",
+	"NOPW",
+	"NOTB",
+	"NOTL",
+	"NOTQ",
+	"NOTW",
+	"ORB",
+	"ORL",
+	"ORPD",
+	"ORPS",
+	"ORQ",
+	"ORW",
+	"OUTB",
+	"OUTL",
+	"OUTSB",
+	"OUTSL",
+	"OUTSW",
+	"OUTW",
+	"PABSB",
+	"PABSD",
+	"PABSW",
+	"PACKSSLW",
+	"PACKSSWB",
+	"PACKUSDW",
+	"PACKUSWB",
+	"PADDB",
+	"PADDL",
+	"PADDQ",
+	"PADDSB",
+	"PADDSW",
+	"PADDUSB",
+	"PADDUSW",
+	"PADDW",
+	"PALIGNR",
+	"PAND",
+	"PANDN",
+	"PAUSE",
+	"PAVGB",
+	"PAVGW",
+	"PBLENDVB",
+	"PBLENDW",
+	"PCLMULQDQ",
+	"PCMPEQB",
+	"PCMPEQL",
+	"PCMPEQQ",
+	"PCMPEQW",
+	"PCMPESTRI",
+	"PCMPESTRM",
+	"PCMPGTB",
+	"PCMPGTL",
+	"PCMPGTQ",
+	"PCMPGTW",
+	"PCMPISTRI",
+	"PCMPISTRM",
+	"PDEPL",
+	"PDEPQ",
+	"PEXTL",
+	"PEXTQ",
+	"PEXTRB",
+	"PEXTRD",
+	"PEXTRQ",
+	"PEXTRW",
+	"PHADDD",
+	"PHADDSW",
+	"PHADDW",
+	"PHMINPOSUW",
+	"PHSUBD",
+	"PHSUBSW",
+	"PHSUBW",
+	"PINSRB",
+	"PINSRD",
+	"PINSRQ",
+	"PINSRW",
+	"PMADDUBSW",
+	"PMADDWL",
+	"PMAXSB",
+	"PMAXSD",
+	"PMAXSW",
+	"PMAXUB",
+	"PMAXUD",
+	"PMAXUW",
+	"PMINSB",
+	"PMINSD",
+	"PMINSW",
+	"PMINUB",
+	"PMINUD",
+	"PMINUW",
+	"PMOVMSKB",
+	"PMOVSXBD",
+	"PMOVSXBQ",
+	"PMOVSXBW",
+	"PMOVSXDQ",
+	"PMOVSXWD",
+	"PMOVSXWQ",
+	"PMOVZXBD",
+	"PMOVZXBQ",
+	"PMOVZXBW",
+	"PMOVZXDQ",
+	"PMOVZXWD",
+	"PMOVZXWQ",
+	"PMULDQ",
+	"PMULHRSW",
+	"PMULHUW",
+	"PMULHW",
+	"PMULLD",
+	"PMULLW",
+	"PMULULQ",
+	"POPAL",
+	"POPAW",
+	"POPCNTL",
+	"POPCNTQ",
+	"POPCNTW",
+	"POPFL",
+	"POPFQ",
+	"POPFW",
+	"POPL",
+	"POPQ",
+	"POPW",
+	"POR",
+	"PREFETCHNTA",
+	"PREFETCHT0",
+	"PREFETCHT1",
+	"PREFETCHT2",
+	"PSADBW",
+	"PSHUFB",
+	"PSHUFD",
+	"PSHUFHW",
+	"PSHUFL",
+	"PSHUFLW",
+	"PSHUFW",
+	"PSIGNB",
+	"PSIGND",
+	"PSIGNW",
+	"PSLLL",
+	"PSLLO",
+	"PSLLQ",
+	"PSLLW",
+	"PSRAL",
+	"PSRAW",
+	"PSRLL",
+	"PSRLO",
+	"PSRLQ",
+	"PSRLW",
+	"PSUBB",
+	"PSUBL",
+	"PSUBQ",
+	"PSUBSB",
+	"PSUBSW",
+	"PSUBUSB",
+	"PSUBUSW",
+	"PSUBW",
+	"PTEST",
+	"PUNPCKHBW",
+	"PUNPCKHLQ",
+	"PUNPCKHQDQ",
+	"PUNPCKHWL",
+	"PUNPCKLBW",
+	"PUNPCKLLQ",
+	"PUNPCKLQDQ",
+	"PUNPCKLWL",
+	"PUSHAL",
+	"PUSHAW",
+	"PUSHFL",
+	"PUSHFQ",
+	"PUSHFW",
+	"PUSHL",
+	"PUSHQ",
+	"PUSHW",
+	"PXOR",
+	"QUAD",
+	"RCLB",
+	"RCLL",
+	"RCLQ",
+	"RCLW",
+	"RCPPS",
+	"RCPSS",
+	"RCRB",
+	"RCRL",
+	"RCRQ",
+	"RCRW",
+	"RDFSBASEL",
+	"RDFSBASEQ",
+	"RDGSBASEL",
+	"RDGSBASEQ",
+	"RDMSR",
+	"RDPKRU",
+	"RDPMC",
+	"RDRANDL",
+	"RDRANDQ",
+	"RDRANDW",
+	"RDSEEDL",
+	"RDSEEDQ",
+	"RDSEEDW",
+	"RDTSC",
+	"RDTSCP",
+	"REP",
+	"REPN",
+	"RETFL",
+	"RETFQ",
+	"RETFW",
+	"ROLB",
+	"ROLL",
+	"ROLQ",
+	"ROLW",
+	"RORB",
+	"RORL",
+	"RORQ",
+	"RORW",
+	"RORXL",
+	"RORXQ",
+	"ROUNDPD",
+	"ROUNDPS",
+	"ROUNDSD",
+	"ROUNDSS",
+	"RSM",
+	"RSQRTPS",
+	"RSQRTSS",
+	"SAHF",
+	"SALB",
+	"SALL",
+	"SALQ",
+	"SALW",
+	"SARB",
+	"SARL",
+	"SARQ",
+	"SARW",
+	"SARXL",
+	"SARXQ",
+	"SBBB",
+	"SBBL",
+	"SBBQ",
+	"SBBW",
+	"SCASB",
+	"SCASL",
+	"SCASQ",
+	"SCASW",
+	"SETCC",
+	"SETCS",
+	"SETEQ",
+	"SETGE",
+	"SETGT",
+	"SETHI",
+	"SETLE",
+	"SETLS",
+	"SETLT",
+	"SETMI",
+	"SETNE",
+	"SETOC",
+	"SETOS",
+	"SETPC",
+	"SETPL",
+	"SETPS",
+	"SFENCE",
+	"SGDT",
+	"SHA1MSG1",
+	"SHA1MSG2",
+	"SHA1NEXTE",
+	"SHA1RNDS4",
+	"SHA256MSG1",
+	"SHA256MSG2",
+	"SHA256RNDS2",
+	"SHLB",
+	"SHLL",
+	"SHLQ",
+	"SHLW",
+	"SHLXL",
+	"SHLXQ",
+	"SHRB",
+	"SHRL",
+	"SHRQ",
+	"SHRW",
+	"SHRXL",
+	"SHRXQ",
+	"SHUFPD",
+	"SHUFPS",
+	"SIDT",
+	"SLDTL",
+	"SLDTQ",
+	"SLDTW",
+	"SMSWL",
+	"SMSWQ",
+	"SMSWW",
+	"SQRTPD",
+	"SQRTPS",
+	"SQRTSD",
+	"SQRTSS",
+	"STAC",
+	"STC",
+	"STD",
+	"STI",
+	"STMXCSR",
+	"STOSB",
+	"STOSL",
+	"STOSQ",
+	"STOSW",
+	"STRL",
+	"STRQ",
+	"STRW",
+	"SUBB",
+	"SUBL",
+	"SUBPD",
+	"SUBPS",
+	"SUBQ",
+	"SUBSD",
+	"SUBSS",
+	"SUBW",
+	"SWAPGS",
+	"SYSCALL",
+	"SYSENTER",
+	"SYSENTER64",
+	"SYSEXIT",
+	"SYSEXIT64",
+	"SYSRET",
+	"TESTB",
+	"TESTL",
+	"TESTQ",
+	"TESTW",
+	"TPAUSE",
+	"TZCNTL",
+	"TZCNTQ",
+	"TZCNTW",
+	"UCOMISD",
+	"UCOMISS",
+	"UD1",
+	"UD2",
+	"UMWAIT",
+	"UNPCKHPD",
+	"UNPCKHPS",
+	"UNPCKLPD",
+	"UNPCKLPS",
+	"UMONITOR",
+	"V4FMADDPS",
+	"V4FMADDSS",
+	"V4FNMADDPS",
+	"V4FNMADDSS",
+	"VADDPD",
+	"VADDPS",
+	"VADDSD",
+	"VADDSS",
+	"VADDSUBPD",
+	"VADDSUBPS",
+	"VAESDEC",
+	"VAESDECLAST",
+	"VAESENC",
+	"VAESENCLAST",
+	"VAESIMC",
+	"VAESKEYGENASSIST",
+	"VALIGND",
+	"VALIGNQ",
+	"VANDNPD",
+	"VANDNPS",
+	"VANDPD",
+	"VANDPS",
+	"VBLENDMPD",
+	"VBLENDMPS",
+	"VBLENDPD",
+	"VBLENDPS",
+	"VBLENDVPD",
+	"VBLENDVPS",
+	"VBROADCASTF128",
+	"VBROADCASTF32X2",
+	"VBROADCASTF32X4",
+	"VBROADCASTF32X8",
+	"VBROADCASTF64X2",
+	"VBROADCASTF64X4",
+	"VBROADCASTI128",
+	"VBROADCASTI32X2",
+	"VBROADCASTI32X4",
+	"VBROADCASTI32X8",
+	"VBROADCASTI64X2",
+	"VBROADCASTI64X4",
+	"VBROADCASTSD",
+	"VBROADCASTSS",
+	"VCMPPD",
+	"VCMPPS",
+	"VCMPSD",
+	"VCMPSS",
+	"VCOMISD",
+	"VCOMISS",
+	"VCOMPRESSPD",
+	"VCOMPRESSPS",
+	"VCVTDQ2PD",
+	"VCVTDQ2PS",
+	"VCVTPD2DQ",
+	"VCVTPD2DQX",
+	"VCVTPD2DQY",
+	"VCVTPD2PS",
+	"VCVTPD2PSX",
+	"VCVTPD2PSY",
+	"VCVTPD2QQ",
+	"VCVTPD2UDQ",
+	"VCVTPD2UDQX",
+	"VCVTPD2UDQY",
+	"VCVTPD2UQQ",
+	"VCVTPH2PS",
+	"VCVTPS2DQ",
+	"VCVTPS2PD",
+	"VCVTPS2PH",
+	"VCVTPS2QQ",
+	"VCVTPS2UDQ",
+	"VCVTPS2UQQ",
+	"VCVTQQ2PD",
+	"VCVTQQ2PS",
+	"VCVTQQ2PSX",
+	"VCVTQQ2PSY",
+	"VCVTSD2SI",
+	"VCVTSD2SIQ",
+	"VCVTSD2SS",
+	"VCVTSD2USI",
+	"VCVTSD2USIL",
+	"VCVTSD2USIQ",
+	"VCVTSI2SDL",
+	"VCVTSI2SDQ",
+	"VCVTSI2SSL",
+	"VCVTSI2SSQ",
+	"VCVTSS2SD",
+	"VCVTSS2SI",
+	"VCVTSS2SIQ",
+	"VCVTSS2USI",
+	"VCVTSS2USIL",
+	"VCVTSS2USIQ",
+	"VCVTTPD2DQ",
+	"VCVTTPD2DQX",
+	"VCVTTPD2DQY",
+	"VCVTTPD2QQ",
+	"VCVTTPD2UDQ",
+	"VCVTTPD2UDQX",
+	"VCVTTPD2UDQY",
+	"VCVTTPD2UQQ",
+	"VCVTTPS2DQ",
+	"VCVTTPS2QQ",
+	"VCVTTPS2UDQ",
+	"VCVTTPS2UQQ",
+	"VCVTTSD2SI",
+	"VCVTTSD2SIQ",
+	"VCVTTSD2USI",
+	"VCVTTSD2USIL",
+	"VCVTTSD2USIQ",
+	"VCVTTSS2SI",
+	"VCVTTSS2SIQ",
+	"VCVTTSS2USI",
+	"VCVTTSS2USIL",
+	"VCVTTSS2USIQ",
+	"VCVTUDQ2PD",
+	"VCVTUDQ2PS",
+	"VCVTUQQ2PD",
+	"VCVTUQQ2PS",
+	"VCVTUQQ2PSX",
+	"VCVTUQQ2PSY",
+	"VCVTUSI2SD",
+	"VCVTUSI2SDL",
+	"VCVTUSI2SDQ",
+	"VCVTUSI2SS",
+	"VCVTUSI2SSL",
+	"VCVTUSI2SSQ",
+	"VDBPSADBW",
+	"VDIVPD",
+	"VDIVPS",
+	"VDIVSD",
+	"VDIVSS",
+	"VDPPD",
+	"VDPPS",
+	"VERR",
+	"VERW",
+	"VEXP2PD",
+	"VEXP2PS",
+	"VEXPANDPD",
+	"VEXPANDPS",
+	"VEXTRACTF128",
+	"VEXTRACTF32X4",
+	"VEXTRACTF32X8",
+	"VEXTRACTF64X2",
+	"VEXTRACTF64X4",
+	"VEXTRACTI128",
+	"VEXTRACTI32X4",
+	"VEXTRACTI32X8",
+	"VEXTRACTI64X2",
+	"VEXTRACTI64X4",
+	"VEXTRACTPS",
+	"VFIXUPIMMPD",
+	"VFIXUPIMMPS",
+	"VFIXUPIMMSD",
+	"VFIXUPIMMSS",
+	"VFMADD132PD",
+	"VFMADD132PS",
+	"VFMADD132SD",
+	"VFMADD132SS",
+	"VFMADD213PD",
+	"VFMADD213PS",
+	"VFMADD213SD",
+	"VFMADD213SS",
+	"VFMADD231PD",
+	"VFMADD231PS",
+	"VFMADD231SD",
+	"VFMADD231SS",
+	"VFMADDSUB132PD",
+	"VFMADDSUB132PS",
+	"VFMADDSUB213PD",
+	"VFMADDSUB213PS",
+	"VFMADDSUB231PD",
+	"VFMADDSUB231PS",
+	"VFMSUB132PD",
+	"VFMSUB132PS",
+	"VFMSUB132SD",
+	"VFMSUB132SS",
+	"VFMSUB213PD",
+	"VFMSUB213PS",
+	"VFMSUB213SD",
+	"VFMSUB213SS",
+	"VFMSUB231PD",
+	"VFMSUB231PS",
+	"VFMSUB231SD",
+	"VFMSUB231SS",
+	"VFMSUBADD132PD",
+	"VFMSUBADD132PS",
+	"VFMSUBADD213PD",
+	"VFMSUBADD213PS",
+	"VFMSUBADD231PD",
+	"VFMSUBADD231PS",
+	"VFNMADD132PD",
+	"VFNMADD132PS",
+	"VFNMADD132SD",
+	"VFNMADD132SS",
+	"VFNMADD213PD",
+	"VFNMADD213PS",
+	"VFNMADD213SD",
+	"VFNMADD213SS",
+	"VFNMADD231PD",
+	"VFNMADD231PS",
+	"VFNMADD231SD",
+	"VFNMADD231SS",
+	"VFNMSUB132PD",
+	"VFNMSUB132PS",
+	"VFNMSUB132SD",
+	"VFNMSUB132SS",
+	"VFNMSUB213PD",
+	"VFNMSUB213PS",
+	"VFNMSUB213SD",
+	"VFNMSUB213SS",
+	"VFNMSUB231PD",
+	"VFNMSUB231PS",
+	"VFNMSUB231SD",
+	"VFNMSUB231SS",
+	"VFPCLASSPD",
+	"VFPCLASSPDX",
+	"VFPCLASSPDY",
+	"VFPCLASSPDZ",
+	"VFPCLASSPS",
+	"VFPCLASSPSX",
+	"VFPCLASSPSY",
+	"VFPCLASSPSZ",
+	"VFPCLASSSD",
+	"VFPCLASSSS",
+	"VGATHERDPD",
+	"VGATHERDPS",
+	"VGATHERPF0DPD",
+	"VGATHERPF0DPS",
+	"VGATHERPF0QPD",
+	"VGATHERPF0QPS",
+	"VGATHERPF1DPD",
+	"VGATHERPF1DPS",
+	"VGATHERPF1QPD",
+	"VGATHERPF1QPS",
+	"VGATHERQPD",
+	"VGATHERQPS",
+	"VGETEXPPD",
+	"VGETEXPPS",
+	"VGETEXPSD",
+	"VGETEXPSS",
+	"VGETMANTPD",
+	"VGETMANTPS",
+	"VGETMANTSD",
+	"VGETMANTSS",
+	"VGF2P8AFFINEINVQB",
+	"VGF2P8AFFINEQB",
+	"VGF2P8MULB",
+	"VHADDPD",
+	"VHADDPS",
+	"VHSUBPD",
+	"VHSUBPS",
+	"VINSERTF128",
+	"VINSERTF32X4",
+	"VINSERTF32X8",
+	"VINSERTF64X2",
+	"VINSERTF64X4",
+	"VINSERTI128",
+	"VINSERTI32X4",
+	"VINSERTI32X8",
+	"VINSERTI64X2",
+	"VINSERTI64X4",
+	"VINSERTPS",
+	"VLDDQU",
+	"VLDMXCSR",
+	"VMASKMOVDQU",
+	"VMASKMOVPD",
+	"VMASKMOVPS",
+	"VMAXPD",
+	"VMAXPS",
+	"VMAXSD",
+	"VMAXSS",
+	"VMINPD",
+	"VMINPS",
+	"VMINSD",
+	"VMINSS",
+	"VMOVAPD",
+	"VMOVAPS",
+	"VMOVD",
+	"VMOVDDUP",
+	"VMOVDQA",
+	"VMOVDQA32",
+	"VMOVDQA64",
+	"VMOVDQU",
+	"VMOVDQU16",
+	"VMOVDQU32",
+	"VMOVDQU64",
+	"VMOVDQU8",
+	"VMOVHLPS",
+	"VMOVHPD",
+	"VMOVHPS",
+	"VMOVLHPS",
+	"VMOVLPD",
+	"VMOVLPS",
+	"VMOVMSKPD",
+	"VMOVMSKPS",
+	"VMOVNTDQ",
+	"VMOVNTDQA",
+	"VMOVNTPD",
+	"VMOVNTPS",
+	"VMOVQ",
+	"VMOVSD",
+	"VMOVSHDUP",
+	"VMOVSLDUP",
+	"VMOVSS",
+	"VMOVUPD",
+	"VMOVUPS",
+	"VMPSADBW",
+	"VMULPD",
+	"VMULPS",
+	"VMULSD",
+	"VMULSS",
+	"VORPD",
+	"VORPS",
+	"VP4DPWSSD",
+	"VP4DPWSSDS",
+	"VPABSB",
+	"VPABSD",
+	"VPABSQ",
+	"VPABSW",
+	"VPACKSSDW",
+	"VPACKSSWB",
+	"VPACKUSDW",
+	"VPACKUSWB",
+	"VPADDB",
+	"VPADDD",
+	"VPADDQ",
+	"VPADDSB",
+	"VPADDSW",
+	"VPADDUSB",
+	"VPADDUSW",
+	"VPADDW",
+	"VPALIGNR",
+	"VPAND",
+	"VPANDD",
+	"VPANDN",
+	"VPANDND",
+	"VPANDNQ",
+	"VPANDQ",
+	"VPAVGB",
+	"VPAVGW",
+	"VPBLENDD",
+	"VPBLENDMB",
+	"VPBLENDMD",
+	"VPBLENDMQ",
+	"VPBLENDMW",
+	"VPBLENDVB",
+	"VPBLENDW",
+	"VPBROADCASTB",
+	"VPBROADCASTD",
+	"VPBROADCASTMB2Q",
+	"VPBROADCASTMW2D",
+	"VPBROADCASTQ",
+	"VPBROADCASTW",
+	"VPCLMULQDQ",
+	"VPCMPB",
+	"VPCMPD",
+	"VPCMPEQB",
+	"VPCMPEQD",
+	"VPCMPEQQ",
+	"VPCMPEQW",
+	"VPCMPESTRI",
+	"VPCMPESTRM",
+	"VPCMPGTB",
+	"VPCMPGTD",
+	"VPCMPGTQ",
+	"VPCMPGTW",
+	"VPCMPISTRI",
+	"VPCMPISTRM",
+	"VPCMPQ",
+	"VPCMPUB",
+	"VPCMPUD",
+	"VPCMPUQ",
+	"VPCMPUW",
+	"VPCMPW",
+	"VPCOMPRESSB",
+	"VPCOMPRESSD",
+	"VPCOMPRESSQ",
+	"VPCOMPRESSW",
+	"VPCONFLICTD",
+	"VPCONFLICTQ",
+	"VPDPBUSD",
+	"VPDPBUSDS",
+	"VPDPWSSD",
+	"VPDPWSSDS",
+	"VPERM2F128",
+	"VPERM2I128",
+	"VPERMB",
+	"VPERMD",
+	"VPERMI2B",
+	"VPERMI2D",
+	"VPERMI2PD",
+	"VPERMI2PS",
+	"VPERMI2Q",
+	"VPERMI2W",
+	"VPERMILPD",
+	"VPERMILPS",
+	"VPERMPD",
+	"VPERMPS",
+	"VPERMQ",
+	"VPERMT2B",
+	"VPERMT2D",
+	"VPERMT2PD",
+	"VPERMT2PS",
+	"VPERMT2Q",
+	"VPERMT2W",
+	"VPERMW",
+	"VPEXPANDB",
+	"VPEXPANDD",
+	"VPEXPANDQ",
+	"VPEXPANDW",
+	"VPEXTRB",
+	"VPEXTRD",
+	"VPEXTRQ",
+	"VPEXTRW",
+	"VPGATHERDD",
+	"VPGATHERDQ",
+	"VPGATHERQD",
+	"VPGATHERQQ",
+	"VPHADDD",
+	"VPHADDSW",
+	"VPHADDW",
+	"VPHMINPOSUW",
+	"VPHSUBD",
+	"VPHSUBSW",
+	"VPHSUBW",
+	"VPINSRB",
+	"VPINSRD",
+	"VPINSRQ",
+	"VPINSRW",
+	"VPLZCNTD",
+	"VPLZCNTQ",
+	"VPMADD52HUQ",
+	"VPMADD52LUQ",
+	"VPMADDUBSW",
+	"VPMADDWD",
+	"VPMASKMOVD",
+	"VPMASKMOVQ",
+	"VPMAXSB",
+	"VPMAXSD",
+	"VPMAXSQ",
+	"VPMAXSW",
+	"VPMAXUB",
+	"VPMAXUD",
+	"VPMAXUQ",
+	"VPMAXUW",
+	"VPMINSB",
+	"VPMINSD",
+	"VPMINSQ",
+	"VPMINSW",
+	"VPMINUB",
+	"VPMINUD",
+	"VPMINUQ",
+	"VPMINUW",
+	"VPMOVB2M",
+	"VPMOVD2M",
+	"VPMOVDB",
+	"VPMOVDW",
+	"VPMOVM2B",
+	"VPMOVM2D",
+	"VPMOVM2Q",
+	"VPMOVM2W",
+	"VPMOVMSKB",
+	"VPMOVQ2M",
+	"VPMOVQB",
+	"VPMOVQD",
+	"VPMOVQW",
+	"VPMOVSDB",
+	"VPMOVSDW",
+	"VPMOVSQB",
+	"VPMOVSQD",
+	"VPMOVSQW",
+	"VPMOVSWB",
+	"VPMOVSXBD",
+	"VPMOVSXBQ",
+	"VPMOVSXBW",
+	"VPMOVSXDQ",
+	"VPMOVSXWD",
+	"VPMOVSXWQ",
+	"VPMOVUSDB",
+	"VPMOVUSDW",
+	"VPMOVUSQB",
+	"VPMOVUSQD",
+	"VPMOVUSQW",
+	"VPMOVUSWB",
+	"VPMOVW2M",
+	"VPMOVWB",
+	"VPMOVZXBD",
+	"VPMOVZXBQ",
+	"VPMOVZXBW",
+	"VPMOVZXDQ",
+	"VPMOVZXWD",
+	"VPMOVZXWQ",
+	"VPMULDQ",
+	"VPMULHRSW",
+	"VPMULHUW",
+	"VPMULHW",
+	"VPMULLD",
+	"VPMULLQ",
+	"VPMULLW",
+	"VPMULTISHIFTQB",
+	"VPMULUDQ",
+	"VPOPCNTB",
+	"VPOPCNTD",
+	"VPOPCNTQ",
+	"VPOPCNTW",
+	"VPOR",
+	"VPORD",
+	"VPORQ",
+	"VPROLD",
+	"VPROLQ",
+	"VPROLVD",
+	"VPROLVQ",
+	"VPRORD",
+	"VPRORQ",
+	"VPRORVD",
+	"VPRORVQ",
+	"VPSADBW",
+	"VPSCATTERDD",
+	"VPSCATTERDQ",
+	"VPSCATTERQD",
+	"VPSCATTERQQ",
+	"VPSHLDD",
+	"VPSHLDQ",
+	"VPSHLDVD",
+	"VPSHLDVQ",
+	"VPSHLDVW",
+	"VPSHLDW",
+	"VPSHRDD",
+	"VPSHRDQ",
+	"VPSHRDVD",
+	"VPSHRDVQ",
+	"VPSHRDVW",
+	"VPSHRDW",
+	"VPSHUFB",
+	"VPSHUFBITQMB",
+	"VPSHUFD",
+	"VPSHUFHW",
+	"VPSHUFLW",
+	"VPSIGNB",
+	"VPSIGND",
+	"VPSIGNW",
+	"VPSLLD",
+	"VPSLLDQ",
+	"VPSLLQ",
+	"VPSLLVD",
+	"VPSLLVQ",
+	"VPSLLVW",
+	"VPSLLW",
+	"VPSRAD",
+	"VPSRAQ",
+	"VPSRAVD",
+	"VPSRAVQ",
+	"VPSRAVW",
+	"VPSRAW",
+	"VPSRLD",
+	"VPSRLDQ",
+	"VPSRLQ",
+	"VPSRLVD",
+	"VPSRLVQ",
+	"VPSRLVW",
+	"VPSRLW",
+	"VPSUBB",
+	"VPSUBD",
+	"VPSUBQ",
+	"VPSUBSB",
+	"VPSUBSW",
+	"VPSUBUSB",
+	"VPSUBUSW",
+	"VPSUBW",
+	"VPTERNLOGD",
+	"VPTERNLOGQ",
+	"VPTEST",
+	"VPTESTMB",
+	"VPTESTMD",
+	"VPTESTMQ",
+	"VPTESTMW",
+	"VPTESTNMB",
+	"VPTESTNMD",
+	"VPTESTNMQ",
+	"VPTESTNMW",
+	"VPUNPCKHBW",
+	"VPUNPCKHDQ",
+	"VPUNPCKHQDQ",
+	"VPUNPCKHWD",
+	"VPUNPCKLBW",
+	"VPUNPCKLDQ",
+	"VPUNPCKLQDQ",
+	"VPUNPCKLWD",
+	"VPXOR",
+	"VPXORD",
+	"VPXORQ",
+	"VRANGEPD",
+	"VRANGEPS",
+	"VRANGESD",
+	"VRANGESS",
+	"VRCP14PD",
+	"VRCP14PS",
+	"VRCP14SD",
+	"VRCP14SS",
+	"VRCP28PD",
+	"VRCP28PS",
+	"VRCP28SD",
+	"VRCP28SS",
+	"VRCPPS",
+	"VRCPSS",
+	"VREDUCEPD",
+	"VREDUCEPS",
+	"VREDUCESD",
+	"VREDUCESS",
+	"VRNDSCALEPD",
+	"VRNDSCALEPS",
+	"VRNDSCALESD",
+	"VRNDSCALESS",
+	"VROUNDPD",
+	"VROUNDPS",
+	"VROUNDSD",
+	"VROUNDSS",
+	"VRSQRT14PD",
+	"VRSQRT14PS",
+	"VRSQRT14SD",
+	"VRSQRT14SS",
+	"VRSQRT28PD",
+	"VRSQRT28PS",
+	"VRSQRT28SD",
+	"VRSQRT28SS",
+	"VRSQRTPS",
+	"VRSQRTSS",
+	"VSCALEFPD",
+	"VSCALEFPS",
+	"VSCALEFSD",
+	"VSCALEFSS",
+	"VSCATTERDPD",
+	"VSCATTERDPS",
+	"VSCATTERPF0DPD",
+	"VSCATTERPF0DPS",
+	"VSCATTERPF0QPD",
+	"VSCATTERPF0QPS",
+	"VSCATTERPF1DPD",
+	"VSCATTERPF1DPS",
+	"VSCATTERPF1QPD",
+	"VSCATTERPF1QPS",
+	"VSCATTERQPD",
+	"VSCATTERQPS",
+	"VSHUFF32X4",
+	"VSHUFF64X2",
+	"VSHUFI32X4",
+	"VSHUFI64X2",
+	"VSHUFPD",
+	"VSHUFPS",
+	"VSQRTPD",
+	"VSQRTPS",
+	"VSQRTSD",
+	"VSQRTSS",
+	"VSTMXCSR",
+	"VSUBPD",
+	"VSUBPS",
+	"VSUBSD",
+	"VSUBSS",
+	"VTESTPD",
+	"VTESTPS",
+	"VUCOMISD",
+	"VUCOMISS",
+	"VUNPCKHPD",
+	"VUNPCKHPS",
+	"VUNPCKLPD",
+	"VUNPCKLPS",
+	"VXORPD",
+	"VXORPS",
+	"VZEROALL",
+	"VZEROUPPER",
+	"WAIT",
+	"WBINVD",
+	"WORD",
+	"WRFSBASEL",
+	"WRFSBASEQ",
+	"WRGSBASEL",
+	"WRGSBASEQ",
+	"WRMSR",
+	"WRPKRU",
+	"XABORT",
+	"XACQUIRE",
+	"XADDB",
+	"XADDL",
+	"XADDQ",
+	"XADDW",
+	"XBEGIN",
+	"XCHGB",
+	"XCHGL",
+	"XCHGQ",
+	"XCHGW",
+	"XEND",
+	"XGETBV",
+	"XLAT",
+	"XORB",
+	"XORL",
+	"XORPD",
+	"XORPS",
+	"XORQ",
+	"XORW",
+	"XRELEASE",
+	"XRSTOR",
+	"XRSTOR64",
+	"XRSTORS",
+	"XRSTORS64",
+	"XSAVE",
+	"XSAVE64",
+	"XSAVEC",
+	"XSAVEC64",
+	"XSAVEOPT",
+	"XSAVEOPT64",
+	"XSAVES",
+	"XSAVES64",
+	"XSETBV",
+	"XTEST",
+	"LAST",
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/asm6.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/asm6.go
new file mode 100644
index 000000000..8b7b9e9fa
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/asm6.go
@@ -0,0 +1,5446 @@
+// Inferno utils/6l/span.c
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/span.c
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package x86
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"github.com/twitchyliquid64/golang-asm/sys"
+	"encoding/binary"
+	"fmt"
+	"log"
+	"strings"
+)
+
+var (
+	plan9privates *obj.LSym
+	deferreturn   *obj.LSym
+)
+
+// Instruction layout.
+
+// Loop alignment constants:
+// want to align loop entry to loopAlign-byte boundary,
+// and willing to insert at most maxLoopPad bytes of NOP to do so.
+// We define a loop entry as the target of a backward jump.
+//
+// gcc uses maxLoopPad = 10 for its 'generic x86-64' config,
+// and it aligns all jump targets, not just backward jump targets.
+//
+// As of 6/1/2012, the effect of setting maxLoopPad = 10 here
+// is very slight but negative, so the alignment is disabled by
+// setting MaxLoopPad = 0. The code is here for reference and
+// for future experiments.
+//
+const (
+	loopAlign  = 16
+	maxLoopPad = 0
+)
+
+// Bit flags that are used to express jump target properties.
+const (
+	// branchBackwards marks targets that are located behind.
+	// Used to express jumps to loop headers.
+	branchBackwards = (1 << iota)
+	// branchShort marks branches those target is close,
+	// with offset is in -128..127 range.
+	branchShort
+	// branchLoopHead marks loop entry.
+	// Used to insert padding for misaligned loops.
+	branchLoopHead
+)
+
+// opBytes holds optab encoding bytes.
+// Each ytab reserves fixed amount of bytes in this array.
+//
+// The size should be the minimal number of bytes that
+// are enough to hold biggest optab op lines.
+type opBytes [31]uint8
+
+type Optab struct {
+	as     obj.As
+	ytab   []ytab
+	prefix uint8
+	op     opBytes
+}
+
+type movtab struct {
+	as   obj.As
+	ft   uint8
+	f3t  uint8
+	tt   uint8
+	code uint8
+	op   [4]uint8
+}
+
+const (
+	Yxxx = iota
+	Ynone
+	Yi0 // $0
+	Yi1 // $1
+	Yu2 // $x, x fits in uint2
+	Yi8 // $x, x fits in int8
+	Yu8 // $x, x fits in uint8
+	Yu7 // $x, x in 0..127 (fits in both int8 and uint8)
+	Ys32
+	Yi32
+	Yi64
+	Yiauto
+	Yal
+	Ycl
+	Yax
+	Ycx
+	Yrb
+	Yrl
+	Yrl32 // Yrl on 32-bit system
+	Yrf
+	Yf0
+	Yrx
+	Ymb
+	Yml
+	Ym
+	Ybr
+	Ycs
+	Yss
+	Yds
+	Yes
+	Yfs
+	Ygs
+	Ygdtr
+	Yidtr
+	Yldtr
+	Ymsw
+	Ytask
+	Ycr0
+	Ycr1
+	Ycr2
+	Ycr3
+	Ycr4
+	Ycr5
+	Ycr6
+	Ycr7
+	Ycr8
+	Ydr0
+	Ydr1
+	Ydr2
+	Ydr3
+	Ydr4
+	Ydr5
+	Ydr6
+	Ydr7
+	Ytr0
+	Ytr1
+	Ytr2
+	Ytr3
+	Ytr4
+	Ytr5
+	Ytr6
+	Ytr7
+	Ymr
+	Ymm
+	Yxr0          // X0 only. "<XMM0>" notation in Intel manual.
+	YxrEvexMulti4 // [ X<n> - X<n+3> ]; multisource YxrEvex
+	Yxr           // X0..X15
+	YxrEvex       // X0..X31
+	Yxm
+	YxmEvex       // YxrEvex+Ym
+	Yxvm          // VSIB vector array; vm32x/vm64x
+	YxvmEvex      // Yxvm which permits High-16 X register as index.
+	YyrEvexMulti4 // [ Y<n> - Y<n+3> ]; multisource YyrEvex
+	Yyr           // Y0..Y15
+	YyrEvex       // Y0..Y31
+	Yym
+	YymEvex   // YyrEvex+Ym
+	Yyvm      // VSIB vector array; vm32y/vm64y
+	YyvmEvex  // Yyvm which permits High-16 Y register as index.
+	YzrMulti4 // [ Z<n> - Z<n+3> ]; multisource YzrEvex
+	Yzr       // Z0..Z31
+	Yzm       // Yzr+Ym
+	Yzvm      // VSIB vector array; vm32z/vm64z
+	Yk0       // K0
+	Yknot0    // K1..K7; write mask
+	Yk        // K0..K7; used for KOP
+	Ykm       // Yk+Ym; used for KOP
+	Ytls
+	Ytextsize
+	Yindir
+	Ymax
+)
+
+const (
+	Zxxx = iota
+	Zlit
+	Zlitm_r
+	Zlitr_m
+	Zlit_m_r
+	Z_rp
+	Zbr
+	Zcall
+	Zcallcon
+	Zcallduff
+	Zcallind
+	Zcallindreg
+	Zib_
+	Zib_rp
+	Zibo_m
+	Zibo_m_xm
+	Zil_
+	Zil_rp
+	Ziq_rp
+	Zilo_m
+	Zjmp
+	Zjmpcon
+	Zloop
+	Zo_iw
+	Zm_o
+	Zm_r
+	Z_m_r
+	Zm2_r
+	Zm_r_xm
+	Zm_r_i_xm
+	Zm_r_xm_nr
+	Zr_m_xm_nr
+	Zibm_r // mmx1,mmx2/mem64,imm8
+	Zibr_m
+	Zmb_r
+	Zaut_r
+	Zo_m
+	Zo_m64
+	Zpseudo
+	Zr_m
+	Zr_m_xm
+	Zrp_
+	Z_ib
+	Z_il
+	Zm_ibo
+	Zm_ilo
+	Zib_rr
+	Zil_rr
+	Zbyte
+
+	Zvex_rm_v_r
+	Zvex_rm_v_ro
+	Zvex_r_v_rm
+	Zvex_i_rm_vo
+	Zvex_v_rm_r
+	Zvex_i_rm_r
+	Zvex_i_r_v
+	Zvex_i_rm_v_r
+	Zvex
+	Zvex_rm_r_vo
+	Zvex_i_r_rm
+	Zvex_hr_rm_v_r
+
+	Zevex_first
+	Zevex_i_r_k_rm
+	Zevex_i_r_rm
+	Zevex_i_rm_k_r
+	Zevex_i_rm_k_vo
+	Zevex_i_rm_r
+	Zevex_i_rm_v_k_r
+	Zevex_i_rm_v_r
+	Zevex_i_rm_vo
+	Zevex_k_rmo
+	Zevex_r_k_rm
+	Zevex_r_v_k_rm
+	Zevex_r_v_rm
+	Zevex_rm_k_r
+	Zevex_rm_v_k_r
+	Zevex_rm_v_r
+	Zevex_last
+
+	Zmax
+)
+
+const (
+	Px   = 0
+	Px1  = 1    // symbolic; exact value doesn't matter
+	P32  = 0x32 // 32-bit only
+	Pe   = 0x66 // operand escape
+	Pm   = 0x0f // 2byte opcode escape
+	Pq   = 0xff // both escapes: 66 0f
+	Pb   = 0xfe // byte operands
+	Pf2  = 0xf2 // xmm escape 1: f2 0f
+	Pf3  = 0xf3 // xmm escape 2: f3 0f
+	Pef3 = 0xf5 // xmm escape 2 with 16-bit prefix: 66 f3 0f
+	Pq3  = 0x67 // xmm escape 3: 66 48 0f
+	Pq4  = 0x68 // xmm escape 4: 66 0F 38
+	Pq4w = 0x69 // Pq4 with Rex.w 66 0F 38
+	Pq5  = 0x6a // xmm escape 5: F3 0F 38
+	Pq5w = 0x6b // Pq5 with Rex.w F3 0F 38
+	Pfw  = 0xf4 // Pf3 with Rex.w: f3 48 0f
+	Pw   = 0x48 // Rex.w
+	Pw8  = 0x90 // symbolic; exact value doesn't matter
+	Py   = 0x80 // defaults to 64-bit mode
+	Py1  = 0x81 // symbolic; exact value doesn't matter
+	Py3  = 0x83 // symbolic; exact value doesn't matter
+	Pavx = 0x84 // symbolic: exact value doesn't matter
+
+	RxrEvex = 1 << 4 // AVX512 extension to REX.R/VEX.R
+	Rxw     = 1 << 3 // =1, 64-bit operand size
+	Rxr     = 1 << 2 // extend modrm reg
+	Rxx     = 1 << 1 // extend sib index
+	Rxb     = 1 << 0 // extend modrm r/m, sib base, or opcode reg
+)
+
+const (
+	// Encoding for VEX prefix in tables.
+	// The P, L, and W fields are chosen to match
+	// their eventual locations in the VEX prefix bytes.
+
+	// Encoding for VEX prefix in tables.
+	// The P, L, and W fields are chosen to match
+	// their eventual locations in the VEX prefix bytes.
+
+	// Using spare bit to make leading [E]VEX encoding byte different from
+	// 0x0f even if all other VEX fields are 0.
+	avxEscape = 1 << 6
+
+	// P field - 2 bits
+	vex66 = 1 << 0
+	vexF3 = 2 << 0
+	vexF2 = 3 << 0
+	// L field - 1 bit
+	vexLZ  = 0 << 2
+	vexLIG = 0 << 2
+	vex128 = 0 << 2
+	vex256 = 1 << 2
+	// W field - 1 bit
+	vexWIG = 0 << 7
+	vexW0  = 0 << 7
+	vexW1  = 1 << 7
+	// M field - 5 bits, but mostly reserved; we can store up to 3
+	vex0F   = 1 << 3
+	vex0F38 = 2 << 3
+	vex0F3A = 3 << 3
+)
+
+var ycover [Ymax * Ymax]uint8
+
+var reg [MAXREG]int
+
+var regrex [MAXREG + 1]int
+
+var ynone = []ytab{
+	{Zlit, 1, argList{}},
+}
+
+var ytext = []ytab{
+	{Zpseudo, 0, argList{Ymb, Ytextsize}},
+	{Zpseudo, 1, argList{Ymb, Yi32, Ytextsize}},
+}
+
+var ynop = []ytab{
+	{Zpseudo, 0, argList{}},
+	{Zpseudo, 0, argList{Yiauto}},
+	{Zpseudo, 0, argList{Yml}},
+	{Zpseudo, 0, argList{Yrf}},
+	{Zpseudo, 0, argList{Yxr}},
+	{Zpseudo, 0, argList{Yiauto}},
+	{Zpseudo, 0, argList{Yml}},
+	{Zpseudo, 0, argList{Yrf}},
+	{Zpseudo, 1, argList{Yxr}},
+}
+
+var yfuncdata = []ytab{
+	{Zpseudo, 0, argList{Yi32, Ym}},
+}
+
+var ypcdata = []ytab{
+	{Zpseudo, 0, argList{Yi32, Yi32}},
+}
+
+var yxorb = []ytab{
+	{Zib_, 1, argList{Yi32, Yal}},
+	{Zibo_m, 2, argList{Yi32, Ymb}},
+	{Zr_m, 1, argList{Yrb, Ymb}},
+	{Zm_r, 1, argList{Ymb, Yrb}},
+}
+
+var yaddl = []ytab{
+	{Zibo_m, 2, argList{Yi8, Yml}},
+	{Zil_, 1, argList{Yi32, Yax}},
+	{Zilo_m, 2, argList{Yi32, Yml}},
+	{Zr_m, 1, argList{Yrl, Yml}},
+	{Zm_r, 1, argList{Yml, Yrl}},
+}
+
+var yincl = []ytab{
+	{Z_rp, 1, argList{Yrl}},
+	{Zo_m, 2, argList{Yml}},
+}
+
+var yincq = []ytab{
+	{Zo_m, 2, argList{Yml}},
+}
+
+var ycmpb = []ytab{
+	{Z_ib, 1, argList{Yal, Yi32}},
+	{Zm_ibo, 2, argList{Ymb, Yi32}},
+	{Zm_r, 1, argList{Ymb, Yrb}},
+	{Zr_m, 1, argList{Yrb, Ymb}},
+}
+
+var ycmpl = []ytab{
+	{Zm_ibo, 2, argList{Yml, Yi8}},
+	{Z_il, 1, argList{Yax, Yi32}},
+	{Zm_ilo, 2, argList{Yml, Yi32}},
+	{Zm_r, 1, argList{Yml, Yrl}},
+	{Zr_m, 1, argList{Yrl, Yml}},
+}
+
+var yshb = []ytab{
+	{Zo_m, 2, argList{Yi1, Ymb}},
+	{Zibo_m, 2, argList{Yu8, Ymb}},
+	{Zo_m, 2, argList{Ycx, Ymb}},
+}
+
+var yshl = []ytab{
+	{Zo_m, 2, argList{Yi1, Yml}},
+	{Zibo_m, 2, argList{Yu8, Yml}},
+	{Zo_m, 2, argList{Ycl, Yml}},
+	{Zo_m, 2, argList{Ycx, Yml}},
+}
+
+var ytestl = []ytab{
+	{Zil_, 1, argList{Yi32, Yax}},
+	{Zilo_m, 2, argList{Yi32, Yml}},
+	{Zr_m, 1, argList{Yrl, Yml}},
+	{Zm_r, 1, argList{Yml, Yrl}},
+}
+
+var ymovb = []ytab{
+	{Zr_m, 1, argList{Yrb, Ymb}},
+	{Zm_r, 1, argList{Ymb, Yrb}},
+	{Zib_rp, 1, argList{Yi32, Yrb}},
+	{Zibo_m, 2, argList{Yi32, Ymb}},
+}
+
+var ybtl = []ytab{
+	{Zibo_m, 2, argList{Yi8, Yml}},
+	{Zr_m, 1, argList{Yrl, Yml}},
+}
+
+var ymovw = []ytab{
+	{Zr_m, 1, argList{Yrl, Yml}},
+	{Zm_r, 1, argList{Yml, Yrl}},
+	{Zil_rp, 1, argList{Yi32, Yrl}},
+	{Zilo_m, 2, argList{Yi32, Yml}},
+	{Zaut_r, 2, argList{Yiauto, Yrl}},
+}
+
+var ymovl = []ytab{
+	{Zr_m, 1, argList{Yrl, Yml}},
+	{Zm_r, 1, argList{Yml, Yrl}},
+	{Zil_rp, 1, argList{Yi32, Yrl}},
+	{Zilo_m, 2, argList{Yi32, Yml}},
+	{Zm_r_xm, 1, argList{Yml, Ymr}}, // MMX MOVD
+	{Zr_m_xm, 1, argList{Ymr, Yml}}, // MMX MOVD
+	{Zm_r_xm, 2, argList{Yml, Yxr}}, // XMM MOVD (32 bit)
+	{Zr_m_xm, 2, argList{Yxr, Yml}}, // XMM MOVD (32 bit)
+	{Zaut_r, 2, argList{Yiauto, Yrl}},
+}
+
+var yret = []ytab{
+	{Zo_iw, 1, argList{}},
+	{Zo_iw, 1, argList{Yi32}},
+}
+
+var ymovq = []ytab{
+	// valid in 32-bit mode
+	{Zm_r_xm_nr, 1, argList{Ym, Ymr}},  // 0x6f MMX MOVQ (shorter encoding)
+	{Zr_m_xm_nr, 1, argList{Ymr, Ym}},  // 0x7f MMX MOVQ
+	{Zm_r_xm_nr, 2, argList{Yxr, Ymr}}, // Pf2, 0xd6 MOVDQ2Q
+	{Zm_r_xm_nr, 2, argList{Yxm, Yxr}}, // Pf3, 0x7e MOVQ xmm1/m64 -> xmm2
+	{Zr_m_xm_nr, 2, argList{Yxr, Yxm}}, // Pe, 0xd6 MOVQ xmm1 -> xmm2/m64
+
+	// valid only in 64-bit mode, usually with 64-bit prefix
+	{Zr_m, 1, argList{Yrl, Yml}},      // 0x89
+	{Zm_r, 1, argList{Yml, Yrl}},      // 0x8b
+	{Zilo_m, 2, argList{Ys32, Yrl}},   // 32 bit signed 0xc7,(0)
+	{Ziq_rp, 1, argList{Yi64, Yrl}},   // 0xb8 -- 32/64 bit immediate
+	{Zilo_m, 2, argList{Yi32, Yml}},   // 0xc7,(0)
+	{Zm_r_xm, 1, argList{Ymm, Ymr}},   // 0x6e MMX MOVD
+	{Zr_m_xm, 1, argList{Ymr, Ymm}},   // 0x7e MMX MOVD
+	{Zm_r_xm, 2, argList{Yml, Yxr}},   // Pe, 0x6e MOVD xmm load
+	{Zr_m_xm, 2, argList{Yxr, Yml}},   // Pe, 0x7e MOVD xmm store
+	{Zaut_r, 1, argList{Yiauto, Yrl}}, // 0 built-in LEAQ
+}
+
+var ymovbe = []ytab{
+	{Zlitm_r, 3, argList{Ym, Yrl}},
+	{Zlitr_m, 3, argList{Yrl, Ym}},
+}
+
+var ym_rl = []ytab{
+	{Zm_r, 1, argList{Ym, Yrl}},
+}
+
+var yrl_m = []ytab{
+	{Zr_m, 1, argList{Yrl, Ym}},
+}
+
+var ymb_rl = []ytab{
+	{Zmb_r, 1, argList{Ymb, Yrl}},
+}
+
+var yml_rl = []ytab{
+	{Zm_r, 1, argList{Yml, Yrl}},
+}
+
+var yrl_ml = []ytab{
+	{Zr_m, 1, argList{Yrl, Yml}},
+}
+
+var yml_mb = []ytab{
+	{Zr_m, 1, argList{Yrb, Ymb}},
+	{Zm_r, 1, argList{Ymb, Yrb}},
+}
+
+var yrb_mb = []ytab{
+	{Zr_m, 1, argList{Yrb, Ymb}},
+}
+
+var yxchg = []ytab{
+	{Z_rp, 1, argList{Yax, Yrl}},
+	{Zrp_, 1, argList{Yrl, Yax}},
+	{Zr_m, 1, argList{Yrl, Yml}},
+	{Zm_r, 1, argList{Yml, Yrl}},
+}
+
+var ydivl = []ytab{
+	{Zm_o, 2, argList{Yml}},
+}
+
+var ydivb = []ytab{
+	{Zm_o, 2, argList{Ymb}},
+}
+
+var yimul = []ytab{
+	{Zm_o, 2, argList{Yml}},
+	{Zib_rr, 1, argList{Yi8, Yrl}},
+	{Zil_rr, 1, argList{Yi32, Yrl}},
+	{Zm_r, 2, argList{Yml, Yrl}},
+}
+
+var yimul3 = []ytab{
+	{Zibm_r, 2, argList{Yi8, Yml, Yrl}},
+	{Zibm_r, 2, argList{Yi32, Yml, Yrl}},
+}
+
+var ybyte = []ytab{
+	{Zbyte, 1, argList{Yi64}},
+}
+
+var yin = []ytab{
+	{Zib_, 1, argList{Yi32}},
+	{Zlit, 1, argList{}},
+}
+
+var yint = []ytab{
+	{Zib_, 1, argList{Yi32}},
+}
+
+var ypushl = []ytab{
+	{Zrp_, 1, argList{Yrl}},
+	{Zm_o, 2, argList{Ym}},
+	{Zib_, 1, argList{Yi8}},
+	{Zil_, 1, argList{Yi32}},
+}
+
+var ypopl = []ytab{
+	{Z_rp, 1, argList{Yrl}},
+	{Zo_m, 2, argList{Ym}},
+}
+
+var ywrfsbase = []ytab{
+	{Zm_o, 2, argList{Yrl}},
+}
+
+var yrdrand = []ytab{
+	{Zo_m, 2, argList{Yrl}},
+}
+
+var yclflush = []ytab{
+	{Zo_m, 2, argList{Ym}},
+}
+
+var ybswap = []ytab{
+	{Z_rp, 2, argList{Yrl}},
+}
+
+var yscond = []ytab{
+	{Zo_m, 2, argList{Ymb}},
+}
+
+var yjcond = []ytab{
+	{Zbr, 0, argList{Ybr}},
+	{Zbr, 0, argList{Yi0, Ybr}},
+	{Zbr, 1, argList{Yi1, Ybr}},
+}
+
+var yloop = []ytab{
+	{Zloop, 1, argList{Ybr}},
+}
+
+var ycall = []ytab{
+	{Zcallindreg, 0, argList{Yml}},
+	{Zcallindreg, 2, argList{Yrx, Yrx}},
+	{Zcallind, 2, argList{Yindir}},
+	{Zcall, 0, argList{Ybr}},
+	{Zcallcon, 1, argList{Yi32}},
+}
+
+var yduff = []ytab{
+	{Zcallduff, 1, argList{Yi32}},
+}
+
+var yjmp = []ytab{
+	{Zo_m64, 2, argList{Yml}},
+	{Zjmp, 0, argList{Ybr}},
+	{Zjmpcon, 1, argList{Yi32}},
+}
+
+var yfmvd = []ytab{
+	{Zm_o, 2, argList{Ym, Yf0}},
+	{Zo_m, 2, argList{Yf0, Ym}},
+	{Zm_o, 2, argList{Yrf, Yf0}},
+	{Zo_m, 2, argList{Yf0, Yrf}},
+}
+
+var yfmvdp = []ytab{
+	{Zo_m, 2, argList{Yf0, Ym}},
+	{Zo_m, 2, argList{Yf0, Yrf}},
+}
+
+var yfmvf = []ytab{
+	{Zm_o, 2, argList{Ym, Yf0}},
+	{Zo_m, 2, argList{Yf0, Ym}},
+}
+
+var yfmvx = []ytab{
+	{Zm_o, 2, argList{Ym, Yf0}},
+}
+
+var yfmvp = []ytab{
+	{Zo_m, 2, argList{Yf0, Ym}},
+}
+
+var yfcmv = []ytab{
+	{Zm_o, 2, argList{Yrf, Yf0}},
+}
+
+var yfadd = []ytab{
+	{Zm_o, 2, argList{Ym, Yf0}},
+	{Zm_o, 2, argList{Yrf, Yf0}},
+	{Zo_m, 2, argList{Yf0, Yrf}},
+}
+
+var yfxch = []ytab{
+	{Zo_m, 2, argList{Yf0, Yrf}},
+	{Zm_o, 2, argList{Yrf, Yf0}},
+}
+
+var ycompp = []ytab{
+	{Zo_m, 2, argList{Yf0, Yrf}}, // botch is really f0,f1
+}
+
+var ystsw = []ytab{
+	{Zo_m, 2, argList{Ym}},
+	{Zlit, 1, argList{Yax}},
+}
+
+var ysvrs_mo = []ytab{
+	{Zm_o, 2, argList{Ym}},
+}
+
+// unaryDst version of "ysvrs_mo".
+var ysvrs_om = []ytab{
+	{Zo_m, 2, argList{Ym}},
+}
+
+var ymm = []ytab{
+	{Zm_r_xm, 1, argList{Ymm, Ymr}},
+	{Zm_r_xm, 2, argList{Yxm, Yxr}},
+}
+
+var yxm = []ytab{
+	{Zm_r_xm, 1, argList{Yxm, Yxr}},
+}
+
+var yxm_q4 = []ytab{
+	{Zm_r, 1, argList{Yxm, Yxr}},
+}
+
+var yxcvm1 = []ytab{
+	{Zm_r_xm, 2, argList{Yxm, Yxr}},
+	{Zm_r_xm, 2, argList{Yxm, Ymr}},
+}
+
+var yxcvm2 = []ytab{
+	{Zm_r_xm, 2, argList{Yxm, Yxr}},
+	{Zm_r_xm, 2, argList{Ymm, Yxr}},
+}
+
+var yxr = []ytab{
+	{Zm_r_xm, 1, argList{Yxr, Yxr}},
+}
+
+var yxr_ml = []ytab{
+	{Zr_m_xm, 1, argList{Yxr, Yml}},
+}
+
+var ymr = []ytab{
+	{Zm_r, 1, argList{Ymr, Ymr}},
+}
+
+var ymr_ml = []ytab{
+	{Zr_m_xm, 1, argList{Ymr, Yml}},
+}
+
+var yxcmpi = []ytab{
+	{Zm_r_i_xm, 2, argList{Yxm, Yxr, Yi8}},
+}
+
+var yxmov = []ytab{
+	{Zm_r_xm, 1, argList{Yxm, Yxr}},
+	{Zr_m_xm, 1, argList{Yxr, Yxm}},
+}
+
+var yxcvfl = []ytab{
+	{Zm_r_xm, 1, argList{Yxm, Yrl}},
+}
+
+var yxcvlf = []ytab{
+	{Zm_r_xm, 1, argList{Yml, Yxr}},
+}
+
+var yxcvfq = []ytab{
+	{Zm_r_xm, 2, argList{Yxm, Yrl}},
+}
+
+var yxcvqf = []ytab{
+	{Zm_r_xm, 2, argList{Yml, Yxr}},
+}
+
+var yps = []ytab{
+	{Zm_r_xm, 1, argList{Ymm, Ymr}},
+	{Zibo_m_xm, 2, argList{Yi8, Ymr}},
+	{Zm_r_xm, 2, argList{Yxm, Yxr}},
+	{Zibo_m_xm, 3, argList{Yi8, Yxr}},
+}
+
+var yxrrl = []ytab{
+	{Zm_r, 1, argList{Yxr, Yrl}},
+}
+
+var ymrxr = []ytab{
+	{Zm_r, 1, argList{Ymr, Yxr}},
+	{Zm_r_xm, 1, argList{Yxm, Yxr}},
+}
+
+var ymshuf = []ytab{
+	{Zibm_r, 2, argList{Yi8, Ymm, Ymr}},
+}
+
+var ymshufb = []ytab{
+	{Zm2_r, 2, argList{Yxm, Yxr}},
+}
+
+// It should never have more than 1 entry,
+// because some optab entries you opcode secuences that
+// are longer than 2 bytes (zoffset=2 here),
+// ROUNDPD and ROUNDPS and recently added BLENDPD,
+// to name a few.
+var yxshuf = []ytab{
+	{Zibm_r, 2, argList{Yu8, Yxm, Yxr}},
+}
+
+var yextrw = []ytab{
+	{Zibm_r, 2, argList{Yu8, Yxr, Yrl}},
+	{Zibr_m, 2, argList{Yu8, Yxr, Yml}},
+}
+
+var yextr = []ytab{
+	{Zibr_m, 3, argList{Yu8, Yxr, Ymm}},
+}
+
+var yinsrw = []ytab{
+	{Zibm_r, 2, argList{Yu8, Yml, Yxr}},
+}
+
+var yinsr = []ytab{
+	{Zibm_r, 3, argList{Yu8, Ymm, Yxr}},
+}
+
+var ypsdq = []ytab{
+	{Zibo_m, 2, argList{Yi8, Yxr}},
+}
+
+var ymskb = []ytab{
+	{Zm_r_xm, 2, argList{Yxr, Yrl}},
+	{Zm_r_xm, 1, argList{Ymr, Yrl}},
+}
+
+var ycrc32l = []ytab{
+	{Zlitm_r, 0, argList{Yml, Yrl}},
+}
+
+var ycrc32b = []ytab{
+	{Zlitm_r, 0, argList{Ymb, Yrl}},
+}
+
+var yprefetch = []ytab{
+	{Zm_o, 2, argList{Ym}},
+}
+
+var yaes = []ytab{
+	{Zlitm_r, 2, argList{Yxm, Yxr}},
+}
+
+var yxbegin = []ytab{
+	{Zjmp, 1, argList{Ybr}},
+}
+
+var yxabort = []ytab{
+	{Zib_, 1, argList{Yu8}},
+}
+
+var ylddqu = []ytab{
+	{Zm_r, 1, argList{Ym, Yxr}},
+}
+
+var ypalignr = []ytab{
+	{Zibm_r, 2, argList{Yu8, Yxm, Yxr}},
+}
+
+var ysha256rnds2 = []ytab{
+	{Zlit_m_r, 0, argList{Yxr0, Yxm, Yxr}},
+}
+
+var yblendvpd = []ytab{
+	{Z_m_r, 1, argList{Yxr0, Yxm, Yxr}},
+}
+
+var ymmxmm0f38 = []ytab{
+	{Zlitm_r, 3, argList{Ymm, Ymr}},
+	{Zlitm_r, 5, argList{Yxm, Yxr}},
+}
+
+var yextractps = []ytab{
+	{Zibr_m, 2, argList{Yu2, Yxr, Yml}},
+}
+
+var ysha1rnds4 = []ytab{
+	{Zibm_r, 2, argList{Yu2, Yxm, Yxr}},
+}
+
+// You are doasm, holding in your hand a *obj.Prog with p.As set to, say,
+// ACRC32, and p.From and p.To as operands (obj.Addr).  The linker scans optab
+// to find the entry with the given p.As and then looks through the ytable for
+// that instruction (the second field in the optab struct) for a line whose
+// first two values match the Ytypes of the p.From and p.To operands.  The
+// function oclass computes the specific Ytype of an operand and then the set
+// of more general Ytypes that it satisfies is implied by the ycover table, set
+// up in instinit.  For example, oclass distinguishes the constants 0 and 1
+// from the more general 8-bit constants, but instinit says
+//
+//        ycover[Yi0*Ymax+Ys32] = 1
+//        ycover[Yi1*Ymax+Ys32] = 1
+//        ycover[Yi8*Ymax+Ys32] = 1
+//
+// which means that Yi0, Yi1, and Yi8 all count as Ys32 (signed 32)
+// if that's what an instruction can handle.
+//
+// In parallel with the scan through the ytable for the appropriate line, there
+// is a z pointer that starts out pointing at the strange magic byte list in
+// the Optab struct.  With each step past a non-matching ytable line, z
+// advances by the 4th entry in the line.  When a matching line is found, that
+// z pointer has the extra data to use in laying down the instruction bytes.
+// The actual bytes laid down are a function of the 3rd entry in the line (that
+// is, the Ztype) and the z bytes.
+//
+// For example, let's look at AADDL.  The optab line says:
+//        {AADDL, yaddl, Px, opBytes{0x83, 00, 0x05, 0x81, 00, 0x01, 0x03}},
+//
+// and yaddl says
+//        var yaddl = []ytab{
+//                {Yi8, Ynone, Yml, Zibo_m, 2},
+//                {Yi32, Ynone, Yax, Zil_, 1},
+//                {Yi32, Ynone, Yml, Zilo_m, 2},
+//                {Yrl, Ynone, Yml, Zr_m, 1},
+//                {Yml, Ynone, Yrl, Zm_r, 1},
+//        }
+//
+// so there are 5 possible types of ADDL instruction that can be laid down, and
+// possible states used to lay them down (Ztype and z pointer, assuming z
+// points at opBytes{0x83, 00, 0x05,0x81, 00, 0x01, 0x03}) are:
+//
+//        Yi8, Yml -> Zibo_m, z (0x83, 00)
+//        Yi32, Yax -> Zil_, z+2 (0x05)
+//        Yi32, Yml -> Zilo_m, z+2+1 (0x81, 0x00)
+//        Yrl, Yml -> Zr_m, z+2+1+2 (0x01)
+//        Yml, Yrl -> Zm_r, z+2+1+2+1 (0x03)
+//
+// The Pconstant in the optab line controls the prefix bytes to emit.  That's
+// relatively straightforward as this program goes.
+//
+// The switch on yt.zcase in doasm implements the various Z cases.  Zibo_m, for
+// example, is an opcode byte (z[0]) then an asmando (which is some kind of
+// encoded addressing mode for the Yml arg), and then a single immediate byte.
+// Zilo_m is the same but a long (32-bit) immediate.
+var optab =
+//	as, ytab, andproto, opcode
+[...]Optab{
+	{obj.AXXX, nil, 0, opBytes{}},
+	{AAAA, ynone, P32, opBytes{0x37}},
+	{AAAD, ynone, P32, opBytes{0xd5, 0x0a}},
+	{AAAM, ynone, P32, opBytes{0xd4, 0x0a}},
+	{AAAS, ynone, P32, opBytes{0x3f}},
+	{AADCB, yxorb, Pb, opBytes{0x14, 0x80, 02, 0x10, 0x12}},
+	{AADCL, yaddl, Px, opBytes{0x83, 02, 0x15, 0x81, 02, 0x11, 0x13}},
+	{AADCQ, yaddl, Pw, opBytes{0x83, 02, 0x15, 0x81, 02, 0x11, 0x13}},
+	{AADCW, yaddl, Pe, opBytes{0x83, 02, 0x15, 0x81, 02, 0x11, 0x13}},
+	{AADCXL, yml_rl, Pq4, opBytes{0xf6}},
+	{AADCXQ, yml_rl, Pq4w, opBytes{0xf6}},
+	{AADDB, yxorb, Pb, opBytes{0x04, 0x80, 00, 0x00, 0x02}},
+	{AADDL, yaddl, Px, opBytes{0x83, 00, 0x05, 0x81, 00, 0x01, 0x03}},
+	{AADDPD, yxm, Pq, opBytes{0x58}},
+	{AADDPS, yxm, Pm, opBytes{0x58}},
+	{AADDQ, yaddl, Pw, opBytes{0x83, 00, 0x05, 0x81, 00, 0x01, 0x03}},
+	{AADDSD, yxm, Pf2, opBytes{0x58}},
+	{AADDSS, yxm, Pf3, opBytes{0x58}},
+	{AADDSUBPD, yxm, Pq, opBytes{0xd0}},
+	{AADDSUBPS, yxm, Pf2, opBytes{0xd0}},
+	{AADDW, yaddl, Pe, opBytes{0x83, 00, 0x05, 0x81, 00, 0x01, 0x03}},
+	{AADOXL, yml_rl, Pq5, opBytes{0xf6}},
+	{AADOXQ, yml_rl, Pq5w, opBytes{0xf6}},
+	{AADJSP, nil, 0, opBytes{}},
+	{AANDB, yxorb, Pb, opBytes{0x24, 0x80, 04, 0x20, 0x22}},
+	{AANDL, yaddl, Px, opBytes{0x83, 04, 0x25, 0x81, 04, 0x21, 0x23}},
+	{AANDNPD, yxm, Pq, opBytes{0x55}},
+	{AANDNPS, yxm, Pm, opBytes{0x55}},
+	{AANDPD, yxm, Pq, opBytes{0x54}},
+	{AANDPS, yxm, Pm, opBytes{0x54}},
+	{AANDQ, yaddl, Pw, opBytes{0x83, 04, 0x25, 0x81, 04, 0x21, 0x23}},
+	{AANDW, yaddl, Pe, opBytes{0x83, 04, 0x25, 0x81, 04, 0x21, 0x23}},
+	{AARPL, yrl_ml, P32, opBytes{0x63}},
+	{ABOUNDL, yrl_m, P32, opBytes{0x62}},
+	{ABOUNDW, yrl_m, Pe, opBytes{0x62}},
+	{ABSFL, yml_rl, Pm, opBytes{0xbc}},
+	{ABSFQ, yml_rl, Pw, opBytes{0x0f, 0xbc}},
+	{ABSFW, yml_rl, Pq, opBytes{0xbc}},
+	{ABSRL, yml_rl, Pm, opBytes{0xbd}},
+	{ABSRQ, yml_rl, Pw, opBytes{0x0f, 0xbd}},
+	{ABSRW, yml_rl, Pq, opBytes{0xbd}},
+	{ABSWAPL, ybswap, Px, opBytes{0x0f, 0xc8}},
+	{ABSWAPQ, ybswap, Pw, opBytes{0x0f, 0xc8}},
+	{ABTCL, ybtl, Pm, opBytes{0xba, 07, 0xbb}},
+	{ABTCQ, ybtl, Pw, opBytes{0x0f, 0xba, 07, 0x0f, 0xbb}},
+	{ABTCW, ybtl, Pq, opBytes{0xba, 07, 0xbb}},
+	{ABTL, ybtl, Pm, opBytes{0xba, 04, 0xa3}},
+	{ABTQ, ybtl, Pw, opBytes{0x0f, 0xba, 04, 0x0f, 0xa3}},
+	{ABTRL, ybtl, Pm, opBytes{0xba, 06, 0xb3}},
+	{ABTRQ, ybtl, Pw, opBytes{0x0f, 0xba, 06, 0x0f, 0xb3}},
+	{ABTRW, ybtl, Pq, opBytes{0xba, 06, 0xb3}},
+	{ABTSL, ybtl, Pm, opBytes{0xba, 05, 0xab}},
+	{ABTSQ, ybtl, Pw, opBytes{0x0f, 0xba, 05, 0x0f, 0xab}},
+	{ABTSW, ybtl, Pq, opBytes{0xba, 05, 0xab}},
+	{ABTW, ybtl, Pq, opBytes{0xba, 04, 0xa3}},
+	{ABYTE, ybyte, Px, opBytes{1}},
+	{obj.ACALL, ycall, Px, opBytes{0xff, 02, 0xff, 0x15, 0xe8}},
+	{ACBW, ynone, Pe, opBytes{0x98}},
+	{ACDQ, ynone, Px, opBytes{0x99}},
+	{ACDQE, ynone, Pw, opBytes{0x98}},
+	{ACLAC, ynone, Pm, opBytes{01, 0xca}},
+	{ACLC, ynone, Px, opBytes{0xf8}},
+	{ACLD, ynone, Px, opBytes{0xfc}},
+	{ACLDEMOTE, yclflush, Pm, opBytes{0x1c, 00}},
+	{ACLFLUSH, yclflush, Pm, opBytes{0xae, 07}},
+	{ACLFLUSHOPT, yclflush, Pq, opBytes{0xae, 07}},
+	{ACLI, ynone, Px, opBytes{0xfa}},
+	{ACLTS, ynone, Pm, opBytes{0x06}},
+	{ACLWB, yclflush, Pq, opBytes{0xae, 06}},
+	{ACMC, ynone, Px, opBytes{0xf5}},
+	{ACMOVLCC, yml_rl, Pm, opBytes{0x43}},
+	{ACMOVLCS, yml_rl, Pm, opBytes{0x42}},
+	{ACMOVLEQ, yml_rl, Pm, opBytes{0x44}},
+	{ACMOVLGE, yml_rl, Pm, opBytes{0x4d}},
+	{ACMOVLGT, yml_rl, Pm, opBytes{0x4f}},
+	{ACMOVLHI, yml_rl, Pm, opBytes{0x47}},
+	{ACMOVLLE, yml_rl, Pm, opBytes{0x4e}},
+	{ACMOVLLS, yml_rl, Pm, opBytes{0x46}},
+	{ACMOVLLT, yml_rl, Pm, opBytes{0x4c}},
+	{ACMOVLMI, yml_rl, Pm, opBytes{0x48}},
+	{ACMOVLNE, yml_rl, Pm, opBytes{0x45}},
+	{ACMOVLOC, yml_rl, Pm, opBytes{0x41}},
+	{ACMOVLOS, yml_rl, Pm, opBytes{0x40}},
+	{ACMOVLPC, yml_rl, Pm, opBytes{0x4b}},
+	{ACMOVLPL, yml_rl, Pm, opBytes{0x49}},
+	{ACMOVLPS, yml_rl, Pm, opBytes{0x4a}},
+	{ACMOVQCC, yml_rl, Pw, opBytes{0x0f, 0x43}},
+	{ACMOVQCS, yml_rl, Pw, opBytes{0x0f, 0x42}},
+	{ACMOVQEQ, yml_rl, Pw, opBytes{0x0f, 0x44}},
+	{ACMOVQGE, yml_rl, Pw, opBytes{0x0f, 0x4d}},
+	{ACMOVQGT, yml_rl, Pw, opBytes{0x0f, 0x4f}},
+	{ACMOVQHI, yml_rl, Pw, opBytes{0x0f, 0x47}},
+	{ACMOVQLE, yml_rl, Pw, opBytes{0x0f, 0x4e}},
+	{ACMOVQLS, yml_rl, Pw, opBytes{0x0f, 0x46}},
+	{ACMOVQLT, yml_rl, Pw, opBytes{0x0f, 0x4c}},
+	{ACMOVQMI, yml_rl, Pw, opBytes{0x0f, 0x48}},
+	{ACMOVQNE, yml_rl, Pw, opBytes{0x0f, 0x45}},
+	{ACMOVQOC, yml_rl, Pw, opBytes{0x0f, 0x41}},
+	{ACMOVQOS, yml_rl, Pw, opBytes{0x0f, 0x40}},
+	{ACMOVQPC, yml_rl, Pw, opBytes{0x0f, 0x4b}},
+	{ACMOVQPL, yml_rl, Pw, opBytes{0x0f, 0x49}},
+	{ACMOVQPS, yml_rl, Pw, opBytes{0x0f, 0x4a}},
+	{ACMOVWCC, yml_rl, Pq, opBytes{0x43}},
+	{ACMOVWCS, yml_rl, Pq, opBytes{0x42}},
+	{ACMOVWEQ, yml_rl, Pq, opBytes{0x44}},
+	{ACMOVWGE, yml_rl, Pq, opBytes{0x4d}},
+	{ACMOVWGT, yml_rl, Pq, opBytes{0x4f}},
+	{ACMOVWHI, yml_rl, Pq, opBytes{0x47}},
+	{ACMOVWLE, yml_rl, Pq, opBytes{0x4e}},
+	{ACMOVWLS, yml_rl, Pq, opBytes{0x46}},
+	{ACMOVWLT, yml_rl, Pq, opBytes{0x4c}},
+	{ACMOVWMI, yml_rl, Pq, opBytes{0x48}},
+	{ACMOVWNE, yml_rl, Pq, opBytes{0x45}},
+	{ACMOVWOC, yml_rl, Pq, opBytes{0x41}},
+	{ACMOVWOS, yml_rl, Pq, opBytes{0x40}},
+	{ACMOVWPC, yml_rl, Pq, opBytes{0x4b}},
+	{ACMOVWPL, yml_rl, Pq, opBytes{0x49}},
+	{ACMOVWPS, yml_rl, Pq, opBytes{0x4a}},
+	{ACMPB, ycmpb, Pb, opBytes{0x3c, 0x80, 07, 0x38, 0x3a}},
+	{ACMPL, ycmpl, Px, opBytes{0x83, 07, 0x3d, 0x81, 07, 0x39, 0x3b}},
+	{ACMPPD, yxcmpi, Px, opBytes{Pe, 0xc2}},
+	{ACMPPS, yxcmpi, Pm, opBytes{0xc2, 0}},
+	{ACMPQ, ycmpl, Pw, opBytes{0x83, 07, 0x3d, 0x81, 07, 0x39, 0x3b}},
+	{ACMPSB, ynone, Pb, opBytes{0xa6}},
+	{ACMPSD, yxcmpi, Px, opBytes{Pf2, 0xc2}},
+	{ACMPSL, ynone, Px, opBytes{0xa7}},
+	{ACMPSQ, ynone, Pw, opBytes{0xa7}},
+	{ACMPSS, yxcmpi, Px, opBytes{Pf3, 0xc2}},
+	{ACMPSW, ynone, Pe, opBytes{0xa7}},
+	{ACMPW, ycmpl, Pe, opBytes{0x83, 07, 0x3d, 0x81, 07, 0x39, 0x3b}},
+	{ACOMISD, yxm, Pe, opBytes{0x2f}},
+	{ACOMISS, yxm, Pm, opBytes{0x2f}},
+	{ACPUID, ynone, Pm, opBytes{0xa2}},
+	{ACVTPL2PD, yxcvm2, Px, opBytes{Pf3, 0xe6, Pe, 0x2a}},
+	{ACVTPL2PS, yxcvm2, Pm, opBytes{0x5b, 0, 0x2a, 0}},
+	{ACVTPD2PL, yxcvm1, Px, opBytes{Pf2, 0xe6, Pe, 0x2d}},
+	{ACVTPD2PS, yxm, Pe, opBytes{0x5a}},
+	{ACVTPS2PL, yxcvm1, Px, opBytes{Pe, 0x5b, Pm, 0x2d}},
+	{ACVTPS2PD, yxm, Pm, opBytes{0x5a}},
+	{ACVTSD2SL, yxcvfl, Pf2, opBytes{0x2d}},
+	{ACVTSD2SQ, yxcvfq, Pw, opBytes{Pf2, 0x2d}},
+	{ACVTSD2SS, yxm, Pf2, opBytes{0x5a}},
+	{ACVTSL2SD, yxcvlf, Pf2, opBytes{0x2a}},
+	{ACVTSQ2SD, yxcvqf, Pw, opBytes{Pf2, 0x2a}},
+	{ACVTSL2SS, yxcvlf, Pf3, opBytes{0x2a}},
+	{ACVTSQ2SS, yxcvqf, Pw, opBytes{Pf3, 0x2a}},
+	{ACVTSS2SD, yxm, Pf3, opBytes{0x5a}},
+	{ACVTSS2SL, yxcvfl, Pf3, opBytes{0x2d}},
+	{ACVTSS2SQ, yxcvfq, Pw, opBytes{Pf3, 0x2d}},
+	{ACVTTPD2PL, yxcvm1, Px, opBytes{Pe, 0xe6, Pe, 0x2c}},
+	{ACVTTPS2PL, yxcvm1, Px, opBytes{Pf3, 0x5b, Pm, 0x2c}},
+	{ACVTTSD2SL, yxcvfl, Pf2, opBytes{0x2c}},
+	{ACVTTSD2SQ, yxcvfq, Pw, opBytes{Pf2, 0x2c}},
+	{ACVTTSS2SL, yxcvfl, Pf3, opBytes{0x2c}},
+	{ACVTTSS2SQ, yxcvfq, Pw, opBytes{Pf3, 0x2c}},
+	{ACWD, ynone, Pe, opBytes{0x99}},
+	{ACWDE, ynone, Px, opBytes{0x98}},
+	{ACQO, ynone, Pw, opBytes{0x99}},
+	{ADAA, ynone, P32, opBytes{0x27}},
+	{ADAS, ynone, P32, opBytes{0x2f}},
+	{ADECB, yscond, Pb, opBytes{0xfe, 01}},
+	{ADECL, yincl, Px1, opBytes{0x48, 0xff, 01}},
+	{ADECQ, yincq, Pw, opBytes{0xff, 01}},
+	{ADECW, yincq, Pe, opBytes{0xff, 01}},
+	{ADIVB, ydivb, Pb, opBytes{0xf6, 06}},
+	{ADIVL, ydivl, Px, opBytes{0xf7, 06}},
+	{ADIVPD, yxm, Pe, opBytes{0x5e}},
+	{ADIVPS, yxm, Pm, opBytes{0x5e}},
+	{ADIVQ, ydivl, Pw, opBytes{0xf7, 06}},
+	{ADIVSD, yxm, Pf2, opBytes{0x5e}},
+	{ADIVSS, yxm, Pf3, opBytes{0x5e}},
+	{ADIVW, ydivl, Pe, opBytes{0xf7, 06}},
+	{ADPPD, yxshuf, Pq, opBytes{0x3a, 0x41, 0}},
+	{ADPPS, yxshuf, Pq, opBytes{0x3a, 0x40, 0}},
+	{AEMMS, ynone, Pm, opBytes{0x77}},
+	{AEXTRACTPS, yextractps, Pq, opBytes{0x3a, 0x17, 0}},
+	{AENTER, nil, 0, opBytes{}}, // botch
+	{AFXRSTOR, ysvrs_mo, Pm, opBytes{0xae, 01, 0xae, 01}},
+	{AFXSAVE, ysvrs_om, Pm, opBytes{0xae, 00, 0xae, 00}},
+	{AFXRSTOR64, ysvrs_mo, Pw, opBytes{0x0f, 0xae, 01, 0x0f, 0xae, 01}},
+	{AFXSAVE64, ysvrs_om, Pw, opBytes{0x0f, 0xae, 00, 0x0f, 0xae, 00}},
+	{AHLT, ynone, Px, opBytes{0xf4}},
+	{AIDIVB, ydivb, Pb, opBytes{0xf6, 07}},
+	{AIDIVL, ydivl, Px, opBytes{0xf7, 07}},
+	{AIDIVQ, ydivl, Pw, opBytes{0xf7, 07}},
+	{AIDIVW, ydivl, Pe, opBytes{0xf7, 07}},
+	{AIMULB, ydivb, Pb, opBytes{0xf6, 05}},
+	{AIMULL, yimul, Px, opBytes{0xf7, 05, 0x6b, 0x69, Pm, 0xaf}},
+	{AIMULQ, yimul, Pw, opBytes{0xf7, 05, 0x6b, 0x69, Pm, 0xaf}},
+	{AIMULW, yimul, Pe, opBytes{0xf7, 05, 0x6b, 0x69, Pm, 0xaf}},
+	{AIMUL3W, yimul3, Pe, opBytes{0x6b, 00, 0x69, 00}},
+	{AIMUL3L, yimul3, Px, opBytes{0x6b, 00, 0x69, 00}},
+	{AIMUL3Q, yimul3, Pw, opBytes{0x6b, 00, 0x69, 00}},
+	{AINB, yin, Pb, opBytes{0xe4, 0xec}},
+	{AINW, yin, Pe, opBytes{0xe5, 0xed}},
+	{AINL, yin, Px, opBytes{0xe5, 0xed}},
+	{AINCB, yscond, Pb, opBytes{0xfe, 00}},
+	{AINCL, yincl, Px1, opBytes{0x40, 0xff, 00}},
+	{AINCQ, yincq, Pw, opBytes{0xff, 00}},
+	{AINCW, yincq, Pe, opBytes{0xff, 00}},
+	{AINSB, ynone, Pb, opBytes{0x6c}},
+	{AINSL, ynone, Px, opBytes{0x6d}},
+	{AINSERTPS, yxshuf, Pq, opBytes{0x3a, 0x21, 0}},
+	{AINSW, ynone, Pe, opBytes{0x6d}},
+	{AICEBP, ynone, Px, opBytes{0xf1}},
+	{AINT, yint, Px, opBytes{0xcd}},
+	{AINTO, ynone, P32, opBytes{0xce}},
+	{AIRETL, ynone, Px, opBytes{0xcf}},
+	{AIRETQ, ynone, Pw, opBytes{0xcf}},
+	{AIRETW, ynone, Pe, opBytes{0xcf}},
+	{AJCC, yjcond, Px, opBytes{0x73, 0x83, 00}},
+	{AJCS, yjcond, Px, opBytes{0x72, 0x82}},
+	{AJCXZL, yloop, Px, opBytes{0xe3}},
+	{AJCXZW, yloop, Px, opBytes{0xe3}},
+	{AJCXZQ, yloop, Px, opBytes{0xe3}},
+	{AJEQ, yjcond, Px, opBytes{0x74, 0x84}},
+	{AJGE, yjcond, Px, opBytes{0x7d, 0x8d}},
+	{AJGT, yjcond, Px, opBytes{0x7f, 0x8f}},
+	{AJHI, yjcond, Px, opBytes{0x77, 0x87}},
+	{AJLE, yjcond, Px, opBytes{0x7e, 0x8e}},
+	{AJLS, yjcond, Px, opBytes{0x76, 0x86}},
+	{AJLT, yjcond, Px, opBytes{0x7c, 0x8c}},
+	{AJMI, yjcond, Px, opBytes{0x78, 0x88}},
+	{obj.AJMP, yjmp, Px, opBytes{0xff, 04, 0xeb, 0xe9}},
+	{AJNE, yjcond, Px, opBytes{0x75, 0x85}},
+	{AJOC, yjcond, Px, opBytes{0x71, 0x81, 00}},
+	{AJOS, yjcond, Px, opBytes{0x70, 0x80, 00}},
+	{AJPC, yjcond, Px, opBytes{0x7b, 0x8b}},
+	{AJPL, yjcond, Px, opBytes{0x79, 0x89}},
+	{AJPS, yjcond, Px, opBytes{0x7a, 0x8a}},
+	{AHADDPD, yxm, Pq, opBytes{0x7c}},
+	{AHADDPS, yxm, Pf2, opBytes{0x7c}},
+	{AHSUBPD, yxm, Pq, opBytes{0x7d}},
+	{AHSUBPS, yxm, Pf2, opBytes{0x7d}},
+	{ALAHF, ynone, Px, opBytes{0x9f}},
+	{ALARL, yml_rl, Pm, opBytes{0x02}},
+	{ALARQ, yml_rl, Pw, opBytes{0x0f, 0x02}},
+	{ALARW, yml_rl, Pq, opBytes{0x02}},
+	{ALDDQU, ylddqu, Pf2, opBytes{0xf0}},
+	{ALDMXCSR, ysvrs_mo, Pm, opBytes{0xae, 02, 0xae, 02}},
+	{ALEAL, ym_rl, Px, opBytes{0x8d}},
+	{ALEAQ, ym_rl, Pw, opBytes{0x8d}},
+	{ALEAVEL, ynone, P32, opBytes{0xc9}},
+	{ALEAVEQ, ynone, Py, opBytes{0xc9}},
+	{ALEAVEW, ynone, Pe, opBytes{0xc9}},
+	{ALEAW, ym_rl, Pe, opBytes{0x8d}},
+	{ALOCK, ynone, Px, opBytes{0xf0}},
+	{ALODSB, ynone, Pb, opBytes{0xac}},
+	{ALODSL, ynone, Px, opBytes{0xad}},
+	{ALODSQ, ynone, Pw, opBytes{0xad}},
+	{ALODSW, ynone, Pe, opBytes{0xad}},
+	{ALONG, ybyte, Px, opBytes{4}},
+	{ALOOP, yloop, Px, opBytes{0xe2}},
+	{ALOOPEQ, yloop, Px, opBytes{0xe1}},
+	{ALOOPNE, yloop, Px, opBytes{0xe0}},
+	{ALTR, ydivl, Pm, opBytes{0x00, 03}},
+	{ALZCNTL, yml_rl, Pf3, opBytes{0xbd}},
+	{ALZCNTQ, yml_rl, Pfw, opBytes{0xbd}},
+	{ALZCNTW, yml_rl, Pef3, opBytes{0xbd}},
+	{ALSLL, yml_rl, Pm, opBytes{0x03}},
+	{ALSLW, yml_rl, Pq, opBytes{0x03}},
+	{ALSLQ, yml_rl, Pw, opBytes{0x0f, 0x03}},
+	{AMASKMOVOU, yxr, Pe, opBytes{0xf7}},
+	{AMASKMOVQ, ymr, Pm, opBytes{0xf7}},
+	{AMAXPD, yxm, Pe, opBytes{0x5f}},
+	{AMAXPS, yxm, Pm, opBytes{0x5f}},
+	{AMAXSD, yxm, Pf2, opBytes{0x5f}},
+	{AMAXSS, yxm, Pf3, opBytes{0x5f}},
+	{AMINPD, yxm, Pe, opBytes{0x5d}},
+	{AMINPS, yxm, Pm, opBytes{0x5d}},
+	{AMINSD, yxm, Pf2, opBytes{0x5d}},
+	{AMINSS, yxm, Pf3, opBytes{0x5d}},
+	{AMONITOR, ynone, Px, opBytes{0x0f, 0x01, 0xc8, 0}},
+	{AMWAIT, ynone, Px, opBytes{0x0f, 0x01, 0xc9, 0}},
+	{AMOVAPD, yxmov, Pe, opBytes{0x28, 0x29}},
+	{AMOVAPS, yxmov, Pm, opBytes{0x28, 0x29}},
+	{AMOVB, ymovb, Pb, opBytes{0x88, 0x8a, 0xb0, 0xc6, 00}},
+	{AMOVBLSX, ymb_rl, Pm, opBytes{0xbe}},
+	{AMOVBLZX, ymb_rl, Pm, opBytes{0xb6}},
+	{AMOVBQSX, ymb_rl, Pw, opBytes{0x0f, 0xbe}},
+	{AMOVBQZX, ymb_rl, Pw, opBytes{0x0f, 0xb6}},
+	{AMOVBWSX, ymb_rl, Pq, opBytes{0xbe}},
+	{AMOVSWW, ymb_rl, Pe, opBytes{0x0f, 0xbf}},
+	{AMOVBWZX, ymb_rl, Pq, opBytes{0xb6}},
+	{AMOVZWW, ymb_rl, Pe, opBytes{0x0f, 0xb7}},
+	{AMOVO, yxmov, Pe, opBytes{0x6f, 0x7f}},
+	{AMOVOU, yxmov, Pf3, opBytes{0x6f, 0x7f}},
+	{AMOVHLPS, yxr, Pm, opBytes{0x12}},
+	{AMOVHPD, yxmov, Pe, opBytes{0x16, 0x17}},
+	{AMOVHPS, yxmov, Pm, opBytes{0x16, 0x17}},
+	{AMOVL, ymovl, Px, opBytes{0x89, 0x8b, 0xb8, 0xc7, 00, 0x6e, 0x7e, Pe, 0x6e, Pe, 0x7e, 0}},
+	{AMOVLHPS, yxr, Pm, opBytes{0x16}},
+	{AMOVLPD, yxmov, Pe, opBytes{0x12, 0x13}},
+	{AMOVLPS, yxmov, Pm, opBytes{0x12, 0x13}},
+	{AMOVLQSX, yml_rl, Pw, opBytes{0x63}},
+	{AMOVLQZX, yml_rl, Px, opBytes{0x8b}},
+	{AMOVMSKPD, yxrrl, Pq, opBytes{0x50}},
+	{AMOVMSKPS, yxrrl, Pm, opBytes{0x50}},
+	{AMOVNTO, yxr_ml, Pe, opBytes{0xe7}},
+	{AMOVNTDQA, ylddqu, Pq4, opBytes{0x2a}},
+	{AMOVNTPD, yxr_ml, Pe, opBytes{0x2b}},
+	{AMOVNTPS, yxr_ml, Pm, opBytes{0x2b}},
+	{AMOVNTQ, ymr_ml, Pm, opBytes{0xe7}},
+	{AMOVQ, ymovq, Pw8, opBytes{0x6f, 0x7f, Pf2, 0xd6, Pf3, 0x7e, Pe, 0xd6, 0x89, 0x8b, 0xc7, 00, 0xb8, 0xc7, 00, 0x6e, 0x7e, Pe, 0x6e, Pe, 0x7e, 0}},
+	{AMOVQOZX, ymrxr, Pf3, opBytes{0xd6, 0x7e}},
+	{AMOVSB, ynone, Pb, opBytes{0xa4}},
+	{AMOVSD, yxmov, Pf2, opBytes{0x10, 0x11}},
+	{AMOVSL, ynone, Px, opBytes{0xa5}},
+	{AMOVSQ, ynone, Pw, opBytes{0xa5}},
+	{AMOVSS, yxmov, Pf3, opBytes{0x10, 0x11}},
+	{AMOVSW, ynone, Pe, opBytes{0xa5}},
+	{AMOVUPD, yxmov, Pe, opBytes{0x10, 0x11}},
+	{AMOVUPS, yxmov, Pm, opBytes{0x10, 0x11}},
+	{AMOVW, ymovw, Pe, opBytes{0x89, 0x8b, 0xb8, 0xc7, 00, 0}},
+	{AMOVWLSX, yml_rl, Pm, opBytes{0xbf}},
+	{AMOVWLZX, yml_rl, Pm, opBytes{0xb7}},
+	{AMOVWQSX, yml_rl, Pw, opBytes{0x0f, 0xbf}},
+	{AMOVWQZX, yml_rl, Pw, opBytes{0x0f, 0xb7}},
+	{AMPSADBW, yxshuf, Pq, opBytes{0x3a, 0x42, 0}},
+	{AMULB, ydivb, Pb, opBytes{0xf6, 04}},
+	{AMULL, ydivl, Px, opBytes{0xf7, 04}},
+	{AMULPD, yxm, Pe, opBytes{0x59}},
+	{AMULPS, yxm, Ym, opBytes{0x59}},
+	{AMULQ, ydivl, Pw, opBytes{0xf7, 04}},
+	{AMULSD, yxm, Pf2, opBytes{0x59}},
+	{AMULSS, yxm, Pf3, opBytes{0x59}},
+	{AMULW, ydivl, Pe, opBytes{0xf7, 04}},
+	{ANEGB, yscond, Pb, opBytes{0xf6, 03}},
+	{ANEGL, yscond, Px, opBytes{0xf7, 03}},
+	{ANEGQ, yscond, Pw, opBytes{0xf7, 03}},
+	{ANEGW, yscond, Pe, opBytes{0xf7, 03}},
+	{obj.ANOP, ynop, Px, opBytes{0, 0}},
+	{ANOTB, yscond, Pb, opBytes{0xf6, 02}},
+	{ANOTL, yscond, Px, opBytes{0xf7, 02}}, // TODO(rsc): yscond is wrong here.
+	{ANOTQ, yscond, Pw, opBytes{0xf7, 02}},
+	{ANOTW, yscond, Pe, opBytes{0xf7, 02}},
+	{AORB, yxorb, Pb, opBytes{0x0c, 0x80, 01, 0x08, 0x0a}},
+	{AORL, yaddl, Px, opBytes{0x83, 01, 0x0d, 0x81, 01, 0x09, 0x0b}},
+	{AORPD, yxm, Pq, opBytes{0x56}},
+	{AORPS, yxm, Pm, opBytes{0x56}},
+	{AORQ, yaddl, Pw, opBytes{0x83, 01, 0x0d, 0x81, 01, 0x09, 0x0b}},
+	{AORW, yaddl, Pe, opBytes{0x83, 01, 0x0d, 0x81, 01, 0x09, 0x0b}},
+	{AOUTB, yin, Pb, opBytes{0xe6, 0xee}},
+	{AOUTL, yin, Px, opBytes{0xe7, 0xef}},
+	{AOUTW, yin, Pe, opBytes{0xe7, 0xef}},
+	{AOUTSB, ynone, Pb, opBytes{0x6e}},
+	{AOUTSL, ynone, Px, opBytes{0x6f}},
+	{AOUTSW, ynone, Pe, opBytes{0x6f}},
+	{APABSB, yxm_q4, Pq4, opBytes{0x1c}},
+	{APABSD, yxm_q4, Pq4, opBytes{0x1e}},
+	{APABSW, yxm_q4, Pq4, opBytes{0x1d}},
+	{APACKSSLW, ymm, Py1, opBytes{0x6b, Pe, 0x6b}},
+	{APACKSSWB, ymm, Py1, opBytes{0x63, Pe, 0x63}},
+	{APACKUSDW, yxm_q4, Pq4, opBytes{0x2b}},
+	{APACKUSWB, ymm, Py1, opBytes{0x67, Pe, 0x67}},
+	{APADDB, ymm, Py1, opBytes{0xfc, Pe, 0xfc}},
+	{APADDL, ymm, Py1, opBytes{0xfe, Pe, 0xfe}},
+	{APADDQ, yxm, Pe, opBytes{0xd4}},
+	{APADDSB, ymm, Py1, opBytes{0xec, Pe, 0xec}},
+	{APADDSW, ymm, Py1, opBytes{0xed, Pe, 0xed}},
+	{APADDUSB, ymm, Py1, opBytes{0xdc, Pe, 0xdc}},
+	{APADDUSW, ymm, Py1, opBytes{0xdd, Pe, 0xdd}},
+	{APADDW, ymm, Py1, opBytes{0xfd, Pe, 0xfd}},
+	{APALIGNR, ypalignr, Pq, opBytes{0x3a, 0x0f}},
+	{APAND, ymm, Py1, opBytes{0xdb, Pe, 0xdb}},
+	{APANDN, ymm, Py1, opBytes{0xdf, Pe, 0xdf}},
+	{APAUSE, ynone, Px, opBytes{0xf3, 0x90}},
+	{APAVGB, ymm, Py1, opBytes{0xe0, Pe, 0xe0}},
+	{APAVGW, ymm, Py1, opBytes{0xe3, Pe, 0xe3}},
+	{APBLENDW, yxshuf, Pq, opBytes{0x3a, 0x0e, 0}},
+	{APCMPEQB, ymm, Py1, opBytes{0x74, Pe, 0x74}},
+	{APCMPEQL, ymm, Py1, opBytes{0x76, Pe, 0x76}},
+	{APCMPEQQ, yxm_q4, Pq4, opBytes{0x29}},
+	{APCMPEQW, ymm, Py1, opBytes{0x75, Pe, 0x75}},
+	{APCMPGTB, ymm, Py1, opBytes{0x64, Pe, 0x64}},
+	{APCMPGTL, ymm, Py1, opBytes{0x66, Pe, 0x66}},
+	{APCMPGTQ, yxm_q4, Pq4, opBytes{0x37}},
+	{APCMPGTW, ymm, Py1, opBytes{0x65, Pe, 0x65}},
+	{APCMPISTRI, yxshuf, Pq, opBytes{0x3a, 0x63, 0}},
+	{APCMPISTRM, yxshuf, Pq, opBytes{0x3a, 0x62, 0}},
+	{APEXTRW, yextrw, Pq, opBytes{0xc5, 0, 0x3a, 0x15, 0}},
+	{APEXTRB, yextr, Pq, opBytes{0x3a, 0x14, 00}},
+	{APEXTRD, yextr, Pq, opBytes{0x3a, 0x16, 00}},
+	{APEXTRQ, yextr, Pq3, opBytes{0x3a, 0x16, 00}},
+	{APHADDD, ymmxmm0f38, Px, opBytes{0x0F, 0x38, 0x02, 0, 0x66, 0x0F, 0x38, 0x02, 0}},
+	{APHADDSW, yxm_q4, Pq4, opBytes{0x03}},
+	{APHADDW, yxm_q4, Pq4, opBytes{0x01}},
+	{APHMINPOSUW, yxm_q4, Pq4, opBytes{0x41}},
+	{APHSUBD, yxm_q4, Pq4, opBytes{0x06}},
+	{APHSUBSW, yxm_q4, Pq4, opBytes{0x07}},
+	{APHSUBW, yxm_q4, Pq4, opBytes{0x05}},
+	{APINSRW, yinsrw, Pq, opBytes{0xc4, 00}},
+	{APINSRB, yinsr, Pq, opBytes{0x3a, 0x20, 00}},
+	{APINSRD, yinsr, Pq, opBytes{0x3a, 0x22, 00}},
+	{APINSRQ, yinsr, Pq3, opBytes{0x3a, 0x22, 00}},
+	{APMADDUBSW, yxm_q4, Pq4, opBytes{0x04}},
+	{APMADDWL, ymm, Py1, opBytes{0xf5, Pe, 0xf5}},
+	{APMAXSB, yxm_q4, Pq4, opBytes{0x3c}},
+	{APMAXSD, yxm_q4, Pq4, opBytes{0x3d}},
+	{APMAXSW, yxm, Pe, opBytes{0xee}},
+	{APMAXUB, yxm, Pe, opBytes{0xde}},
+	{APMAXUD, yxm_q4, Pq4, opBytes{0x3f}},
+	{APMAXUW, yxm_q4, Pq4, opBytes{0x3e}},
+	{APMINSB, yxm_q4, Pq4, opBytes{0x38}},
+	{APMINSD, yxm_q4, Pq4, opBytes{0x39}},
+	{APMINSW, yxm, Pe, opBytes{0xea}},
+	{APMINUB, yxm, Pe, opBytes{0xda}},
+	{APMINUD, yxm_q4, Pq4, opBytes{0x3b}},
+	{APMINUW, yxm_q4, Pq4, opBytes{0x3a}},
+	{APMOVMSKB, ymskb, Px, opBytes{Pe, 0xd7, 0xd7}},
+	{APMOVSXBD, yxm_q4, Pq4, opBytes{0x21}},
+	{APMOVSXBQ, yxm_q4, Pq4, opBytes{0x22}},
+	{APMOVSXBW, yxm_q4, Pq4, opBytes{0x20}},
+	{APMOVSXDQ, yxm_q4, Pq4, opBytes{0x25}},
+	{APMOVSXWD, yxm_q4, Pq4, opBytes{0x23}},
+	{APMOVSXWQ, yxm_q4, Pq4, opBytes{0x24}},
+	{APMOVZXBD, yxm_q4, Pq4, opBytes{0x31}},
+	{APMOVZXBQ, yxm_q4, Pq4, opBytes{0x32}},
+	{APMOVZXBW, yxm_q4, Pq4, opBytes{0x30}},
+	{APMOVZXDQ, yxm_q4, Pq4, opBytes{0x35}},
+	{APMOVZXWD, yxm_q4, Pq4, opBytes{0x33}},
+	{APMOVZXWQ, yxm_q4, Pq4, opBytes{0x34}},
+	{APMULDQ, yxm_q4, Pq4, opBytes{0x28}},
+	{APMULHRSW, yxm_q4, Pq4, opBytes{0x0b}},
+	{APMULHUW, ymm, Py1, opBytes{0xe4, Pe, 0xe4}},
+	{APMULHW, ymm, Py1, opBytes{0xe5, Pe, 0xe5}},
+	{APMULLD, yxm_q4, Pq4, opBytes{0x40}},
+	{APMULLW, ymm, Py1, opBytes{0xd5, Pe, 0xd5}},
+	{APMULULQ, ymm, Py1, opBytes{0xf4, Pe, 0xf4}},
+	{APOPAL, ynone, P32, opBytes{0x61}},
+	{APOPAW, ynone, Pe, opBytes{0x61}},
+	{APOPCNTW, yml_rl, Pef3, opBytes{0xb8}},
+	{APOPCNTL, yml_rl, Pf3, opBytes{0xb8}},
+	{APOPCNTQ, yml_rl, Pfw, opBytes{0xb8}},
+	{APOPFL, ynone, P32, opBytes{0x9d}},
+	{APOPFQ, ynone, Py, opBytes{0x9d}},
+	{APOPFW, ynone, Pe, opBytes{0x9d}},
+	{APOPL, ypopl, P32, opBytes{0x58, 0x8f, 00}},
+	{APOPQ, ypopl, Py, opBytes{0x58, 0x8f, 00}},
+	{APOPW, ypopl, Pe, opBytes{0x58, 0x8f, 00}},
+	{APOR, ymm, Py1, opBytes{0xeb, Pe, 0xeb}},
+	{APSADBW, yxm, Pq, opBytes{0xf6}},
+	{APSHUFHW, yxshuf, Pf3, opBytes{0x70, 00}},
+	{APSHUFL, yxshuf, Pq, opBytes{0x70, 00}},
+	{APSHUFLW, yxshuf, Pf2, opBytes{0x70, 00}},
+	{APSHUFW, ymshuf, Pm, opBytes{0x70, 00}},
+	{APSHUFB, ymshufb, Pq, opBytes{0x38, 0x00}},
+	{APSIGNB, yxm_q4, Pq4, opBytes{0x08}},
+	{APSIGND, yxm_q4, Pq4, opBytes{0x0a}},
+	{APSIGNW, yxm_q4, Pq4, opBytes{0x09}},
+	{APSLLO, ypsdq, Pq, opBytes{0x73, 07}},
+	{APSLLL, yps, Py3, opBytes{0xf2, 0x72, 06, Pe, 0xf2, Pe, 0x72, 06}},
+	{APSLLQ, yps, Py3, opBytes{0xf3, 0x73, 06, Pe, 0xf3, Pe, 0x73, 06}},
+	{APSLLW, yps, Py3, opBytes{0xf1, 0x71, 06, Pe, 0xf1, Pe, 0x71, 06}},
+	{APSRAL, yps, Py3, opBytes{0xe2, 0x72, 04, Pe, 0xe2, Pe, 0x72, 04}},
+	{APSRAW, yps, Py3, opBytes{0xe1, 0x71, 04, Pe, 0xe1, Pe, 0x71, 04}},
+	{APSRLO, ypsdq, Pq, opBytes{0x73, 03}},
+	{APSRLL, yps, Py3, opBytes{0xd2, 0x72, 02, Pe, 0xd2, Pe, 0x72, 02}},
+	{APSRLQ, yps, Py3, opBytes{0xd3, 0x73, 02, Pe, 0xd3, Pe, 0x73, 02}},
+	{APSRLW, yps, Py3, opBytes{0xd1, 0x71, 02, Pe, 0xd1, Pe, 0x71, 02}},
+	{APSUBB, yxm, Pe, opBytes{0xf8}},
+	{APSUBL, yxm, Pe, opBytes{0xfa}},
+	{APSUBQ, yxm, Pe, opBytes{0xfb}},
+	{APSUBSB, yxm, Pe, opBytes{0xe8}},
+	{APSUBSW, yxm, Pe, opBytes{0xe9}},
+	{APSUBUSB, yxm, Pe, opBytes{0xd8}},
+	{APSUBUSW, yxm, Pe, opBytes{0xd9}},
+	{APSUBW, yxm, Pe, opBytes{0xf9}},
+	{APTEST, yxm_q4, Pq4, opBytes{0x17}},
+	{APUNPCKHBW, ymm, Py1, opBytes{0x68, Pe, 0x68}},
+	{APUNPCKHLQ, ymm, Py1, opBytes{0x6a, Pe, 0x6a}},
+	{APUNPCKHQDQ, yxm, Pe, opBytes{0x6d}},
+	{APUNPCKHWL, ymm, Py1, opBytes{0x69, Pe, 0x69}},
+	{APUNPCKLBW, ymm, Py1, opBytes{0x60, Pe, 0x60}},
+	{APUNPCKLLQ, ymm, Py1, opBytes{0x62, Pe, 0x62}},
+	{APUNPCKLQDQ, yxm, Pe, opBytes{0x6c}},
+	{APUNPCKLWL, ymm, Py1, opBytes{0x61, Pe, 0x61}},
+	{APUSHAL, ynone, P32, opBytes{0x60}},
+	{APUSHAW, ynone, Pe, opBytes{0x60}},
+	{APUSHFL, ynone, P32, opBytes{0x9c}},
+	{APUSHFQ, ynone, Py, opBytes{0x9c}},
+	{APUSHFW, ynone, Pe, opBytes{0x9c}},
+	{APUSHL, ypushl, P32, opBytes{0x50, 0xff, 06, 0x6a, 0x68}},
+	{APUSHQ, ypushl, Py, opBytes{0x50, 0xff, 06, 0x6a, 0x68}},
+	{APUSHW, ypushl, Pe, opBytes{0x50, 0xff, 06, 0x6a, 0x68}},
+	{APXOR, ymm, Py1, opBytes{0xef, Pe, 0xef}},
+	{AQUAD, ybyte, Px, opBytes{8}},
+	{ARCLB, yshb, Pb, opBytes{0xd0, 02, 0xc0, 02, 0xd2, 02}},
+	{ARCLL, yshl, Px, opBytes{0xd1, 02, 0xc1, 02, 0xd3, 02, 0xd3, 02}},
+	{ARCLQ, yshl, Pw, opBytes{0xd1, 02, 0xc1, 02, 0xd3, 02, 0xd3, 02}},
+	{ARCLW, yshl, Pe, opBytes{0xd1, 02, 0xc1, 02, 0xd3, 02, 0xd3, 02}},
+	{ARCPPS, yxm, Pm, opBytes{0x53}},
+	{ARCPSS, yxm, Pf3, opBytes{0x53}},
+	{ARCRB, yshb, Pb, opBytes{0xd0, 03, 0xc0, 03, 0xd2, 03}},
+	{ARCRL, yshl, Px, opBytes{0xd1, 03, 0xc1, 03, 0xd3, 03, 0xd3, 03}},
+	{ARCRQ, yshl, Pw, opBytes{0xd1, 03, 0xc1, 03, 0xd3, 03, 0xd3, 03}},
+	{ARCRW, yshl, Pe, opBytes{0xd1, 03, 0xc1, 03, 0xd3, 03, 0xd3, 03}},
+	{AREP, ynone, Px, opBytes{0xf3}},
+	{AREPN, ynone, Px, opBytes{0xf2}},
+	{obj.ARET, ynone, Px, opBytes{0xc3}},
+	{ARETFW, yret, Pe, opBytes{0xcb, 0xca}},
+	{ARETFL, yret, Px, opBytes{0xcb, 0xca}},
+	{ARETFQ, yret, Pw, opBytes{0xcb, 0xca}},
+	{AROLB, yshb, Pb, opBytes{0xd0, 00, 0xc0, 00, 0xd2, 00}},
+	{AROLL, yshl, Px, opBytes{0xd1, 00, 0xc1, 00, 0xd3, 00, 0xd3, 00}},
+	{AROLQ, yshl, Pw, opBytes{0xd1, 00, 0xc1, 00, 0xd3, 00, 0xd3, 00}},
+	{AROLW, yshl, Pe, opBytes{0xd1, 00, 0xc1, 00, 0xd3, 00, 0xd3, 00}},
+	{ARORB, yshb, Pb, opBytes{0xd0, 01, 0xc0, 01, 0xd2, 01}},
+	{ARORL, yshl, Px, opBytes{0xd1, 01, 0xc1, 01, 0xd3, 01, 0xd3, 01}},
+	{ARORQ, yshl, Pw, opBytes{0xd1, 01, 0xc1, 01, 0xd3, 01, 0xd3, 01}},
+	{ARORW, yshl, Pe, opBytes{0xd1, 01, 0xc1, 01, 0xd3, 01, 0xd3, 01}},
+	{ARSQRTPS, yxm, Pm, opBytes{0x52}},
+	{ARSQRTSS, yxm, Pf3, opBytes{0x52}},
+	{ASAHF, ynone, Px, opBytes{0x9e, 00, 0x86, 0xe0, 0x50, 0x9d}}, // XCHGB AH,AL; PUSH AX; POPFL
+	{ASALB, yshb, Pb, opBytes{0xd0, 04, 0xc0, 04, 0xd2, 04}},
+	{ASALL, yshl, Px, opBytes{0xd1, 04, 0xc1, 04, 0xd3, 04, 0xd3, 04}},
+	{ASALQ, yshl, Pw, opBytes{0xd1, 04, 0xc1, 04, 0xd3, 04, 0xd3, 04}},
+	{ASALW, yshl, Pe, opBytes{0xd1, 04, 0xc1, 04, 0xd3, 04, 0xd3, 04}},
+	{ASARB, yshb, Pb, opBytes{0xd0, 07, 0xc0, 07, 0xd2, 07}},
+	{ASARL, yshl, Px, opBytes{0xd1, 07, 0xc1, 07, 0xd3, 07, 0xd3, 07}},
+	{ASARQ, yshl, Pw, opBytes{0xd1, 07, 0xc1, 07, 0xd3, 07, 0xd3, 07}},
+	{ASARW, yshl, Pe, opBytes{0xd1, 07, 0xc1, 07, 0xd3, 07, 0xd3, 07}},
+	{ASBBB, yxorb, Pb, opBytes{0x1c, 0x80, 03, 0x18, 0x1a}},
+	{ASBBL, yaddl, Px, opBytes{0x83, 03, 0x1d, 0x81, 03, 0x19, 0x1b}},
+	{ASBBQ, yaddl, Pw, opBytes{0x83, 03, 0x1d, 0x81, 03, 0x19, 0x1b}},
+	{ASBBW, yaddl, Pe, opBytes{0x83, 03, 0x1d, 0x81, 03, 0x19, 0x1b}},
+	{ASCASB, ynone, Pb, opBytes{0xae}},
+	{ASCASL, ynone, Px, opBytes{0xaf}},
+	{ASCASQ, ynone, Pw, opBytes{0xaf}},
+	{ASCASW, ynone, Pe, opBytes{0xaf}},
+	{ASETCC, yscond, Pb, opBytes{0x0f, 0x93, 00}},
+	{ASETCS, yscond, Pb, opBytes{0x0f, 0x92, 00}},
+	{ASETEQ, yscond, Pb, opBytes{0x0f, 0x94, 00}},
+	{ASETGE, yscond, Pb, opBytes{0x0f, 0x9d, 00}},
+	{ASETGT, yscond, Pb, opBytes{0x0f, 0x9f, 00}},
+	{ASETHI, yscond, Pb, opBytes{0x0f, 0x97, 00}},
+	{ASETLE, yscond, Pb, opBytes{0x0f, 0x9e, 00}},
+	{ASETLS, yscond, Pb, opBytes{0x0f, 0x96, 00}},
+	{ASETLT, yscond, Pb, opBytes{0x0f, 0x9c, 00}},
+	{ASETMI, yscond, Pb, opBytes{0x0f, 0x98, 00}},
+	{ASETNE, yscond, Pb, opBytes{0x0f, 0x95, 00}},
+	{ASETOC, yscond, Pb, opBytes{0x0f, 0x91, 00}},
+	{ASETOS, yscond, Pb, opBytes{0x0f, 0x90, 00}},
+	{ASETPC, yscond, Pb, opBytes{0x0f, 0x9b, 00}},
+	{ASETPL, yscond, Pb, opBytes{0x0f, 0x99, 00}},
+	{ASETPS, yscond, Pb, opBytes{0x0f, 0x9a, 00}},
+	{ASHLB, yshb, Pb, opBytes{0xd0, 04, 0xc0, 04, 0xd2, 04}},
+	{ASHLL, yshl, Px, opBytes{0xd1, 04, 0xc1, 04, 0xd3, 04, 0xd3, 04}},
+	{ASHLQ, yshl, Pw, opBytes{0xd1, 04, 0xc1, 04, 0xd3, 04, 0xd3, 04}},
+	{ASHLW, yshl, Pe, opBytes{0xd1, 04, 0xc1, 04, 0xd3, 04, 0xd3, 04}},
+	{ASHRB, yshb, Pb, opBytes{0xd0, 05, 0xc0, 05, 0xd2, 05}},
+	{ASHRL, yshl, Px, opBytes{0xd1, 05, 0xc1, 05, 0xd3, 05, 0xd3, 05}},
+	{ASHRQ, yshl, Pw, opBytes{0xd1, 05, 0xc1, 05, 0xd3, 05, 0xd3, 05}},
+	{ASHRW, yshl, Pe, opBytes{0xd1, 05, 0xc1, 05, 0xd3, 05, 0xd3, 05}},
+	{ASHUFPD, yxshuf, Pq, opBytes{0xc6, 00}},
+	{ASHUFPS, yxshuf, Pm, opBytes{0xc6, 00}},
+	{ASQRTPD, yxm, Pe, opBytes{0x51}},
+	{ASQRTPS, yxm, Pm, opBytes{0x51}},
+	{ASQRTSD, yxm, Pf2, opBytes{0x51}},
+	{ASQRTSS, yxm, Pf3, opBytes{0x51}},
+	{ASTC, ynone, Px, opBytes{0xf9}},
+	{ASTD, ynone, Px, opBytes{0xfd}},
+	{ASTI, ynone, Px, opBytes{0xfb}},
+	{ASTMXCSR, ysvrs_om, Pm, opBytes{0xae, 03, 0xae, 03}},
+	{ASTOSB, ynone, Pb, opBytes{0xaa}},
+	{ASTOSL, ynone, Px, opBytes{0xab}},
+	{ASTOSQ, ynone, Pw, opBytes{0xab}},
+	{ASTOSW, ynone, Pe, opBytes{0xab}},
+	{ASUBB, yxorb, Pb, opBytes{0x2c, 0x80, 05, 0x28, 0x2a}},
+	{ASUBL, yaddl, Px, opBytes{0x83, 05, 0x2d, 0x81, 05, 0x29, 0x2b}},
+	{ASUBPD, yxm, Pe, opBytes{0x5c}},
+	{ASUBPS, yxm, Pm, opBytes{0x5c}},
+	{ASUBQ, yaddl, Pw, opBytes{0x83, 05, 0x2d, 0x81, 05, 0x29, 0x2b}},
+	{ASUBSD, yxm, Pf2, opBytes{0x5c}},
+	{ASUBSS, yxm, Pf3, opBytes{0x5c}},
+	{ASUBW, yaddl, Pe, opBytes{0x83, 05, 0x2d, 0x81, 05, 0x29, 0x2b}},
+	{ASWAPGS, ynone, Pm, opBytes{0x01, 0xf8}},
+	{ASYSCALL, ynone, Px, opBytes{0x0f, 0x05}}, // fast syscall
+	{ATESTB, yxorb, Pb, opBytes{0xa8, 0xf6, 00, 0x84, 0x84}},
+	{ATESTL, ytestl, Px, opBytes{0xa9, 0xf7, 00, 0x85, 0x85}},
+	{ATESTQ, ytestl, Pw, opBytes{0xa9, 0xf7, 00, 0x85, 0x85}},
+	{ATESTW, ytestl, Pe, opBytes{0xa9, 0xf7, 00, 0x85, 0x85}},
+	{ATPAUSE, ywrfsbase, Pq, opBytes{0xae, 06}},
+	{obj.ATEXT, ytext, Px, opBytes{}},
+	{AUCOMISD, yxm, Pe, opBytes{0x2e}},
+	{AUCOMISS, yxm, Pm, opBytes{0x2e}},
+	{AUNPCKHPD, yxm, Pe, opBytes{0x15}},
+	{AUNPCKHPS, yxm, Pm, opBytes{0x15}},
+	{AUNPCKLPD, yxm, Pe, opBytes{0x14}},
+	{AUNPCKLPS, yxm, Pm, opBytes{0x14}},
+	{AUMONITOR, ywrfsbase, Pf3, opBytes{0xae, 06}},
+	{AVERR, ydivl, Pm, opBytes{0x00, 04}},
+	{AVERW, ydivl, Pm, opBytes{0x00, 05}},
+	{AWAIT, ynone, Px, opBytes{0x9b}},
+	{AWORD, ybyte, Px, opBytes{2}},
+	{AXCHGB, yml_mb, Pb, opBytes{0x86, 0x86}},
+	{AXCHGL, yxchg, Px, opBytes{0x90, 0x90, 0x87, 0x87}},
+	{AXCHGQ, yxchg, Pw, opBytes{0x90, 0x90, 0x87, 0x87}},
+	{AXCHGW, yxchg, Pe, opBytes{0x90, 0x90, 0x87, 0x87}},
+	{AXLAT, ynone, Px, opBytes{0xd7}},
+	{AXORB, yxorb, Pb, opBytes{0x34, 0x80, 06, 0x30, 0x32}},
+	{AXORL, yaddl, Px, opBytes{0x83, 06, 0x35, 0x81, 06, 0x31, 0x33}},
+	{AXORPD, yxm, Pe, opBytes{0x57}},
+	{AXORPS, yxm, Pm, opBytes{0x57}},
+	{AXORQ, yaddl, Pw, opBytes{0x83, 06, 0x35, 0x81, 06, 0x31, 0x33}},
+	{AXORW, yaddl, Pe, opBytes{0x83, 06, 0x35, 0x81, 06, 0x31, 0x33}},
+	{AFMOVB, yfmvx, Px, opBytes{0xdf, 04}},
+	{AFMOVBP, yfmvp, Px, opBytes{0xdf, 06}},
+	{AFMOVD, yfmvd, Px, opBytes{0xdd, 00, 0xdd, 02, 0xd9, 00, 0xdd, 02}},
+	{AFMOVDP, yfmvdp, Px, opBytes{0xdd, 03, 0xdd, 03}},
+	{AFMOVF, yfmvf, Px, opBytes{0xd9, 00, 0xd9, 02}},
+	{AFMOVFP, yfmvp, Px, opBytes{0xd9, 03}},
+	{AFMOVL, yfmvf, Px, opBytes{0xdb, 00, 0xdb, 02}},
+	{AFMOVLP, yfmvp, Px, opBytes{0xdb, 03}},
+	{AFMOVV, yfmvx, Px, opBytes{0xdf, 05}},
+	{AFMOVVP, yfmvp, Px, opBytes{0xdf, 07}},
+	{AFMOVW, yfmvf, Px, opBytes{0xdf, 00, 0xdf, 02}},
+	{AFMOVWP, yfmvp, Px, opBytes{0xdf, 03}},
+	{AFMOVX, yfmvx, Px, opBytes{0xdb, 05}},
+	{AFMOVXP, yfmvp, Px, opBytes{0xdb, 07}},
+	{AFCMOVCC, yfcmv, Px, opBytes{0xdb, 00}},
+	{AFCMOVCS, yfcmv, Px, opBytes{0xda, 00}},
+	{AFCMOVEQ, yfcmv, Px, opBytes{0xda, 01}},
+	{AFCMOVHI, yfcmv, Px, opBytes{0xdb, 02}},
+	{AFCMOVLS, yfcmv, Px, opBytes{0xda, 02}},
+	{AFCMOVB, yfcmv, Px, opBytes{0xda, 00}},
+	{AFCMOVBE, yfcmv, Px, opBytes{0xda, 02}},
+	{AFCMOVNB, yfcmv, Px, opBytes{0xdb, 00}},
+	{AFCMOVNBE, yfcmv, Px, opBytes{0xdb, 02}},
+	{AFCMOVE, yfcmv, Px, opBytes{0xda, 01}},
+	{AFCMOVNE, yfcmv, Px, opBytes{0xdb, 01}},
+	{AFCMOVNU, yfcmv, Px, opBytes{0xdb, 03}},
+	{AFCMOVU, yfcmv, Px, opBytes{0xda, 03}},
+	{AFCMOVUN, yfcmv, Px, opBytes{0xda, 03}},
+	{AFCOMD, yfadd, Px, opBytes{0xdc, 02, 0xd8, 02, 0xdc, 02}},  // botch
+	{AFCOMDP, yfadd, Px, opBytes{0xdc, 03, 0xd8, 03, 0xdc, 03}}, // botch
+	{AFCOMDPP, ycompp, Px, opBytes{0xde, 03}},
+	{AFCOMF, yfmvx, Px, opBytes{0xd8, 02}},
+	{AFCOMFP, yfmvx, Px, opBytes{0xd8, 03}},
+	{AFCOMI, yfcmv, Px, opBytes{0xdb, 06}},
+	{AFCOMIP, yfcmv, Px, opBytes{0xdf, 06}},
+	{AFCOML, yfmvx, Px, opBytes{0xda, 02}},
+	{AFCOMLP, yfmvx, Px, opBytes{0xda, 03}},
+	{AFCOMW, yfmvx, Px, opBytes{0xde, 02}},
+	{AFCOMWP, yfmvx, Px, opBytes{0xde, 03}},
+	{AFUCOM, ycompp, Px, opBytes{0xdd, 04}},
+	{AFUCOMI, ycompp, Px, opBytes{0xdb, 05}},
+	{AFUCOMIP, ycompp, Px, opBytes{0xdf, 05}},
+	{AFUCOMP, ycompp, Px, opBytes{0xdd, 05}},
+	{AFUCOMPP, ycompp, Px, opBytes{0xda, 13}},
+	{AFADDDP, ycompp, Px, opBytes{0xde, 00}},
+	{AFADDW, yfmvx, Px, opBytes{0xde, 00}},
+	{AFADDL, yfmvx, Px, opBytes{0xda, 00}},
+	{AFADDF, yfmvx, Px, opBytes{0xd8, 00}},
+	{AFADDD, yfadd, Px, opBytes{0xdc, 00, 0xd8, 00, 0xdc, 00}},
+	{AFMULDP, ycompp, Px, opBytes{0xde, 01}},
+	{AFMULW, yfmvx, Px, opBytes{0xde, 01}},
+	{AFMULL, yfmvx, Px, opBytes{0xda, 01}},
+	{AFMULF, yfmvx, Px, opBytes{0xd8, 01}},
+	{AFMULD, yfadd, Px, opBytes{0xdc, 01, 0xd8, 01, 0xdc, 01}},
+	{AFSUBDP, ycompp, Px, opBytes{0xde, 05}},
+	{AFSUBW, yfmvx, Px, opBytes{0xde, 04}},
+	{AFSUBL, yfmvx, Px, opBytes{0xda, 04}},
+	{AFSUBF, yfmvx, Px, opBytes{0xd8, 04}},
+	{AFSUBD, yfadd, Px, opBytes{0xdc, 04, 0xd8, 04, 0xdc, 05}},
+	{AFSUBRDP, ycompp, Px, opBytes{0xde, 04}},
+	{AFSUBRW, yfmvx, Px, opBytes{0xde, 05}},
+	{AFSUBRL, yfmvx, Px, opBytes{0xda, 05}},
+	{AFSUBRF, yfmvx, Px, opBytes{0xd8, 05}},
+	{AFSUBRD, yfadd, Px, opBytes{0xdc, 05, 0xd8, 05, 0xdc, 04}},
+	{AFDIVDP, ycompp, Px, opBytes{0xde, 07}},
+	{AFDIVW, yfmvx, Px, opBytes{0xde, 06}},
+	{AFDIVL, yfmvx, Px, opBytes{0xda, 06}},
+	{AFDIVF, yfmvx, Px, opBytes{0xd8, 06}},
+	{AFDIVD, yfadd, Px, opBytes{0xdc, 06, 0xd8, 06, 0xdc, 07}},
+	{AFDIVRDP, ycompp, Px, opBytes{0xde, 06}},
+	{AFDIVRW, yfmvx, Px, opBytes{0xde, 07}},
+	{AFDIVRL, yfmvx, Px, opBytes{0xda, 07}},
+	{AFDIVRF, yfmvx, Px, opBytes{0xd8, 07}},
+	{AFDIVRD, yfadd, Px, opBytes{0xdc, 07, 0xd8, 07, 0xdc, 06}},
+	{AFXCHD, yfxch, Px, opBytes{0xd9, 01, 0xd9, 01}},
+	{AFFREE, nil, 0, opBytes{}},
+	{AFLDCW, ysvrs_mo, Px, opBytes{0xd9, 05, 0xd9, 05}},
+	{AFLDENV, ysvrs_mo, Px, opBytes{0xd9, 04, 0xd9, 04}},
+	{AFRSTOR, ysvrs_mo, Px, opBytes{0xdd, 04, 0xdd, 04}},
+	{AFSAVE, ysvrs_om, Px, opBytes{0xdd, 06, 0xdd, 06}},
+	{AFSTCW, ysvrs_om, Px, opBytes{0xd9, 07, 0xd9, 07}},
+	{AFSTENV, ysvrs_om, Px, opBytes{0xd9, 06, 0xd9, 06}},
+	{AFSTSW, ystsw, Px, opBytes{0xdd, 07, 0xdf, 0xe0}},
+	{AF2XM1, ynone, Px, opBytes{0xd9, 0xf0}},
+	{AFABS, ynone, Px, opBytes{0xd9, 0xe1}},
+	{AFBLD, ysvrs_mo, Px, opBytes{0xdf, 04}},
+	{AFBSTP, yclflush, Px, opBytes{0xdf, 06}},
+	{AFCHS, ynone, Px, opBytes{0xd9, 0xe0}},
+	{AFCLEX, ynone, Px, opBytes{0xdb, 0xe2}},
+	{AFCOS, ynone, Px, opBytes{0xd9, 0xff}},
+	{AFDECSTP, ynone, Px, opBytes{0xd9, 0xf6}},
+	{AFINCSTP, ynone, Px, opBytes{0xd9, 0xf7}},
+	{AFINIT, ynone, Px, opBytes{0xdb, 0xe3}},
+	{AFLD1, ynone, Px, opBytes{0xd9, 0xe8}},
+	{AFLDL2E, ynone, Px, opBytes{0xd9, 0xea}},
+	{AFLDL2T, ynone, Px, opBytes{0xd9, 0xe9}},
+	{AFLDLG2, ynone, Px, opBytes{0xd9, 0xec}},
+	{AFLDLN2, ynone, Px, opBytes{0xd9, 0xed}},
+	{AFLDPI, ynone, Px, opBytes{0xd9, 0xeb}},
+	{AFLDZ, ynone, Px, opBytes{0xd9, 0xee}},
+	{AFNOP, ynone, Px, opBytes{0xd9, 0xd0}},
+	{AFPATAN, ynone, Px, opBytes{0xd9, 0xf3}},
+	{AFPREM, ynone, Px, opBytes{0xd9, 0xf8}},
+	{AFPREM1, ynone, Px, opBytes{0xd9, 0xf5}},
+	{AFPTAN, ynone, Px, opBytes{0xd9, 0xf2}},
+	{AFRNDINT, ynone, Px, opBytes{0xd9, 0xfc}},
+	{AFSCALE, ynone, Px, opBytes{0xd9, 0xfd}},
+	{AFSIN, ynone, Px, opBytes{0xd9, 0xfe}},
+	{AFSINCOS, ynone, Px, opBytes{0xd9, 0xfb}},
+	{AFSQRT, ynone, Px, opBytes{0xd9, 0xfa}},
+	{AFTST, ynone, Px, opBytes{0xd9, 0xe4}},
+	{AFXAM, ynone, Px, opBytes{0xd9, 0xe5}},
+	{AFXTRACT, ynone, Px, opBytes{0xd9, 0xf4}},
+	{AFYL2X, ynone, Px, opBytes{0xd9, 0xf1}},
+	{AFYL2XP1, ynone, Px, opBytes{0xd9, 0xf9}},
+	{ACMPXCHGB, yrb_mb, Pb, opBytes{0x0f, 0xb0}},
+	{ACMPXCHGL, yrl_ml, Px, opBytes{0x0f, 0xb1}},
+	{ACMPXCHGW, yrl_ml, Pe, opBytes{0x0f, 0xb1}},
+	{ACMPXCHGQ, yrl_ml, Pw, opBytes{0x0f, 0xb1}},
+	{ACMPXCHG8B, yscond, Pm, opBytes{0xc7, 01}},
+	{ACMPXCHG16B, yscond, Pw, opBytes{0x0f, 0xc7, 01}},
+	{AINVD, ynone, Pm, opBytes{0x08}},
+	{AINVLPG, ydivb, Pm, opBytes{0x01, 07}},
+	{AINVPCID, ycrc32l, Pe, opBytes{0x0f, 0x38, 0x82, 0}},
+	{ALFENCE, ynone, Pm, opBytes{0xae, 0xe8}},
+	{AMFENCE, ynone, Pm, opBytes{0xae, 0xf0}},
+	{AMOVNTIL, yrl_ml, Pm, opBytes{0xc3}},
+	{AMOVNTIQ, yrl_ml, Pw, opBytes{0x0f, 0xc3}},
+	{ARDPKRU, ynone, Pm, opBytes{0x01, 0xee, 0}},
+	{ARDMSR, ynone, Pm, opBytes{0x32}},
+	{ARDPMC, ynone, Pm, opBytes{0x33}},
+	{ARDTSC, ynone, Pm, opBytes{0x31}},
+	{ARSM, ynone, Pm, opBytes{0xaa}},
+	{ASFENCE, ynone, Pm, opBytes{0xae, 0xf8}},
+	{ASYSRET, ynone, Pm, opBytes{0x07}},
+	{AWBINVD, ynone, Pm, opBytes{0x09}},
+	{AWRMSR, ynone, Pm, opBytes{0x30}},
+	{AWRPKRU, ynone, Pm, opBytes{0x01, 0xef, 0}},
+	{AXADDB, yrb_mb, Pb, opBytes{0x0f, 0xc0}},
+	{AXADDL, yrl_ml, Px, opBytes{0x0f, 0xc1}},
+	{AXADDQ, yrl_ml, Pw, opBytes{0x0f, 0xc1}},
+	{AXADDW, yrl_ml, Pe, opBytes{0x0f, 0xc1}},
+	{ACRC32B, ycrc32b, Px, opBytes{0xf2, 0x0f, 0x38, 0xf0, 0}},
+	{ACRC32L, ycrc32l, Px, opBytes{0xf2, 0x0f, 0x38, 0xf1, 0}},
+	{ACRC32Q, ycrc32l, Pw, opBytes{0xf2, 0x0f, 0x38, 0xf1, 0}},
+	{ACRC32W, ycrc32l, Pe, opBytes{0xf2, 0x0f, 0x38, 0xf1, 0}},
+	{APREFETCHT0, yprefetch, Pm, opBytes{0x18, 01}},
+	{APREFETCHT1, yprefetch, Pm, opBytes{0x18, 02}},
+	{APREFETCHT2, yprefetch, Pm, opBytes{0x18, 03}},
+	{APREFETCHNTA, yprefetch, Pm, opBytes{0x18, 00}},
+	{AMOVQL, yrl_ml, Px, opBytes{0x89}},
+	{obj.AUNDEF, ynone, Px, opBytes{0x0f, 0x0b}},
+	{AAESENC, yaes, Pq, opBytes{0x38, 0xdc, 0}},
+	{AAESENCLAST, yaes, Pq, opBytes{0x38, 0xdd, 0}},
+	{AAESDEC, yaes, Pq, opBytes{0x38, 0xde, 0}},
+	{AAESDECLAST, yaes, Pq, opBytes{0x38, 0xdf, 0}},
+	{AAESIMC, yaes, Pq, opBytes{0x38, 0xdb, 0}},
+	{AAESKEYGENASSIST, yxshuf, Pq, opBytes{0x3a, 0xdf, 0}},
+	{AROUNDPD, yxshuf, Pq, opBytes{0x3a, 0x09, 0}},
+	{AROUNDPS, yxshuf, Pq, opBytes{0x3a, 0x08, 0}},
+	{AROUNDSD, yxshuf, Pq, opBytes{0x3a, 0x0b, 0}},
+	{AROUNDSS, yxshuf, Pq, opBytes{0x3a, 0x0a, 0}},
+	{APSHUFD, yxshuf, Pq, opBytes{0x70, 0}},
+	{APCLMULQDQ, yxshuf, Pq, opBytes{0x3a, 0x44, 0}},
+	{APCMPESTRI, yxshuf, Pq, opBytes{0x3a, 0x61, 0}},
+	{APCMPESTRM, yxshuf, Pq, opBytes{0x3a, 0x60, 0}},
+	{AMOVDDUP, yxm, Pf2, opBytes{0x12}},
+	{AMOVSHDUP, yxm, Pf3, opBytes{0x16}},
+	{AMOVSLDUP, yxm, Pf3, opBytes{0x12}},
+	{ARDTSCP, ynone, Pm, opBytes{0x01, 0xf9, 0}},
+	{ASTAC, ynone, Pm, opBytes{0x01, 0xcb, 0}},
+	{AUD1, ynone, Pm, opBytes{0xb9, 0}},
+	{AUD2, ynone, Pm, opBytes{0x0b, 0}},
+	{AUMWAIT, ywrfsbase, Pf2, opBytes{0xae, 06}},
+	{ASYSENTER, ynone, Px, opBytes{0x0f, 0x34, 0}},
+	{ASYSENTER64, ynone, Pw, opBytes{0x0f, 0x34, 0}},
+	{ASYSEXIT, ynone, Px, opBytes{0x0f, 0x35, 0}},
+	{ASYSEXIT64, ynone, Pw, opBytes{0x0f, 0x35, 0}},
+	{ALMSW, ydivl, Pm, opBytes{0x01, 06}},
+	{ALLDT, ydivl, Pm, opBytes{0x00, 02}},
+	{ALIDT, ysvrs_mo, Pm, opBytes{0x01, 03}},
+	{ALGDT, ysvrs_mo, Pm, opBytes{0x01, 02}},
+	{ATZCNTW, ycrc32l, Pe, opBytes{0xf3, 0x0f, 0xbc, 0}},
+	{ATZCNTL, ycrc32l, Px, opBytes{0xf3, 0x0f, 0xbc, 0}},
+	{ATZCNTQ, ycrc32l, Pw, opBytes{0xf3, 0x0f, 0xbc, 0}},
+	{AXRSTOR, ydivl, Px, opBytes{0x0f, 0xae, 05}},
+	{AXRSTOR64, ydivl, Pw, opBytes{0x0f, 0xae, 05}},
+	{AXRSTORS, ydivl, Px, opBytes{0x0f, 0xc7, 03}},
+	{AXRSTORS64, ydivl, Pw, opBytes{0x0f, 0xc7, 03}},
+	{AXSAVE, yclflush, Px, opBytes{0x0f, 0xae, 04}},
+	{AXSAVE64, yclflush, Pw, opBytes{0x0f, 0xae, 04}},
+	{AXSAVEOPT, yclflush, Px, opBytes{0x0f, 0xae, 06}},
+	{AXSAVEOPT64, yclflush, Pw, opBytes{0x0f, 0xae, 06}},
+	{AXSAVEC, yclflush, Px, opBytes{0x0f, 0xc7, 04}},
+	{AXSAVEC64, yclflush, Pw, opBytes{0x0f, 0xc7, 04}},
+	{AXSAVES, yclflush, Px, opBytes{0x0f, 0xc7, 05}},
+	{AXSAVES64, yclflush, Pw, opBytes{0x0f, 0xc7, 05}},
+	{ASGDT, yclflush, Pm, opBytes{0x01, 00}},
+	{ASIDT, yclflush, Pm, opBytes{0x01, 01}},
+	{ARDRANDW, yrdrand, Pe, opBytes{0x0f, 0xc7, 06}},
+	{ARDRANDL, yrdrand, Px, opBytes{0x0f, 0xc7, 06}},
+	{ARDRANDQ, yrdrand, Pw, opBytes{0x0f, 0xc7, 06}},
+	{ARDSEEDW, yrdrand, Pe, opBytes{0x0f, 0xc7, 07}},
+	{ARDSEEDL, yrdrand, Px, opBytes{0x0f, 0xc7, 07}},
+	{ARDSEEDQ, yrdrand, Pw, opBytes{0x0f, 0xc7, 07}},
+	{ASTRW, yincq, Pe, opBytes{0x0f, 0x00, 01}},
+	{ASTRL, yincq, Px, opBytes{0x0f, 0x00, 01}},
+	{ASTRQ, yincq, Pw, opBytes{0x0f, 0x00, 01}},
+	{AXSETBV, ynone, Pm, opBytes{0x01, 0xd1, 0}},
+	{AMOVBEWW, ymovbe, Pq, opBytes{0x38, 0xf0, 0, 0x38, 0xf1, 0}},
+	{AMOVBELL, ymovbe, Pm, opBytes{0x38, 0xf0, 0, 0x38, 0xf1, 0}},
+	{AMOVBEQQ, ymovbe, Pw, opBytes{0x0f, 0x38, 0xf0, 0, 0x0f, 0x38, 0xf1, 0}},
+	{ANOPW, ydivl, Pe, opBytes{0x0f, 0x1f, 00}},
+	{ANOPL, ydivl, Px, opBytes{0x0f, 0x1f, 00}},
+	{ASLDTW, yincq, Pe, opBytes{0x0f, 0x00, 00}},
+	{ASLDTL, yincq, Px, opBytes{0x0f, 0x00, 00}},
+	{ASLDTQ, yincq, Pw, opBytes{0x0f, 0x00, 00}},
+	{ASMSWW, yincq, Pe, opBytes{0x0f, 0x01, 04}},
+	{ASMSWL, yincq, Px, opBytes{0x0f, 0x01, 04}},
+	{ASMSWQ, yincq, Pw, opBytes{0x0f, 0x01, 04}},
+	{ABLENDVPS, yblendvpd, Pq4, opBytes{0x14}},
+	{ABLENDVPD, yblendvpd, Pq4, opBytes{0x15}},
+	{APBLENDVB, yblendvpd, Pq4, opBytes{0x10}},
+	{ASHA1MSG1, yaes, Px, opBytes{0x0f, 0x38, 0xc9, 0}},
+	{ASHA1MSG2, yaes, Px, opBytes{0x0f, 0x38, 0xca, 0}},
+	{ASHA1NEXTE, yaes, Px, opBytes{0x0f, 0x38, 0xc8, 0}},
+	{ASHA256MSG1, yaes, Px, opBytes{0x0f, 0x38, 0xcc, 0}},
+	{ASHA256MSG2, yaes, Px, opBytes{0x0f, 0x38, 0xcd, 0}},
+	{ASHA1RNDS4, ysha1rnds4, Pm, opBytes{0x3a, 0xcc, 0}},
+	{ASHA256RNDS2, ysha256rnds2, Px, opBytes{0x0f, 0x38, 0xcb, 0}},
+	{ARDFSBASEL, yrdrand, Pf3, opBytes{0xae, 00}},
+	{ARDFSBASEQ, yrdrand, Pfw, opBytes{0xae, 00}},
+	{ARDGSBASEL, yrdrand, Pf3, opBytes{0xae, 01}},
+	{ARDGSBASEQ, yrdrand, Pfw, opBytes{0xae, 01}},
+	{AWRFSBASEL, ywrfsbase, Pf3, opBytes{0xae, 02}},
+	{AWRFSBASEQ, ywrfsbase, Pfw, opBytes{0xae, 02}},
+	{AWRGSBASEL, ywrfsbase, Pf3, opBytes{0xae, 03}},
+	{AWRGSBASEQ, ywrfsbase, Pfw, opBytes{0xae, 03}},
+	{ALFSW, ym_rl, Pe, opBytes{0x0f, 0xb4}},
+	{ALFSL, ym_rl, Px, opBytes{0x0f, 0xb4}},
+	{ALFSQ, ym_rl, Pw, opBytes{0x0f, 0xb4}},
+	{ALGSW, ym_rl, Pe, opBytes{0x0f, 0xb5}},
+	{ALGSL, ym_rl, Px, opBytes{0x0f, 0xb5}},
+	{ALGSQ, ym_rl, Pw, opBytes{0x0f, 0xb5}},
+	{ALSSW, ym_rl, Pe, opBytes{0x0f, 0xb2}},
+	{ALSSL, ym_rl, Px, opBytes{0x0f, 0xb2}},
+	{ALSSQ, ym_rl, Pw, opBytes{0x0f, 0xb2}},
+
+	{ABLENDPD, yxshuf, Pq, opBytes{0x3a, 0x0d, 0}},
+	{ABLENDPS, yxshuf, Pq, opBytes{0x3a, 0x0c, 0}},
+	{AXACQUIRE, ynone, Px, opBytes{0xf2}},
+	{AXRELEASE, ynone, Px, opBytes{0xf3}},
+	{AXBEGIN, yxbegin, Px, opBytes{0xc7, 0xf8}},
+	{AXABORT, yxabort, Px, opBytes{0xc6, 0xf8}},
+	{AXEND, ynone, Px, opBytes{0x0f, 01, 0xd5}},
+	{AXTEST, ynone, Px, opBytes{0x0f, 01, 0xd6}},
+	{AXGETBV, ynone, Pm, opBytes{01, 0xd0}},
+	{obj.AFUNCDATA, yfuncdata, Px, opBytes{0, 0}},
+	{obj.APCDATA, ypcdata, Px, opBytes{0, 0}},
+	{obj.ADUFFCOPY, yduff, Px, opBytes{0xe8}},
+	{obj.ADUFFZERO, yduff, Px, opBytes{0xe8}},
+
+	{obj.AEND, nil, 0, opBytes{}},
+	{0, nil, 0, opBytes{}},
+}
+
+var opindex [(ALAST + 1) & obj.AMask]*Optab
+
+// useAbs reports whether s describes a symbol that must avoid pc-relative addressing.
+// This happens on systems like Solaris that call .so functions instead of system calls.
+// It does not seem to be necessary for any other systems. This is probably working
+// around a Solaris-specific bug that should be fixed differently, but we don't know
+// what that bug is. And this does fix it.
+func useAbs(ctxt *obj.Link, s *obj.LSym) bool {
+	if ctxt.Headtype == objabi.Hsolaris {
+		// All the Solaris dynamic imports from libc.so begin with "libc_".
+		return strings.HasPrefix(s.Name, "libc_")
+	}
+	return ctxt.Arch.Family == sys.I386 && !ctxt.Flag_shared
+}
+
+// single-instruction no-ops of various lengths.
+// constructed by hand and disassembled with gdb to verify.
+// see http://www.agner.org/optimize/optimizing_assembly.pdf for discussion.
+var nop = [][16]uint8{
+	{0x90},
+	{0x66, 0x90},
+	{0x0F, 0x1F, 0x00},
+	{0x0F, 0x1F, 0x40, 0x00},
+	{0x0F, 0x1F, 0x44, 0x00, 0x00},
+	{0x66, 0x0F, 0x1F, 0x44, 0x00, 0x00},
+	{0x0F, 0x1F, 0x80, 0x00, 0x00, 0x00, 0x00},
+	{0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00},
+	{0x66, 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00},
+}
+
+// Native Client rejects the repeated 0x66 prefix.
+// {0x66, 0x66, 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00},
+func fillnop(p []byte, n int) {
+	var m int
+
+	for n > 0 {
+		m = n
+		if m > len(nop) {
+			m = len(nop)
+		}
+		copy(p[:m], nop[m-1][:m])
+		p = p[m:]
+		n -= m
+	}
+}
+
+func noppad(ctxt *obj.Link, s *obj.LSym, c int32, pad int32) int32 {
+	s.Grow(int64(c) + int64(pad))
+	fillnop(s.P[c:], int(pad))
+	return c + pad
+}
+
+func spadjop(ctxt *obj.Link, l, q obj.As) obj.As {
+	if ctxt.Arch.Family != sys.AMD64 || ctxt.Arch.PtrSize == 4 {
+		return l
+	}
+	return q
+}
+
+// If the environment variable GOAMD64=alignedjumps the assembler will ensure that
+// no standalone or macro-fused jump will straddle or end on a 32 byte boundary
+// by inserting NOPs before the jumps
+func isJump(p *obj.Prog) bool {
+	return p.To.Target() != nil || p.As == obj.AJMP || p.As == obj.ACALL ||
+		p.As == obj.ARET || p.As == obj.ADUFFCOPY || p.As == obj.ADUFFZERO
+}
+
+// lookForJCC returns the first real instruction starting from p, if that instruction is a conditional
+// jump. Otherwise, nil is returned.
+func lookForJCC(p *obj.Prog) *obj.Prog {
+	// Skip any PCDATA, FUNCDATA or NOP instructions
+	var q *obj.Prog
+	for q = p.Link; q != nil && (q.As == obj.APCDATA || q.As == obj.AFUNCDATA || q.As == obj.ANOP); q = q.Link {
+	}
+
+	if q == nil || q.To.Target() == nil || p.As == obj.AJMP || p.As == obj.ACALL {
+		return nil
+	}
+
+	switch q.As {
+	case AJOS, AJOC, AJCS, AJCC, AJEQ, AJNE, AJLS, AJHI,
+		AJMI, AJPL, AJPS, AJPC, AJLT, AJGE, AJLE, AJGT:
+	default:
+		return nil
+	}
+
+	return q
+}
+
+// fusedJump determines whether p can be fused with a subsequent conditional jump instruction.
+// If it can, we return true followed by the total size of the fused jump. If it can't, we return false.
+// Macro fusion rules are derived from the Intel Optimization Manual (April 2019) section 3.4.2.2.
+func fusedJump(p *obj.Prog) (bool, uint8) {
+	var fusedSize uint8
+
+	// The first instruction in a macro fused pair may be preceeded by the LOCK prefix,
+	// or possibly an XACQUIRE/XRELEASE prefix followed by a LOCK prefix. If it is, we
+	// need to be careful to insert any padding before the locks rather than directly after them.
+
+	if p.As == AXRELEASE || p.As == AXACQUIRE {
+		fusedSize += p.Isize
+		for p = p.Link; p != nil && (p.As == obj.APCDATA || p.As == obj.AFUNCDATA); p = p.Link {
+		}
+		if p == nil {
+			return false, 0
+		}
+	}
+	if p.As == ALOCK {
+		fusedSize += p.Isize
+		for p = p.Link; p != nil && (p.As == obj.APCDATA || p.As == obj.AFUNCDATA); p = p.Link {
+		}
+		if p == nil {
+			return false, 0
+		}
+	}
+	cmp := p.As == ACMPB || p.As == ACMPL || p.As == ACMPQ || p.As == ACMPW
+
+	cmpAddSub := p.As == AADDB || p.As == AADDL || p.As == AADDW || p.As == AADDQ ||
+		p.As == ASUBB || p.As == ASUBL || p.As == ASUBW || p.As == ASUBQ || cmp
+
+	testAnd := p.As == ATESTB || p.As == ATESTL || p.As == ATESTQ || p.As == ATESTW ||
+		p.As == AANDB || p.As == AANDL || p.As == AANDQ || p.As == AANDW
+
+	incDec := p.As == AINCB || p.As == AINCL || p.As == AINCQ || p.As == AINCW ||
+		p.As == ADECB || p.As == ADECL || p.As == ADECQ || p.As == ADECW
+
+	if !cmpAddSub && !testAnd && !incDec {
+		return false, 0
+	}
+
+	if !incDec {
+		var argOne obj.AddrType
+		var argTwo obj.AddrType
+		if cmp {
+			argOne = p.From.Type
+			argTwo = p.To.Type
+		} else {
+			argOne = p.To.Type
+			argTwo = p.From.Type
+		}
+		if argOne == obj.TYPE_REG {
+			if argTwo != obj.TYPE_REG && argTwo != obj.TYPE_CONST && argTwo != obj.TYPE_MEM {
+				return false, 0
+			}
+		} else if argOne == obj.TYPE_MEM {
+			if argTwo != obj.TYPE_REG {
+				return false, 0
+			}
+		} else {
+			return false, 0
+		}
+	}
+
+	fusedSize += p.Isize
+	jmp := lookForJCC(p)
+	if jmp == nil {
+		return false, 0
+	}
+
+	fusedSize += jmp.Isize
+
+	if testAnd {
+		return true, fusedSize
+	}
+
+	if jmp.As == AJOC || jmp.As == AJOS || jmp.As == AJMI ||
+		jmp.As == AJPL || jmp.As == AJPS || jmp.As == AJPC {
+		return false, 0
+	}
+
+	if cmpAddSub {
+		return true, fusedSize
+	}
+
+	if jmp.As == AJCS || jmp.As == AJCC || jmp.As == AJHI || jmp.As == AJLS {
+		return false, 0
+	}
+
+	return true, fusedSize
+}
+
+type padJumpsCtx int32
+
+func makePjcCtx(ctxt *obj.Link) padJumpsCtx {
+	// Disable jump padding on 32 bit builds by settting
+	// padJumps to 0.
+	if ctxt.Arch.Family == sys.I386 {
+		return padJumpsCtx(0)
+	}
+
+	// Disable jump padding for hand written assembly code.
+	if ctxt.IsAsm {
+		return padJumpsCtx(0)
+	}
+
+	if objabi.GOAMD64 != "alignedjumps" {
+		return padJumpsCtx(0)
+
+	}
+
+	return padJumpsCtx(32)
+}
+
+// padJump detects whether the instruction being assembled is a standalone or a macro-fused
+// jump that needs to be padded. If it is, NOPs are inserted to ensure that the jump does
+// not cross or end on a 32 byte boundary.
+func (pjc padJumpsCtx) padJump(ctxt *obj.Link, s *obj.LSym, p *obj.Prog, c int32) int32 {
+	if pjc == 0 {
+		return c
+	}
+
+	var toPad int32
+	fj, fjSize := fusedJump(p)
+	mask := int32(pjc - 1)
+	if fj {
+		if (c&mask)+int32(fjSize) >= int32(pjc) {
+			toPad = int32(pjc) - (c & mask)
+		}
+	} else if isJump(p) {
+		if (c&mask)+int32(p.Isize) >= int32(pjc) {
+			toPad = int32(pjc) - (c & mask)
+		}
+	}
+	if toPad <= 0 {
+		return c
+	}
+
+	return noppad(ctxt, s, c, toPad)
+}
+
+// reAssemble is called if an instruction's size changes during assembly. If
+// it does and the instruction is a standalone or a macro-fused jump we need to
+// reassemble.
+func (pjc padJumpsCtx) reAssemble(p *obj.Prog) bool {
+	if pjc == 0 {
+		return false
+	}
+
+	fj, _ := fusedJump(p)
+	return fj || isJump(p)
+}
+
+type nopPad struct {
+	p *obj.Prog // Instruction before the pad
+	n int32     // Size of the pad
+}
+
+func span6(ctxt *obj.Link, s *obj.LSym, newprog obj.ProgAlloc) {
+	pjc := makePjcCtx(ctxt)
+
+	if s.P != nil {
+		return
+	}
+
+	if ycover[0] == 0 {
+		ctxt.Diag("x86 tables not initialized, call x86.instinit first")
+	}
+
+	for p := s.Func.Text; p != nil; p = p.Link {
+		if p.To.Type == obj.TYPE_BRANCH && p.To.Target() == nil {
+			p.To.SetTarget(p)
+		}
+		if p.As == AADJSP {
+			p.To.Type = obj.TYPE_REG
+			p.To.Reg = REG_SP
+			// Generate 'ADDQ $x, SP' or 'SUBQ $x, SP', with x positive.
+			// One exception: It is smaller to encode $-0x80 than $0x80.
+			// For that case, flip the sign and the op:
+			// Instead of 'ADDQ $0x80, SP', generate 'SUBQ $-0x80, SP'.
+			switch v := p.From.Offset; {
+			case v == 0:
+				p.As = obj.ANOP
+			case v == 0x80 || (v < 0 && v != -0x80):
+				p.As = spadjop(ctxt, AADDL, AADDQ)
+				p.From.Offset *= -1
+			default:
+				p.As = spadjop(ctxt, ASUBL, ASUBQ)
+			}
+		}
+		if ctxt.Retpoline && (p.As == obj.ACALL || p.As == obj.AJMP) && (p.To.Type == obj.TYPE_REG || p.To.Type == obj.TYPE_MEM) {
+			if p.To.Type != obj.TYPE_REG {
+				ctxt.Diag("non-retpoline-compatible: %v", p)
+				continue
+			}
+			p.To.Type = obj.TYPE_BRANCH
+			p.To.Name = obj.NAME_EXTERN
+			p.To.Sym = ctxt.Lookup("runtime.retpoline" + obj.Rconv(int(p.To.Reg)))
+			p.To.Reg = 0
+			p.To.Offset = 0
+		}
+	}
+
+	var count int64 // rough count of number of instructions
+	for p := s.Func.Text; p != nil; p = p.Link {
+		count++
+		p.Back = branchShort // use short branches first time through
+		if q := p.To.Target(); q != nil && (q.Back&branchShort != 0) {
+			p.Back |= branchBackwards
+			q.Back |= branchLoopHead
+		}
+	}
+	s.GrowCap(count * 5) // preallocate roughly 5 bytes per instruction
+
+	var ab AsmBuf
+	var n int
+	var c int32
+	errors := ctxt.Errors
+	var nops []nopPad // Padding for a particular assembly (reuse slice storage if multiple assemblies)
+	for {
+		// This loop continues while there are reasons to re-assemble
+		// whole block, like the presence of long forward jumps.
+		reAssemble := false
+		for i := range s.R {
+			s.R[i] = obj.Reloc{}
+		}
+		s.R = s.R[:0]
+		s.P = s.P[:0]
+		c = 0
+		var pPrev *obj.Prog
+		nops = nops[:0]
+		for p := s.Func.Text; p != nil; p = p.Link {
+			c0 := c
+			c = pjc.padJump(ctxt, s, p, c)
+
+			if maxLoopPad > 0 && p.Back&branchLoopHead != 0 && c&(loopAlign-1) != 0 {
+				// pad with NOPs
+				v := -c & (loopAlign - 1)
+
+				if v <= maxLoopPad {
+					s.Grow(int64(c) + int64(v))
+					fillnop(s.P[c:], int(v))
+					c += v
+				}
+			}
+
+			p.Pc = int64(c)
+
+			// process forward jumps to p
+			for q := p.Rel; q != nil; q = q.Forwd {
+				v := int32(p.Pc - (q.Pc + int64(q.Isize)))
+				if q.Back&branchShort != 0 {
+					if v > 127 {
+						reAssemble = true
+						q.Back ^= branchShort
+					}
+
+					if q.As == AJCXZL || q.As == AXBEGIN {
+						s.P[q.Pc+2] = byte(v)
+					} else {
+						s.P[q.Pc+1] = byte(v)
+					}
+				} else {
+					binary.LittleEndian.PutUint32(s.P[q.Pc+int64(q.Isize)-4:], uint32(v))
+				}
+			}
+
+			p.Rel = nil
+
+			p.Pc = int64(c)
+			ab.asmins(ctxt, s, p)
+			m := ab.Len()
+			if int(p.Isize) != m {
+				p.Isize = uint8(m)
+				if pjc.reAssemble(p) {
+					// We need to re-assemble here to check for jumps and fused jumps
+					// that span or end on 32 byte boundaries.
+					reAssemble = true
+				}
+			}
+
+			s.Grow(p.Pc + int64(m))
+			copy(s.P[p.Pc:], ab.Bytes())
+			// If there was padding, remember it.
+			if pPrev != nil && !ctxt.IsAsm && c > c0 {
+				nops = append(nops, nopPad{p: pPrev, n: c - c0})
+			}
+			c += int32(m)
+			pPrev = p
+		}
+
+		n++
+		if n > 20 {
+			ctxt.Diag("span must be looping")
+			log.Fatalf("loop")
+		}
+		if !reAssemble {
+			break
+		}
+		if ctxt.Errors > errors {
+			return
+		}
+	}
+	// splice padding nops into Progs
+	for _, n := range nops {
+		pp := n.p
+		np := &obj.Prog{Link: pp.Link, Ctxt: pp.Ctxt, As: obj.ANOP, Pos: pp.Pos.WithNotStmt(), Pc: pp.Pc + int64(pp.Isize), Isize: uint8(n.n)}
+		pp.Link = np
+	}
+
+	s.Size = int64(c)
+
+	if false { /* debug['a'] > 1 */
+		fmt.Printf("span1 %s %d (%d tries)\n %.6x", s.Name, s.Size, n, 0)
+		var i int
+		for i = 0; i < len(s.P); i++ {
+			fmt.Printf(" %.2x", s.P[i])
+			if i%16 == 15 {
+				fmt.Printf("\n  %.6x", uint(i+1))
+			}
+		}
+
+		if i%16 != 0 {
+			fmt.Printf("\n")
+		}
+
+		for i := 0; i < len(s.R); i++ {
+			r := &s.R[i]
+			fmt.Printf(" rel %#.4x/%d %s%+d\n", uint32(r.Off), r.Siz, r.Sym.Name, r.Add)
+		}
+	}
+
+	// Mark nonpreemptible instruction sequences.
+	// The 2-instruction TLS access sequence
+	//	MOVQ TLS, BX
+	//	MOVQ 0(BX)(TLS*1), BX
+	// is not async preemptible, as if it is preempted and resumed on
+	// a different thread, the TLS address may become invalid.
+	if !CanUse1InsnTLS(ctxt) {
+		useTLS := func(p *obj.Prog) bool {
+			// Only need to mark the second instruction, which has
+			// REG_TLS as Index. (It is okay to interrupt and restart
+			// the first instruction.)
+			return p.From.Index == REG_TLS
+		}
+		obj.MarkUnsafePoints(ctxt, s.Func.Text, newprog, useTLS, nil)
+	}
+}
+
+func instinit(ctxt *obj.Link) {
+	if ycover[0] != 0 {
+		// Already initialized; stop now.
+		// This happens in the cmd/asm tests,
+		// each of which re-initializes the arch.
+		return
+	}
+
+	switch ctxt.Headtype {
+	case objabi.Hplan9:
+		plan9privates = ctxt.Lookup("_privates")
+	}
+
+	for i := range avxOptab {
+		c := avxOptab[i].as
+		if opindex[c&obj.AMask] != nil {
+			ctxt.Diag("phase error in avxOptab: %d (%v)", i, c)
+		}
+		opindex[c&obj.AMask] = &avxOptab[i]
+	}
+	for i := 1; optab[i].as != 0; i++ {
+		c := optab[i].as
+		if opindex[c&obj.AMask] != nil {
+			ctxt.Diag("phase error in optab: %d (%v)", i, c)
+		}
+		opindex[c&obj.AMask] = &optab[i]
+	}
+
+	for i := 0; i < Ymax; i++ {
+		ycover[i*Ymax+i] = 1
+	}
+
+	ycover[Yi0*Ymax+Yu2] = 1
+	ycover[Yi1*Ymax+Yu2] = 1
+
+	ycover[Yi0*Ymax+Yi8] = 1
+	ycover[Yi1*Ymax+Yi8] = 1
+	ycover[Yu2*Ymax+Yi8] = 1
+	ycover[Yu7*Ymax+Yi8] = 1
+
+	ycover[Yi0*Ymax+Yu7] = 1
+	ycover[Yi1*Ymax+Yu7] = 1
+	ycover[Yu2*Ymax+Yu7] = 1
+
+	ycover[Yi0*Ymax+Yu8] = 1
+	ycover[Yi1*Ymax+Yu8] = 1
+	ycover[Yu2*Ymax+Yu8] = 1
+	ycover[Yu7*Ymax+Yu8] = 1
+
+	ycover[Yi0*Ymax+Ys32] = 1
+	ycover[Yi1*Ymax+Ys32] = 1
+	ycover[Yu2*Ymax+Ys32] = 1
+	ycover[Yu7*Ymax+Ys32] = 1
+	ycover[Yu8*Ymax+Ys32] = 1
+	ycover[Yi8*Ymax+Ys32] = 1
+
+	ycover[Yi0*Ymax+Yi32] = 1
+	ycover[Yi1*Ymax+Yi32] = 1
+	ycover[Yu2*Ymax+Yi32] = 1
+	ycover[Yu7*Ymax+Yi32] = 1
+	ycover[Yu8*Ymax+Yi32] = 1
+	ycover[Yi8*Ymax+Yi32] = 1
+	ycover[Ys32*Ymax+Yi32] = 1
+
+	ycover[Yi0*Ymax+Yi64] = 1
+	ycover[Yi1*Ymax+Yi64] = 1
+	ycover[Yu7*Ymax+Yi64] = 1
+	ycover[Yu2*Ymax+Yi64] = 1
+	ycover[Yu8*Ymax+Yi64] = 1
+	ycover[Yi8*Ymax+Yi64] = 1
+	ycover[Ys32*Ymax+Yi64] = 1
+	ycover[Yi32*Ymax+Yi64] = 1
+
+	ycover[Yal*Ymax+Yrb] = 1
+	ycover[Ycl*Ymax+Yrb] = 1
+	ycover[Yax*Ymax+Yrb] = 1
+	ycover[Ycx*Ymax+Yrb] = 1
+	ycover[Yrx*Ymax+Yrb] = 1
+	ycover[Yrl*Ymax+Yrb] = 1 // but not Yrl32
+
+	ycover[Ycl*Ymax+Ycx] = 1
+
+	ycover[Yax*Ymax+Yrx] = 1
+	ycover[Ycx*Ymax+Yrx] = 1
+
+	ycover[Yax*Ymax+Yrl] = 1
+	ycover[Ycx*Ymax+Yrl] = 1
+	ycover[Yrx*Ymax+Yrl] = 1
+	ycover[Yrl32*Ymax+Yrl] = 1
+
+	ycover[Yf0*Ymax+Yrf] = 1
+
+	ycover[Yal*Ymax+Ymb] = 1
+	ycover[Ycl*Ymax+Ymb] = 1
+	ycover[Yax*Ymax+Ymb] = 1
+	ycover[Ycx*Ymax+Ymb] = 1
+	ycover[Yrx*Ymax+Ymb] = 1
+	ycover[Yrb*Ymax+Ymb] = 1
+	ycover[Yrl*Ymax+Ymb] = 1 // but not Yrl32
+	ycover[Ym*Ymax+Ymb] = 1
+
+	ycover[Yax*Ymax+Yml] = 1
+	ycover[Ycx*Ymax+Yml] = 1
+	ycover[Yrx*Ymax+Yml] = 1
+	ycover[Yrl*Ymax+Yml] = 1
+	ycover[Yrl32*Ymax+Yml] = 1
+	ycover[Ym*Ymax+Yml] = 1
+
+	ycover[Yax*Ymax+Ymm] = 1
+	ycover[Ycx*Ymax+Ymm] = 1
+	ycover[Yrx*Ymax+Ymm] = 1
+	ycover[Yrl*Ymax+Ymm] = 1
+	ycover[Yrl32*Ymax+Ymm] = 1
+	ycover[Ym*Ymax+Ymm] = 1
+	ycover[Ymr*Ymax+Ymm] = 1
+
+	ycover[Yxr0*Ymax+Yxr] = 1
+
+	ycover[Ym*Ymax+Yxm] = 1
+	ycover[Yxr0*Ymax+Yxm] = 1
+	ycover[Yxr*Ymax+Yxm] = 1
+
+	ycover[Ym*Ymax+Yym] = 1
+	ycover[Yyr*Ymax+Yym] = 1
+
+	ycover[Yxr0*Ymax+YxrEvex] = 1
+	ycover[Yxr*Ymax+YxrEvex] = 1
+
+	ycover[Ym*Ymax+YxmEvex] = 1
+	ycover[Yxr0*Ymax+YxmEvex] = 1
+	ycover[Yxr*Ymax+YxmEvex] = 1
+	ycover[YxrEvex*Ymax+YxmEvex] = 1
+
+	ycover[Yyr*Ymax+YyrEvex] = 1
+
+	ycover[Ym*Ymax+YymEvex] = 1
+	ycover[Yyr*Ymax+YymEvex] = 1
+	ycover[YyrEvex*Ymax+YymEvex] = 1
+
+	ycover[Ym*Ymax+Yzm] = 1
+	ycover[Yzr*Ymax+Yzm] = 1
+
+	ycover[Yk0*Ymax+Yk] = 1
+	ycover[Yknot0*Ymax+Yk] = 1
+
+	ycover[Yk0*Ymax+Ykm] = 1
+	ycover[Yknot0*Ymax+Ykm] = 1
+	ycover[Yk*Ymax+Ykm] = 1
+	ycover[Ym*Ymax+Ykm] = 1
+
+	ycover[Yxvm*Ymax+YxvmEvex] = 1
+
+	ycover[Yyvm*Ymax+YyvmEvex] = 1
+
+	for i := 0; i < MAXREG; i++ {
+		reg[i] = -1
+		if i >= REG_AL && i <= REG_R15B {
+			reg[i] = (i - REG_AL) & 7
+			if i >= REG_SPB && i <= REG_DIB {
+				regrex[i] = 0x40
+			}
+			if i >= REG_R8B && i <= REG_R15B {
+				regrex[i] = Rxr | Rxx | Rxb
+			}
+		}
+
+		if i >= REG_AH && i <= REG_BH {
+			reg[i] = 4 + ((i - REG_AH) & 7)
+		}
+		if i >= REG_AX && i <= REG_R15 {
+			reg[i] = (i - REG_AX) & 7
+			if i >= REG_R8 {
+				regrex[i] = Rxr | Rxx | Rxb
+			}
+		}
+
+		if i >= REG_F0 && i <= REG_F0+7 {
+			reg[i] = (i - REG_F0) & 7
+		}
+		if i >= REG_M0 && i <= REG_M0+7 {
+			reg[i] = (i - REG_M0) & 7
+		}
+		if i >= REG_K0 && i <= REG_K0+7 {
+			reg[i] = (i - REG_K0) & 7
+		}
+		if i >= REG_X0 && i <= REG_X0+15 {
+			reg[i] = (i - REG_X0) & 7
+			if i >= REG_X0+8 {
+				regrex[i] = Rxr | Rxx | Rxb
+			}
+		}
+		if i >= REG_X16 && i <= REG_X16+15 {
+			reg[i] = (i - REG_X16) & 7
+			if i >= REG_X16+8 {
+				regrex[i] = Rxr | Rxx | Rxb | RxrEvex
+			} else {
+				regrex[i] = RxrEvex
+			}
+		}
+		if i >= REG_Y0 && i <= REG_Y0+15 {
+			reg[i] = (i - REG_Y0) & 7
+			if i >= REG_Y0+8 {
+				regrex[i] = Rxr | Rxx | Rxb
+			}
+		}
+		if i >= REG_Y16 && i <= REG_Y16+15 {
+			reg[i] = (i - REG_Y16) & 7
+			if i >= REG_Y16+8 {
+				regrex[i] = Rxr | Rxx | Rxb | RxrEvex
+			} else {
+				regrex[i] = RxrEvex
+			}
+		}
+		if i >= REG_Z0 && i <= REG_Z0+15 {
+			reg[i] = (i - REG_Z0) & 7
+			if i > REG_Z0+7 {
+				regrex[i] = Rxr | Rxx | Rxb
+			}
+		}
+		if i >= REG_Z16 && i <= REG_Z16+15 {
+			reg[i] = (i - REG_Z16) & 7
+			if i >= REG_Z16+8 {
+				regrex[i] = Rxr | Rxx | Rxb | RxrEvex
+			} else {
+				regrex[i] = RxrEvex
+			}
+		}
+
+		if i >= REG_CR+8 && i <= REG_CR+15 {
+			regrex[i] = Rxr
+		}
+	}
+}
+
+var isAndroid = objabi.GOOS == "android"
+
+func prefixof(ctxt *obj.Link, a *obj.Addr) int {
+	if a.Reg < REG_CS && a.Index < REG_CS { // fast path
+		return 0
+	}
+	if a.Type == obj.TYPE_MEM && a.Name == obj.NAME_NONE {
+		switch a.Reg {
+		case REG_CS:
+			return 0x2e
+
+		case REG_DS:
+			return 0x3e
+
+		case REG_ES:
+			return 0x26
+
+		case REG_FS:
+			return 0x64
+
+		case REG_GS:
+			return 0x65
+
+		case REG_TLS:
+			// NOTE: Systems listed here should be only systems that
+			// support direct TLS references like 8(TLS) implemented as
+			// direct references from FS or GS. Systems that require
+			// the initial-exec model, where you load the TLS base into
+			// a register and then index from that register, do not reach
+			// this code and should not be listed.
+			if ctxt.Arch.Family == sys.I386 {
+				switch ctxt.Headtype {
+				default:
+					if isAndroid {
+						return 0x65 // GS
+					}
+					log.Fatalf("unknown TLS base register for %v", ctxt.Headtype)
+
+				case objabi.Hdarwin,
+					objabi.Hdragonfly,
+					objabi.Hfreebsd,
+					objabi.Hnetbsd,
+					objabi.Hopenbsd:
+					return 0x65 // GS
+				}
+			}
+
+			switch ctxt.Headtype {
+			default:
+				log.Fatalf("unknown TLS base register for %v", ctxt.Headtype)
+
+			case objabi.Hlinux:
+				if isAndroid {
+					return 0x64 // FS
+				}
+
+				if ctxt.Flag_shared {
+					log.Fatalf("unknown TLS base register for linux with -shared")
+				} else {
+					return 0x64 // FS
+				}
+
+			case objabi.Hdragonfly,
+				objabi.Hfreebsd,
+				objabi.Hnetbsd,
+				objabi.Hopenbsd,
+				objabi.Hsolaris:
+				return 0x64 // FS
+
+			case objabi.Hdarwin:
+				return 0x65 // GS
+			}
+		}
+	}
+
+	if ctxt.Arch.Family == sys.I386 {
+		if a.Index == REG_TLS && ctxt.Flag_shared {
+			// When building for inclusion into a shared library, an instruction of the form
+			//     MOVL off(CX)(TLS*1), AX
+			// becomes
+			//     mov %gs:off(%ecx), %eax
+			// which assumes that the correct TLS offset has been loaded into %ecx (today
+			// there is only one TLS variable -- g -- so this is OK). When not building for
+			// a shared library the instruction it becomes
+			//     mov 0x0(%ecx), %eax
+			// and a R_TLS_LE relocation, and so does not require a prefix.
+			return 0x65 // GS
+		}
+		return 0
+	}
+
+	switch a.Index {
+	case REG_CS:
+		return 0x2e
+
+	case REG_DS:
+		return 0x3e
+
+	case REG_ES:
+		return 0x26
+
+	case REG_TLS:
+		if ctxt.Flag_shared && ctxt.Headtype != objabi.Hwindows {
+			// When building for inclusion into a shared library, an instruction of the form
+			//     MOV off(CX)(TLS*1), AX
+			// becomes
+			//     mov %fs:off(%rcx), %rax
+			// which assumes that the correct TLS offset has been loaded into %rcx (today
+			// there is only one TLS variable -- g -- so this is OK). When not building for
+			// a shared library the instruction does not require a prefix.
+			return 0x64
+		}
+
+	case REG_FS:
+		return 0x64
+
+	case REG_GS:
+		return 0x65
+	}
+
+	return 0
+}
+
+// oclassRegList returns multisource operand class for addr.
+func oclassRegList(ctxt *obj.Link, addr *obj.Addr) int {
+	// TODO(quasilyte): when oclass register case is refactored into
+	// lookup table, use it here to get register kind more easily.
+	// Helper functions like regIsXmm should go away too (they will become redundant).
+
+	regIsXmm := func(r int) bool { return r >= REG_X0 && r <= REG_X31 }
+	regIsYmm := func(r int) bool { return r >= REG_Y0 && r <= REG_Y31 }
+	regIsZmm := func(r int) bool { return r >= REG_Z0 && r <= REG_Z31 }
+
+	reg0, reg1 := decodeRegisterRange(addr.Offset)
+	low := regIndex(int16(reg0))
+	high := regIndex(int16(reg1))
+
+	if ctxt.Arch.Family == sys.I386 {
+		if low >= 8 || high >= 8 {
+			return Yxxx
+		}
+	}
+
+	switch high - low {
+	case 3:
+		switch {
+		case regIsXmm(reg0) && regIsXmm(reg1):
+			return YxrEvexMulti4
+		case regIsYmm(reg0) && regIsYmm(reg1):
+			return YyrEvexMulti4
+		case regIsZmm(reg0) && regIsZmm(reg1):
+			return YzrMulti4
+		default:
+			return Yxxx
+		}
+	default:
+		return Yxxx
+	}
+}
+
+// oclassVMem returns V-mem (vector memory with VSIB) operand class.
+// For addr that is not V-mem returns (Yxxx, false).
+func oclassVMem(ctxt *obj.Link, addr *obj.Addr) (int, bool) {
+	switch addr.Index {
+	case REG_X0 + 0,
+		REG_X0 + 1,
+		REG_X0 + 2,
+		REG_X0 + 3,
+		REG_X0 + 4,
+		REG_X0 + 5,
+		REG_X0 + 6,
+		REG_X0 + 7:
+		return Yxvm, true
+	case REG_X8 + 0,
+		REG_X8 + 1,
+		REG_X8 + 2,
+		REG_X8 + 3,
+		REG_X8 + 4,
+		REG_X8 + 5,
+		REG_X8 + 6,
+		REG_X8 + 7:
+		if ctxt.Arch.Family == sys.I386 {
+			return Yxxx, true
+		}
+		return Yxvm, true
+	case REG_X16 + 0,
+		REG_X16 + 1,
+		REG_X16 + 2,
+		REG_X16 + 3,
+		REG_X16 + 4,
+		REG_X16 + 5,
+		REG_X16 + 6,
+		REG_X16 + 7,
+		REG_X16 + 8,
+		REG_X16 + 9,
+		REG_X16 + 10,
+		REG_X16 + 11,
+		REG_X16 + 12,
+		REG_X16 + 13,
+		REG_X16 + 14,
+		REG_X16 + 15:
+		if ctxt.Arch.Family == sys.I386 {
+			return Yxxx, true
+		}
+		return YxvmEvex, true
+
+	case REG_Y0 + 0,
+		REG_Y0 + 1,
+		REG_Y0 + 2,
+		REG_Y0 + 3,
+		REG_Y0 + 4,
+		REG_Y0 + 5,
+		REG_Y0 + 6,
+		REG_Y0 + 7:
+		return Yyvm, true
+	case REG_Y8 + 0,
+		REG_Y8 + 1,
+		REG_Y8 + 2,
+		REG_Y8 + 3,
+		REG_Y8 + 4,
+		REG_Y8 + 5,
+		REG_Y8 + 6,
+		REG_Y8 + 7:
+		if ctxt.Arch.Family == sys.I386 {
+			return Yxxx, true
+		}
+		return Yyvm, true
+	case REG_Y16 + 0,
+		REG_Y16 + 1,
+		REG_Y16 + 2,
+		REG_Y16 + 3,
+		REG_Y16 + 4,
+		REG_Y16 + 5,
+		REG_Y16 + 6,
+		REG_Y16 + 7,
+		REG_Y16 + 8,
+		REG_Y16 + 9,
+		REG_Y16 + 10,
+		REG_Y16 + 11,
+		REG_Y16 + 12,
+		REG_Y16 + 13,
+		REG_Y16 + 14,
+		REG_Y16 + 15:
+		if ctxt.Arch.Family == sys.I386 {
+			return Yxxx, true
+		}
+		return YyvmEvex, true
+
+	case REG_Z0 + 0,
+		REG_Z0 + 1,
+		REG_Z0 + 2,
+		REG_Z0 + 3,
+		REG_Z0 + 4,
+		REG_Z0 + 5,
+		REG_Z0 + 6,
+		REG_Z0 + 7:
+		return Yzvm, true
+	case REG_Z8 + 0,
+		REG_Z8 + 1,
+		REG_Z8 + 2,
+		REG_Z8 + 3,
+		REG_Z8 + 4,
+		REG_Z8 + 5,
+		REG_Z8 + 6,
+		REG_Z8 + 7,
+		REG_Z8 + 8,
+		REG_Z8 + 9,
+		REG_Z8 + 10,
+		REG_Z8 + 11,
+		REG_Z8 + 12,
+		REG_Z8 + 13,
+		REG_Z8 + 14,
+		REG_Z8 + 15,
+		REG_Z8 + 16,
+		REG_Z8 + 17,
+		REG_Z8 + 18,
+		REG_Z8 + 19,
+		REG_Z8 + 20,
+		REG_Z8 + 21,
+		REG_Z8 + 22,
+		REG_Z8 + 23:
+		if ctxt.Arch.Family == sys.I386 {
+			return Yxxx, true
+		}
+		return Yzvm, true
+	}
+
+	return Yxxx, false
+}
+
+func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
+	switch a.Type {
+	case obj.TYPE_REGLIST:
+		return oclassRegList(ctxt, a)
+
+	case obj.TYPE_NONE:
+		return Ynone
+
+	case obj.TYPE_BRANCH:
+		return Ybr
+
+	case obj.TYPE_INDIR:
+		if a.Name != obj.NAME_NONE && a.Reg == REG_NONE && a.Index == REG_NONE && a.Scale == 0 {
+			return Yindir
+		}
+		return Yxxx
+
+	case obj.TYPE_MEM:
+		// Pseudo registers have negative index, but SP is
+		// not pseudo on x86, hence REG_SP check is not redundant.
+		if a.Index == REG_SP || a.Index < 0 {
+			// Can't use FP/SB/PC/SP as the index register.
+			return Yxxx
+		}
+
+		if vmem, ok := oclassVMem(ctxt, a); ok {
+			return vmem
+		}
+
+		if ctxt.Arch.Family == sys.AMD64 {
+			switch a.Name {
+			case obj.NAME_EXTERN, obj.NAME_STATIC, obj.NAME_GOTREF:
+				// Global variables can't use index registers and their
+				// base register is %rip (%rip is encoded as REG_NONE).
+				if a.Reg != REG_NONE || a.Index != REG_NONE || a.Scale != 0 {
+					return Yxxx
+				}
+			case obj.NAME_AUTO, obj.NAME_PARAM:
+				// These names must have a base of SP.  The old compiler
+				// uses 0 for the base register. SSA uses REG_SP.
+				if a.Reg != REG_SP && a.Reg != 0 {
+					return Yxxx
+				}
+			case obj.NAME_NONE:
+				// everything is ok
+			default:
+				// unknown name
+				return Yxxx
+			}
+		}
+		return Ym
+
+	case obj.TYPE_ADDR:
+		switch a.Name {
+		case obj.NAME_GOTREF:
+			ctxt.Diag("unexpected TYPE_ADDR with NAME_GOTREF")
+			return Yxxx
+
+		case obj.NAME_EXTERN,
+			obj.NAME_STATIC:
+			if a.Sym != nil && useAbs(ctxt, a.Sym) {
+				return Yi32
+			}
+			return Yiauto // use pc-relative addressing
+
+		case obj.NAME_AUTO,
+			obj.NAME_PARAM:
+			return Yiauto
+		}
+
+		// TODO(rsc): DUFFZERO/DUFFCOPY encoding forgot to set a->index
+		// and got Yi32 in an earlier version of this code.
+		// Keep doing that until we fix yduff etc.
+		if a.Sym != nil && strings.HasPrefix(a.Sym.Name, "runtime.duff") {
+			return Yi32
+		}
+
+		if a.Sym != nil || a.Name != obj.NAME_NONE {
+			ctxt.Diag("unexpected addr: %v", obj.Dconv(p, a))
+		}
+		fallthrough
+
+	case obj.TYPE_CONST:
+		if a.Sym != nil {
+			ctxt.Diag("TYPE_CONST with symbol: %v", obj.Dconv(p, a))
+		}
+
+		v := a.Offset
+		if ctxt.Arch.Family == sys.I386 {
+			v = int64(int32(v))
+		}
+		switch {
+		case v == 0:
+			return Yi0
+		case v == 1:
+			return Yi1
+		case v >= 0 && v <= 3:
+			return Yu2
+		case v >= 0 && v <= 127:
+			return Yu7
+		case v >= 0 && v <= 255:
+			return Yu8
+		case v >= -128 && v <= 127:
+			return Yi8
+		}
+		if ctxt.Arch.Family == sys.I386 {
+			return Yi32
+		}
+		l := int32(v)
+		if int64(l) == v {
+			return Ys32 // can sign extend
+		}
+		if v>>32 == 0 {
+			return Yi32 // unsigned
+		}
+		return Yi64
+
+	case obj.TYPE_TEXTSIZE:
+		return Ytextsize
+	}
+
+	if a.Type != obj.TYPE_REG {
+		ctxt.Diag("unexpected addr1: type=%d %v", a.Type, obj.Dconv(p, a))
+		return Yxxx
+	}
+
+	switch a.Reg {
+	case REG_AL:
+		return Yal
+
+	case REG_AX:
+		return Yax
+
+		/*
+			case REG_SPB:
+		*/
+	case REG_BPB,
+		REG_SIB,
+		REG_DIB,
+		REG_R8B,
+		REG_R9B,
+		REG_R10B,
+		REG_R11B,
+		REG_R12B,
+		REG_R13B,
+		REG_R14B,
+		REG_R15B:
+		if ctxt.Arch.Family == sys.I386 {
+			return Yxxx
+		}
+		fallthrough
+
+	case REG_DL,
+		REG_BL,
+		REG_AH,
+		REG_CH,
+		REG_DH,
+		REG_BH:
+		return Yrb
+
+	case REG_CL:
+		return Ycl
+
+	case REG_CX:
+		return Ycx
+
+	case REG_DX, REG_BX:
+		return Yrx
+
+	case REG_R8, // not really Yrl
+		REG_R9,
+		REG_R10,
+		REG_R11,
+		REG_R12,
+		REG_R13,
+		REG_R14,
+		REG_R15:
+		if ctxt.Arch.Family == sys.I386 {
+			return Yxxx
+		}
+		fallthrough
+
+	case REG_SP, REG_BP, REG_SI, REG_DI:
+		if ctxt.Arch.Family == sys.I386 {
+			return Yrl32
+		}
+		return Yrl
+
+	case REG_F0 + 0:
+		return Yf0
+
+	case REG_F0 + 1,
+		REG_F0 + 2,
+		REG_F0 + 3,
+		REG_F0 + 4,
+		REG_F0 + 5,
+		REG_F0 + 6,
+		REG_F0 + 7:
+		return Yrf
+
+	case REG_M0 + 0,
+		REG_M0 + 1,
+		REG_M0 + 2,
+		REG_M0 + 3,
+		REG_M0 + 4,
+		REG_M0 + 5,
+		REG_M0 + 6,
+		REG_M0 + 7:
+		return Ymr
+
+	case REG_X0:
+		return Yxr0
+
+	case REG_X0 + 1,
+		REG_X0 + 2,
+		REG_X0 + 3,
+		REG_X0 + 4,
+		REG_X0 + 5,
+		REG_X0 + 6,
+		REG_X0 + 7,
+		REG_X0 + 8,
+		REG_X0 + 9,
+		REG_X0 + 10,
+		REG_X0 + 11,
+		REG_X0 + 12,
+		REG_X0 + 13,
+		REG_X0 + 14,
+		REG_X0 + 15:
+		return Yxr
+
+	case REG_X0 + 16,
+		REG_X0 + 17,
+		REG_X0 + 18,
+		REG_X0 + 19,
+		REG_X0 + 20,
+		REG_X0 + 21,
+		REG_X0 + 22,
+		REG_X0 + 23,
+		REG_X0 + 24,
+		REG_X0 + 25,
+		REG_X0 + 26,
+		REG_X0 + 27,
+		REG_X0 + 28,
+		REG_X0 + 29,
+		REG_X0 + 30,
+		REG_X0 + 31:
+		return YxrEvex
+
+	case REG_Y0 + 0,
+		REG_Y0 + 1,
+		REG_Y0 + 2,
+		REG_Y0 + 3,
+		REG_Y0 + 4,
+		REG_Y0 + 5,
+		REG_Y0 + 6,
+		REG_Y0 + 7,
+		REG_Y0 + 8,
+		REG_Y0 + 9,
+		REG_Y0 + 10,
+		REG_Y0 + 11,
+		REG_Y0 + 12,
+		REG_Y0 + 13,
+		REG_Y0 + 14,
+		REG_Y0 + 15:
+		return Yyr
+
+	case REG_Y0 + 16,
+		REG_Y0 + 17,
+		REG_Y0 + 18,
+		REG_Y0 + 19,
+		REG_Y0 + 20,
+		REG_Y0 + 21,
+		REG_Y0 + 22,
+		REG_Y0 + 23,
+		REG_Y0 + 24,
+		REG_Y0 + 25,
+		REG_Y0 + 26,
+		REG_Y0 + 27,
+		REG_Y0 + 28,
+		REG_Y0 + 29,
+		REG_Y0 + 30,
+		REG_Y0 + 31:
+		return YyrEvex
+
+	case REG_Z0 + 0,
+		REG_Z0 + 1,
+		REG_Z0 + 2,
+		REG_Z0 + 3,
+		REG_Z0 + 4,
+		REG_Z0 + 5,
+		REG_Z0 + 6,
+		REG_Z0 + 7:
+		return Yzr
+
+	case REG_Z0 + 8,
+		REG_Z0 + 9,
+		REG_Z0 + 10,
+		REG_Z0 + 11,
+		REG_Z0 + 12,
+		REG_Z0 + 13,
+		REG_Z0 + 14,
+		REG_Z0 + 15,
+		REG_Z0 + 16,
+		REG_Z0 + 17,
+		REG_Z0 + 18,
+		REG_Z0 + 19,
+		REG_Z0 + 20,
+		REG_Z0 + 21,
+		REG_Z0 + 22,
+		REG_Z0 + 23,
+		REG_Z0 + 24,
+		REG_Z0 + 25,
+		REG_Z0 + 26,
+		REG_Z0 + 27,
+		REG_Z0 + 28,
+		REG_Z0 + 29,
+		REG_Z0 + 30,
+		REG_Z0 + 31:
+		if ctxt.Arch.Family == sys.I386 {
+			return Yxxx
+		}
+		return Yzr
+
+	case REG_K0:
+		return Yk0
+
+	case REG_K0 + 1,
+		REG_K0 + 2,
+		REG_K0 + 3,
+		REG_K0 + 4,
+		REG_K0 + 5,
+		REG_K0 + 6,
+		REG_K0 + 7:
+		return Yknot0
+
+	case REG_CS:
+		return Ycs
+	case REG_SS:
+		return Yss
+	case REG_DS:
+		return Yds
+	case REG_ES:
+		return Yes
+	case REG_FS:
+		return Yfs
+	case REG_GS:
+		return Ygs
+	case REG_TLS:
+		return Ytls
+
+	case REG_GDTR:
+		return Ygdtr
+	case REG_IDTR:
+		return Yidtr
+	case REG_LDTR:
+		return Yldtr
+	case REG_MSW:
+		return Ymsw
+	case REG_TASK:
+		return Ytask
+
+	case REG_CR + 0:
+		return Ycr0
+	case REG_CR + 1:
+		return Ycr1
+	case REG_CR + 2:
+		return Ycr2
+	case REG_CR + 3:
+		return Ycr3
+	case REG_CR + 4:
+		return Ycr4
+	case REG_CR + 5:
+		return Ycr5
+	case REG_CR + 6:
+		return Ycr6
+	case REG_CR + 7:
+		return Ycr7
+	case REG_CR + 8:
+		return Ycr8
+
+	case REG_DR + 0:
+		return Ydr0
+	case REG_DR + 1:
+		return Ydr1
+	case REG_DR + 2:
+		return Ydr2
+	case REG_DR + 3:
+		return Ydr3
+	case REG_DR + 4:
+		return Ydr4
+	case REG_DR + 5:
+		return Ydr5
+	case REG_DR + 6:
+		return Ydr6
+	case REG_DR + 7:
+		return Ydr7
+
+	case REG_TR + 0:
+		return Ytr0
+	case REG_TR + 1:
+		return Ytr1
+	case REG_TR + 2:
+		return Ytr2
+	case REG_TR + 3:
+		return Ytr3
+	case REG_TR + 4:
+		return Ytr4
+	case REG_TR + 5:
+		return Ytr5
+	case REG_TR + 6:
+		return Ytr6
+	case REG_TR + 7:
+		return Ytr7
+	}
+
+	return Yxxx
+}
+
+// AsmBuf is a simple buffer to assemble variable-length x86 instructions into
+// and hold assembly state.
+type AsmBuf struct {
+	buf      [100]byte
+	off      int
+	rexflag  int
+	vexflag  bool // Per inst: true for VEX-encoded
+	evexflag bool // Per inst: true for EVEX-encoded
+	rep      bool
+	repn     bool
+	lock     bool
+
+	evex evexBits // Initialized when evexflag is true
+}
+
+// Put1 appends one byte to the end of the buffer.
+func (ab *AsmBuf) Put1(x byte) {
+	ab.buf[ab.off] = x
+	ab.off++
+}
+
+// Put2 appends two bytes to the end of the buffer.
+func (ab *AsmBuf) Put2(x, y byte) {
+	ab.buf[ab.off+0] = x
+	ab.buf[ab.off+1] = y
+	ab.off += 2
+}
+
+// Put3 appends three bytes to the end of the buffer.
+func (ab *AsmBuf) Put3(x, y, z byte) {
+	ab.buf[ab.off+0] = x
+	ab.buf[ab.off+1] = y
+	ab.buf[ab.off+2] = z
+	ab.off += 3
+}
+
+// Put4 appends four bytes to the end of the buffer.
+func (ab *AsmBuf) Put4(x, y, z, w byte) {
+	ab.buf[ab.off+0] = x
+	ab.buf[ab.off+1] = y
+	ab.buf[ab.off+2] = z
+	ab.buf[ab.off+3] = w
+	ab.off += 4
+}
+
+// PutInt16 writes v into the buffer using little-endian encoding.
+func (ab *AsmBuf) PutInt16(v int16) {
+	ab.buf[ab.off+0] = byte(v)
+	ab.buf[ab.off+1] = byte(v >> 8)
+	ab.off += 2
+}
+
+// PutInt32 writes v into the buffer using little-endian encoding.
+func (ab *AsmBuf) PutInt32(v int32) {
+	ab.buf[ab.off+0] = byte(v)
+	ab.buf[ab.off+1] = byte(v >> 8)
+	ab.buf[ab.off+2] = byte(v >> 16)
+	ab.buf[ab.off+3] = byte(v >> 24)
+	ab.off += 4
+}
+
+// PutInt64 writes v into the buffer using little-endian encoding.
+func (ab *AsmBuf) PutInt64(v int64) {
+	ab.buf[ab.off+0] = byte(v)
+	ab.buf[ab.off+1] = byte(v >> 8)
+	ab.buf[ab.off+2] = byte(v >> 16)
+	ab.buf[ab.off+3] = byte(v >> 24)
+	ab.buf[ab.off+4] = byte(v >> 32)
+	ab.buf[ab.off+5] = byte(v >> 40)
+	ab.buf[ab.off+6] = byte(v >> 48)
+	ab.buf[ab.off+7] = byte(v >> 56)
+	ab.off += 8
+}
+
+// Put copies b into the buffer.
+func (ab *AsmBuf) Put(b []byte) {
+	copy(ab.buf[ab.off:], b)
+	ab.off += len(b)
+}
+
+// PutOpBytesLit writes zero terminated sequence of bytes from op,
+// starting at specified offset (e.g. z counter value).
+// Trailing 0 is not written.
+//
+// Intended to be used for literal Z cases.
+// Literal Z cases usually have "Zlit" in their name (Zlit, Zlitr_m, Zlitm_r).
+func (ab *AsmBuf) PutOpBytesLit(offset int, op *opBytes) {
+	for int(op[offset]) != 0 {
+		ab.Put1(byte(op[offset]))
+		offset++
+	}
+}
+
+// Insert inserts b at offset i.
+func (ab *AsmBuf) Insert(i int, b byte) {
+	ab.off++
+	copy(ab.buf[i+1:ab.off], ab.buf[i:ab.off-1])
+	ab.buf[i] = b
+}
+
+// Last returns the byte at the end of the buffer.
+func (ab *AsmBuf) Last() byte { return ab.buf[ab.off-1] }
+
+// Len returns the length of the buffer.
+func (ab *AsmBuf) Len() int { return ab.off }
+
+// Bytes returns the contents of the buffer.
+func (ab *AsmBuf) Bytes() []byte { return ab.buf[:ab.off] }
+
+// Reset empties the buffer.
+func (ab *AsmBuf) Reset() { ab.off = 0 }
+
+// At returns the byte at offset i.
+func (ab *AsmBuf) At(i int) byte { return ab.buf[i] }
+
+// asmidx emits SIB byte.
+func (ab *AsmBuf) asmidx(ctxt *obj.Link, scale int, index int, base int) {
+	var i int
+
+	// X/Y index register is used in VSIB.
+	switch index {
+	default:
+		goto bad
+
+	case REG_NONE:
+		i = 4 << 3
+		goto bas
+
+	case REG_R8,
+		REG_R9,
+		REG_R10,
+		REG_R11,
+		REG_R12,
+		REG_R13,
+		REG_R14,
+		REG_R15,
+		REG_X8,
+		REG_X9,
+		REG_X10,
+		REG_X11,
+		REG_X12,
+		REG_X13,
+		REG_X14,
+		REG_X15,
+		REG_X16,
+		REG_X17,
+		REG_X18,
+		REG_X19,
+		REG_X20,
+		REG_X21,
+		REG_X22,
+		REG_X23,
+		REG_X24,
+		REG_X25,
+		REG_X26,
+		REG_X27,
+		REG_X28,
+		REG_X29,
+		REG_X30,
+		REG_X31,
+		REG_Y8,
+		REG_Y9,
+		REG_Y10,
+		REG_Y11,
+		REG_Y12,
+		REG_Y13,
+		REG_Y14,
+		REG_Y15,
+		REG_Y16,
+		REG_Y17,
+		REG_Y18,
+		REG_Y19,
+		REG_Y20,
+		REG_Y21,
+		REG_Y22,
+		REG_Y23,
+		REG_Y24,
+		REG_Y25,
+		REG_Y26,
+		REG_Y27,
+		REG_Y28,
+		REG_Y29,
+		REG_Y30,
+		REG_Y31,
+		REG_Z8,
+		REG_Z9,
+		REG_Z10,
+		REG_Z11,
+		REG_Z12,
+		REG_Z13,
+		REG_Z14,
+		REG_Z15,
+		REG_Z16,
+		REG_Z17,
+		REG_Z18,
+		REG_Z19,
+		REG_Z20,
+		REG_Z21,
+		REG_Z22,
+		REG_Z23,
+		REG_Z24,
+		REG_Z25,
+		REG_Z26,
+		REG_Z27,
+		REG_Z28,
+		REG_Z29,
+		REG_Z30,
+		REG_Z31:
+		if ctxt.Arch.Family == sys.I386 {
+			goto bad
+		}
+		fallthrough
+
+	case REG_AX,
+		REG_CX,
+		REG_DX,
+		REG_BX,
+		REG_BP,
+		REG_SI,
+		REG_DI,
+		REG_X0,
+		REG_X1,
+		REG_X2,
+		REG_X3,
+		REG_X4,
+		REG_X5,
+		REG_X6,
+		REG_X7,
+		REG_Y0,
+		REG_Y1,
+		REG_Y2,
+		REG_Y3,
+		REG_Y4,
+		REG_Y5,
+		REG_Y6,
+		REG_Y7,
+		REG_Z0,
+		REG_Z1,
+		REG_Z2,
+		REG_Z3,
+		REG_Z4,
+		REG_Z5,
+		REG_Z6,
+		REG_Z7:
+		i = reg[index] << 3
+	}
+
+	switch scale {
+	default:
+		goto bad
+
+	case 1:
+		break
+
+	case 2:
+		i |= 1 << 6
+
+	case 4:
+		i |= 2 << 6
+
+	case 8:
+		i |= 3 << 6
+	}
+
+bas:
+	switch base {
+	default:
+		goto bad
+
+	case REG_NONE: // must be mod=00
+		i |= 5
+
+	case REG_R8,
+		REG_R9,
+		REG_R10,
+		REG_R11,
+		REG_R12,
+		REG_R13,
+		REG_R14,
+		REG_R15:
+		if ctxt.Arch.Family == sys.I386 {
+			goto bad
+		}
+		fallthrough
+
+	case REG_AX,
+		REG_CX,
+		REG_DX,
+		REG_BX,
+		REG_SP,
+		REG_BP,
+		REG_SI,
+		REG_DI:
+		i |= reg[base]
+	}
+
+	ab.Put1(byte(i))
+	return
+
+bad:
+	ctxt.Diag("asmidx: bad address %d/%d/%d", scale, index, base)
+	ab.Put1(0)
+}
+
+func (ab *AsmBuf) relput4(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, a *obj.Addr) {
+	var rel obj.Reloc
+
+	v := vaddr(ctxt, p, a, &rel)
+	if rel.Siz != 0 {
+		if rel.Siz != 4 {
+			ctxt.Diag("bad reloc")
+		}
+		r := obj.Addrel(cursym)
+		*r = rel
+		r.Off = int32(p.Pc + int64(ab.Len()))
+	}
+
+	ab.PutInt32(int32(v))
+}
+
+func vaddr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r *obj.Reloc) int64 {
+	if r != nil {
+		*r = obj.Reloc{}
+	}
+
+	switch a.Name {
+	case obj.NAME_STATIC,
+		obj.NAME_GOTREF,
+		obj.NAME_EXTERN:
+		s := a.Sym
+		if r == nil {
+			ctxt.Diag("need reloc for %v", obj.Dconv(p, a))
+			log.Fatalf("reloc")
+		}
+
+		if a.Name == obj.NAME_GOTREF {
+			r.Siz = 4
+			r.Type = objabi.R_GOTPCREL
+		} else if useAbs(ctxt, s) {
+			r.Siz = 4
+			r.Type = objabi.R_ADDR
+		} else {
+			r.Siz = 4
+			r.Type = objabi.R_PCREL
+		}
+
+		r.Off = -1 // caller must fill in
+		r.Sym = s
+		r.Add = a.Offset
+
+		return 0
+	}
+
+	if (a.Type == obj.TYPE_MEM || a.Type == obj.TYPE_ADDR) && a.Reg == REG_TLS {
+		if r == nil {
+			ctxt.Diag("need reloc for %v", obj.Dconv(p, a))
+			log.Fatalf("reloc")
+		}
+
+		if !ctxt.Flag_shared || isAndroid || ctxt.Headtype == objabi.Hdarwin {
+			r.Type = objabi.R_TLS_LE
+			r.Siz = 4
+			r.Off = -1 // caller must fill in
+			r.Add = a.Offset
+		}
+		return 0
+	}
+
+	return a.Offset
+}
+
+func (ab *AsmBuf) asmandsz(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, a *obj.Addr, r int, rex int, m64 int) {
+	var base int
+	var rel obj.Reloc
+
+	rex &= 0x40 | Rxr
+	if a.Offset != int64(int32(a.Offset)) {
+		// The rules are slightly different for 386 and AMD64,
+		// mostly for historical reasons. We may unify them later,
+		// but it must be discussed beforehand.
+		//
+		// For 64bit mode only LEAL is allowed to overflow.
+		// It's how https://golang.org/cl/59630 made it.
+		// crypto/sha1/sha1block_amd64.s depends on this feature.
+		//
+		// For 32bit mode rules are more permissive.
+		// If offset fits uint32, it's permitted.
+		// This is allowed for assembly that wants to use 32-bit hex
+		// constants, e.g. LEAL 0x99999999(AX), AX.
+		overflowOK := (ctxt.Arch.Family == sys.AMD64 && p.As == ALEAL) ||
+			(ctxt.Arch.Family != sys.AMD64 &&
+				int64(uint32(a.Offset)) == a.Offset &&
+				ab.rexflag&Rxw == 0)
+		if !overflowOK {
+			ctxt.Diag("offset too large in %s", p)
+		}
+	}
+	v := int32(a.Offset)
+	rel.Siz = 0
+
+	switch a.Type {
+	case obj.TYPE_ADDR:
+		if a.Name == obj.NAME_NONE {
+			ctxt.Diag("unexpected TYPE_ADDR with NAME_NONE")
+		}
+		if a.Index == REG_TLS {
+			ctxt.Diag("unexpected TYPE_ADDR with index==REG_TLS")
+		}
+		goto bad
+
+	case obj.TYPE_REG:
+		const regFirst = REG_AL
+		const regLast = REG_Z31
+		if a.Reg < regFirst || regLast < a.Reg {
+			goto bad
+		}
+		if v != 0 {
+			goto bad
+		}
+		ab.Put1(byte(3<<6 | reg[a.Reg]<<0 | r<<3))
+		ab.rexflag |= regrex[a.Reg]&(0x40|Rxb) | rex
+		return
+	}
+
+	if a.Type != obj.TYPE_MEM {
+		goto bad
+	}
+
+	if a.Index != REG_NONE && a.Index != REG_TLS {
+		base := int(a.Reg)
+		switch a.Name {
+		case obj.NAME_EXTERN,
+			obj.NAME_GOTREF,
+			obj.NAME_STATIC:
+			if !useAbs(ctxt, a.Sym) && ctxt.Arch.Family == sys.AMD64 {
+				goto bad
+			}
+			if ctxt.Arch.Family == sys.I386 && ctxt.Flag_shared {
+				// The base register has already been set. It holds the PC
+				// of this instruction returned by a PC-reading thunk.
+				// See obj6.go:rewriteToPcrel.
+			} else {
+				base = REG_NONE
+			}
+			v = int32(vaddr(ctxt, p, a, &rel))
+
+		case obj.NAME_AUTO,
+			obj.NAME_PARAM:
+			base = REG_SP
+		}
+
+		ab.rexflag |= regrex[int(a.Index)]&Rxx | regrex[base]&Rxb | rex
+		if base == REG_NONE {
+			ab.Put1(byte(0<<6 | 4<<0 | r<<3))
+			ab.asmidx(ctxt, int(a.Scale), int(a.Index), base)
+			goto putrelv
+		}
+
+		if v == 0 && rel.Siz == 0 && base != REG_BP && base != REG_R13 {
+			ab.Put1(byte(0<<6 | 4<<0 | r<<3))
+			ab.asmidx(ctxt, int(a.Scale), int(a.Index), base)
+			return
+		}
+
+		if disp8, ok := toDisp8(v, p, ab); ok && rel.Siz == 0 {
+			ab.Put1(byte(1<<6 | 4<<0 | r<<3))
+			ab.asmidx(ctxt, int(a.Scale), int(a.Index), base)
+			ab.Put1(disp8)
+			return
+		}
+
+		ab.Put1(byte(2<<6 | 4<<0 | r<<3))
+		ab.asmidx(ctxt, int(a.Scale), int(a.Index), base)
+		goto putrelv
+	}
+
+	base = int(a.Reg)
+	switch a.Name {
+	case obj.NAME_STATIC,
+		obj.NAME_GOTREF,
+		obj.NAME_EXTERN:
+		if a.Sym == nil {
+			ctxt.Diag("bad addr: %v", p)
+		}
+		if ctxt.Arch.Family == sys.I386 && ctxt.Flag_shared {
+			// The base register has already been set. It holds the PC
+			// of this instruction returned by a PC-reading thunk.
+			// See obj6.go:rewriteToPcrel.
+		} else {
+			base = REG_NONE
+		}
+		v = int32(vaddr(ctxt, p, a, &rel))
+
+	case obj.NAME_AUTO,
+		obj.NAME_PARAM:
+		base = REG_SP
+	}
+
+	if base == REG_TLS {
+		v = int32(vaddr(ctxt, p, a, &rel))
+	}
+
+	ab.rexflag |= regrex[base]&Rxb | rex
+	if base == REG_NONE || (REG_CS <= base && base <= REG_GS) || base == REG_TLS {
+		if (a.Sym == nil || !useAbs(ctxt, a.Sym)) && base == REG_NONE && (a.Name == obj.NAME_STATIC || a.Name == obj.NAME_EXTERN || a.Name == obj.NAME_GOTREF) || ctxt.Arch.Family != sys.AMD64 {
+			if a.Name == obj.NAME_GOTREF && (a.Offset != 0 || a.Index != 0 || a.Scale != 0) {
+				ctxt.Diag("%v has offset against gotref", p)
+			}
+			ab.Put1(byte(0<<6 | 5<<0 | r<<3))
+			goto putrelv
+		}
+
+		// temporary
+		ab.Put2(
+			byte(0<<6|4<<0|r<<3), // sib present
+			0<<6|4<<3|5<<0,       // DS:d32
+		)
+		goto putrelv
+	}
+
+	if base == REG_SP || base == REG_R12 {
+		if v == 0 {
+			ab.Put1(byte(0<<6 | reg[base]<<0 | r<<3))
+			ab.asmidx(ctxt, int(a.Scale), REG_NONE, base)
+			return
+		}
+
+		if disp8, ok := toDisp8(v, p, ab); ok {
+			ab.Put1(byte(1<<6 | reg[base]<<0 | r<<3))
+			ab.asmidx(ctxt, int(a.Scale), REG_NONE, base)
+			ab.Put1(disp8)
+			return
+		}
+
+		ab.Put1(byte(2<<6 | reg[base]<<0 | r<<3))
+		ab.asmidx(ctxt, int(a.Scale), REG_NONE, base)
+		goto putrelv
+	}
+
+	if REG_AX <= base && base <= REG_R15 {
+		if a.Index == REG_TLS && !ctxt.Flag_shared && !isAndroid {
+			rel = obj.Reloc{}
+			rel.Type = objabi.R_TLS_LE
+			rel.Siz = 4
+			rel.Sym = nil
+			rel.Add = int64(v)
+			v = 0
+		}
+
+		if v == 0 && rel.Siz == 0 && base != REG_BP && base != REG_R13 {
+			ab.Put1(byte(0<<6 | reg[base]<<0 | r<<3))
+			return
+		}
+
+		if disp8, ok := toDisp8(v, p, ab); ok && rel.Siz == 0 {
+			ab.Put2(byte(1<<6|reg[base]<<0|r<<3), disp8)
+			return
+		}
+
+		ab.Put1(byte(2<<6 | reg[base]<<0 | r<<3))
+		goto putrelv
+	}
+
+	goto bad
+
+putrelv:
+	if rel.Siz != 0 {
+		if rel.Siz != 4 {
+			ctxt.Diag("bad rel")
+			goto bad
+		}
+
+		r := obj.Addrel(cursym)
+		*r = rel
+		r.Off = int32(p.Pc + int64(ab.Len()))
+	}
+
+	ab.PutInt32(v)
+	return
+
+bad:
+	ctxt.Diag("asmand: bad address %v", obj.Dconv(p, a))
+}
+
+func (ab *AsmBuf) asmand(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, a *obj.Addr, ra *obj.Addr) {
+	ab.asmandsz(ctxt, cursym, p, a, reg[ra.Reg], regrex[ra.Reg], 0)
+}
+
+func (ab *AsmBuf) asmando(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, a *obj.Addr, o int) {
+	ab.asmandsz(ctxt, cursym, p, a, o, 0, 0)
+}
+
+func bytereg(a *obj.Addr, t *uint8) {
+	if a.Type == obj.TYPE_REG && a.Index == REG_NONE && (REG_AX <= a.Reg && a.Reg <= REG_R15) {
+		a.Reg += REG_AL - REG_AX
+		*t = 0
+	}
+}
+
+func unbytereg(a *obj.Addr, t *uint8) {
+	if a.Type == obj.TYPE_REG && a.Index == REG_NONE && (REG_AL <= a.Reg && a.Reg <= REG_R15B) {
+		a.Reg += REG_AX - REG_AL
+		*t = 0
+	}
+}
+
+const (
+	movLit uint8 = iota // Like Zlit
+	movRegMem
+	movMemReg
+	movRegMem2op
+	movMemReg2op
+	movFullPtr // Load full pointer, trash heap (unsupported)
+	movDoubleShift
+	movTLSReg
+)
+
+var ymovtab = []movtab{
+	// push
+	{APUSHL, Ycs, Ynone, Ynone, movLit, [4]uint8{0x0e, 0}},
+	{APUSHL, Yss, Ynone, Ynone, movLit, [4]uint8{0x16, 0}},
+	{APUSHL, Yds, Ynone, Ynone, movLit, [4]uint8{0x1e, 0}},
+	{APUSHL, Yes, Ynone, Ynone, movLit, [4]uint8{0x06, 0}},
+	{APUSHL, Yfs, Ynone, Ynone, movLit, [4]uint8{0x0f, 0xa0, 0}},
+	{APUSHL, Ygs, Ynone, Ynone, movLit, [4]uint8{0x0f, 0xa8, 0}},
+	{APUSHQ, Yfs, Ynone, Ynone, movLit, [4]uint8{0x0f, 0xa0, 0}},
+	{APUSHQ, Ygs, Ynone, Ynone, movLit, [4]uint8{0x0f, 0xa8, 0}},
+	{APUSHW, Ycs, Ynone, Ynone, movLit, [4]uint8{Pe, 0x0e, 0}},
+	{APUSHW, Yss, Ynone, Ynone, movLit, [4]uint8{Pe, 0x16, 0}},
+	{APUSHW, Yds, Ynone, Ynone, movLit, [4]uint8{Pe, 0x1e, 0}},
+	{APUSHW, Yes, Ynone, Ynone, movLit, [4]uint8{Pe, 0x06, 0}},
+	{APUSHW, Yfs, Ynone, Ynone, movLit, [4]uint8{Pe, 0x0f, 0xa0, 0}},
+	{APUSHW, Ygs, Ynone, Ynone, movLit, [4]uint8{Pe, 0x0f, 0xa8, 0}},
+
+	// pop
+	{APOPL, Ynone, Ynone, Yds, movLit, [4]uint8{0x1f, 0}},
+	{APOPL, Ynone, Ynone, Yes, movLit, [4]uint8{0x07, 0}},
+	{APOPL, Ynone, Ynone, Yss, movLit, [4]uint8{0x17, 0}},
+	{APOPL, Ynone, Ynone, Yfs, movLit, [4]uint8{0x0f, 0xa1, 0}},
+	{APOPL, Ynone, Ynone, Ygs, movLit, [4]uint8{0x0f, 0xa9, 0}},
+	{APOPQ, Ynone, Ynone, Yfs, movLit, [4]uint8{0x0f, 0xa1, 0}},
+	{APOPQ, Ynone, Ynone, Ygs, movLit, [4]uint8{0x0f, 0xa9, 0}},
+	{APOPW, Ynone, Ynone, Yds, movLit, [4]uint8{Pe, 0x1f, 0}},
+	{APOPW, Ynone, Ynone, Yes, movLit, [4]uint8{Pe, 0x07, 0}},
+	{APOPW, Ynone, Ynone, Yss, movLit, [4]uint8{Pe, 0x17, 0}},
+	{APOPW, Ynone, Ynone, Yfs, movLit, [4]uint8{Pe, 0x0f, 0xa1, 0}},
+	{APOPW, Ynone, Ynone, Ygs, movLit, [4]uint8{Pe, 0x0f, 0xa9, 0}},
+
+	// mov seg
+	{AMOVW, Yes, Ynone, Yml, movRegMem, [4]uint8{0x8c, 0, 0, 0}},
+	{AMOVW, Ycs, Ynone, Yml, movRegMem, [4]uint8{0x8c, 1, 0, 0}},
+	{AMOVW, Yss, Ynone, Yml, movRegMem, [4]uint8{0x8c, 2, 0, 0}},
+	{AMOVW, Yds, Ynone, Yml, movRegMem, [4]uint8{0x8c, 3, 0, 0}},
+	{AMOVW, Yfs, Ynone, Yml, movRegMem, [4]uint8{0x8c, 4, 0, 0}},
+	{AMOVW, Ygs, Ynone, Yml, movRegMem, [4]uint8{0x8c, 5, 0, 0}},
+	{AMOVW, Yml, Ynone, Yes, movMemReg, [4]uint8{0x8e, 0, 0, 0}},
+	{AMOVW, Yml, Ynone, Ycs, movMemReg, [4]uint8{0x8e, 1, 0, 0}},
+	{AMOVW, Yml, Ynone, Yss, movMemReg, [4]uint8{0x8e, 2, 0, 0}},
+	{AMOVW, Yml, Ynone, Yds, movMemReg, [4]uint8{0x8e, 3, 0, 0}},
+	{AMOVW, Yml, Ynone, Yfs, movMemReg, [4]uint8{0x8e, 4, 0, 0}},
+	{AMOVW, Yml, Ynone, Ygs, movMemReg, [4]uint8{0x8e, 5, 0, 0}},
+
+	// mov cr
+	{AMOVL, Ycr0, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x20, 0, 0}},
+	{AMOVL, Ycr2, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x20, 2, 0}},
+	{AMOVL, Ycr3, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x20, 3, 0}},
+	{AMOVL, Ycr4, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x20, 4, 0}},
+	{AMOVL, Ycr8, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x20, 8, 0}},
+	{AMOVQ, Ycr0, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x20, 0, 0}},
+	{AMOVQ, Ycr2, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x20, 2, 0}},
+	{AMOVQ, Ycr3, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x20, 3, 0}},
+	{AMOVQ, Ycr4, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x20, 4, 0}},
+	{AMOVQ, Ycr8, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x20, 8, 0}},
+	{AMOVL, Yrl, Ynone, Ycr0, movMemReg2op, [4]uint8{0x0f, 0x22, 0, 0}},
+	{AMOVL, Yrl, Ynone, Ycr2, movMemReg2op, [4]uint8{0x0f, 0x22, 2, 0}},
+	{AMOVL, Yrl, Ynone, Ycr3, movMemReg2op, [4]uint8{0x0f, 0x22, 3, 0}},
+	{AMOVL, Yrl, Ynone, Ycr4, movMemReg2op, [4]uint8{0x0f, 0x22, 4, 0}},
+	{AMOVL, Yrl, Ynone, Ycr8, movMemReg2op, [4]uint8{0x0f, 0x22, 8, 0}},
+	{AMOVQ, Yrl, Ynone, Ycr0, movMemReg2op, [4]uint8{0x0f, 0x22, 0, 0}},
+	{AMOVQ, Yrl, Ynone, Ycr2, movMemReg2op, [4]uint8{0x0f, 0x22, 2, 0}},
+	{AMOVQ, Yrl, Ynone, Ycr3, movMemReg2op, [4]uint8{0x0f, 0x22, 3, 0}},
+	{AMOVQ, Yrl, Ynone, Ycr4, movMemReg2op, [4]uint8{0x0f, 0x22, 4, 0}},
+	{AMOVQ, Yrl, Ynone, Ycr8, movMemReg2op, [4]uint8{0x0f, 0x22, 8, 0}},
+
+	// mov dr
+	{AMOVL, Ydr0, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x21, 0, 0}},
+	{AMOVL, Ydr6, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x21, 6, 0}},
+	{AMOVL, Ydr7, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x21, 7, 0}},
+	{AMOVQ, Ydr0, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x21, 0, 0}},
+	{AMOVQ, Ydr2, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x21, 2, 0}},
+	{AMOVQ, Ydr3, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x21, 3, 0}},
+	{AMOVQ, Ydr6, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x21, 6, 0}},
+	{AMOVQ, Ydr7, Ynone, Yrl, movRegMem2op, [4]uint8{0x0f, 0x21, 7, 0}},
+	{AMOVL, Yrl, Ynone, Ydr0, movMemReg2op, [4]uint8{0x0f, 0x23, 0, 0}},
+	{AMOVL, Yrl, Ynone, Ydr6, movMemReg2op, [4]uint8{0x0f, 0x23, 6, 0}},
+	{AMOVL, Yrl, Ynone, Ydr7, movMemReg2op, [4]uint8{0x0f, 0x23, 7, 0}},
+	{AMOVQ, Yrl, Ynone, Ydr0, movMemReg2op, [4]uint8{0x0f, 0x23, 0, 0}},
+	{AMOVQ, Yrl, Ynone, Ydr2, movMemReg2op, [4]uint8{0x0f, 0x23, 2, 0}},
+	{AMOVQ, Yrl, Ynone, Ydr3, movMemReg2op, [4]uint8{0x0f, 0x23, 3, 0}},
+	{AMOVQ, Yrl, Ynone, Ydr6, movMemReg2op, [4]uint8{0x0f, 0x23, 6, 0}},
+	{AMOVQ, Yrl, Ynone, Ydr7, movMemReg2op, [4]uint8{0x0f, 0x23, 7, 0}},
+
+	// mov tr
+	{AMOVL, Ytr6, Ynone, Yml, movRegMem2op, [4]uint8{0x0f, 0x24, 6, 0}},
+	{AMOVL, Ytr7, Ynone, Yml, movRegMem2op, [4]uint8{0x0f, 0x24, 7, 0}},
+	{AMOVL, Yml, Ynone, Ytr6, movMemReg2op, [4]uint8{0x0f, 0x26, 6, 0xff}},
+	{AMOVL, Yml, Ynone, Ytr7, movMemReg2op, [4]uint8{0x0f, 0x26, 7, 0xff}},
+
+	// lgdt, sgdt, lidt, sidt
+	{AMOVL, Ym, Ynone, Ygdtr, movMemReg2op, [4]uint8{0x0f, 0x01, 2, 0}},
+	{AMOVL, Ygdtr, Ynone, Ym, movRegMem2op, [4]uint8{0x0f, 0x01, 0, 0}},
+	{AMOVL, Ym, Ynone, Yidtr, movMemReg2op, [4]uint8{0x0f, 0x01, 3, 0}},
+	{AMOVL, Yidtr, Ynone, Ym, movRegMem2op, [4]uint8{0x0f, 0x01, 1, 0}},
+	{AMOVQ, Ym, Ynone, Ygdtr, movMemReg2op, [4]uint8{0x0f, 0x01, 2, 0}},
+	{AMOVQ, Ygdtr, Ynone, Ym, movRegMem2op, [4]uint8{0x0f, 0x01, 0, 0}},
+	{AMOVQ, Ym, Ynone, Yidtr, movMemReg2op, [4]uint8{0x0f, 0x01, 3, 0}},
+	{AMOVQ, Yidtr, Ynone, Ym, movRegMem2op, [4]uint8{0x0f, 0x01, 1, 0}},
+
+	// lldt, sldt
+	{AMOVW, Yml, Ynone, Yldtr, movMemReg2op, [4]uint8{0x0f, 0x00, 2, 0}},
+	{AMOVW, Yldtr, Ynone, Yml, movRegMem2op, [4]uint8{0x0f, 0x00, 0, 0}},
+
+	// lmsw, smsw
+	{AMOVW, Yml, Ynone, Ymsw, movMemReg2op, [4]uint8{0x0f, 0x01, 6, 0}},
+	{AMOVW, Ymsw, Ynone, Yml, movRegMem2op, [4]uint8{0x0f, 0x01, 4, 0}},
+
+	// ltr, str
+	{AMOVW, Yml, Ynone, Ytask, movMemReg2op, [4]uint8{0x0f, 0x00, 3, 0}},
+	{AMOVW, Ytask, Ynone, Yml, movRegMem2op, [4]uint8{0x0f, 0x00, 1, 0}},
+
+	/* load full pointer - unsupported
+	{AMOVL, Yml, Ycol, movFullPtr, [4]uint8{0, 0, 0, 0}},
+	{AMOVW, Yml, Ycol, movFullPtr, [4]uint8{Pe, 0, 0, 0}},
+	*/
+
+	// double shift
+	{ASHLL, Yi8, Yrl, Yml, movDoubleShift, [4]uint8{0xa4, 0xa5, 0, 0}},
+	{ASHLL, Ycl, Yrl, Yml, movDoubleShift, [4]uint8{0xa4, 0xa5, 0, 0}},
+	{ASHLL, Ycx, Yrl, Yml, movDoubleShift, [4]uint8{0xa4, 0xa5, 0, 0}},
+	{ASHRL, Yi8, Yrl, Yml, movDoubleShift, [4]uint8{0xac, 0xad, 0, 0}},
+	{ASHRL, Ycl, Yrl, Yml, movDoubleShift, [4]uint8{0xac, 0xad, 0, 0}},
+	{ASHRL, Ycx, Yrl, Yml, movDoubleShift, [4]uint8{0xac, 0xad, 0, 0}},
+	{ASHLQ, Yi8, Yrl, Yml, movDoubleShift, [4]uint8{Pw, 0xa4, 0xa5, 0}},
+	{ASHLQ, Ycl, Yrl, Yml, movDoubleShift, [4]uint8{Pw, 0xa4, 0xa5, 0}},
+	{ASHLQ, Ycx, Yrl, Yml, movDoubleShift, [4]uint8{Pw, 0xa4, 0xa5, 0}},
+	{ASHRQ, Yi8, Yrl, Yml, movDoubleShift, [4]uint8{Pw, 0xac, 0xad, 0}},
+	{ASHRQ, Ycl, Yrl, Yml, movDoubleShift, [4]uint8{Pw, 0xac, 0xad, 0}},
+	{ASHRQ, Ycx, Yrl, Yml, movDoubleShift, [4]uint8{Pw, 0xac, 0xad, 0}},
+	{ASHLW, Yi8, Yrl, Yml, movDoubleShift, [4]uint8{Pe, 0xa4, 0xa5, 0}},
+	{ASHLW, Ycl, Yrl, Yml, movDoubleShift, [4]uint8{Pe, 0xa4, 0xa5, 0}},
+	{ASHLW, Ycx, Yrl, Yml, movDoubleShift, [4]uint8{Pe, 0xa4, 0xa5, 0}},
+	{ASHRW, Yi8, Yrl, Yml, movDoubleShift, [4]uint8{Pe, 0xac, 0xad, 0}},
+	{ASHRW, Ycl, Yrl, Yml, movDoubleShift, [4]uint8{Pe, 0xac, 0xad, 0}},
+	{ASHRW, Ycx, Yrl, Yml, movDoubleShift, [4]uint8{Pe, 0xac, 0xad, 0}},
+
+	// load TLS base
+	{AMOVL, Ytls, Ynone, Yrl, movTLSReg, [4]uint8{0, 0, 0, 0}},
+	{AMOVQ, Ytls, Ynone, Yrl, movTLSReg, [4]uint8{0, 0, 0, 0}},
+	{0, 0, 0, 0, 0, [4]uint8{}},
+}
+
+func isax(a *obj.Addr) bool {
+	switch a.Reg {
+	case REG_AX, REG_AL, REG_AH:
+		return true
+	}
+
+	if a.Index == REG_AX {
+		return true
+	}
+	return false
+}
+
+func subreg(p *obj.Prog, from int, to int) {
+	if false { /* debug['Q'] */
+		fmt.Printf("\n%v\ts/%v/%v/\n", p, rconv(from), rconv(to))
+	}
+
+	if int(p.From.Reg) == from {
+		p.From.Reg = int16(to)
+		p.Ft = 0
+	}
+
+	if int(p.To.Reg) == from {
+		p.To.Reg = int16(to)
+		p.Tt = 0
+	}
+
+	if int(p.From.Index) == from {
+		p.From.Index = int16(to)
+		p.Ft = 0
+	}
+
+	if int(p.To.Index) == from {
+		p.To.Index = int16(to)
+		p.Tt = 0
+	}
+
+	if false { /* debug['Q'] */
+		fmt.Printf("%v\n", p)
+	}
+}
+
+func (ab *AsmBuf) mediaop(ctxt *obj.Link, o *Optab, op int, osize int, z int) int {
+	switch op {
+	case Pm, Pe, Pf2, Pf3:
+		if osize != 1 {
+			if op != Pm {
+				ab.Put1(byte(op))
+			}
+			ab.Put1(Pm)
+			z++
+			op = int(o.op[z])
+			break
+		}
+		fallthrough
+
+	default:
+		if ab.Len() == 0 || ab.Last() != Pm {
+			ab.Put1(Pm)
+		}
+	}
+
+	ab.Put1(byte(op))
+	return z
+}
+
+var bpduff1 = []byte{
+	0x48, 0x89, 0x6c, 0x24, 0xf0, // MOVQ BP, -16(SP)
+	0x48, 0x8d, 0x6c, 0x24, 0xf0, // LEAQ -16(SP), BP
+}
+
+var bpduff2 = []byte{
+	0x48, 0x8b, 0x6d, 0x00, // MOVQ 0(BP), BP
+}
+
+// asmevex emits EVEX pregis and opcode byte.
+// In addition to asmvex r/m, vvvv and reg fields also requires optional
+// K-masking register.
+//
+// Expects asmbuf.evex to be properly initialized.
+func (ab *AsmBuf) asmevex(ctxt *obj.Link, p *obj.Prog, rm, v, r, k *obj.Addr) {
+	ab.evexflag = true
+	evex := ab.evex
+
+	rexR := byte(1)
+	evexR := byte(1)
+	rexX := byte(1)
+	rexB := byte(1)
+	if r != nil {
+		if regrex[r.Reg]&Rxr != 0 {
+			rexR = 0 // "ModR/M.reg" selector 4th bit.
+		}
+		if regrex[r.Reg]&RxrEvex != 0 {
+			evexR = 0 // "ModR/M.reg" selector 5th bit.
+		}
+	}
+	if rm != nil {
+		if rm.Index == REG_NONE && regrex[rm.Reg]&RxrEvex != 0 {
+			rexX = 0
+		} else if regrex[rm.Index]&Rxx != 0 {
+			rexX = 0
+		}
+		if regrex[rm.Reg]&Rxb != 0 {
+			rexB = 0
+		}
+	}
+	// P0 = [R][X][B][R'][00][mm]
+	p0 := (rexR << 7) |
+		(rexX << 6) |
+		(rexB << 5) |
+		(evexR << 4) |
+		(0 << 2) |
+		(evex.M() << 0)
+
+	vexV := byte(0)
+	if v != nil {
+		// 4bit-wide reg index.
+		vexV = byte(reg[v.Reg]|(regrex[v.Reg]&Rxr)<<1) & 0xF
+	}
+	vexV ^= 0x0F
+	// P1 = [W][vvvv][1][pp]
+	p1 := (evex.W() << 7) |
+		(vexV << 3) |
+		(1 << 2) |
+		(evex.P() << 0)
+
+	suffix := evexSuffixMap[p.Scond]
+	evexZ := byte(0)
+	evexLL := evex.L()
+	evexB := byte(0)
+	evexV := byte(1)
+	evexA := byte(0)
+	if suffix.zeroing {
+		if !evex.ZeroingEnabled() {
+			ctxt.Diag("unsupported zeroing: %v", p)
+		}
+		evexZ = 1
+	}
+	switch {
+	case suffix.rounding != rcUnset:
+		if rm != nil && rm.Type == obj.TYPE_MEM {
+			ctxt.Diag("illegal rounding with memory argument: %v", p)
+		} else if !evex.RoundingEnabled() {
+			ctxt.Diag("unsupported rounding: %v", p)
+		}
+		evexB = 1
+		evexLL = suffix.rounding
+	case suffix.broadcast:
+		if rm == nil || rm.Type != obj.TYPE_MEM {
+			ctxt.Diag("illegal broadcast without memory argument: %v", p)
+		} else if !evex.BroadcastEnabled() {
+			ctxt.Diag("unsupported broadcast: %v", p)
+		}
+		evexB = 1
+	case suffix.sae:
+		if rm != nil && rm.Type == obj.TYPE_MEM {
+			ctxt.Diag("illegal SAE with memory argument: %v", p)
+		} else if !evex.SaeEnabled() {
+			ctxt.Diag("unsupported SAE: %v", p)
+		}
+		evexB = 1
+	}
+	if rm != nil && regrex[rm.Index]&RxrEvex != 0 {
+		evexV = 0
+	} else if v != nil && regrex[v.Reg]&RxrEvex != 0 {
+		evexV = 0 // VSR selector 5th bit.
+	}
+	if k != nil {
+		evexA = byte(reg[k.Reg])
+	}
+	// P2 = [z][L'L][b][V'][aaa]
+	p2 := (evexZ << 7) |
+		(evexLL << 5) |
+		(evexB << 4) |
+		(evexV << 3) |
+		(evexA << 0)
+
+	const evexEscapeByte = 0x62
+	ab.Put4(evexEscapeByte, p0, p1, p2)
+	ab.Put1(evex.opcode)
+}
+
+// Emit VEX prefix and opcode byte.
+// The three addresses are the r/m, vvvv, and reg fields.
+// The reg and rm arguments appear in the same order as the
+// arguments to asmand, which typically follows the call to asmvex.
+// The final two arguments are the VEX prefix (see encoding above)
+// and the opcode byte.
+// For details about vex prefix see:
+// https://en.wikipedia.org/wiki/VEX_prefix#Technical_description
+func (ab *AsmBuf) asmvex(ctxt *obj.Link, rm, v, r *obj.Addr, vex, opcode uint8) {
+	ab.vexflag = true
+	rexR := 0
+	if r != nil {
+		rexR = regrex[r.Reg] & Rxr
+	}
+	rexB := 0
+	rexX := 0
+	if rm != nil {
+		rexB = regrex[rm.Reg] & Rxb
+		rexX = regrex[rm.Index] & Rxx
+	}
+	vexM := (vex >> 3) & 0x7
+	vexWLP := vex & 0x87
+	vexV := byte(0)
+	if v != nil {
+		vexV = byte(reg[v.Reg]|(regrex[v.Reg]&Rxr)<<1) & 0xF
+	}
+	vexV ^= 0xF
+	if vexM == 1 && (rexX|rexB) == 0 && vex&vexW1 == 0 {
+		// Can use 2-byte encoding.
+		ab.Put2(0xc5, byte(rexR<<5)^0x80|vexV<<3|vexWLP)
+	} else {
+		// Must use 3-byte encoding.
+		ab.Put3(0xc4,
+			(byte(rexR|rexX|rexB)<<5)^0xE0|vexM,
+			vexV<<3|vexWLP,
+		)
+	}
+	ab.Put1(opcode)
+}
+
+// regIndex returns register index that fits in 5 bits.
+//
+//	R         : 3 bit | legacy instructions     | N/A
+//	[R/V]EX.R : 1 bit | REX / VEX extension bit | Rxr
+//	EVEX.R    : 1 bit | EVEX extension bit      | RxrEvex
+//
+// Examples:
+//	REG_Z30 => 30
+//	REG_X15 => 15
+//	REG_R9  => 9
+//	REG_AX  => 0
+//
+func regIndex(r int16) int {
+	lower3bits := reg[r]
+	high4bit := regrex[r] & Rxr << 1
+	high5bit := regrex[r] & RxrEvex << 0
+	return lower3bits | high4bit | high5bit
+}
+
+// avx2gatherValid reports whether p satisfies AVX2 gather constraints.
+// Reports errors via ctxt.
+func avx2gatherValid(ctxt *obj.Link, p *obj.Prog) bool {
+	// If any pair of the index, mask, or destination registers
+	// are the same, illegal instruction trap (#UD) is triggered.
+	index := regIndex(p.GetFrom3().Index)
+	mask := regIndex(p.From.Reg)
+	dest := regIndex(p.To.Reg)
+	if dest == mask || dest == index || mask == index {
+		ctxt.Diag("mask, index, and destination registers should be distinct: %v", p)
+		return false
+	}
+
+	return true
+}
+
+// avx512gatherValid reports whether p satisfies AVX512 gather constraints.
+// Reports errors via ctxt.
+func avx512gatherValid(ctxt *obj.Link, p *obj.Prog) bool {
+	// Illegal instruction trap (#UD) is triggered if the destination vector
+	// register is the same as index vector in VSIB.
+	index := regIndex(p.From.Index)
+	dest := regIndex(p.To.Reg)
+	if dest == index {
+		ctxt.Diag("index and destination registers should be distinct: %v", p)
+		return false
+	}
+
+	return true
+}
+
+func (ab *AsmBuf) doasm(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog) {
+	o := opindex[p.As&obj.AMask]
+
+	if o == nil {
+		ctxt.Diag("asmins: missing op %v", p)
+		return
+	}
+
+	if pre := prefixof(ctxt, &p.From); pre != 0 {
+		ab.Put1(byte(pre))
+	}
+	if pre := prefixof(ctxt, &p.To); pre != 0 {
+		ab.Put1(byte(pre))
+	}
+
+	// Checks to warn about instruction/arguments combinations that
+	// will unconditionally trigger illegal instruction trap (#UD).
+	switch p.As {
+	case AVGATHERDPD,
+		AVGATHERQPD,
+		AVGATHERDPS,
+		AVGATHERQPS,
+		AVPGATHERDD,
+		AVPGATHERQD,
+		AVPGATHERDQ,
+		AVPGATHERQQ:
+		// AVX512 gather requires explicit K mask.
+		if p.GetFrom3().Reg >= REG_K0 && p.GetFrom3().Reg <= REG_K7 {
+			if !avx512gatherValid(ctxt, p) {
+				return
+			}
+		} else {
+			if !avx2gatherValid(ctxt, p) {
+				return
+			}
+		}
+	}
+
+	if p.Ft == 0 {
+		p.Ft = uint8(oclass(ctxt, p, &p.From))
+	}
+	if p.Tt == 0 {
+		p.Tt = uint8(oclass(ctxt, p, &p.To))
+	}
+
+	ft := int(p.Ft) * Ymax
+	var f3t int
+	tt := int(p.Tt) * Ymax
+
+	xo := obj.Bool2int(o.op[0] == 0x0f)
+	z := 0
+	var a *obj.Addr
+	var l int
+	var op int
+	var q *obj.Prog
+	var r *obj.Reloc
+	var rel obj.Reloc
+	var v int64
+
+	args := make([]int, 0, argListMax)
+	if ft != Ynone*Ymax {
+		args = append(args, ft)
+	}
+	for i := range p.RestArgs {
+		args = append(args, oclass(ctxt, p, &p.RestArgs[i])*Ymax)
+	}
+	if tt != Ynone*Ymax {
+		args = append(args, tt)
+	}
+
+	for _, yt := range o.ytab {
+		// ytab matching is purely args-based,
+		// but AVX512 suffixes like "Z" or "RU_SAE" will
+		// add EVEX-only filter that will reject non-EVEX matches.
+		//
+		// Consider "VADDPD.BCST 2032(DX), X0, X0".
+		// Without this rule, operands will lead to VEX-encoded form
+		// and produce "c5b15813" encoding.
+		if !yt.match(args) {
+			// "xo" is always zero for VEX/EVEX encoded insts.
+			z += int(yt.zoffset) + xo
+		} else {
+			if p.Scond != 0 && !evexZcase(yt.zcase) {
+				// Do not signal error and continue to search
+				// for matching EVEX-encoded form.
+				z += int(yt.zoffset)
+				continue
+			}
+
+			switch o.prefix {
+			case Px1: // first option valid only in 32-bit mode
+				if ctxt.Arch.Family == sys.AMD64 && z == 0 {
+					z += int(yt.zoffset) + xo
+					continue
+				}
+			case Pq: // 16 bit escape and opcode escape
+				ab.Put2(Pe, Pm)
+
+			case Pq3: // 16 bit escape and opcode escape + REX.W
+				ab.rexflag |= Pw
+				ab.Put2(Pe, Pm)
+
+			case Pq4: // 66 0F 38
+				ab.Put3(0x66, 0x0F, 0x38)
+
+			case Pq4w: // 66 0F 38 + REX.W
+				ab.rexflag |= Pw
+				ab.Put3(0x66, 0x0F, 0x38)
+
+			case Pq5: // F3 0F 38
+				ab.Put3(0xF3, 0x0F, 0x38)
+
+			case Pq5w: //  F3 0F 38 + REX.W
+				ab.rexflag |= Pw
+				ab.Put3(0xF3, 0x0F, 0x38)
+
+			case Pf2, // xmm opcode escape
+				Pf3:
+				ab.Put2(o.prefix, Pm)
+
+			case Pef3:
+				ab.Put3(Pe, Pf3, Pm)
+
+			case Pfw: // xmm opcode escape + REX.W
+				ab.rexflag |= Pw
+				ab.Put2(Pf3, Pm)
+
+			case Pm: // opcode escape
+				ab.Put1(Pm)
+
+			case Pe: // 16 bit escape
+				ab.Put1(Pe)
+
+			case Pw: // 64-bit escape
+				if ctxt.Arch.Family != sys.AMD64 {
+					ctxt.Diag("asmins: illegal 64: %v", p)
+				}
+				ab.rexflag |= Pw
+
+			case Pw8: // 64-bit escape if z >= 8
+				if z >= 8 {
+					if ctxt.Arch.Family != sys.AMD64 {
+						ctxt.Diag("asmins: illegal 64: %v", p)
+					}
+					ab.rexflag |= Pw
+				}
+
+			case Pb: // botch
+				if ctxt.Arch.Family != sys.AMD64 && (isbadbyte(&p.From) || isbadbyte(&p.To)) {
+					goto bad
+				}
+				// NOTE(rsc): This is probably safe to do always,
+				// but when enabled it chooses different encodings
+				// than the old cmd/internal/obj/i386 code did,
+				// which breaks our "same bits out" checks.
+				// In particular, CMPB AX, $0 encodes as 80 f8 00
+				// in the original obj/i386, and it would encode
+				// (using a valid, shorter form) as 3c 00 if we enabled
+				// the call to bytereg here.
+				if ctxt.Arch.Family == sys.AMD64 {
+					bytereg(&p.From, &p.Ft)
+					bytereg(&p.To, &p.Tt)
+				}
+
+			case P32: // 32 bit but illegal if 64-bit mode
+				if ctxt.Arch.Family == sys.AMD64 {
+					ctxt.Diag("asmins: illegal in 64-bit mode: %v", p)
+				}
+
+			case Py: // 64-bit only, no prefix
+				if ctxt.Arch.Family != sys.AMD64 {
+					ctxt.Diag("asmins: illegal in %d-bit mode: %v", ctxt.Arch.RegSize*8, p)
+				}
+
+			case Py1: // 64-bit only if z < 1, no prefix
+				if z < 1 && ctxt.Arch.Family != sys.AMD64 {
+					ctxt.Diag("asmins: illegal in %d-bit mode: %v", ctxt.Arch.RegSize*8, p)
+				}
+
+			case Py3: // 64-bit only if z < 3, no prefix
+				if z < 3 && ctxt.Arch.Family != sys.AMD64 {
+					ctxt.Diag("asmins: illegal in %d-bit mode: %v", ctxt.Arch.RegSize*8, p)
+				}
+			}
+
+			if z >= len(o.op) {
+				log.Fatalf("asmins bad table %v", p)
+			}
+			op = int(o.op[z])
+			if op == 0x0f {
+				ab.Put1(byte(op))
+				z++
+				op = int(o.op[z])
+			}
+
+			switch yt.zcase {
+			default:
+				ctxt.Diag("asmins: unknown z %d %v", yt.zcase, p)
+				return
+
+			case Zpseudo:
+				break
+
+			case Zlit:
+				ab.PutOpBytesLit(z, &o.op)
+
+			case Zlitr_m:
+				ab.PutOpBytesLit(z, &o.op)
+				ab.asmand(ctxt, cursym, p, &p.To, &p.From)
+
+			case Zlitm_r:
+				ab.PutOpBytesLit(z, &o.op)
+				ab.asmand(ctxt, cursym, p, &p.From, &p.To)
+
+			case Zlit_m_r:
+				ab.PutOpBytesLit(z, &o.op)
+				ab.asmand(ctxt, cursym, p, p.GetFrom3(), &p.To)
+
+			case Zmb_r:
+				bytereg(&p.From, &p.Ft)
+				fallthrough
+
+			case Zm_r:
+				ab.Put1(byte(op))
+				ab.asmand(ctxt, cursym, p, &p.From, &p.To)
+
+			case Z_m_r:
+				ab.Put1(byte(op))
+				ab.asmand(ctxt, cursym, p, p.GetFrom3(), &p.To)
+
+			case Zm2_r:
+				ab.Put2(byte(op), o.op[z+1])
+				ab.asmand(ctxt, cursym, p, &p.From, &p.To)
+
+			case Zm_r_xm:
+				ab.mediaop(ctxt, o, op, int(yt.zoffset), z)
+				ab.asmand(ctxt, cursym, p, &p.From, &p.To)
+
+			case Zm_r_xm_nr:
+				ab.rexflag = 0
+				ab.mediaop(ctxt, o, op, int(yt.zoffset), z)
+				ab.asmand(ctxt, cursym, p, &p.From, &p.To)
+
+			case Zm_r_i_xm:
+				ab.mediaop(ctxt, o, op, int(yt.zoffset), z)
+				ab.asmand(ctxt, cursym, p, &p.From, p.GetFrom3())
+				ab.Put1(byte(p.To.Offset))
+
+			case Zibm_r, Zibr_m:
+				ab.PutOpBytesLit(z, &o.op)
+				if yt.zcase == Zibr_m {
+					ab.asmand(ctxt, cursym, p, &p.To, p.GetFrom3())
+				} else {
+					ab.asmand(ctxt, cursym, p, p.GetFrom3(), &p.To)
+				}
+				switch {
+				default:
+					ab.Put1(byte(p.From.Offset))
+				case yt.args[0] == Yi32 && o.prefix == Pe:
+					ab.PutInt16(int16(p.From.Offset))
+				case yt.args[0] == Yi32:
+					ab.PutInt32(int32(p.From.Offset))
+				}
+
+			case Zaut_r:
+				ab.Put1(0x8d) // leal
+				if p.From.Type != obj.TYPE_ADDR {
+					ctxt.Diag("asmins: Zaut sb type ADDR")
+				}
+				p.From.Type = obj.TYPE_MEM
+				ab.asmand(ctxt, cursym, p, &p.From, &p.To)
+				p.From.Type = obj.TYPE_ADDR
+
+			case Zm_o:
+				ab.Put1(byte(op))
+				ab.asmando(ctxt, cursym, p, &p.From, int(o.op[z+1]))
+
+			case Zr_m:
+				ab.Put1(byte(op))
+				ab.asmand(ctxt, cursym, p, &p.To, &p.From)
+
+			case Zvex:
+				ab.asmvex(ctxt, &p.From, p.GetFrom3(), &p.To, o.op[z], o.op[z+1])
+
+			case Zvex_rm_v_r:
+				ab.asmvex(ctxt, &p.From, p.GetFrom3(), &p.To, o.op[z], o.op[z+1])
+				ab.asmand(ctxt, cursym, p, &p.From, &p.To)
+
+			case Zvex_rm_v_ro:
+				ab.asmvex(ctxt, &p.From, p.GetFrom3(), &p.To, o.op[z], o.op[z+1])
+				ab.asmando(ctxt, cursym, p, &p.From, int(o.op[z+2]))
+
+			case Zvex_i_rm_vo:
+				ab.asmvex(ctxt, p.GetFrom3(), &p.To, nil, o.op[z], o.op[z+1])
+				ab.asmando(ctxt, cursym, p, p.GetFrom3(), int(o.op[z+2]))
+				ab.Put1(byte(p.From.Offset))
+
+			case Zvex_i_r_v:
+				ab.asmvex(ctxt, p.GetFrom3(), &p.To, nil, o.op[z], o.op[z+1])
+				regnum := byte(0x7)
+				if p.GetFrom3().Reg >= REG_X0 && p.GetFrom3().Reg <= REG_X15 {
+					regnum &= byte(p.GetFrom3().Reg - REG_X0)
+				} else {
+					regnum &= byte(p.GetFrom3().Reg - REG_Y0)
+				}
+				ab.Put1(o.op[z+2] | regnum)
+				ab.Put1(byte(p.From.Offset))
+
+			case Zvex_i_rm_v_r:
+				imm, from, from3, to := unpackOps4(p)
+				ab.asmvex(ctxt, from, from3, to, o.op[z], o.op[z+1])
+				ab.asmand(ctxt, cursym, p, from, to)
+				ab.Put1(byte(imm.Offset))
+
+			case Zvex_i_rm_r:
+				ab.asmvex(ctxt, p.GetFrom3(), nil, &p.To, o.op[z], o.op[z+1])
+				ab.asmand(ctxt, cursym, p, p.GetFrom3(), &p.To)
+				ab.Put1(byte(p.From.Offset))
+
+			case Zvex_v_rm_r:
+				ab.asmvex(ctxt, p.GetFrom3(), &p.From, &p.To, o.op[z], o.op[z+1])
+				ab.asmand(ctxt, cursym, p, p.GetFrom3(), &p.To)
+
+			case Zvex_r_v_rm:
+				ab.asmvex(ctxt, &p.To, p.GetFrom3(), &p.From, o.op[z], o.op[z+1])
+				ab.asmand(ctxt, cursym, p, &p.To, &p.From)
+
+			case Zvex_rm_r_vo:
+				ab.asmvex(ctxt, &p.From, &p.To, p.GetFrom3(), o.op[z], o.op[z+1])
+				ab.asmando(ctxt, cursym, p, &p.From, int(o.op[z+2]))
+
+			case Zvex_i_r_rm:
+				ab.asmvex(ctxt, &p.To, nil, p.GetFrom3(), o.op[z], o.op[z+1])
+				ab.asmand(ctxt, cursym, p, &p.To, p.GetFrom3())
+				ab.Put1(byte(p.From.Offset))
+
+			case Zvex_hr_rm_v_r:
+				hr, from, from3, to := unpackOps4(p)
+				ab.asmvex(ctxt, from, from3, to, o.op[z], o.op[z+1])
+				ab.asmand(ctxt, cursym, p, from, to)
+				ab.Put1(byte(regIndex(hr.Reg) << 4))
+
+			case Zevex_k_rmo:
+				ab.evex = newEVEXBits(z, &o.op)
+				ab.asmevex(ctxt, p, &p.To, nil, nil, &p.From)
+				ab.asmando(ctxt, cursym, p, &p.To, int(o.op[z+3]))
+
+			case Zevex_i_rm_vo:
+				ab.evex = newEVEXBits(z, &o.op)
+				ab.asmevex(ctxt, p, p.GetFrom3(), &p.To, nil, nil)
+				ab.asmando(ctxt, cursym, p, p.GetFrom3(), int(o.op[z+3]))
+				ab.Put1(byte(p.From.Offset))
+
+			case Zevex_i_rm_k_vo:
+				imm, from, kmask, to := unpackOps4(p)
+				ab.evex = newEVEXBits(z, &o.op)
+				ab.asmevex(ctxt, p, from, to, nil, kmask)
+				ab.asmando(ctxt, cursym, p, from, int(o.op[z+3]))
+				ab.Put1(byte(imm.Offset))
+
+			case Zevex_i_r_rm:
+				ab.evex = newEVEXBits(z, &o.op)
+				ab.asmevex(ctxt, p, &p.To, nil, p.GetFrom3(), nil)
+				ab.asmand(ctxt, cursym, p, &p.To, p.GetFrom3())
+				ab.Put1(byte(p.From.Offset))
+
+			case Zevex_i_r_k_rm:
+				imm, from, kmask, to := unpackOps4(p)
+				ab.evex = newEVEXBits(z, &o.op)
+				ab.asmevex(ctxt, p, to, nil, from, kmask)
+				ab.asmand(ctxt, cursym, p, to, from)
+				ab.Put1(byte(imm.Offset))
+
+			case Zevex_i_rm_r:
+				ab.evex = newEVEXBits(z, &o.op)
+				ab.asmevex(ctxt, p, p.GetFrom3(), nil, &p.To, nil)
+				ab.asmand(ctxt, cursym, p, p.GetFrom3(), &p.To)
+				ab.Put1(byte(p.From.Offset))
+
+			case Zevex_i_rm_k_r:
+				imm, from, kmask, to := unpackOps4(p)
+				ab.evex = newEVEXBits(z, &o.op)
+				ab.asmevex(ctxt, p, from, nil, to, kmask)
+				ab.asmand(ctxt, cursym, p, from, to)
+				ab.Put1(byte(imm.Offset))
+
+			case Zevex_i_rm_v_r:
+				imm, from, from3, to := unpackOps4(p)
+				ab.evex = newEVEXBits(z, &o.op)
+				ab.asmevex(ctxt, p, from, from3, to, nil)
+				ab.asmand(ctxt, cursym, p, from, to)
+				ab.Put1(byte(imm.Offset))
+
+			case Zevex_i_rm_v_k_r:
+				imm, from, from3, kmask, to := unpackOps5(p)
+				ab.evex = newEVEXBits(z, &o.op)
+				ab.asmevex(ctxt, p, from, from3, to, kmask)
+				ab.asmand(ctxt, cursym, p, from, to)
+				ab.Put1(byte(imm.Offset))
+
+			case Zevex_r_v_rm:
+				ab.evex = newEVEXBits(z, &o.op)
+				ab.asmevex(ctxt, p, &p.To, p.GetFrom3(), &p.From, nil)
+				ab.asmand(ctxt, cursym, p, &p.To, &p.From)
+
+			case Zevex_rm_v_r:
+				ab.evex = newEVEXBits(z, &o.op)
+				ab.asmevex(ctxt, p, &p.From, p.GetFrom3(), &p.To, nil)
+				ab.asmand(ctxt, cursym, p, &p.From, &p.To)
+
+			case Zevex_rm_k_r:
+				ab.evex = newEVEXBits(z, &o.op)
+				ab.asmevex(ctxt, p, &p.From, nil, &p.To, p.GetFrom3())
+				ab.asmand(ctxt, cursym, p, &p.From, &p.To)
+
+			case Zevex_r_k_rm:
+				ab.evex = newEVEXBits(z, &o.op)
+				ab.asmevex(ctxt, p, &p.To, nil, &p.From, p.GetFrom3())
+				ab.asmand(ctxt, cursym, p, &p.To, &p.From)
+
+			case Zevex_rm_v_k_r:
+				from, from3, kmask, to := unpackOps4(p)
+				ab.evex = newEVEXBits(z, &o.op)
+				ab.asmevex(ctxt, p, from, from3, to, kmask)
+				ab.asmand(ctxt, cursym, p, from, to)
+
+			case Zevex_r_v_k_rm:
+				from, from3, kmask, to := unpackOps4(p)
+				ab.evex = newEVEXBits(z, &o.op)
+				ab.asmevex(ctxt, p, to, from3, from, kmask)
+				ab.asmand(ctxt, cursym, p, to, from)
+
+			case Zr_m_xm:
+				ab.mediaop(ctxt, o, op, int(yt.zoffset), z)
+				ab.asmand(ctxt, cursym, p, &p.To, &p.From)
+
+			case Zr_m_xm_nr:
+				ab.rexflag = 0
+				ab.mediaop(ctxt, o, op, int(yt.zoffset), z)
+				ab.asmand(ctxt, cursym, p, &p.To, &p.From)
+
+			case Zo_m:
+				ab.Put1(byte(op))
+				ab.asmando(ctxt, cursym, p, &p.To, int(o.op[z+1]))
+
+			case Zcallindreg:
+				r = obj.Addrel(cursym)
+				r.Off = int32(p.Pc)
+				r.Type = objabi.R_CALLIND
+				r.Siz = 0
+				fallthrough
+
+			case Zo_m64:
+				ab.Put1(byte(op))
+				ab.asmandsz(ctxt, cursym, p, &p.To, int(o.op[z+1]), 0, 1)
+
+			case Zm_ibo:
+				ab.Put1(byte(op))
+				ab.asmando(ctxt, cursym, p, &p.From, int(o.op[z+1]))
+				ab.Put1(byte(vaddr(ctxt, p, &p.To, nil)))
+
+			case Zibo_m:
+				ab.Put1(byte(op))
+				ab.asmando(ctxt, cursym, p, &p.To, int(o.op[z+1]))
+				ab.Put1(byte(vaddr(ctxt, p, &p.From, nil)))
+
+			case Zibo_m_xm:
+				z = ab.mediaop(ctxt, o, op, int(yt.zoffset), z)
+				ab.asmando(ctxt, cursym, p, &p.To, int(o.op[z+1]))
+				ab.Put1(byte(vaddr(ctxt, p, &p.From, nil)))
+
+			case Z_ib, Zib_:
+				if yt.zcase == Zib_ {
+					a = &p.From
+				} else {
+					a = &p.To
+				}
+				ab.Put1(byte(op))
+				if p.As == AXABORT {
+					ab.Put1(o.op[z+1])
+				}
+				ab.Put1(byte(vaddr(ctxt, p, a, nil)))
+
+			case Zib_rp:
+				ab.rexflag |= regrex[p.To.Reg] & (Rxb | 0x40)
+				ab.Put2(byte(op+reg[p.To.Reg]), byte(vaddr(ctxt, p, &p.From, nil)))
+
+			case Zil_rp:
+				ab.rexflag |= regrex[p.To.Reg] & Rxb
+				ab.Put1(byte(op + reg[p.To.Reg]))
+				if o.prefix == Pe {
+					v = vaddr(ctxt, p, &p.From, nil)
+					ab.PutInt16(int16(v))
+				} else {
+					ab.relput4(ctxt, cursym, p, &p.From)
+				}
+
+			case Zo_iw:
+				ab.Put1(byte(op))
+				if p.From.Type != obj.TYPE_NONE {
+					v = vaddr(ctxt, p, &p.From, nil)
+					ab.PutInt16(int16(v))
+				}
+
+			case Ziq_rp:
+				v = vaddr(ctxt, p, &p.From, &rel)
+				l = int(v >> 32)
+				if l == 0 && rel.Siz != 8 {
+					ab.rexflag &^= (0x40 | Rxw)
+
+					ab.rexflag |= regrex[p.To.Reg] & Rxb
+					ab.Put1(byte(0xb8 + reg[p.To.Reg]))
+					if rel.Type != 0 {
+						r = obj.Addrel(cursym)
+						*r = rel
+						r.Off = int32(p.Pc + int64(ab.Len()))
+					}
+
+					ab.PutInt32(int32(v))
+				} else if l == -1 && uint64(v)&(uint64(1)<<31) != 0 { // sign extend
+					ab.Put1(0xc7)
+					ab.asmando(ctxt, cursym, p, &p.To, 0)
+
+					ab.PutInt32(int32(v)) // need all 8
+				} else {
+					ab.rexflag |= regrex[p.To.Reg] & Rxb
+					ab.Put1(byte(op + reg[p.To.Reg]))
+					if rel.Type != 0 {
+						r = obj.Addrel(cursym)
+						*r = rel
+						r.Off = int32(p.Pc + int64(ab.Len()))
+					}
+
+					ab.PutInt64(v)
+				}
+
+			case Zib_rr:
+				ab.Put1(byte(op))
+				ab.asmand(ctxt, cursym, p, &p.To, &p.To)
+				ab.Put1(byte(vaddr(ctxt, p, &p.From, nil)))
+
+			case Z_il, Zil_:
+				if yt.zcase == Zil_ {
+					a = &p.From
+				} else {
+					a = &p.To
+				}
+				ab.Put1(byte(op))
+				if o.prefix == Pe {
+					v = vaddr(ctxt, p, a, nil)
+					ab.PutInt16(int16(v))
+				} else {
+					ab.relput4(ctxt, cursym, p, a)
+				}
+
+			case Zm_ilo, Zilo_m:
+				ab.Put1(byte(op))
+				if yt.zcase == Zilo_m {
+					a = &p.From
+					ab.asmando(ctxt, cursym, p, &p.To, int(o.op[z+1]))
+				} else {
+					a = &p.To
+					ab.asmando(ctxt, cursym, p, &p.From, int(o.op[z+1]))
+				}
+
+				if o.prefix == Pe {
+					v = vaddr(ctxt, p, a, nil)
+					ab.PutInt16(int16(v))
+				} else {
+					ab.relput4(ctxt, cursym, p, a)
+				}
+
+			case Zil_rr:
+				ab.Put1(byte(op))
+				ab.asmand(ctxt, cursym, p, &p.To, &p.To)
+				if o.prefix == Pe {
+					v = vaddr(ctxt, p, &p.From, nil)
+					ab.PutInt16(int16(v))
+				} else {
+					ab.relput4(ctxt, cursym, p, &p.From)
+				}
+
+			case Z_rp:
+				ab.rexflag |= regrex[p.To.Reg] & (Rxb | 0x40)
+				ab.Put1(byte(op + reg[p.To.Reg]))
+
+			case Zrp_:
+				ab.rexflag |= regrex[p.From.Reg] & (Rxb | 0x40)
+				ab.Put1(byte(op + reg[p.From.Reg]))
+
+			case Zcallcon, Zjmpcon:
+				if yt.zcase == Zcallcon {
+					ab.Put1(byte(op))
+				} else {
+					ab.Put1(o.op[z+1])
+				}
+				r = obj.Addrel(cursym)
+				r.Off = int32(p.Pc + int64(ab.Len()))
+				r.Type = objabi.R_PCREL
+				r.Siz = 4
+				r.Add = p.To.Offset
+				ab.PutInt32(0)
+
+			case Zcallind:
+				ab.Put2(byte(op), o.op[z+1])
+				r = obj.Addrel(cursym)
+				r.Off = int32(p.Pc + int64(ab.Len()))
+				if ctxt.Arch.Family == sys.AMD64 {
+					r.Type = objabi.R_PCREL
+				} else {
+					r.Type = objabi.R_ADDR
+				}
+				r.Siz = 4
+				r.Add = p.To.Offset
+				r.Sym = p.To.Sym
+				ab.PutInt32(0)
+
+			case Zcall, Zcallduff:
+				if p.To.Sym == nil {
+					ctxt.Diag("call without target")
+					ctxt.DiagFlush()
+					log.Fatalf("bad code")
+				}
+
+				if yt.zcase == Zcallduff && ctxt.Flag_dynlink {
+					ctxt.Diag("directly calling duff when dynamically linking Go")
+				}
+
+				if yt.zcase == Zcallduff && ctxt.Arch.Family == sys.AMD64 {
+					// Maintain BP around call, since duffcopy/duffzero can't do it
+					// (the call jumps into the middle of the function).
+					// This makes it possible to see call sites for duffcopy/duffzero in
+					// BP-based profiling tools like Linux perf (which is the
+					// whole point of maintaining frame pointers in Go).
+					// MOVQ BP, -16(SP)
+					// LEAQ -16(SP), BP
+					ab.Put(bpduff1)
+				}
+				ab.Put1(byte(op))
+				r = obj.Addrel(cursym)
+				r.Off = int32(p.Pc + int64(ab.Len()))
+				r.Sym = p.To.Sym
+				r.Add = p.To.Offset
+				r.Type = objabi.R_CALL
+				r.Siz = 4
+				ab.PutInt32(0)
+
+				if yt.zcase == Zcallduff && ctxt.Arch.Family == sys.AMD64 {
+					// Pop BP pushed above.
+					// MOVQ 0(BP), BP
+					ab.Put(bpduff2)
+				}
+
+			// TODO: jump across functions needs reloc
+			case Zbr, Zjmp, Zloop:
+				if p.As == AXBEGIN {
+					ab.Put1(byte(op))
+				}
+				if p.To.Sym != nil {
+					if yt.zcase != Zjmp {
+						ctxt.Diag("branch to ATEXT")
+						ctxt.DiagFlush()
+						log.Fatalf("bad code")
+					}
+
+					ab.Put1(o.op[z+1])
+					r = obj.Addrel(cursym)
+					r.Off = int32(p.Pc + int64(ab.Len()))
+					r.Sym = p.To.Sym
+					// Note: R_CALL instead of R_PCREL. R_CALL is more permissive in that
+					// it can point to a trampoline instead of the destination itself.
+					r.Type = objabi.R_CALL
+					r.Siz = 4
+					ab.PutInt32(0)
+					break
+				}
+
+				// Assumes q is in this function.
+				// TODO: Check in input, preserve in brchain.
+
+				// Fill in backward jump now.
+				q = p.To.Target()
+
+				if q == nil {
+					ctxt.Diag("jmp/branch/loop without target")
+					ctxt.DiagFlush()
+					log.Fatalf("bad code")
+				}
+
+				if p.Back&branchBackwards != 0 {
+					v = q.Pc - (p.Pc + 2)
+					if v >= -128 && p.As != AXBEGIN {
+						if p.As == AJCXZL {
+							ab.Put1(0x67)
+						}
+						ab.Put2(byte(op), byte(v))
+					} else if yt.zcase == Zloop {
+						ctxt.Diag("loop too far: %v", p)
+					} else {
+						v -= 5 - 2
+						if p.As == AXBEGIN {
+							v--
+						}
+						if yt.zcase == Zbr {
+							ab.Put1(0x0f)
+							v--
+						}
+
+						ab.Put1(o.op[z+1])
+						ab.PutInt32(int32(v))
+					}
+
+					break
+				}
+
+				// Annotate target; will fill in later.
+				p.Forwd = q.Rel
+
+				q.Rel = p
+				if p.Back&branchShort != 0 && p.As != AXBEGIN {
+					if p.As == AJCXZL {
+						ab.Put1(0x67)
+					}
+					ab.Put2(byte(op), 0)
+				} else if yt.zcase == Zloop {
+					ctxt.Diag("loop too far: %v", p)
+				} else {
+					if yt.zcase == Zbr {
+						ab.Put1(0x0f)
+					}
+					ab.Put1(o.op[z+1])
+					ab.PutInt32(0)
+				}
+
+			case Zbyte:
+				v = vaddr(ctxt, p, &p.From, &rel)
+				if rel.Siz != 0 {
+					rel.Siz = uint8(op)
+					r = obj.Addrel(cursym)
+					*r = rel
+					r.Off = int32(p.Pc + int64(ab.Len()))
+				}
+
+				ab.Put1(byte(v))
+				if op > 1 {
+					ab.Put1(byte(v >> 8))
+					if op > 2 {
+						ab.PutInt16(int16(v >> 16))
+						if op > 4 {
+							ab.PutInt32(int32(v >> 32))
+						}
+					}
+				}
+			}
+
+			return
+		}
+	}
+	f3t = Ynone * Ymax
+	if p.GetFrom3() != nil {
+		f3t = oclass(ctxt, p, p.GetFrom3()) * Ymax
+	}
+	for mo := ymovtab; mo[0].as != 0; mo = mo[1:] {
+		var pp obj.Prog
+		var t []byte
+		if p.As == mo[0].as {
+			if ycover[ft+int(mo[0].ft)] != 0 && ycover[f3t+int(mo[0].f3t)] != 0 && ycover[tt+int(mo[0].tt)] != 0 {
+				t = mo[0].op[:]
+				switch mo[0].code {
+				default:
+					ctxt.Diag("asmins: unknown mov %d %v", mo[0].code, p)
+
+				case movLit:
+					for z = 0; t[z] != 0; z++ {
+						ab.Put1(t[z])
+					}
+
+				case movRegMem:
+					ab.Put1(t[0])
+					ab.asmando(ctxt, cursym, p, &p.To, int(t[1]))
+
+				case movMemReg:
+					ab.Put1(t[0])
+					ab.asmando(ctxt, cursym, p, &p.From, int(t[1]))
+
+				case movRegMem2op: // r,m - 2op
+					ab.Put2(t[0], t[1])
+					ab.asmando(ctxt, cursym, p, &p.To, int(t[2]))
+					ab.rexflag |= regrex[p.From.Reg] & (Rxr | 0x40)
+
+				case movMemReg2op:
+					ab.Put2(t[0], t[1])
+					ab.asmando(ctxt, cursym, p, &p.From, int(t[2]))
+					ab.rexflag |= regrex[p.To.Reg] & (Rxr | 0x40)
+
+				case movFullPtr:
+					if t[0] != 0 {
+						ab.Put1(t[0])
+					}
+					switch p.To.Index {
+					default:
+						goto bad
+
+					case REG_DS:
+						ab.Put1(0xc5)
+
+					case REG_SS:
+						ab.Put2(0x0f, 0xb2)
+
+					case REG_ES:
+						ab.Put1(0xc4)
+
+					case REG_FS:
+						ab.Put2(0x0f, 0xb4)
+
+					case REG_GS:
+						ab.Put2(0x0f, 0xb5)
+					}
+
+					ab.asmand(ctxt, cursym, p, &p.From, &p.To)
+
+				case movDoubleShift:
+					if t[0] == Pw {
+						if ctxt.Arch.Family != sys.AMD64 {
+							ctxt.Diag("asmins: illegal 64: %v", p)
+						}
+						ab.rexflag |= Pw
+						t = t[1:]
+					} else if t[0] == Pe {
+						ab.Put1(Pe)
+						t = t[1:]
+					}
+
+					switch p.From.Type {
+					default:
+						goto bad
+
+					case obj.TYPE_CONST:
+						ab.Put2(0x0f, t[0])
+						ab.asmandsz(ctxt, cursym, p, &p.To, reg[p.GetFrom3().Reg], regrex[p.GetFrom3().Reg], 0)
+						ab.Put1(byte(p.From.Offset))
+
+					case obj.TYPE_REG:
+						switch p.From.Reg {
+						default:
+							goto bad
+
+						case REG_CL, REG_CX:
+							ab.Put2(0x0f, t[1])
+							ab.asmandsz(ctxt, cursym, p, &p.To, reg[p.GetFrom3().Reg], regrex[p.GetFrom3().Reg], 0)
+						}
+					}
+
+				// NOTE: The systems listed here are the ones that use the "TLS initial exec" model,
+				// where you load the TLS base register into a register and then index off that
+				// register to access the actual TLS variables. Systems that allow direct TLS access
+				// are handled in prefixof above and should not be listed here.
+				case movTLSReg:
+					if ctxt.Arch.Family == sys.AMD64 && p.As != AMOVQ || ctxt.Arch.Family == sys.I386 && p.As != AMOVL {
+						ctxt.Diag("invalid load of TLS: %v", p)
+					}
+
+					if ctxt.Arch.Family == sys.I386 {
+						// NOTE: The systems listed here are the ones that use the "TLS initial exec" model,
+						// where you load the TLS base register into a register and then index off that
+						// register to access the actual TLS variables. Systems that allow direct TLS access
+						// are handled in prefixof above and should not be listed here.
+						switch ctxt.Headtype {
+						default:
+							log.Fatalf("unknown TLS base location for %v", ctxt.Headtype)
+
+						case objabi.Hlinux, objabi.Hfreebsd:
+							if ctxt.Flag_shared {
+								// Note that this is not generating the same insns as the other cases.
+								//     MOV TLS, dst
+								// becomes
+								//     call __x86.get_pc_thunk.dst
+								//     movl (gotpc + g@gotntpoff)(dst), dst
+								// which is encoded as
+								//     call __x86.get_pc_thunk.dst
+								//     movq 0(dst), dst
+								// and R_CALL & R_TLS_IE relocs. This all assumes the only tls variable we access
+								// is g, which we can't check here, but will when we assemble the second
+								// instruction.
+								dst := p.To.Reg
+								ab.Put1(0xe8)
+								r = obj.Addrel(cursym)
+								r.Off = int32(p.Pc + int64(ab.Len()))
+								r.Type = objabi.R_CALL
+								r.Siz = 4
+								r.Sym = ctxt.Lookup("__x86.get_pc_thunk." + strings.ToLower(rconv(int(dst))))
+								ab.PutInt32(0)
+
+								ab.Put2(0x8B, byte(2<<6|reg[dst]|(reg[dst]<<3)))
+								r = obj.Addrel(cursym)
+								r.Off = int32(p.Pc + int64(ab.Len()))
+								r.Type = objabi.R_TLS_IE
+								r.Siz = 4
+								r.Add = 2
+								ab.PutInt32(0)
+							} else {
+								// ELF TLS base is 0(GS).
+								pp.From = p.From
+
+								pp.From.Type = obj.TYPE_MEM
+								pp.From.Reg = REG_GS
+								pp.From.Offset = 0
+								pp.From.Index = REG_NONE
+								pp.From.Scale = 0
+								ab.Put2(0x65, // GS
+									0x8B)
+								ab.asmand(ctxt, cursym, p, &pp.From, &p.To)
+							}
+						case objabi.Hplan9:
+							pp.From = obj.Addr{}
+							pp.From.Type = obj.TYPE_MEM
+							pp.From.Name = obj.NAME_EXTERN
+							pp.From.Sym = plan9privates
+							pp.From.Offset = 0
+							pp.From.Index = REG_NONE
+							ab.Put1(0x8B)
+							ab.asmand(ctxt, cursym, p, &pp.From, &p.To)
+
+						case objabi.Hwindows:
+							// Windows TLS base is always 0x14(FS).
+							pp.From = p.From
+
+							pp.From.Type = obj.TYPE_MEM
+							pp.From.Reg = REG_FS
+							pp.From.Offset = 0x14
+							pp.From.Index = REG_NONE
+							pp.From.Scale = 0
+							ab.Put2(0x64, // FS
+								0x8B)
+							ab.asmand(ctxt, cursym, p, &pp.From, &p.To)
+						}
+						break
+					}
+
+					switch ctxt.Headtype {
+					default:
+						log.Fatalf("unknown TLS base location for %v", ctxt.Headtype)
+
+					case objabi.Hlinux, objabi.Hfreebsd:
+						if !ctxt.Flag_shared {
+							log.Fatalf("unknown TLS base location for linux/freebsd without -shared")
+						}
+						// Note that this is not generating the same insn as the other cases.
+						//     MOV TLS, R_to
+						// becomes
+						//     movq g@gottpoff(%rip), R_to
+						// which is encoded as
+						//     movq 0(%rip), R_to
+						// and a R_TLS_IE reloc. This all assumes the only tls variable we access
+						// is g, which we can't check here, but will when we assemble the second
+						// instruction.
+						ab.rexflag = Pw | (regrex[p.To.Reg] & Rxr)
+
+						ab.Put2(0x8B, byte(0x05|(reg[p.To.Reg]<<3)))
+						r = obj.Addrel(cursym)
+						r.Off = int32(p.Pc + int64(ab.Len()))
+						r.Type = objabi.R_TLS_IE
+						r.Siz = 4
+						r.Add = -4
+						ab.PutInt32(0)
+
+					case objabi.Hplan9:
+						pp.From = obj.Addr{}
+						pp.From.Type = obj.TYPE_MEM
+						pp.From.Name = obj.NAME_EXTERN
+						pp.From.Sym = plan9privates
+						pp.From.Offset = 0
+						pp.From.Index = REG_NONE
+						ab.rexflag |= Pw
+						ab.Put1(0x8B)
+						ab.asmand(ctxt, cursym, p, &pp.From, &p.To)
+
+					case objabi.Hsolaris: // TODO(rsc): Delete Hsolaris from list. Should not use this code. See progedit in obj6.c.
+						// TLS base is 0(FS).
+						pp.From = p.From
+
+						pp.From.Type = obj.TYPE_MEM
+						pp.From.Name = obj.NAME_NONE
+						pp.From.Reg = REG_NONE
+						pp.From.Offset = 0
+						pp.From.Index = REG_NONE
+						pp.From.Scale = 0
+						ab.rexflag |= Pw
+						ab.Put2(0x64, // FS
+							0x8B)
+						ab.asmand(ctxt, cursym, p, &pp.From, &p.To)
+
+					case objabi.Hwindows:
+						// Windows TLS base is always 0x28(GS).
+						pp.From = p.From
+
+						pp.From.Type = obj.TYPE_MEM
+						pp.From.Name = obj.NAME_NONE
+						pp.From.Reg = REG_GS
+						pp.From.Offset = 0x28
+						pp.From.Index = REG_NONE
+						pp.From.Scale = 0
+						ab.rexflag |= Pw
+						ab.Put2(0x65, // GS
+							0x8B)
+						ab.asmand(ctxt, cursym, p, &pp.From, &p.To)
+					}
+				}
+				return
+			}
+		}
+	}
+	goto bad
+
+bad:
+	if ctxt.Arch.Family != sys.AMD64 {
+		// here, the assembly has failed.
+		// if it's a byte instruction that has
+		// unaddressable registers, try to
+		// exchange registers and reissue the
+		// instruction with the operands renamed.
+		pp := *p
+
+		unbytereg(&pp.From, &pp.Ft)
+		unbytereg(&pp.To, &pp.Tt)
+
+		z := int(p.From.Reg)
+		if p.From.Type == obj.TYPE_REG && z >= REG_BP && z <= REG_DI {
+			// TODO(rsc): Use this code for x86-64 too. It has bug fixes not present in the amd64 code base.
+			// For now, different to keep bit-for-bit compatibility.
+			if ctxt.Arch.Family == sys.I386 {
+				breg := byteswapreg(ctxt, &p.To)
+				if breg != REG_AX {
+					ab.Put1(0x87) // xchg lhs,bx
+					ab.asmando(ctxt, cursym, p, &p.From, reg[breg])
+					subreg(&pp, z, breg)
+					ab.doasm(ctxt, cursym, &pp)
+					ab.Put1(0x87) // xchg lhs,bx
+					ab.asmando(ctxt, cursym, p, &p.From, reg[breg])
+				} else {
+					ab.Put1(byte(0x90 + reg[z])) // xchg lsh,ax
+					subreg(&pp, z, REG_AX)
+					ab.doasm(ctxt, cursym, &pp)
+					ab.Put1(byte(0x90 + reg[z])) // xchg lsh,ax
+				}
+				return
+			}
+
+			if isax(&p.To) || p.To.Type == obj.TYPE_NONE {
+				// We certainly don't want to exchange
+				// with AX if the op is MUL or DIV.
+				ab.Put1(0x87) // xchg lhs,bx
+				ab.asmando(ctxt, cursym, p, &p.From, reg[REG_BX])
+				subreg(&pp, z, REG_BX)
+				ab.doasm(ctxt, cursym, &pp)
+				ab.Put1(0x87) // xchg lhs,bx
+				ab.asmando(ctxt, cursym, p, &p.From, reg[REG_BX])
+			} else {
+				ab.Put1(byte(0x90 + reg[z])) // xchg lsh,ax
+				subreg(&pp, z, REG_AX)
+				ab.doasm(ctxt, cursym, &pp)
+				ab.Put1(byte(0x90 + reg[z])) // xchg lsh,ax
+			}
+			return
+		}
+
+		z = int(p.To.Reg)
+		if p.To.Type == obj.TYPE_REG && z >= REG_BP && z <= REG_DI {
+			// TODO(rsc): Use this code for x86-64 too. It has bug fixes not present in the amd64 code base.
+			// For now, different to keep bit-for-bit compatibility.
+			if ctxt.Arch.Family == sys.I386 {
+				breg := byteswapreg(ctxt, &p.From)
+				if breg != REG_AX {
+					ab.Put1(0x87) //xchg rhs,bx
+					ab.asmando(ctxt, cursym, p, &p.To, reg[breg])
+					subreg(&pp, z, breg)
+					ab.doasm(ctxt, cursym, &pp)
+					ab.Put1(0x87) // xchg rhs,bx
+					ab.asmando(ctxt, cursym, p, &p.To, reg[breg])
+				} else {
+					ab.Put1(byte(0x90 + reg[z])) // xchg rsh,ax
+					subreg(&pp, z, REG_AX)
+					ab.doasm(ctxt, cursym, &pp)
+					ab.Put1(byte(0x90 + reg[z])) // xchg rsh,ax
+				}
+				return
+			}
+
+			if isax(&p.From) {
+				ab.Put1(0x87) // xchg rhs,bx
+				ab.asmando(ctxt, cursym, p, &p.To, reg[REG_BX])
+				subreg(&pp, z, REG_BX)
+				ab.doasm(ctxt, cursym, &pp)
+				ab.Put1(0x87) // xchg rhs,bx
+				ab.asmando(ctxt, cursym, p, &p.To, reg[REG_BX])
+			} else {
+				ab.Put1(byte(0x90 + reg[z])) // xchg rsh,ax
+				subreg(&pp, z, REG_AX)
+				ab.doasm(ctxt, cursym, &pp)
+				ab.Put1(byte(0x90 + reg[z])) // xchg rsh,ax
+			}
+			return
+		}
+	}
+
+	ctxt.Diag("invalid instruction: %v", p)
+}
+
+// byteswapreg returns a byte-addressable register (AX, BX, CX, DX)
+// which is not referenced in a.
+// If a is empty, it returns BX to account for MULB-like instructions
+// that might use DX and AX.
+func byteswapreg(ctxt *obj.Link, a *obj.Addr) int {
+	cana, canb, canc, cand := true, true, true, true
+	if a.Type == obj.TYPE_NONE {
+		cana, cand = false, false
+	}
+
+	if a.Type == obj.TYPE_REG || ((a.Type == obj.TYPE_MEM || a.Type == obj.TYPE_ADDR) && a.Name == obj.NAME_NONE) {
+		switch a.Reg {
+		case REG_NONE:
+			cana, cand = false, false
+		case REG_AX, REG_AL, REG_AH:
+			cana = false
+		case REG_BX, REG_BL, REG_BH:
+			canb = false
+		case REG_CX, REG_CL, REG_CH:
+			canc = false
+		case REG_DX, REG_DL, REG_DH:
+			cand = false
+		}
+	}
+
+	if a.Type == obj.TYPE_MEM || a.Type == obj.TYPE_ADDR {
+		switch a.Index {
+		case REG_AX:
+			cana = false
+		case REG_BX:
+			canb = false
+		case REG_CX:
+			canc = false
+		case REG_DX:
+			cand = false
+		}
+	}
+
+	switch {
+	case cana:
+		return REG_AX
+	case canb:
+		return REG_BX
+	case canc:
+		return REG_CX
+	case cand:
+		return REG_DX
+	default:
+		ctxt.Diag("impossible byte register")
+		ctxt.DiagFlush()
+		log.Fatalf("bad code")
+		return 0
+	}
+}
+
+func isbadbyte(a *obj.Addr) bool {
+	return a.Type == obj.TYPE_REG && (REG_BP <= a.Reg && a.Reg <= REG_DI || REG_BPB <= a.Reg && a.Reg <= REG_DIB)
+}
+
+func (ab *AsmBuf) asmins(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog) {
+	ab.Reset()
+
+	ab.rexflag = 0
+	ab.vexflag = false
+	ab.evexflag = false
+	mark := ab.Len()
+	ab.doasm(ctxt, cursym, p)
+	if ab.rexflag != 0 && !ab.vexflag && !ab.evexflag {
+		// as befits the whole approach of the architecture,
+		// the rex prefix must appear before the first opcode byte
+		// (and thus after any 66/67/f2/f3/26/2e/3e prefix bytes, but
+		// before the 0f opcode escape!), or it might be ignored.
+		// note that the handbook often misleadingly shows 66/f2/f3 in `opcode'.
+		if ctxt.Arch.Family != sys.AMD64 {
+			ctxt.Diag("asmins: illegal in mode %d: %v (%d %d)", ctxt.Arch.RegSize*8, p, p.Ft, p.Tt)
+		}
+		n := ab.Len()
+		var np int
+		for np = mark; np < n; np++ {
+			c := ab.At(np)
+			if c != 0xf2 && c != 0xf3 && (c < 0x64 || c > 0x67) && c != 0x2e && c != 0x3e && c != 0x26 {
+				break
+			}
+		}
+		ab.Insert(np, byte(0x40|ab.rexflag))
+	}
+
+	n := ab.Len()
+	for i := len(cursym.R) - 1; i >= 0; i-- {
+		r := &cursym.R[i]
+		if int64(r.Off) < p.Pc {
+			break
+		}
+		if ab.rexflag != 0 && !ab.vexflag && !ab.evexflag {
+			r.Off++
+		}
+		if r.Type == objabi.R_PCREL {
+			if ctxt.Arch.Family == sys.AMD64 || p.As == obj.AJMP || p.As == obj.ACALL {
+				// PC-relative addressing is relative to the end of the instruction,
+				// but the relocations applied by the linker are relative to the end
+				// of the relocation. Because immediate instruction
+				// arguments can follow the PC-relative memory reference in the
+				// instruction encoding, the two may not coincide. In this case,
+				// adjust addend so that linker can keep relocating relative to the
+				// end of the relocation.
+				r.Add -= p.Pc + int64(n) - (int64(r.Off) + int64(r.Siz))
+			} else if ctxt.Arch.Family == sys.I386 {
+				// On 386 PC-relative addressing (for non-call/jmp instructions)
+				// assumes that the previous instruction loaded the PC of the end
+				// of that instruction into CX, so the adjustment is relative to
+				// that.
+				r.Add += int64(r.Off) - p.Pc + int64(r.Siz)
+			}
+		}
+		if r.Type == objabi.R_GOTPCREL && ctxt.Arch.Family == sys.I386 {
+			// On 386, R_GOTPCREL makes the same assumptions as R_PCREL.
+			r.Add += int64(r.Off) - p.Pc + int64(r.Siz)
+		}
+
+	}
+}
+
+// unpackOps4 extracts 4 operands from p.
+func unpackOps4(p *obj.Prog) (arg0, arg1, arg2, dst *obj.Addr) {
+	return &p.From, &p.RestArgs[0], &p.RestArgs[1], &p.To
+}
+
+// unpackOps5 extracts 5 operands from p.
+func unpackOps5(p *obj.Prog) (arg0, arg1, arg2, arg3, dst *obj.Addr) {
+	return &p.From, &p.RestArgs[0], &p.RestArgs[1], &p.RestArgs[2], &p.To
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/avx_optabs.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/avx_optabs.go
new file mode 100644
index 000000000..b8ff4699d
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/avx_optabs.go
@@ -0,0 +1,4628 @@
+// Code generated by x86avxgen. DO NOT EDIT.
+
+package x86
+
+// VEX instructions that come in two forms:
+//	VTHING xmm2/m128, xmmV, xmm1
+//	VTHING ymm2/m256, ymmV, ymm1
+//
+// The opcode array in the corresponding Optab entry
+// should contain the (VEX prefixes, opcode byte) pair
+// for each of the two forms.
+// For example, the entries for VPXOR are:
+//
+//	VPXOR xmm2/m128, xmmV, xmm1
+//	VEX.NDS.128.66.0F.WIG EF /r
+//
+//	VPXOR ymm2/m256, ymmV, ymm1
+//	VEX.NDS.256.66.0F.WIG EF /r
+//
+// Produce this optab entry:
+//
+//	{AVPXOR, yvex_xy3, Pavx, opBytes{vex128|vex66|vex0F|vexWIG, 0xEF, vex256|vex66|vex0F|vexWIG, 0xEF}}
+//
+// VEX requires at least 2 bytes inside opBytes:
+//	- VEX prefixes (vex-prefixed constants)
+//	- Opcode byte
+//
+// EVEX instructions extend VEX form variety:
+//	VTHING zmm2/m512, zmmV, zmm1    -- implicit K0 (merging)
+//	VTHING zmm2/m512, zmmV, K, zmm1 -- explicit K mask (can't use K0)
+//
+// EVEX requires at least 3 bytes inside opBytes:
+//	- EVEX prefixes (evex-prefixed constants); similar to VEX
+//	- Displacement multiplier info (scale / broadcast scale)
+//	- Opcode byte; similar to VEX
+//
+// Both VEX and EVEX instructions may have opdigit (opcode extension) byte
+// which follows the primary opcode byte.
+// Because it can only have value of 0-7, it is written in octal notation.
+//
+// x86.csv can be very useful for figuring out proper [E]VEX parts.
+
+var _yandnl = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yml, Yrl, Yrl}},
+}
+
+var _ybextrl = []ytab{
+	{zcase: Zvex_v_rm_r, zoffset: 2, args: argList{Yrl, Yml, Yrl}},
+}
+
+var _yblsil = []ytab{
+	{zcase: Zvex_rm_r_vo, zoffset: 3, args: argList{Yml, Yrl}},
+}
+
+var _ykaddb = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yk, Yk, Yk}},
+}
+
+var _ykmovb = []ytab{
+	{zcase: Zvex_r_v_rm, zoffset: 2, args: argList{Yk, Ym}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yk, Yrl}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Ykm, Yk}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yrl, Yk}},
+}
+
+var _yknotb = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yk, Yk}},
+}
+
+var _ykshiftlb = []ytab{
+	{zcase: Zvex_i_rm_r, zoffset: 2, args: argList{Yu8, Yk, Yk}},
+}
+
+var _yrorxl = []ytab{
+	{zcase: Zvex_i_rm_r, zoffset: 0, args: argList{Yu8, Yml, Yrl}},
+	{zcase: Zvex_i_rm_r, zoffset: 2, args: argList{Yi8, Yml, Yrl}},
+}
+
+var _yv4fmaddps = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Ym, YzrMulti4, Yzr}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{Ym, YzrMulti4, Yknot0, Yzr}},
+}
+
+var _yv4fmaddss = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Ym, YxrEvexMulti4, YxrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{Ym, YxrEvexMulti4, Yknot0, YxrEvex}},
+}
+
+var _yvaddpd = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yym, Yyr, Yyr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr, Yzr}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{Yzm, Yzr, Yknot0, Yzr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, YxrEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YymEvex, YyrEvex, Yknot0, YyrEvex}},
+}
+
+var _yvaddsd = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr, Yxr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, YxrEvex, Yknot0, YxrEvex}},
+}
+
+var _yvaddsubpd = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yym, Yyr, Yyr}},
+}
+
+var _yvaesdec = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yym, Yyr, Yyr}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{YxmEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{YymEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{Yzm, Yzr, Yzr}},
+}
+
+var _yvaesimc = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr}},
+}
+
+var _yvaeskeygenassist = []ytab{
+	{zcase: Zvex_i_rm_r, zoffset: 0, args: argList{Yu8, Yxm, Yxr}},
+	{zcase: Zvex_i_rm_r, zoffset: 2, args: argList{Yi8, Yxm, Yxr}},
+}
+
+var _yvalignd = []ytab{
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YxmEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YxmEvex, YxrEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YymEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YymEvex, YyrEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, Yzm, Yzr, Yzr}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, Yzm, Yzr, Yknot0, Yzr}},
+}
+
+var _yvandnpd = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yym, Yyr, Yyr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, YxrEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YymEvex, YyrEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr, Yzr}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{Yzm, Yzr, Yknot0, Yzr}},
+}
+
+var _yvblendmpd = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, YxrEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YymEvex, YyrEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr, Yzr}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{Yzm, Yzr, Yknot0, Yzr}},
+}
+
+var _yvblendpd = []ytab{
+	{zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yxm, Yxr, Yxr}},
+	{zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yym, Yyr, Yyr}},
+}
+
+var _yvblendvpd = []ytab{
+	{zcase: Zvex_hr_rm_v_r, zoffset: 2, args: argList{Yxr, Yxm, Yxr, Yxr}},
+	{zcase: Zvex_hr_rm_v_r, zoffset: 2, args: argList{Yyr, Yym, Yyr, Yyr}},
+}
+
+var _yvbroadcastf128 = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Ym, Yyr}},
+}
+
+var _yvbroadcastf32x2 = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, Yzr}},
+}
+
+var _yvbroadcastf32x4 = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Ym, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{Ym, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Ym, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{Ym, Yknot0, Yzr}},
+}
+
+var _yvbroadcastf32x8 = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Ym, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{Ym, Yknot0, Yzr}},
+}
+
+var _yvbroadcasti32x2 = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, Yzr}},
+}
+
+var _yvbroadcastsd = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yyr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, Yzr}},
+}
+
+var _yvbroadcastss = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yyr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, Yzr}},
+}
+
+var _yvcmppd = []ytab{
+	{zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yxm, Yxr, Yxr}},
+	{zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yym, Yyr, Yyr}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, Yzm, Yzr, Yk}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, Yzm, Yzr, Yknot0, Yk}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YxmEvex, YxrEvex, Yk}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YxmEvex, YxrEvex, Yknot0, Yk}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YymEvex, YyrEvex, Yk}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YymEvex, YyrEvex, Yknot0, Yk}},
+}
+
+var _yvcmpsd = []ytab{
+	{zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yxm, Yxr, Yxr}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YxmEvex, YxrEvex, Yk}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YxmEvex, YxrEvex, Yknot0, Yk}},
+}
+
+var _yvcomisd = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{YxmEvex, YxrEvex}},
+}
+
+var _yvcompresspd = []ytab{
+	{zcase: Zevex_r_v_rm, zoffset: 0, args: argList{YxrEvex, YxmEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YxrEvex, Yknot0, YxmEvex}},
+	{zcase: Zevex_r_v_rm, zoffset: 0, args: argList{YyrEvex, YymEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YyrEvex, Yknot0, YymEvex}},
+	{zcase: Zevex_r_v_rm, zoffset: 0, args: argList{Yzr, Yzm}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{Yzr, Yknot0, Yzm}},
+}
+
+var _yvcvtdq2pd = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yyr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YymEvex, Yknot0, Yzr}},
+}
+
+var _yvcvtdq2ps = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yym, Yyr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{Yzm, Yknot0, Yzr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YymEvex, Yknot0, YyrEvex}},
+}
+
+var _yvcvtpd2dq = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{Yzm, Yknot0, YyrEvex}},
+}
+
+var _yvcvtpd2dqx = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YxrEvex}},
+}
+
+var _yvcvtpd2dqy = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yym, Yxr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YymEvex, Yknot0, YxrEvex}},
+}
+
+var _yvcvtpd2qq = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{Yzm, Yknot0, Yzr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YymEvex, Yknot0, YyrEvex}},
+}
+
+var _yvcvtpd2udqx = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YxrEvex}},
+}
+
+var _yvcvtpd2udqy = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YymEvex, Yknot0, YxrEvex}},
+}
+
+var _yvcvtph2ps = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yyr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YymEvex, Yknot0, Yzr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YyrEvex}},
+}
+
+var _yvcvtps2ph = []ytab{
+	{zcase: Zvex_i_r_rm, zoffset: 0, args: argList{Yu8, Yxr, Yxm}},
+	{zcase: Zvex_i_r_rm, zoffset: 2, args: argList{Yi8, Yxr, Yxm}},
+	{zcase: Zvex_i_r_rm, zoffset: 0, args: argList{Yu8, Yyr, Yxm}},
+	{zcase: Zvex_i_r_rm, zoffset: 2, args: argList{Yi8, Yyr, Yxm}},
+	{zcase: Zevex_i_r_rm, zoffset: 0, args: argList{Yu8, Yzr, YymEvex}},
+	{zcase: Zevex_i_r_k_rm, zoffset: 3, args: argList{Yu8, Yzr, Yknot0, YymEvex}},
+	{zcase: Zevex_i_r_rm, zoffset: 0, args: argList{Yu8, YxrEvex, YxmEvex}},
+	{zcase: Zevex_i_r_k_rm, zoffset: 3, args: argList{Yu8, YxrEvex, Yknot0, YxmEvex}},
+	{zcase: Zevex_i_r_rm, zoffset: 0, args: argList{Yu8, YyrEvex, YxmEvex}},
+	{zcase: Zevex_i_r_k_rm, zoffset: 3, args: argList{Yu8, YyrEvex, Yknot0, YxmEvex}},
+}
+
+var _yvcvtps2qq = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YymEvex, Yknot0, Yzr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YyrEvex}},
+}
+
+var _yvcvtsd2si = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yrl}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{YxmEvex, Yrl}},
+}
+
+var _yvcvtsd2usil = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{YxmEvex, Yrl}},
+}
+
+var _yvcvtsi2sdl = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yml, Yxr, Yxr}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{Yml, YxrEvex, YxrEvex}},
+}
+
+var _yvcvtudq2pd = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YymEvex, Yknot0, Yzr}},
+}
+
+var _yvcvtusi2sdl = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{Yml, YxrEvex, YxrEvex}},
+}
+
+var _yvdppd = []ytab{
+	{zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yxm, Yxr, Yxr}},
+}
+
+var _yvexp2pd = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{Yzm, Yknot0, Yzr}},
+}
+
+var _yvexpandpd = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YymEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{Yzm, Yknot0, Yzr}},
+}
+
+var _yvextractf128 = []ytab{
+	{zcase: Zvex_i_r_rm, zoffset: 0, args: argList{Yu8, Yyr, Yxm}},
+	{zcase: Zvex_i_r_rm, zoffset: 2, args: argList{Yi8, Yyr, Yxm}},
+}
+
+var _yvextractf32x4 = []ytab{
+	{zcase: Zevex_i_r_rm, zoffset: 0, args: argList{Yu8, YyrEvex, YxmEvex}},
+	{zcase: Zevex_i_r_k_rm, zoffset: 3, args: argList{Yu8, YyrEvex, Yknot0, YxmEvex}},
+	{zcase: Zevex_i_r_rm, zoffset: 0, args: argList{Yu8, Yzr, YxmEvex}},
+	{zcase: Zevex_i_r_k_rm, zoffset: 3, args: argList{Yu8, Yzr, Yknot0, YxmEvex}},
+}
+
+var _yvextractf32x8 = []ytab{
+	{zcase: Zevex_i_r_rm, zoffset: 0, args: argList{Yu8, Yzr, YymEvex}},
+	{zcase: Zevex_i_r_k_rm, zoffset: 3, args: argList{Yu8, Yzr, Yknot0, YymEvex}},
+}
+
+var _yvextractps = []ytab{
+	{zcase: Zvex_i_r_rm, zoffset: 0, args: argList{Yu8, Yxr, Yml}},
+	{zcase: Zvex_i_r_rm, zoffset: 2, args: argList{Yi8, Yxr, Yml}},
+	{zcase: Zevex_i_r_rm, zoffset: 3, args: argList{Yu8, YxrEvex, Yml}},
+}
+
+var _yvfixupimmpd = []ytab{
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, Yzm, Yzr, Yzr}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, Yzm, Yzr, Yknot0, Yzr}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YxmEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YxmEvex, YxrEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YymEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YymEvex, YyrEvex, Yknot0, YyrEvex}},
+}
+
+var _yvfixupimmsd = []ytab{
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YxmEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YxmEvex, YxrEvex, Yknot0, YxrEvex}},
+}
+
+var _yvfpclasspdx = []ytab{
+	{zcase: Zevex_i_rm_r, zoffset: 0, args: argList{Yu8, YxmEvex, Yk}},
+	{zcase: Zevex_i_rm_k_r, zoffset: 3, args: argList{Yu8, YxmEvex, Yknot0, Yk}},
+}
+
+var _yvfpclasspdy = []ytab{
+	{zcase: Zevex_i_rm_r, zoffset: 0, args: argList{Yu8, YymEvex, Yk}},
+	{zcase: Zevex_i_rm_k_r, zoffset: 3, args: argList{Yu8, YymEvex, Yknot0, Yk}},
+}
+
+var _yvfpclasspdz = []ytab{
+	{zcase: Zevex_i_rm_r, zoffset: 0, args: argList{Yu8, Yzm, Yk}},
+	{zcase: Zevex_i_rm_k_r, zoffset: 3, args: argList{Yu8, Yzm, Yknot0, Yk}},
+}
+
+var _yvgatherdpd = []ytab{
+	{zcase: Zvex_v_rm_r, zoffset: 2, args: argList{Yxr, Yxvm, Yxr}},
+	{zcase: Zvex_v_rm_r, zoffset: 2, args: argList{Yyr, Yxvm, Yyr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxvmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxvmEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YyvmEvex, Yknot0, Yzr}},
+}
+
+var _yvgatherdps = []ytab{
+	{zcase: Zvex_v_rm_r, zoffset: 2, args: argList{Yxr, Yxvm, Yxr}},
+	{zcase: Zvex_v_rm_r, zoffset: 2, args: argList{Yyr, Yyvm, Yyr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxvmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YyvmEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{Yzvm, Yknot0, Yzr}},
+}
+
+var _yvgatherpf0dpd = []ytab{
+	{zcase: Zevex_k_rmo, zoffset: 4, args: argList{Yknot0, YyvmEvex}},
+}
+
+var _yvgatherpf0dps = []ytab{
+	{zcase: Zevex_k_rmo, zoffset: 4, args: argList{Yknot0, Yzvm}},
+}
+
+var _yvgatherqps = []ytab{
+	{zcase: Zvex_v_rm_r, zoffset: 2, args: argList{Yxr, Yxvm, Yxr}},
+	{zcase: Zvex_v_rm_r, zoffset: 2, args: argList{Yxr, Yyvm, Yxr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxvmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YyvmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{Yzvm, Yknot0, YyrEvex}},
+}
+
+var _yvgetexpsd = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, YxrEvex, Yknot0, YxrEvex}},
+}
+
+var _yvgetmantpd = []ytab{
+	{zcase: Zevex_i_rm_r, zoffset: 0, args: argList{Yu8, Yzm, Yzr}},
+	{zcase: Zevex_i_rm_k_r, zoffset: 3, args: argList{Yu8, Yzm, Yknot0, Yzr}},
+	{zcase: Zevex_i_rm_r, zoffset: 0, args: argList{Yu8, YxmEvex, YxrEvex}},
+	{zcase: Zevex_i_rm_k_r, zoffset: 3, args: argList{Yu8, YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_i_rm_r, zoffset: 0, args: argList{Yu8, YymEvex, YyrEvex}},
+	{zcase: Zevex_i_rm_k_r, zoffset: 3, args: argList{Yu8, YymEvex, Yknot0, YyrEvex}},
+}
+
+var _yvgf2p8affineinvqb = []ytab{
+	{zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yxm, Yxr, Yxr}},
+	{zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yym, Yyr, Yyr}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YxmEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YxmEvex, YxrEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YymEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YymEvex, YyrEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, Yzm, Yzr, Yzr}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, Yzm, Yzr, Yknot0, Yzr}},
+}
+
+var _yvinsertf128 = []ytab{
+	{zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yxm, Yyr, Yyr}},
+}
+
+var _yvinsertf32x4 = []ytab{
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YxmEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YxmEvex, YyrEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YxmEvex, Yzr, Yzr}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YxmEvex, Yzr, Yknot0, Yzr}},
+}
+
+var _yvinsertf32x8 = []ytab{
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YymEvex, Yzr, Yzr}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YymEvex, Yzr, Yknot0, Yzr}},
+}
+
+var _yvinsertps = []ytab{
+	{zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yxm, Yxr, Yxr}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 3, args: argList{Yu8, YxmEvex, YxrEvex, YxrEvex}},
+}
+
+var _yvlddqu = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Ym, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Ym, Yyr}},
+}
+
+var _yvldmxcsr = []ytab{
+	{zcase: Zvex_rm_v_ro, zoffset: 3, args: argList{Ym}},
+}
+
+var _yvmaskmovdqu = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxr, Yxr}},
+}
+
+var _yvmaskmovpd = []ytab{
+	{zcase: Zvex_r_v_rm, zoffset: 2, args: argList{Yxr, Yxr, Ym}},
+	{zcase: Zvex_r_v_rm, zoffset: 2, args: argList{Yyr, Yyr, Ym}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Ym, Yxr, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Ym, Yyr, Yyr}},
+}
+
+var _yvmovapd = []ytab{
+	{zcase: Zvex_r_v_rm, zoffset: 2, args: argList{Yxr, Yxm}},
+	{zcase: Zvex_r_v_rm, zoffset: 2, args: argList{Yyr, Yym}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yym, Yyr}},
+	{zcase: Zevex_r_v_rm, zoffset: 0, args: argList{YxrEvex, YxmEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YxrEvex, Yknot0, YxmEvex}},
+	{zcase: Zevex_r_v_rm, zoffset: 0, args: argList{YyrEvex, YymEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YyrEvex, Yknot0, YymEvex}},
+	{zcase: Zevex_r_v_rm, zoffset: 0, args: argList{Yzr, Yzm}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{Yzr, Yknot0, Yzm}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YymEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{Yzm, Yknot0, Yzr}},
+}
+
+var _yvmovd = []ytab{
+	{zcase: Zvex_r_v_rm, zoffset: 2, args: argList{Yxr, Yml}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yml, Yxr}},
+	{zcase: Zevex_r_v_rm, zoffset: 3, args: argList{YxrEvex, Yml}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{Yml, YxrEvex}},
+}
+
+var _yvmovddup = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yym, Yyr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YymEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{Yzm, Yknot0, Yzr}},
+}
+
+var _yvmovdqa = []ytab{
+	{zcase: Zvex_r_v_rm, zoffset: 2, args: argList{Yxr, Yxm}},
+	{zcase: Zvex_r_v_rm, zoffset: 2, args: argList{Yyr, Yym}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yym, Yyr}},
+}
+
+var _yvmovdqa32 = []ytab{
+	{zcase: Zevex_r_v_rm, zoffset: 0, args: argList{YxrEvex, YxmEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YxrEvex, Yknot0, YxmEvex}},
+	{zcase: Zevex_r_v_rm, zoffset: 0, args: argList{YyrEvex, YymEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YyrEvex, Yknot0, YymEvex}},
+	{zcase: Zevex_r_v_rm, zoffset: 0, args: argList{Yzr, Yzm}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{Yzr, Yknot0, Yzm}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YymEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{Yzm, Yknot0, Yzr}},
+}
+
+var _yvmovhlps = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxr, Yxr, Yxr}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{YxrEvex, YxrEvex, YxrEvex}},
+}
+
+var _yvmovhpd = []ytab{
+	{zcase: Zvex_r_v_rm, zoffset: 2, args: argList{Yxr, Ym}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Ym, Yxr, Yxr}},
+	{zcase: Zevex_r_v_rm, zoffset: 3, args: argList{YxrEvex, Ym}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{Ym, YxrEvex, YxrEvex}},
+}
+
+var _yvmovmskpd = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxr, Yrl}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yyr, Yrl}},
+}
+
+var _yvmovntdq = []ytab{
+	{zcase: Zvex_r_v_rm, zoffset: 2, args: argList{Yxr, Ym}},
+	{zcase: Zvex_r_v_rm, zoffset: 2, args: argList{Yyr, Ym}},
+	{zcase: Zevex_r_v_rm, zoffset: 3, args: argList{YxrEvex, Ym}},
+	{zcase: Zevex_r_v_rm, zoffset: 3, args: argList{YyrEvex, Ym}},
+	{zcase: Zevex_r_v_rm, zoffset: 3, args: argList{Yzr, Ym}},
+}
+
+var _yvmovntdqa = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Ym, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Ym, Yyr}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{Ym, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{Ym, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{Ym, Yzr}},
+}
+
+var _yvmovq = []ytab{
+	{zcase: Zvex_r_v_rm, zoffset: 2, args: argList{Yxr, Yml}},
+	{zcase: Zvex_r_v_rm, zoffset: 2, args: argList{Yxr, Yxm}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yml, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr}},
+	{zcase: Zevex_r_v_rm, zoffset: 3, args: argList{YxrEvex, Yml}},
+	{zcase: Zevex_r_v_rm, zoffset: 3, args: argList{YxrEvex, YxmEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{Yml, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{YxmEvex, YxrEvex}},
+}
+
+var _yvmovsd = []ytab{
+	{zcase: Zvex_r_v_rm, zoffset: 2, args: argList{Yxr, Yxr, Yxr}},
+	{zcase: Zvex_r_v_rm, zoffset: 2, args: argList{Yxr, Ym}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Ym, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxr, Yxr, Yxr}},
+	{zcase: Zevex_r_v_rm, zoffset: 0, args: argList{YxrEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_r_v_k_rm, zoffset: 3, args: argList{YxrEvex, YxrEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_r_v_rm, zoffset: 0, args: argList{YxrEvex, Ym}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YxrEvex, Yknot0, Ym}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Ym, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{Ym, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxrEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxrEvex, YxrEvex, Yknot0, YxrEvex}},
+}
+
+var _yvpbroadcastb = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yyr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yrl, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{Yrl, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yrl, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{Yrl, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yrl, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{Yrl, Yknot0, Yzr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YyrEvex}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, Yzr}},
+	{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{YxmEvex, Yknot0, Yzr}},
+}
+
+var _yvpbroadcastmb2q = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{Yk, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{Yk, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{Yk, Yzr}},
+}
+
+var _yvpclmulqdq = []ytab{
+	{zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yxm, Yxr, Yxr}},
+	{zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yym, Yyr, Yyr}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 3, args: argList{Yu8, YxmEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 3, args: argList{Yu8, YymEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 3, args: argList{Yu8, Yzm, Yzr, Yzr}},
+}
+
+var _yvpcmpb = []ytab{
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YxmEvex, YxrEvex, Yk}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YxmEvex, YxrEvex, Yknot0, Yk}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YymEvex, YyrEvex, Yk}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YymEvex, YyrEvex, Yknot0, Yk}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, Yzm, Yzr, Yk}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, Yzm, Yzr, Yknot0, Yk}},
+}
+
+var _yvpcmpeqb = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yym, Yyr, Yyr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex, Yk}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, YxrEvex, Yknot0, Yk}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex, Yk}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YymEvex, YyrEvex, Yknot0, Yk}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr, Yk}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{Yzm, Yzr, Yknot0, Yk}},
+}
+
+var _yvperm2f128 = []ytab{
+	{zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yym, Yyr, Yyr}},
+}
+
+var _yvpermd = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yym, Yyr, Yyr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YymEvex, YyrEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr, Yzr}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{Yzm, Yzr, Yknot0, Yzr}},
+}
+
+var _yvpermilpd = []ytab{
+	{zcase: Zvex_i_rm_r, zoffset: 0, args: argList{Yu8, Yxm, Yxr}},
+	{zcase: Zvex_i_rm_r, zoffset: 2, args: argList{Yi8, Yxm, Yxr}},
+	{zcase: Zvex_i_rm_r, zoffset: 0, args: argList{Yu8, Yym, Yyr}},
+	{zcase: Zvex_i_rm_r, zoffset: 2, args: argList{Yi8, Yym, Yyr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yym, Yyr, Yyr}},
+	{zcase: Zevex_i_rm_r, zoffset: 0, args: argList{Yu8, YxmEvex, YxrEvex}},
+	{zcase: Zevex_i_rm_k_r, zoffset: 3, args: argList{Yu8, YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_i_rm_r, zoffset: 0, args: argList{Yu8, YymEvex, YyrEvex}},
+	{zcase: Zevex_i_rm_k_r, zoffset: 3, args: argList{Yu8, YymEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_i_rm_r, zoffset: 0, args: argList{Yu8, Yzm, Yzr}},
+	{zcase: Zevex_i_rm_k_r, zoffset: 3, args: argList{Yu8, Yzm, Yknot0, Yzr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, YxrEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YymEvex, YyrEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr, Yzr}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{Yzm, Yzr, Yknot0, Yzr}},
+}
+
+var _yvpermpd = []ytab{
+	{zcase: Zvex_i_rm_r, zoffset: 2, args: argList{Yu8, Yym, Yyr}},
+	{zcase: Zevex_i_rm_r, zoffset: 0, args: argList{Yu8, YymEvex, YyrEvex}},
+	{zcase: Zevex_i_rm_k_r, zoffset: 3, args: argList{Yu8, YymEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_i_rm_r, zoffset: 0, args: argList{Yu8, Yzm, Yzr}},
+	{zcase: Zevex_i_rm_k_r, zoffset: 3, args: argList{Yu8, Yzm, Yknot0, Yzr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YymEvex, YyrEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr, Yzr}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{Yzm, Yzr, Yknot0, Yzr}},
+}
+
+var _yvpermq = []ytab{
+	{zcase: Zvex_i_rm_r, zoffset: 0, args: argList{Yu8, Yym, Yyr}},
+	{zcase: Zvex_i_rm_r, zoffset: 2, args: argList{Yi8, Yym, Yyr}},
+	{zcase: Zevex_i_rm_r, zoffset: 0, args: argList{Yu8, YymEvex, YyrEvex}},
+	{zcase: Zevex_i_rm_k_r, zoffset: 3, args: argList{Yu8, YymEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_i_rm_r, zoffset: 0, args: argList{Yu8, Yzm, Yzr}},
+	{zcase: Zevex_i_rm_k_r, zoffset: 3, args: argList{Yu8, Yzm, Yknot0, Yzr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YymEvex, YyrEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr, Yzr}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{Yzm, Yzr, Yknot0, Yzr}},
+}
+
+var _yvpextrw = []ytab{
+	{zcase: Zvex_i_r_rm, zoffset: 0, args: argList{Yu8, Yxr, Yml}},
+	{zcase: Zvex_i_r_rm, zoffset: 2, args: argList{Yi8, Yxr, Yml}},
+	{zcase: Zvex_i_rm_r, zoffset: 0, args: argList{Yu8, Yxr, Yrl}},
+	{zcase: Zvex_i_rm_r, zoffset: 2, args: argList{Yi8, Yxr, Yrl}},
+	{zcase: Zevex_i_r_rm, zoffset: 3, args: argList{Yu8, YxrEvex, Yml}},
+	{zcase: Zevex_i_rm_r, zoffset: 3, args: argList{Yu8, YxrEvex, Yrl}},
+}
+
+var _yvpinsrb = []ytab{
+	{zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yml, Yxr, Yxr}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 3, args: argList{Yu8, Yml, YxrEvex, YxrEvex}},
+}
+
+var _yvpmovb2m = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{YxrEvex, Yk}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{YyrEvex, Yk}},
+	{zcase: Zevex_rm_v_r, zoffset: 3, args: argList{Yzr, Yk}},
+}
+
+var _yvpmovdb = []ytab{
+	{zcase: Zevex_r_v_rm, zoffset: 0, args: argList{YxrEvex, YxmEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YxrEvex, Yknot0, YxmEvex}},
+	{zcase: Zevex_r_v_rm, zoffset: 0, args: argList{YyrEvex, YxmEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YyrEvex, Yknot0, YxmEvex}},
+	{zcase: Zevex_r_v_rm, zoffset: 0, args: argList{Yzr, YxmEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{Yzr, Yknot0, YxmEvex}},
+}
+
+var _yvpmovdw = []ytab{
+	{zcase: Zevex_r_v_rm, zoffset: 0, args: argList{YxrEvex, YxmEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YxrEvex, Yknot0, YxmEvex}},
+	{zcase: Zevex_r_v_rm, zoffset: 0, args: argList{YyrEvex, YxmEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YyrEvex, Yknot0, YxmEvex}},
+	{zcase: Zevex_r_v_rm, zoffset: 0, args: argList{Yzr, YymEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{Yzr, Yknot0, YymEvex}},
+}
+
+var _yvprold = []ytab{
+	{zcase: Zevex_i_rm_vo, zoffset: 0, args: argList{Yu8, YxmEvex, YxrEvex}},
+	{zcase: Zevex_i_rm_k_vo, zoffset: 4, args: argList{Yu8, YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_i_rm_vo, zoffset: 0, args: argList{Yu8, YymEvex, YyrEvex}},
+	{zcase: Zevex_i_rm_k_vo, zoffset: 4, args: argList{Yu8, YymEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_i_rm_vo, zoffset: 0, args: argList{Yu8, Yzm, Yzr}},
+	{zcase: Zevex_i_rm_k_vo, zoffset: 4, args: argList{Yu8, Yzm, Yknot0, Yzr}},
+}
+
+var _yvpscatterdd = []ytab{
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YxrEvex, Yknot0, YxvmEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YyrEvex, Yknot0, YyvmEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{Yzr, Yknot0, Yzvm}},
+}
+
+var _yvpscatterdq = []ytab{
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YxrEvex, Yknot0, YxvmEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YyrEvex, Yknot0, YxvmEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{Yzr, Yknot0, YyvmEvex}},
+}
+
+var _yvpscatterqd = []ytab{
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YxrEvex, Yknot0, YxvmEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YxrEvex, Yknot0, YyvmEvex}},
+	{zcase: Zevex_r_k_rm, zoffset: 3, args: argList{YyrEvex, Yknot0, Yzvm}},
+}
+
+var _yvpshufbitqmb = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex, Yk}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, YxrEvex, Yknot0, Yk}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex, Yk}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YymEvex, YyrEvex, Yknot0, Yk}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr, Yk}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{Yzm, Yzr, Yknot0, Yk}},
+}
+
+var _yvpshufd = []ytab{
+	{zcase: Zvex_i_rm_r, zoffset: 0, args: argList{Yu8, Yxm, Yxr}},
+	{zcase: Zvex_i_rm_r, zoffset: 2, args: argList{Yi8, Yxm, Yxr}},
+	{zcase: Zvex_i_rm_r, zoffset: 0, args: argList{Yu8, Yym, Yyr}},
+	{zcase: Zvex_i_rm_r, zoffset: 2, args: argList{Yi8, Yym, Yyr}},
+	{zcase: Zevex_i_rm_r, zoffset: 0, args: argList{Yu8, YxmEvex, YxrEvex}},
+	{zcase: Zevex_i_rm_k_r, zoffset: 3, args: argList{Yu8, YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_i_rm_r, zoffset: 0, args: argList{Yu8, YymEvex, YyrEvex}},
+	{zcase: Zevex_i_rm_k_r, zoffset: 3, args: argList{Yu8, YymEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_i_rm_r, zoffset: 0, args: argList{Yu8, Yzm, Yzr}},
+	{zcase: Zevex_i_rm_k_r, zoffset: 3, args: argList{Yu8, Yzm, Yknot0, Yzr}},
+}
+
+var _yvpslld = []ytab{
+	{zcase: Zvex_i_rm_vo, zoffset: 0, args: argList{Yu8, Yxr, Yxr}},
+	{zcase: Zvex_i_rm_vo, zoffset: 3, args: argList{Yi8, Yxr, Yxr}},
+	{zcase: Zvex_i_rm_vo, zoffset: 0, args: argList{Yu8, Yyr, Yyr}},
+	{zcase: Zvex_i_rm_vo, zoffset: 3, args: argList{Yi8, Yyr, Yyr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yyr, Yyr}},
+	{zcase: Zevex_i_rm_vo, zoffset: 0, args: argList{Yu8, YxmEvex, YxrEvex}},
+	{zcase: Zevex_i_rm_k_vo, zoffset: 4, args: argList{Yu8, YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_i_rm_vo, zoffset: 0, args: argList{Yu8, YymEvex, YyrEvex}},
+	{zcase: Zevex_i_rm_k_vo, zoffset: 4, args: argList{Yu8, YymEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_i_rm_vo, zoffset: 0, args: argList{Yu8, Yzm, Yzr}},
+	{zcase: Zevex_i_rm_k_vo, zoffset: 4, args: argList{Yu8, Yzm, Yknot0, Yzr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, YxrEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, YyrEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, Yzr, Yzr}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, Yzr, Yknot0, Yzr}},
+}
+
+var _yvpslldq = []ytab{
+	{zcase: Zvex_i_rm_vo, zoffset: 0, args: argList{Yu8, Yxr, Yxr}},
+	{zcase: Zvex_i_rm_vo, zoffset: 3, args: argList{Yi8, Yxr, Yxr}},
+	{zcase: Zvex_i_rm_vo, zoffset: 0, args: argList{Yu8, Yyr, Yyr}},
+	{zcase: Zvex_i_rm_vo, zoffset: 3, args: argList{Yi8, Yyr, Yyr}},
+	{zcase: Zevex_i_rm_vo, zoffset: 4, args: argList{Yu8, YxmEvex, YxrEvex}},
+	{zcase: Zevex_i_rm_vo, zoffset: 4, args: argList{Yu8, YymEvex, YyrEvex}},
+	{zcase: Zevex_i_rm_vo, zoffset: 4, args: argList{Yu8, Yzm, Yzr}},
+}
+
+var _yvpsraq = []ytab{
+	{zcase: Zevex_i_rm_vo, zoffset: 0, args: argList{Yu8, YxmEvex, YxrEvex}},
+	{zcase: Zevex_i_rm_k_vo, zoffset: 4, args: argList{Yu8, YxmEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_i_rm_vo, zoffset: 0, args: argList{Yu8, YymEvex, YyrEvex}},
+	{zcase: Zevex_i_rm_k_vo, zoffset: 4, args: argList{Yu8, YymEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_i_rm_vo, zoffset: 0, args: argList{Yu8, Yzm, Yzr}},
+	{zcase: Zevex_i_rm_k_vo, zoffset: 4, args: argList{Yu8, Yzm, Yknot0, Yzr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, YxrEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, YyrEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, Yzr, Yzr}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, Yzr, Yknot0, Yzr}},
+}
+
+var _yvptest = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yym, Yyr}},
+}
+
+var _yvrcpss = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr, Yxr}},
+}
+
+var _yvroundpd = []ytab{
+	{zcase: Zvex_i_rm_r, zoffset: 0, args: argList{Yu8, Yxm, Yxr}},
+	{zcase: Zvex_i_rm_r, zoffset: 2, args: argList{Yi8, Yxm, Yxr}},
+	{zcase: Zvex_i_rm_r, zoffset: 0, args: argList{Yu8, Yym, Yyr}},
+	{zcase: Zvex_i_rm_r, zoffset: 2, args: argList{Yi8, Yym, Yyr}},
+}
+
+var _yvscalefpd = []ytab{
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr, Yzr}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{Yzm, Yzr, Yknot0, Yzr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, YxrEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YymEvex, YyrEvex, Yknot0, YyrEvex}},
+}
+
+var _yvshuff32x4 = []ytab{
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YymEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YymEvex, YyrEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, Yzm, Yzr, Yzr}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, Yzm, Yzr, Yknot0, Yzr}},
+}
+
+var _yvzeroall = []ytab{
+	{zcase: Zvex, zoffset: 2, args: argList{}},
+}
+
+var avxOptab = [...]Optab{
+	{as: AANDNL, ytab: _yandnl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F38 | vexW0, 0xF2,
+	}},
+	{as: AANDNQ, ytab: _yandnl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F38 | vexW1, 0xF2,
+	}},
+	{as: ABEXTRL, ytab: _ybextrl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F38 | vexW0, 0xF7,
+	}},
+	{as: ABEXTRQ, ytab: _ybextrl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F38 | vexW1, 0xF7,
+	}},
+	{as: ABLSIL, ytab: _yblsil, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F38 | vexW0, 0xF3, 03,
+	}},
+	{as: ABLSIQ, ytab: _yblsil, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F38 | vexW1, 0xF3, 03,
+	}},
+	{as: ABLSMSKL, ytab: _yblsil, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F38 | vexW0, 0xF3, 02,
+	}},
+	{as: ABLSMSKQ, ytab: _yblsil, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F38 | vexW1, 0xF3, 02,
+	}},
+	{as: ABLSRL, ytab: _yblsil, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F38 | vexW0, 0xF3, 01,
+	}},
+	{as: ABLSRQ, ytab: _yblsil, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F38 | vexW1, 0xF3, 01,
+	}},
+	{as: ABZHIL, ytab: _ybextrl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F38 | vexW0, 0xF5,
+	}},
+	{as: ABZHIQ, ytab: _ybextrl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F38 | vexW1, 0xF5,
+	}},
+	{as: AKADDB, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x4A,
+	}},
+	{as: AKADDD, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F | vexW1, 0x4A,
+	}},
+	{as: AKADDQ, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex0F | vexW1, 0x4A,
+	}},
+	{as: AKADDW, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex0F | vexW0, 0x4A,
+	}},
+	{as: AKANDB, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x41,
+	}},
+	{as: AKANDD, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F | vexW1, 0x41,
+	}},
+	{as: AKANDNB, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x42,
+	}},
+	{as: AKANDND, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F | vexW1, 0x42,
+	}},
+	{as: AKANDNQ, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex0F | vexW1, 0x42,
+	}},
+	{as: AKANDNW, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex0F | vexW0, 0x42,
+	}},
+	{as: AKANDQ, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex0F | vexW1, 0x41,
+	}},
+	{as: AKANDW, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex0F | vexW0, 0x41,
+	}},
+	{as: AKMOVB, ytab: _ykmovb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x91,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x93,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x90,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x92,
+	}},
+	{as: AKMOVD, ytab: _ykmovb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW1, 0x91,
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x93,
+		avxEscape | vex128 | vex66 | vex0F | vexW1, 0x90,
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x92,
+	}},
+	{as: AKMOVQ, ytab: _ykmovb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW1, 0x91,
+		avxEscape | vex128 | vexF2 | vex0F | vexW1, 0x93,
+		avxEscape | vex128 | vex0F | vexW1, 0x90,
+		avxEscape | vex128 | vexF2 | vex0F | vexW1, 0x92,
+	}},
+	{as: AKMOVW, ytab: _ykmovb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x91,
+		avxEscape | vex128 | vex0F | vexW0, 0x93,
+		avxEscape | vex128 | vex0F | vexW0, 0x90,
+		avxEscape | vex128 | vex0F | vexW0, 0x92,
+	}},
+	{as: AKNOTB, ytab: _yknotb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x44,
+	}},
+	{as: AKNOTD, ytab: _yknotb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW1, 0x44,
+	}},
+	{as: AKNOTQ, ytab: _yknotb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW1, 0x44,
+	}},
+	{as: AKNOTW, ytab: _yknotb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x44,
+	}},
+	{as: AKORB, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x45,
+	}},
+	{as: AKORD, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F | vexW1, 0x45,
+	}},
+	{as: AKORQ, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex0F | vexW1, 0x45,
+	}},
+	{as: AKORTESTB, ytab: _yknotb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x98,
+	}},
+	{as: AKORTESTD, ytab: _yknotb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW1, 0x98,
+	}},
+	{as: AKORTESTQ, ytab: _yknotb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW1, 0x98,
+	}},
+	{as: AKORTESTW, ytab: _yknotb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x98,
+	}},
+	{as: AKORW, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex0F | vexW0, 0x45,
+	}},
+	{as: AKSHIFTLB, ytab: _ykshiftlb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x32,
+	}},
+	{as: AKSHIFTLD, ytab: _ykshiftlb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x33,
+	}},
+	{as: AKSHIFTLQ, ytab: _ykshiftlb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW1, 0x33,
+	}},
+	{as: AKSHIFTLW, ytab: _ykshiftlb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW1, 0x32,
+	}},
+	{as: AKSHIFTRB, ytab: _ykshiftlb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x30,
+	}},
+	{as: AKSHIFTRD, ytab: _ykshiftlb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x31,
+	}},
+	{as: AKSHIFTRQ, ytab: _ykshiftlb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW1, 0x31,
+	}},
+	{as: AKSHIFTRW, ytab: _ykshiftlb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW1, 0x30,
+	}},
+	{as: AKTESTB, ytab: _yknotb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x99,
+	}},
+	{as: AKTESTD, ytab: _yknotb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW1, 0x99,
+	}},
+	{as: AKTESTQ, ytab: _yknotb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW1, 0x99,
+	}},
+	{as: AKTESTW, ytab: _yknotb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x99,
+	}},
+	{as: AKUNPCKBW, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x4B,
+	}},
+	{as: AKUNPCKDQ, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex0F | vexW1, 0x4B,
+	}},
+	{as: AKUNPCKWD, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex0F | vexW0, 0x4B,
+	}},
+	{as: AKXNORB, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x46,
+	}},
+	{as: AKXNORD, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F | vexW1, 0x46,
+	}},
+	{as: AKXNORQ, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex0F | vexW1, 0x46,
+	}},
+	{as: AKXNORW, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex0F | vexW0, 0x46,
+	}},
+	{as: AKXORB, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x47,
+	}},
+	{as: AKXORD, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F | vexW1, 0x47,
+	}},
+	{as: AKXORQ, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex0F | vexW1, 0x47,
+	}},
+	{as: AKXORW, ytab: _ykaddb, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex0F | vexW0, 0x47,
+	}},
+	{as: AMULXL, ytab: _yandnl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F38 | vexW0, 0xF6,
+	}},
+	{as: AMULXQ, ytab: _yandnl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F38 | vexW1, 0xF6,
+	}},
+	{as: APDEPL, ytab: _yandnl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F38 | vexW0, 0xF5,
+	}},
+	{as: APDEPQ, ytab: _yandnl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F38 | vexW1, 0xF5,
+	}},
+	{as: APEXTL, ytab: _yandnl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F38 | vexW0, 0xF5,
+	}},
+	{as: APEXTQ, ytab: _yandnl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F38 | vexW1, 0xF5,
+	}},
+	{as: ARORXL, ytab: _yrorxl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F3A | vexW0, 0xF0,
+	}},
+	{as: ARORXQ, ytab: _yrorxl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F3A | vexW1, 0xF0,
+	}},
+	{as: ASARXL, ytab: _ybextrl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F38 | vexW0, 0xF7,
+	}},
+	{as: ASARXQ, ytab: _ybextrl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F38 | vexW1, 0xF7,
+	}},
+	{as: ASHLXL, ytab: _ybextrl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xF7,
+	}},
+	{as: ASHLXQ, ytab: _ybextrl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xF7,
+	}},
+	{as: ASHRXL, ytab: _ybextrl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F38 | vexW0, 0xF7,
+	}},
+	{as: ASHRXQ, ytab: _ybextrl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F38 | vexW1, 0xF7,
+	}},
+	{as: AV4FMADDPS, ytab: _yv4fmaddps, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evexF2 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x9A,
+	}},
+	{as: AV4FMADDSS, ytab: _yv4fmaddss, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF2 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x9B,
+	}},
+	{as: AV4FNMADDPS, ytab: _yv4fmaddps, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evexF2 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0xAA,
+	}},
+	{as: AV4FNMADDSS, ytab: _yv4fmaddss, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF2 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0xAB,
+	}},
+	{as: AVADDPD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x58,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x58,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x58,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x58,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x58,
+	}},
+	{as: AVADDPS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x58,
+		avxEscape | vex256 | vex0F | vexW0, 0x58,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x58,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x58,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x58,
+	}},
+	{as: AVADDSD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x58,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0x58,
+	}},
+	{as: AVADDSS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x58,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0x58,
+	}},
+	{as: AVADDSUBPD, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xD0,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xD0,
+	}},
+	{as: AVADDSUBPS, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0xD0,
+		avxEscape | vex256 | vexF2 | vex0F | vexW0, 0xD0,
+	}},
+	{as: AVAESDEC, ytab: _yvaesdec, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xDE,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xDE,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16, 0xDE,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32, 0xDE,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64, 0xDE,
+	}},
+	{as: AVAESDECLAST, ytab: _yvaesdec, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xDF,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xDF,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16, 0xDF,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32, 0xDF,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64, 0xDF,
+	}},
+	{as: AVAESENC, ytab: _yvaesdec, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xDC,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xDC,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16, 0xDC,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32, 0xDC,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64, 0xDC,
+	}},
+	{as: AVAESENCLAST, ytab: _yvaesdec, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xDD,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xDD,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16, 0xDD,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32, 0xDD,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64, 0xDD,
+	}},
+	{as: AVAESIMC, ytab: _yvaesimc, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xDB,
+	}},
+	{as: AVAESKEYGENASSIST, ytab: _yvaeskeygenassist, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0xDF,
+	}},
+	{as: AVALIGND, ytab: _yvalignd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x03,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x03,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x03,
+	}},
+	{as: AVALIGNQ, ytab: _yvalignd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x03,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x03,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x03,
+	}},
+	{as: AVANDNPD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x55,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x55,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x55,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x55,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x55,
+	}},
+	{as: AVANDNPS, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x55,
+		avxEscape | vex256 | vex0F | vexW0, 0x55,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x55,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x55,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x55,
+	}},
+	{as: AVANDPD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x54,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x54,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x54,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x54,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x54,
+	}},
+	{as: AVANDPS, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x54,
+		avxEscape | vex256 | vex0F | vexW0, 0x54,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x54,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x54,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x54,
+	}},
+	{as: AVBLENDMPD, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x65,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x65,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x65,
+	}},
+	{as: AVBLENDMPS, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x65,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x65,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x65,
+	}},
+	{as: AVBLENDPD, ytab: _yvblendpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x0D,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x0D,
+	}},
+	{as: AVBLENDPS, ytab: _yvblendpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x0C,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x0C,
+	}},
+	{as: AVBLENDVPD, ytab: _yvblendvpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x4B,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x4B,
+	}},
+	{as: AVBLENDVPS, ytab: _yvblendvpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x4A,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x4A,
+	}},
+	{as: AVBROADCASTF128, ytab: _yvbroadcastf128, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x1A,
+	}},
+	{as: AVBROADCASTF32X2, ytab: _yvbroadcastf32x2, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x19,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x19,
+	}},
+	{as: AVBROADCASTF32X4, ytab: _yvbroadcastf32x4, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x1A,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x1A,
+	}},
+	{as: AVBROADCASTF32X8, ytab: _yvbroadcastf32x8, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x1B,
+	}},
+	{as: AVBROADCASTF64X2, ytab: _yvbroadcastf32x4, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN16 | evexZeroingEnabled, 0x1A,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN16 | evexZeroingEnabled, 0x1A,
+	}},
+	{as: AVBROADCASTF64X4, ytab: _yvbroadcastf32x8, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN32 | evexZeroingEnabled, 0x1B,
+	}},
+	{as: AVBROADCASTI128, ytab: _yvbroadcastf128, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x5A,
+	}},
+	{as: AVBROADCASTI32X2, ytab: _yvbroadcasti32x2, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x59,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x59,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x59,
+	}},
+	{as: AVBROADCASTI32X4, ytab: _yvbroadcastf32x4, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x5A,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x5A,
+	}},
+	{as: AVBROADCASTI32X8, ytab: _yvbroadcastf32x8, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x5B,
+	}},
+	{as: AVBROADCASTI64X2, ytab: _yvbroadcastf32x4, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN16 | evexZeroingEnabled, 0x5A,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN16 | evexZeroingEnabled, 0x5A,
+	}},
+	{as: AVBROADCASTI64X4, ytab: _yvbroadcastf32x8, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN32 | evexZeroingEnabled, 0x5B,
+	}},
+	{as: AVBROADCASTSD, ytab: _yvbroadcastsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x19,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x19,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x19,
+	}},
+	{as: AVBROADCASTSS, ytab: _yvbroadcastss, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x18,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x18,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x18,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x18,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x18,
+	}},
+	{as: AVCMPPD, ytab: _yvcmppd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xC2,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xC2,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexSaeEnabled, 0xC2,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8, 0xC2,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8, 0xC2,
+	}},
+	{as: AVCMPPS, ytab: _yvcmppd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0xC2,
+		avxEscape | vex256 | vex0F | vexW0, 0xC2,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexSaeEnabled, 0xC2,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4, 0xC2,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4, 0xC2,
+	}},
+	{as: AVCMPSD, ytab: _yvcmpsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0xC2,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8 | evexSaeEnabled, 0xC2,
+	}},
+	{as: AVCMPSS, ytab: _yvcmpsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0xC2,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN4 | evexSaeEnabled, 0xC2,
+	}},
+	{as: AVCOMISD, ytab: _yvcomisd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x2F,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN8 | evexSaeEnabled, 0x2F,
+	}},
+	{as: AVCOMISS, ytab: _yvcomisd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x2F,
+		avxEscape | evex128 | evex0F | evexW0, evexN4 | evexSaeEnabled, 0x2F,
+	}},
+	{as: AVCOMPRESSPD, ytab: _yvcompresspd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x8A,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x8A,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x8A,
+	}},
+	{as: AVCOMPRESSPS, ytab: _yvcompresspd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x8A,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x8A,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x8A,
+	}},
+	{as: AVCVTDQ2PD, ytab: _yvcvtdq2pd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0xE6,
+		avxEscape | vex256 | vexF3 | vex0F | vexW0, 0xE6,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN8 | evexBcstN4 | evexZeroingEnabled, 0xE6,
+		avxEscape | evex256 | evexF3 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xE6,
+		avxEscape | evex512 | evexF3 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xE6,
+	}},
+	{as: AVCVTDQ2PS, ytab: _yvcvtdq2ps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x5B,
+		avxEscape | vex256 | vex0F | vexW0, 0x5B,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x5B,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x5B,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x5B,
+	}},
+	{as: AVCVTPD2DQ, ytab: _yvcvtpd2dq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evexF2 | evex0F | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0xE6,
+	}},
+	{as: AVCVTPD2DQX, ytab: _yvcvtpd2dqx, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0xE6,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xE6,
+	}},
+	{as: AVCVTPD2DQY, ytab: _yvcvtpd2dqy, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vexF2 | vex0F | vexW0, 0xE6,
+		avxEscape | evex256 | evexF2 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xE6,
+	}},
+	{as: AVCVTPD2PS, ytab: _yvcvtpd2dq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x5A,
+	}},
+	{as: AVCVTPD2PSX, ytab: _yvcvtpd2dqx, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x5A,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x5A,
+	}},
+	{as: AVCVTPD2PSY, ytab: _yvcvtpd2dqy, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x5A,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x5A,
+	}},
+	{as: AVCVTPD2QQ, ytab: _yvcvtpd2qq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x7B,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x7B,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x7B,
+	}},
+	{as: AVCVTPD2UDQ, ytab: _yvcvtpd2dq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex0F | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x79,
+	}},
+	{as: AVCVTPD2UDQX, ytab: _yvcvtpd2udqx, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x79,
+	}},
+	{as: AVCVTPD2UDQY, ytab: _yvcvtpd2udqy, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x79,
+	}},
+	{as: AVCVTPD2UQQ, ytab: _yvcvtpd2qq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x79,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x79,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x79,
+	}},
+	{as: AVCVTPH2PS, ytab: _yvcvtph2ps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x13,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x13,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN32 | evexSaeEnabled | evexZeroingEnabled, 0x13,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x13,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x13,
+	}},
+	{as: AVCVTPS2DQ, ytab: _yvcvtdq2ps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x5B,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x5B,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x5B,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x5B,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x5B,
+	}},
+	{as: AVCVTPS2PD, ytab: _yvcvtph2ps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x5A,
+		avxEscape | vex256 | vex0F | vexW0, 0x5A,
+		avxEscape | evex512 | evex0F | evexW0, evexN32 | evexBcstN4 | evexSaeEnabled | evexZeroingEnabled, 0x5A,
+		avxEscape | evex128 | evex0F | evexW0, evexN8 | evexBcstN4 | evexZeroingEnabled, 0x5A,
+		avxEscape | evex256 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x5A,
+	}},
+	{as: AVCVTPS2PH, ytab: _yvcvtps2ph, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x1D,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x1D,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN32 | evexSaeEnabled | evexZeroingEnabled, 0x1D,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN8 | evexZeroingEnabled, 0x1D,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN16 | evexZeroingEnabled, 0x1D,
+	}},
+	{as: AVCVTPS2QQ, ytab: _yvcvtps2qq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x7B,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN8 | evexBcstN4 | evexZeroingEnabled, 0x7B,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x7B,
+	}},
+	{as: AVCVTPS2UDQ, ytab: _yvcvtpd2qq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x79,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x79,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x79,
+	}},
+	{as: AVCVTPS2UQQ, ytab: _yvcvtps2qq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x79,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN8 | evexBcstN4 | evexZeroingEnabled, 0x79,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x79,
+	}},
+	{as: AVCVTQQ2PD, ytab: _yvcvtpd2qq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evexF3 | evex0F | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0xE6,
+		avxEscape | evex128 | evexF3 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xE6,
+		avxEscape | evex256 | evexF3 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xE6,
+	}},
+	{as: AVCVTQQ2PS, ytab: _yvcvtpd2dq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex0F | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x5B,
+	}},
+	{as: AVCVTQQ2PSX, ytab: _yvcvtpd2udqx, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x5B,
+	}},
+	{as: AVCVTQQ2PSY, ytab: _yvcvtpd2udqy, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x5B,
+	}},
+	{as: AVCVTSD2SI, ytab: _yvcvtsd2si, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x2D,
+		avxEscape | evex128 | evexF2 | evex0F | evexW0, evexN8 | evexRoundingEnabled, 0x2D,
+	}},
+	{as: AVCVTSD2SIQ, ytab: _yvcvtsd2si, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW1, 0x2D,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8 | evexRoundingEnabled, 0x2D,
+	}},
+	{as: AVCVTSD2SS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x5A,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0x5A,
+	}},
+	{as: AVCVTSD2USIL, ytab: _yvcvtsd2usil, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF2 | evex0F | evexW0, evexN8 | evexRoundingEnabled, 0x79,
+	}},
+	{as: AVCVTSD2USIQ, ytab: _yvcvtsd2usil, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8 | evexRoundingEnabled, 0x79,
+	}},
+	{as: AVCVTSI2SDL, ytab: _yvcvtsi2sdl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x2A,
+		avxEscape | evex128 | evexF2 | evex0F | evexW0, evexN4, 0x2A,
+	}},
+	{as: AVCVTSI2SDQ, ytab: _yvcvtsi2sdl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW1, 0x2A,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8 | evexRoundingEnabled, 0x2A,
+	}},
+	{as: AVCVTSI2SSL, ytab: _yvcvtsi2sdl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x2A,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN4 | evexRoundingEnabled, 0x2A,
+	}},
+	{as: AVCVTSI2SSQ, ytab: _yvcvtsi2sdl, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW1, 0x2A,
+		avxEscape | evex128 | evexF3 | evex0F | evexW1, evexN8 | evexRoundingEnabled, 0x2A,
+	}},
+	{as: AVCVTSS2SD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x5A,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN4 | evexSaeEnabled | evexZeroingEnabled, 0x5A,
+	}},
+	{as: AVCVTSS2SI, ytab: _yvcvtsd2si, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x2D,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN4 | evexRoundingEnabled, 0x2D,
+	}},
+	{as: AVCVTSS2SIQ, ytab: _yvcvtsd2si, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW1, 0x2D,
+		avxEscape | evex128 | evexF3 | evex0F | evexW1, evexN4 | evexRoundingEnabled, 0x2D,
+	}},
+	{as: AVCVTSS2USIL, ytab: _yvcvtsd2usil, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN4 | evexRoundingEnabled, 0x79,
+	}},
+	{as: AVCVTSS2USIQ, ytab: _yvcvtsd2usil, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F | evexW1, evexN4 | evexRoundingEnabled, 0x79,
+	}},
+	{as: AVCVTTPD2DQ, ytab: _yvcvtpd2dq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexSaeEnabled | evexZeroingEnabled, 0xE6,
+	}},
+	{as: AVCVTTPD2DQX, ytab: _yvcvtpd2dqx, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xE6,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xE6,
+	}},
+	{as: AVCVTTPD2DQY, ytab: _yvcvtpd2dqy, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xE6,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xE6,
+	}},
+	{as: AVCVTTPD2QQ, ytab: _yvcvtpd2qq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexSaeEnabled | evexZeroingEnabled, 0x7A,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x7A,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x7A,
+	}},
+	{as: AVCVTTPD2UDQ, ytab: _yvcvtpd2dq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex0F | evexW1, evexN64 | evexBcstN8 | evexSaeEnabled | evexZeroingEnabled, 0x78,
+	}},
+	{as: AVCVTTPD2UDQX, ytab: _yvcvtpd2udqx, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x78,
+	}},
+	{as: AVCVTTPD2UDQY, ytab: _yvcvtpd2udqy, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x78,
+	}},
+	{as: AVCVTTPD2UQQ, ytab: _yvcvtpd2qq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexSaeEnabled | evexZeroingEnabled, 0x78,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x78,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x78,
+	}},
+	{as: AVCVTTPS2DQ, ytab: _yvcvtdq2ps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x5B,
+		avxEscape | vex256 | vexF3 | vex0F | vexW0, 0x5B,
+		avxEscape | evex512 | evexF3 | evex0F | evexW0, evexN64 | evexBcstN4 | evexSaeEnabled | evexZeroingEnabled, 0x5B,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x5B,
+		avxEscape | evex256 | evexF3 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x5B,
+	}},
+	{as: AVCVTTPS2QQ, ytab: _yvcvtps2qq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexSaeEnabled | evexZeroingEnabled, 0x7A,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN8 | evexBcstN4 | evexZeroingEnabled, 0x7A,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x7A,
+	}},
+	{as: AVCVTTPS2UDQ, ytab: _yvcvtpd2qq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexSaeEnabled | evexZeroingEnabled, 0x78,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x78,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x78,
+	}},
+	{as: AVCVTTPS2UQQ, ytab: _yvcvtps2qq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexSaeEnabled | evexZeroingEnabled, 0x78,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN8 | evexBcstN4 | evexZeroingEnabled, 0x78,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x78,
+	}},
+	{as: AVCVTTSD2SI, ytab: _yvcvtsd2si, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x2C,
+		avxEscape | evex128 | evexF2 | evex0F | evexW0, evexN8 | evexSaeEnabled, 0x2C,
+	}},
+	{as: AVCVTTSD2SIQ, ytab: _yvcvtsd2si, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW1, 0x2C,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8 | evexSaeEnabled, 0x2C,
+	}},
+	{as: AVCVTTSD2USIL, ytab: _yvcvtsd2usil, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF2 | evex0F | evexW0, evexN8 | evexSaeEnabled, 0x78,
+	}},
+	{as: AVCVTTSD2USIQ, ytab: _yvcvtsd2usil, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8 | evexSaeEnabled, 0x78,
+	}},
+	{as: AVCVTTSS2SI, ytab: _yvcvtsd2si, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x2C,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN4 | evexSaeEnabled, 0x2C,
+	}},
+	{as: AVCVTTSS2SIQ, ytab: _yvcvtsd2si, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW1, 0x2C,
+		avxEscape | evex128 | evexF3 | evex0F | evexW1, evexN4 | evexSaeEnabled, 0x2C,
+	}},
+	{as: AVCVTTSS2USIL, ytab: _yvcvtsd2usil, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN4 | evexSaeEnabled, 0x78,
+	}},
+	{as: AVCVTTSS2USIQ, ytab: _yvcvtsd2usil, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F | evexW1, evexN4 | evexSaeEnabled, 0x78,
+	}},
+	{as: AVCVTUDQ2PD, ytab: _yvcvtudq2pd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN8 | evexBcstN4 | evexZeroingEnabled, 0x7A,
+		avxEscape | evex256 | evexF3 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x7A,
+		avxEscape | evex512 | evexF3 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x7A,
+	}},
+	{as: AVCVTUDQ2PS, ytab: _yvcvtpd2qq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evexF2 | evex0F | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x7A,
+		avxEscape | evex128 | evexF2 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x7A,
+		avxEscape | evex256 | evexF2 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x7A,
+	}},
+	{as: AVCVTUQQ2PD, ytab: _yvcvtpd2qq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evexF3 | evex0F | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x7A,
+		avxEscape | evex128 | evexF3 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x7A,
+		avxEscape | evex256 | evexF3 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x7A,
+	}},
+	{as: AVCVTUQQ2PS, ytab: _yvcvtpd2dq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evexF2 | evex0F | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x7A,
+	}},
+	{as: AVCVTUQQ2PSX, ytab: _yvcvtpd2udqx, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x7A,
+	}},
+	{as: AVCVTUQQ2PSY, ytab: _yvcvtpd2udqy, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evexF2 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x7A,
+	}},
+	{as: AVCVTUSI2SDL, ytab: _yvcvtusi2sdl, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF2 | evex0F | evexW0, evexN4, 0x7B,
+	}},
+	{as: AVCVTUSI2SDQ, ytab: _yvcvtusi2sdl, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8 | evexRoundingEnabled, 0x7B,
+	}},
+	{as: AVCVTUSI2SSL, ytab: _yvcvtusi2sdl, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN4 | evexRoundingEnabled, 0x7B,
+	}},
+	{as: AVCVTUSI2SSQ, ytab: _yvcvtusi2sdl, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F | evexW1, evexN8 | evexRoundingEnabled, 0x7B,
+	}},
+	{as: AVDBPSADBW, ytab: _yvalignd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16 | evexZeroingEnabled, 0x42,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32 | evexZeroingEnabled, 0x42,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64 | evexZeroingEnabled, 0x42,
+	}},
+	{as: AVDIVPD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x5E,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x5E,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x5E,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x5E,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x5E,
+	}},
+	{as: AVDIVPS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x5E,
+		avxEscape | vex256 | vex0F | vexW0, 0x5E,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x5E,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x5E,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x5E,
+	}},
+	{as: AVDIVSD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x5E,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0x5E,
+	}},
+	{as: AVDIVSS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x5E,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0x5E,
+	}},
+	{as: AVDPPD, ytab: _yvdppd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x41,
+	}},
+	{as: AVDPPS, ytab: _yvblendpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x40,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x40,
+	}},
+	{as: AVEXP2PD, ytab: _yvexp2pd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexSaeEnabled | evexZeroingEnabled, 0xC8,
+	}},
+	{as: AVEXP2PS, ytab: _yvexp2pd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexSaeEnabled | evexZeroingEnabled, 0xC8,
+	}},
+	{as: AVEXPANDPD, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x88,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x88,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x88,
+	}},
+	{as: AVEXPANDPS, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x88,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x88,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x88,
+	}},
+	{as: AVEXTRACTF128, ytab: _yvextractf128, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x19,
+	}},
+	{as: AVEXTRACTF32X4, ytab: _yvextractf32x4, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN16 | evexZeroingEnabled, 0x19,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN16 | evexZeroingEnabled, 0x19,
+	}},
+	{as: AVEXTRACTF32X8, ytab: _yvextractf32x8, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN32 | evexZeroingEnabled, 0x1B,
+	}},
+	{as: AVEXTRACTF64X2, ytab: _yvextractf32x4, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN16 | evexZeroingEnabled, 0x19,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN16 | evexZeroingEnabled, 0x19,
+	}},
+	{as: AVEXTRACTF64X4, ytab: _yvextractf32x8, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN32 | evexZeroingEnabled, 0x1B,
+	}},
+	{as: AVEXTRACTI128, ytab: _yvextractf128, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x39,
+	}},
+	{as: AVEXTRACTI32X4, ytab: _yvextractf32x4, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN16 | evexZeroingEnabled, 0x39,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN16 | evexZeroingEnabled, 0x39,
+	}},
+	{as: AVEXTRACTI32X8, ytab: _yvextractf32x8, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN32 | evexZeroingEnabled, 0x3B,
+	}},
+	{as: AVEXTRACTI64X2, ytab: _yvextractf32x4, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN16 | evexZeroingEnabled, 0x39,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN16 | evexZeroingEnabled, 0x39,
+	}},
+	{as: AVEXTRACTI64X4, ytab: _yvextractf32x8, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN32 | evexZeroingEnabled, 0x3B,
+	}},
+	{as: AVEXTRACTPS, ytab: _yvextractps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x17,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN4, 0x17,
+	}},
+	{as: AVFIXUPIMMPD, ytab: _yvfixupimmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexSaeEnabled | evexZeroingEnabled, 0x54,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x54,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x54,
+	}},
+	{as: AVFIXUPIMMPS, ytab: _yvfixupimmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64 | evexBcstN4 | evexSaeEnabled | evexZeroingEnabled, 0x54,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x54,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x54,
+	}},
+	{as: AVFIXUPIMMSD, ytab: _yvfixupimmsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN8 | evexSaeEnabled | evexZeroingEnabled, 0x55,
+	}},
+	{as: AVFIXUPIMMSS, ytab: _yvfixupimmsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN4 | evexSaeEnabled | evexZeroingEnabled, 0x55,
+	}},
+	{as: AVFMADD132PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x98,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0x98,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x98,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x98,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x98,
+	}},
+	{as: AVFMADD132PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x98,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x98,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x98,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x98,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x98,
+	}},
+	{as: AVFMADD132SD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x99,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0x99,
+	}},
+	{as: AVFMADD132SS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x99,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0x99,
+	}},
+	{as: AVFMADD213PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xA8,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0xA8,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0xA8,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xA8,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xA8,
+	}},
+	{as: AVFMADD213PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xA8,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xA8,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0xA8,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xA8,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xA8,
+	}},
+	{as: AVFMADD213SD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xA9,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0xA9,
+	}},
+	{as: AVFMADD213SS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xA9,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0xA9,
+	}},
+	{as: AVFMADD231PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xB8,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0xB8,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0xB8,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xB8,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xB8,
+	}},
+	{as: AVFMADD231PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xB8,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xB8,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0xB8,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xB8,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xB8,
+	}},
+	{as: AVFMADD231SD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xB9,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0xB9,
+	}},
+	{as: AVFMADD231SS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xB9,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0xB9,
+	}},
+	{as: AVFMADDSUB132PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x96,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0x96,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x96,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x96,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x96,
+	}},
+	{as: AVFMADDSUB132PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x96,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x96,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x96,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x96,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x96,
+	}},
+	{as: AVFMADDSUB213PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xA6,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0xA6,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0xA6,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xA6,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xA6,
+	}},
+	{as: AVFMADDSUB213PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xA6,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xA6,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0xA6,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xA6,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xA6,
+	}},
+	{as: AVFMADDSUB231PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xB6,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0xB6,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0xB6,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xB6,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xB6,
+	}},
+	{as: AVFMADDSUB231PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xB6,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xB6,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0xB6,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xB6,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xB6,
+	}},
+	{as: AVFMSUB132PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x9A,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0x9A,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x9A,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x9A,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x9A,
+	}},
+	{as: AVFMSUB132PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x9A,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x9A,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x9A,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x9A,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x9A,
+	}},
+	{as: AVFMSUB132SD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x9B,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0x9B,
+	}},
+	{as: AVFMSUB132SS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x9B,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0x9B,
+	}},
+	{as: AVFMSUB213PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xAA,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0xAA,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0xAA,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xAA,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xAA,
+	}},
+	{as: AVFMSUB213PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xAA,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xAA,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0xAA,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xAA,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xAA,
+	}},
+	{as: AVFMSUB213SD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xAB,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0xAB,
+	}},
+	{as: AVFMSUB213SS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xAB,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0xAB,
+	}},
+	{as: AVFMSUB231PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xBA,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0xBA,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0xBA,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xBA,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xBA,
+	}},
+	{as: AVFMSUB231PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xBA,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xBA,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0xBA,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xBA,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xBA,
+	}},
+	{as: AVFMSUB231SD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xBB,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0xBB,
+	}},
+	{as: AVFMSUB231SS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xBB,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0xBB,
+	}},
+	{as: AVFMSUBADD132PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x97,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0x97,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x97,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x97,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x97,
+	}},
+	{as: AVFMSUBADD132PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x97,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x97,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x97,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x97,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x97,
+	}},
+	{as: AVFMSUBADD213PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xA7,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0xA7,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0xA7,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xA7,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xA7,
+	}},
+	{as: AVFMSUBADD213PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xA7,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xA7,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0xA7,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xA7,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xA7,
+	}},
+	{as: AVFMSUBADD231PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xB7,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0xB7,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0xB7,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xB7,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xB7,
+	}},
+	{as: AVFMSUBADD231PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xB7,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xB7,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0xB7,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xB7,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xB7,
+	}},
+	{as: AVFNMADD132PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x9C,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0x9C,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x9C,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x9C,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x9C,
+	}},
+	{as: AVFNMADD132PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x9C,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x9C,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x9C,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x9C,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x9C,
+	}},
+	{as: AVFNMADD132SD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x9D,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0x9D,
+	}},
+	{as: AVFNMADD132SS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x9D,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0x9D,
+	}},
+	{as: AVFNMADD213PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xAC,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0xAC,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0xAC,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xAC,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xAC,
+	}},
+	{as: AVFNMADD213PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xAC,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xAC,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0xAC,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xAC,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xAC,
+	}},
+	{as: AVFNMADD213SD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xAD,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0xAD,
+	}},
+	{as: AVFNMADD213SS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xAD,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0xAD,
+	}},
+	{as: AVFNMADD231PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xBC,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0xBC,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0xBC,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xBC,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xBC,
+	}},
+	{as: AVFNMADD231PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xBC,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xBC,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0xBC,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xBC,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xBC,
+	}},
+	{as: AVFNMADD231SD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xBD,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0xBD,
+	}},
+	{as: AVFNMADD231SS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xBD,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0xBD,
+	}},
+	{as: AVFNMSUB132PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x9E,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0x9E,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x9E,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x9E,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x9E,
+	}},
+	{as: AVFNMSUB132PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x9E,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x9E,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x9E,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x9E,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x9E,
+	}},
+	{as: AVFNMSUB132SD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x9F,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0x9F,
+	}},
+	{as: AVFNMSUB132SS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x9F,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0x9F,
+	}},
+	{as: AVFNMSUB213PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xAE,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0xAE,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0xAE,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xAE,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xAE,
+	}},
+	{as: AVFNMSUB213PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xAE,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xAE,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0xAE,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xAE,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xAE,
+	}},
+	{as: AVFNMSUB213SD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xAF,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0xAF,
+	}},
+	{as: AVFNMSUB213SS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xAF,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0xAF,
+	}},
+	{as: AVFNMSUB231PD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xBE,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0xBE,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0xBE,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xBE,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xBE,
+	}},
+	{as: AVFNMSUB231PS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xBE,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xBE,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0xBE,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xBE,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xBE,
+	}},
+	{as: AVFNMSUB231SD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0xBF,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0xBF,
+	}},
+	{as: AVFNMSUB231SS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xBF,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0xBF,
+	}},
+	{as: AVFPCLASSPDX, ytab: _yvfpclasspdx, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexBcstN8, 0x66,
+	}},
+	{as: AVFPCLASSPDY, ytab: _yvfpclasspdy, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8, 0x66,
+	}},
+	{as: AVFPCLASSPDZ, ytab: _yvfpclasspdz, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8, 0x66,
+	}},
+	{as: AVFPCLASSPSX, ytab: _yvfpclasspdx, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16 | evexBcstN4, 0x66,
+	}},
+	{as: AVFPCLASSPSY, ytab: _yvfpclasspdy, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32 | evexBcstN4, 0x66,
+	}},
+	{as: AVFPCLASSPSZ, ytab: _yvfpclasspdz, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64 | evexBcstN4, 0x66,
+	}},
+	{as: AVFPCLASSSD, ytab: _yvfpclasspdx, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN8, 0x67,
+	}},
+	{as: AVFPCLASSSS, ytab: _yvfpclasspdx, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN4, 0x67,
+	}},
+	{as: AVGATHERDPD, ytab: _yvgatherdpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x92,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0x92,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8, 0x92,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN8, 0x92,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8, 0x92,
+	}},
+	{as: AVGATHERDPS, ytab: _yvgatherdps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x92,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x92,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4, 0x92,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN4, 0x92,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4, 0x92,
+	}},
+	{as: AVGATHERPF0DPD, ytab: _yvgatherpf0dpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8, 0xC6, 01,
+	}},
+	{as: AVGATHERPF0DPS, ytab: _yvgatherpf0dps, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4, 0xC6, 01,
+	}},
+	{as: AVGATHERPF0QPD, ytab: _yvgatherpf0dps, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8, 0xC7, 01,
+	}},
+	{as: AVGATHERPF0QPS, ytab: _yvgatherpf0dps, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4, 0xC7, 01,
+	}},
+	{as: AVGATHERPF1DPD, ytab: _yvgatherpf0dpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8, 0xC6, 02,
+	}},
+	{as: AVGATHERPF1DPS, ytab: _yvgatherpf0dps, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4, 0xC6, 02,
+	}},
+	{as: AVGATHERPF1QPD, ytab: _yvgatherpf0dps, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8, 0xC7, 02,
+	}},
+	{as: AVGATHERPF1QPS, ytab: _yvgatherpf0dps, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4, 0xC7, 02,
+	}},
+	{as: AVGATHERQPD, ytab: _yvgatherdps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x93,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0x93,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8, 0x93,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN8, 0x93,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8, 0x93,
+	}},
+	{as: AVGATHERQPS, ytab: _yvgatherqps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x93,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x93,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4, 0x93,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN4, 0x93,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4, 0x93,
+	}},
+	{as: AVGETEXPPD, ytab: _yvcvtpd2qq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexSaeEnabled | evexZeroingEnabled, 0x42,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x42,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x42,
+	}},
+	{as: AVGETEXPPS, ytab: _yvcvtpd2qq, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexSaeEnabled | evexZeroingEnabled, 0x42,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x42,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x42,
+	}},
+	{as: AVGETEXPSD, ytab: _yvgetexpsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexSaeEnabled | evexZeroingEnabled, 0x43,
+	}},
+	{as: AVGETEXPSS, ytab: _yvgetexpsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexSaeEnabled | evexZeroingEnabled, 0x43,
+	}},
+	{as: AVGETMANTPD, ytab: _yvgetmantpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexSaeEnabled | evexZeroingEnabled, 0x26,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x26,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x26,
+	}},
+	{as: AVGETMANTPS, ytab: _yvgetmantpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64 | evexBcstN4 | evexSaeEnabled | evexZeroingEnabled, 0x26,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x26,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x26,
+	}},
+	{as: AVGETMANTSD, ytab: _yvfixupimmsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN8 | evexSaeEnabled | evexZeroingEnabled, 0x27,
+	}},
+	{as: AVGETMANTSS, ytab: _yvfixupimmsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN4 | evexSaeEnabled | evexZeroingEnabled, 0x27,
+	}},
+	{as: AVGF2P8AFFINEINVQB, ytab: _yvgf2p8affineinvqb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW1, 0xCF,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW1, 0xCF,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xCF,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xCF,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0xCF,
+	}},
+	{as: AVGF2P8AFFINEQB, ytab: _yvgf2p8affineinvqb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW1, 0xCE,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW1, 0xCE,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xCE,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xCE,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0xCE,
+	}},
+	{as: AVGF2P8MULB, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0xCF,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0xCF,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0xCF,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0xCF,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexZeroingEnabled, 0xCF,
+	}},
+	{as: AVHADDPD, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x7C,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x7C,
+	}},
+	{as: AVHADDPS, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x7C,
+		avxEscape | vex256 | vexF2 | vex0F | vexW0, 0x7C,
+	}},
+	{as: AVHSUBPD, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x7D,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x7D,
+	}},
+	{as: AVHSUBPS, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x7D,
+		avxEscape | vex256 | vexF2 | vex0F | vexW0, 0x7D,
+	}},
+	{as: AVINSERTF128, ytab: _yvinsertf128, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x18,
+	}},
+	{as: AVINSERTF32X4, ytab: _yvinsertf32x4, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN16 | evexZeroingEnabled, 0x18,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN16 | evexZeroingEnabled, 0x18,
+	}},
+	{as: AVINSERTF32X8, ytab: _yvinsertf32x8, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN32 | evexZeroingEnabled, 0x1A,
+	}},
+	{as: AVINSERTF64X2, ytab: _yvinsertf32x4, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN16 | evexZeroingEnabled, 0x18,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN16 | evexZeroingEnabled, 0x18,
+	}},
+	{as: AVINSERTF64X4, ytab: _yvinsertf32x8, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN32 | evexZeroingEnabled, 0x1A,
+	}},
+	{as: AVINSERTI128, ytab: _yvinsertf128, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x38,
+	}},
+	{as: AVINSERTI32X4, ytab: _yvinsertf32x4, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN16 | evexZeroingEnabled, 0x38,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN16 | evexZeroingEnabled, 0x38,
+	}},
+	{as: AVINSERTI32X8, ytab: _yvinsertf32x8, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN32 | evexZeroingEnabled, 0x3A,
+	}},
+	{as: AVINSERTI64X2, ytab: _yvinsertf32x4, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN16 | evexZeroingEnabled, 0x38,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN16 | evexZeroingEnabled, 0x38,
+	}},
+	{as: AVINSERTI64X4, ytab: _yvinsertf32x8, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN32 | evexZeroingEnabled, 0x3A,
+	}},
+	{as: AVINSERTPS, ytab: _yvinsertps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x21,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN4, 0x21,
+	}},
+	{as: AVLDDQU, ytab: _yvlddqu, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0xF0,
+		avxEscape | vex256 | vexF2 | vex0F | vexW0, 0xF0,
+	}},
+	{as: AVLDMXCSR, ytab: _yvldmxcsr, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0xAE, 02,
+	}},
+	{as: AVMASKMOVDQU, ytab: _yvmaskmovdqu, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xF7,
+	}},
+	{as: AVMASKMOVPD, ytab: _yvmaskmovpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x2F,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x2F,
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x2D,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x2D,
+	}},
+	{as: AVMASKMOVPS, ytab: _yvmaskmovpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x2E,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x2E,
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x2C,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x2C,
+	}},
+	{as: AVMAXPD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x5F,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x5F,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexSaeEnabled | evexZeroingEnabled, 0x5F,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x5F,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x5F,
+	}},
+	{as: AVMAXPS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x5F,
+		avxEscape | vex256 | vex0F | vexW0, 0x5F,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexSaeEnabled | evexZeroingEnabled, 0x5F,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x5F,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x5F,
+	}},
+	{as: AVMAXSD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x5F,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8 | evexSaeEnabled | evexZeroingEnabled, 0x5F,
+	}},
+	{as: AVMAXSS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x5F,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN4 | evexSaeEnabled | evexZeroingEnabled, 0x5F,
+	}},
+	{as: AVMINPD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x5D,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x5D,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexSaeEnabled | evexZeroingEnabled, 0x5D,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x5D,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x5D,
+	}},
+	{as: AVMINPS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x5D,
+		avxEscape | vex256 | vex0F | vexW0, 0x5D,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexSaeEnabled | evexZeroingEnabled, 0x5D,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x5D,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x5D,
+	}},
+	{as: AVMINSD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x5D,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8 | evexSaeEnabled | evexZeroingEnabled, 0x5D,
+	}},
+	{as: AVMINSS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x5D,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN4 | evexSaeEnabled | evexZeroingEnabled, 0x5D,
+	}},
+	{as: AVMOVAPD, ytab: _yvmovapd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x29,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x29,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x28,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x28,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0x29,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexZeroingEnabled, 0x29,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexZeroingEnabled, 0x29,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0x28,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexZeroingEnabled, 0x28,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexZeroingEnabled, 0x28,
+	}},
+	{as: AVMOVAPS, ytab: _yvmovapd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x29,
+		avxEscape | vex256 | vex0F | vexW0, 0x29,
+		avxEscape | vex128 | vex0F | vexW0, 0x28,
+		avxEscape | vex256 | vex0F | vexW0, 0x28,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x29,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x29,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x29,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x28,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x28,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x28,
+	}},
+	{as: AVMOVD, ytab: _yvmovd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x7E,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x6E,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN4, 0x7E,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN4, 0x6E,
+	}},
+	{as: AVMOVDDUP, ytab: _yvmovddup, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x12,
+		avxEscape | vex256 | vexF2 | vex0F | vexW0, 0x12,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8 | evexZeroingEnabled, 0x12,
+		avxEscape | evex256 | evexF2 | evex0F | evexW1, evexN32 | evexZeroingEnabled, 0x12,
+		avxEscape | evex512 | evexF2 | evex0F | evexW1, evexN64 | evexZeroingEnabled, 0x12,
+	}},
+	{as: AVMOVDQA, ytab: _yvmovdqa, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x7F,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x7F,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x6F,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x6F,
+	}},
+	{as: AVMOVDQA32, ytab: _yvmovdqa32, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x6F,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x6F,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x6F,
+	}},
+	{as: AVMOVDQA64, ytab: _yvmovdqa32, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0x6F,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexZeroingEnabled, 0x6F,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexZeroingEnabled, 0x6F,
+	}},
+	{as: AVMOVDQU, ytab: _yvmovdqa, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x7F,
+		avxEscape | vex256 | vexF3 | vex0F | vexW0, 0x7F,
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x6F,
+		avxEscape | vex256 | vexF3 | vex0F | vexW0, 0x6F,
+	}},
+	{as: AVMOVDQU16, ytab: _yvmovdqa32, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex256 | evexF2 | evex0F | evexW1, evexN32 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex512 | evexF2 | evex0F | evexW1, evexN64 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0x6F,
+		avxEscape | evex256 | evexF2 | evex0F | evexW1, evexN32 | evexZeroingEnabled, 0x6F,
+		avxEscape | evex512 | evexF2 | evex0F | evexW1, evexN64 | evexZeroingEnabled, 0x6F,
+	}},
+	{as: AVMOVDQU32, ytab: _yvmovdqa32, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex256 | evexF3 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex512 | evexF3 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x6F,
+		avxEscape | evex256 | evexF3 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x6F,
+		avxEscape | evex512 | evexF3 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x6F,
+	}},
+	{as: AVMOVDQU64, ytab: _yvmovdqa32, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex256 | evexF3 | evex0F | evexW1, evexN32 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex512 | evexF3 | evex0F | evexW1, evexN64 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex128 | evexF3 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0x6F,
+		avxEscape | evex256 | evexF3 | evex0F | evexW1, evexN32 | evexZeroingEnabled, 0x6F,
+		avxEscape | evex512 | evexF3 | evex0F | evexW1, evexN64 | evexZeroingEnabled, 0x6F,
+	}},
+	{as: AVMOVDQU8, ytab: _yvmovdqa32, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF2 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex256 | evexF2 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex512 | evexF2 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex128 | evexF2 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x6F,
+		avxEscape | evex256 | evexF2 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x6F,
+		avxEscape | evex512 | evexF2 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x6F,
+	}},
+	{as: AVMOVHLPS, ytab: _yvmovhlps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x12,
+		avxEscape | evex128 | evex0F | evexW0, 0, 0x12,
+	}},
+	{as: AVMOVHPD, ytab: _yvmovhpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x17,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x16,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN8, 0x17,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN8, 0x16,
+	}},
+	{as: AVMOVHPS, ytab: _yvmovhpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x17,
+		avxEscape | vex128 | vex0F | vexW0, 0x16,
+		avxEscape | evex128 | evex0F | evexW0, evexN8, 0x17,
+		avxEscape | evex128 | evex0F | evexW0, evexN8, 0x16,
+	}},
+	{as: AVMOVLHPS, ytab: _yvmovhlps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x16,
+		avxEscape | evex128 | evex0F | evexW0, 0, 0x16,
+	}},
+	{as: AVMOVLPD, ytab: _yvmovhpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x13,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x12,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN8, 0x13,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN8, 0x12,
+	}},
+	{as: AVMOVLPS, ytab: _yvmovhpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x13,
+		avxEscape | vex128 | vex0F | vexW0, 0x12,
+		avxEscape | evex128 | evex0F | evexW0, evexN8, 0x13,
+		avxEscape | evex128 | evex0F | evexW0, evexN8, 0x12,
+	}},
+	{as: AVMOVMSKPD, ytab: _yvmovmskpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x50,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x50,
+	}},
+	{as: AVMOVMSKPS, ytab: _yvmovmskpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x50,
+		avxEscape | vex256 | vex0F | vexW0, 0x50,
+	}},
+	{as: AVMOVNTDQ, ytab: _yvmovntdq, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xE7,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xE7,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16, 0xE7,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32, 0xE7,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64, 0xE7,
+	}},
+	{as: AVMOVNTDQA, ytab: _yvmovntdqa, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x2A,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x2A,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16, 0x2A,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32, 0x2A,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64, 0x2A,
+	}},
+	{as: AVMOVNTPD, ytab: _yvmovntdq, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x2B,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x2B,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16, 0x2B,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32, 0x2B,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64, 0x2B,
+	}},
+	{as: AVMOVNTPS, ytab: _yvmovntdq, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x2B,
+		avxEscape | vex256 | vex0F | vexW0, 0x2B,
+		avxEscape | evex128 | evex0F | evexW0, evexN16, 0x2B,
+		avxEscape | evex256 | evex0F | evexW0, evexN32, 0x2B,
+		avxEscape | evex512 | evex0F | evexW0, evexN64, 0x2B,
+	}},
+	{as: AVMOVQ, ytab: _yvmovq, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW1, 0x7E,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xD6,
+		avxEscape | vex128 | vex66 | vex0F | vexW1, 0x6E,
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x7E,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN8, 0x7E,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN8, 0xD6,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN8, 0x6E,
+		avxEscape | evex128 | evexF3 | evex0F | evexW1, evexN8, 0x7E,
+	}},
+	{as: AVMOVSD, ytab: _yvmovsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x11,
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x11,
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x10,
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x10,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexZeroingEnabled, 0x11,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8, 0x11,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8 | evexZeroingEnabled, 0x10,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexZeroingEnabled, 0x10,
+	}},
+	{as: AVMOVSHDUP, ytab: _yvmovddup, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x16,
+		avxEscape | vex256 | vexF3 | vex0F | vexW0, 0x16,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x16,
+		avxEscape | evex256 | evexF3 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x16,
+		avxEscape | evex512 | evexF3 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x16,
+	}},
+	{as: AVMOVSLDUP, ytab: _yvmovddup, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x12,
+		avxEscape | vex256 | vexF3 | vex0F | vexW0, 0x12,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x12,
+		avxEscape | evex256 | evexF3 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x12,
+		avxEscape | evex512 | evexF3 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x12,
+	}},
+	{as: AVMOVSS, ytab: _yvmovsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x11,
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x11,
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x10,
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x10,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexZeroingEnabled, 0x11,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN4, 0x11,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN4 | evexZeroingEnabled, 0x10,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexZeroingEnabled, 0x10,
+	}},
+	{as: AVMOVUPD, ytab: _yvmovapd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x11,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x11,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x10,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x10,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0x11,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexZeroingEnabled, 0x11,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexZeroingEnabled, 0x11,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0x10,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexZeroingEnabled, 0x10,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexZeroingEnabled, 0x10,
+	}},
+	{as: AVMOVUPS, ytab: _yvmovapd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x11,
+		avxEscape | vex256 | vex0F | vexW0, 0x11,
+		avxEscape | vex128 | vex0F | vexW0, 0x10,
+		avxEscape | vex256 | vex0F | vexW0, 0x10,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x11,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x11,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x11,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x10,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x10,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x10,
+	}},
+	{as: AVMPSADBW, ytab: _yvblendpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x42,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x42,
+	}},
+	{as: AVMULPD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x59,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x59,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x59,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x59,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x59,
+	}},
+	{as: AVMULPS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x59,
+		avxEscape | vex256 | vex0F | vexW0, 0x59,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x59,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x59,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x59,
+	}},
+	{as: AVMULSD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x59,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0x59,
+	}},
+	{as: AVMULSS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x59,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0x59,
+	}},
+	{as: AVORPD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x56,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x56,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x56,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x56,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x56,
+	}},
+	{as: AVORPS, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x56,
+		avxEscape | vex256 | vex0F | vexW0, 0x56,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x56,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x56,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x56,
+	}},
+	{as: AVP4DPWSSD, ytab: _yv4fmaddps, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evexF2 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x52,
+	}},
+	{as: AVP4DPWSSDS, ytab: _yv4fmaddps, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evexF2 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x53,
+	}},
+	{as: AVPABSB, ytab: _yvmovddup, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x1C,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x1C,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x1C,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x1C,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexZeroingEnabled, 0x1C,
+	}},
+	{as: AVPABSD, ytab: _yvmovddup, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x1E,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x1E,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x1E,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x1E,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x1E,
+	}},
+	{as: AVPABSQ, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x1F,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x1F,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x1F,
+	}},
+	{as: AVPABSW, ytab: _yvmovddup, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x1D,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x1D,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x1D,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x1D,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexZeroingEnabled, 0x1D,
+	}},
+	{as: AVPACKSSDW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x6B,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x6B,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x6B,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x6B,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x6B,
+	}},
+	{as: AVPACKSSWB, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x63,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x63,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x63,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x63,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x63,
+	}},
+	{as: AVPACKUSDW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x2B,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x2B,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x2B,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x2B,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x2B,
+	}},
+	{as: AVPACKUSWB, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x67,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x67,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x67,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x67,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x67,
+	}},
+	{as: AVPADDB, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xFC,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xFC,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xFC,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xFC,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xFC,
+	}},
+	{as: AVPADDD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xFE,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xFE,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xFE,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xFE,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0xFE,
+	}},
+	{as: AVPADDQ, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xD4,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xD4,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xD4,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xD4,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0xD4,
+	}},
+	{as: AVPADDSB, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xEC,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xEC,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xEC,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xEC,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xEC,
+	}},
+	{as: AVPADDSW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xED,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xED,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xED,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xED,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xED,
+	}},
+	{as: AVPADDUSB, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xDC,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xDC,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xDC,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xDC,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xDC,
+	}},
+	{as: AVPADDUSW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xDD,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xDD,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xDD,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xDD,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xDD,
+	}},
+	{as: AVPADDW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xFD,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xFD,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xFD,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xFD,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xFD,
+	}},
+	{as: AVPALIGNR, ytab: _yvgf2p8affineinvqb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x0F,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x0F,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16 | evexZeroingEnabled, 0x0F,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32 | evexZeroingEnabled, 0x0F,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64 | evexZeroingEnabled, 0x0F,
+	}},
+	{as: AVPAND, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xDB,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xDB,
+	}},
+	{as: AVPANDD, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xDB,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xDB,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0xDB,
+	}},
+	{as: AVPANDN, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xDF,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xDF,
+	}},
+	{as: AVPANDND, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xDF,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xDF,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0xDF,
+	}},
+	{as: AVPANDNQ, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xDF,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xDF,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0xDF,
+	}},
+	{as: AVPANDQ, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xDB,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xDB,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0xDB,
+	}},
+	{as: AVPAVGB, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xE0,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xE0,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xE0,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xE0,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xE0,
+	}},
+	{as: AVPAVGW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xE3,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xE3,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xE3,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xE3,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xE3,
+	}},
+	{as: AVPBLENDD, ytab: _yvblendpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x02,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x02,
+	}},
+	{as: AVPBLENDMB, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x66,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x66,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexZeroingEnabled, 0x66,
+	}},
+	{as: AVPBLENDMD, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x64,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x64,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x64,
+	}},
+	{as: AVPBLENDMQ, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x64,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x64,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x64,
+	}},
+	{as: AVPBLENDMW, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexZeroingEnabled, 0x66,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexZeroingEnabled, 0x66,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexZeroingEnabled, 0x66,
+	}},
+	{as: AVPBLENDVB, ytab: _yvblendvpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x4C,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x4C,
+	}},
+	{as: AVPBLENDW, ytab: _yvblendpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x0E,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x0E,
+	}},
+	{as: AVPBROADCASTB, ytab: _yvpbroadcastb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x78,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x78,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexZeroingEnabled, 0x7A,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexZeroingEnabled, 0x7A,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexZeroingEnabled, 0x7A,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN1 | evexZeroingEnabled, 0x78,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN1 | evexZeroingEnabled, 0x78,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN1 | evexZeroingEnabled, 0x78,
+	}},
+	{as: AVPBROADCASTD, ytab: _yvpbroadcastb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x58,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x58,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexZeroingEnabled, 0x7C,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexZeroingEnabled, 0x7C,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexZeroingEnabled, 0x7C,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x58,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x58,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x58,
+	}},
+	{as: AVPBROADCASTMB2Q, ytab: _yvpbroadcastmb2q, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW1, 0, 0x2A,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW1, 0, 0x2A,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW1, 0, 0x2A,
+	}},
+	{as: AVPBROADCASTMW2D, ytab: _yvpbroadcastmb2q, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, 0, 0x3A,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, 0, 0x3A,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, 0, 0x3A,
+	}},
+	{as: AVPBROADCASTQ, ytab: _yvpbroadcastb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x59,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x59,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexZeroingEnabled, 0x7C,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexZeroingEnabled, 0x7C,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexZeroingEnabled, 0x7C,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x59,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x59,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x59,
+	}},
+	{as: AVPBROADCASTW, ytab: _yvpbroadcastb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x79,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x79,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexZeroingEnabled, 0x7B,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexZeroingEnabled, 0x7B,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexZeroingEnabled, 0x7B,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN2 | evexZeroingEnabled, 0x79,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN2 | evexZeroingEnabled, 0x79,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN2 | evexZeroingEnabled, 0x79,
+	}},
+	{as: AVPCLMULQDQ, ytab: _yvpclmulqdq, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x44,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x44,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16, 0x44,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32, 0x44,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64, 0x44,
+	}},
+	{as: AVPCMPB, ytab: _yvpcmpb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16, 0x3F,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32, 0x3F,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64, 0x3F,
+	}},
+	{as: AVPCMPD, ytab: _yvpcmpb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16 | evexBcstN4, 0x1F,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32 | evexBcstN4, 0x1F,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64 | evexBcstN4, 0x1F,
+	}},
+	{as: AVPCMPEQB, ytab: _yvpcmpeqb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x74,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x74,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16, 0x74,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32, 0x74,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64, 0x74,
+	}},
+	{as: AVPCMPEQD, ytab: _yvpcmpeqb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x76,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x76,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4, 0x76,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4, 0x76,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4, 0x76,
+	}},
+	{as: AVPCMPEQQ, ytab: _yvpcmpeqb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x29,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x29,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8, 0x29,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8, 0x29,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8, 0x29,
+	}},
+	{as: AVPCMPEQW, ytab: _yvpcmpeqb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x75,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x75,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16, 0x75,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32, 0x75,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64, 0x75,
+	}},
+	{as: AVPCMPESTRI, ytab: _yvaeskeygenassist, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexWIG, 0x61,
+	}},
+	{as: AVPCMPESTRM, ytab: _yvaeskeygenassist, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexWIG, 0x60,
+	}},
+	{as: AVPCMPGTB, ytab: _yvpcmpeqb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x64,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x64,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16, 0x64,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32, 0x64,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64, 0x64,
+	}},
+	{as: AVPCMPGTD, ytab: _yvpcmpeqb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x66,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x66,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4, 0x66,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4, 0x66,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4, 0x66,
+	}},
+	{as: AVPCMPGTQ, ytab: _yvpcmpeqb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x37,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x37,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8, 0x37,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8, 0x37,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8, 0x37,
+	}},
+	{as: AVPCMPGTW, ytab: _yvpcmpeqb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x65,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x65,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16, 0x65,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32, 0x65,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64, 0x65,
+	}},
+	{as: AVPCMPISTRI, ytab: _yvaeskeygenassist, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexWIG, 0x63,
+	}},
+	{as: AVPCMPISTRM, ytab: _yvaeskeygenassist, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x62,
+	}},
+	{as: AVPCMPQ, ytab: _yvpcmpb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexBcstN8, 0x1F,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8, 0x1F,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8, 0x1F,
+	}},
+	{as: AVPCMPUB, ytab: _yvpcmpb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16, 0x3E,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32, 0x3E,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64, 0x3E,
+	}},
+	{as: AVPCMPUD, ytab: _yvpcmpb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16 | evexBcstN4, 0x1E,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32 | evexBcstN4, 0x1E,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64 | evexBcstN4, 0x1E,
+	}},
+	{as: AVPCMPUQ, ytab: _yvpcmpb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexBcstN8, 0x1E,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8, 0x1E,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8, 0x1E,
+	}},
+	{as: AVPCMPUW, ytab: _yvpcmpb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16, 0x3E,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32, 0x3E,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64, 0x3E,
+	}},
+	{as: AVPCMPW, ytab: _yvpcmpb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16, 0x3F,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32, 0x3F,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64, 0x3F,
+	}},
+	{as: AVPCOMPRESSB, ytab: _yvcompresspd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN1 | evexZeroingEnabled, 0x63,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN1 | evexZeroingEnabled, 0x63,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN1 | evexZeroingEnabled, 0x63,
+	}},
+	{as: AVPCOMPRESSD, ytab: _yvcompresspd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x8B,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x8B,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x8B,
+	}},
+	{as: AVPCOMPRESSQ, ytab: _yvcompresspd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x8B,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x8B,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x8B,
+	}},
+	{as: AVPCOMPRESSW, ytab: _yvcompresspd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN2 | evexZeroingEnabled, 0x63,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN2 | evexZeroingEnabled, 0x63,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN2 | evexZeroingEnabled, 0x63,
+	}},
+	{as: AVPCONFLICTD, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xC4,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xC4,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0xC4,
+	}},
+	{as: AVPCONFLICTQ, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xC4,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xC4,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0xC4,
+	}},
+	{as: AVPDPBUSD, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x50,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x50,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x50,
+	}},
+	{as: AVPDPBUSDS, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x51,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x51,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x51,
+	}},
+	{as: AVPDPWSSD, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x52,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x52,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x52,
+	}},
+	{as: AVPDPWSSDS, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x53,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x53,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x53,
+	}},
+	{as: AVPERM2F128, ytab: _yvperm2f128, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x06,
+	}},
+	{as: AVPERM2I128, ytab: _yvperm2f128, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x46,
+	}},
+	{as: AVPERMB, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x8D,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x8D,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexZeroingEnabled, 0x8D,
+	}},
+	{as: AVPERMD, ytab: _yvpermd, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x36,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x36,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x36,
+	}},
+	{as: AVPERMI2B, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x75,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x75,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexZeroingEnabled, 0x75,
+	}},
+	{as: AVPERMI2D, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x76,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x76,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x76,
+	}},
+	{as: AVPERMI2PD, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x77,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x77,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x77,
+	}},
+	{as: AVPERMI2PS, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x77,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x77,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x77,
+	}},
+	{as: AVPERMI2Q, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x76,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x76,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x76,
+	}},
+	{as: AVPERMI2W, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexZeroingEnabled, 0x75,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexZeroingEnabled, 0x75,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexZeroingEnabled, 0x75,
+	}},
+	{as: AVPERMILPD, ytab: _yvpermilpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x05,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x05,
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x0D,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x0D,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x05,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x05,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x05,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x0D,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x0D,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x0D,
+	}},
+	{as: AVPERMILPS, ytab: _yvpermilpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x04,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x04,
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x0C,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x0C,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x04,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x04,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x04,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x0C,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x0C,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x0C,
+	}},
+	{as: AVPERMPD, ytab: _yvpermq, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F3A | vexW1, 0x01,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x01,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x01,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x16,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x16,
+	}},
+	{as: AVPERMPS, ytab: _yvpermd, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x16,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x16,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x16,
+	}},
+	{as: AVPERMQ, ytab: _yvpermq, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex66 | vex0F3A | vexW1, 0x00,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x00,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x00,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x36,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x36,
+	}},
+	{as: AVPERMT2B, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x7D,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x7D,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexZeroingEnabled, 0x7D,
+	}},
+	{as: AVPERMT2D, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x7E,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x7E,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x7E,
+	}},
+	{as: AVPERMT2PD, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x7F,
+	}},
+	{as: AVPERMT2PS, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x7F,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x7F,
+	}},
+	{as: AVPERMT2Q, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x7E,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x7E,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x7E,
+	}},
+	{as: AVPERMT2W, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexZeroingEnabled, 0x7D,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexZeroingEnabled, 0x7D,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexZeroingEnabled, 0x7D,
+	}},
+	{as: AVPERMW, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexZeroingEnabled, 0x8D,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexZeroingEnabled, 0x8D,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexZeroingEnabled, 0x8D,
+	}},
+	{as: AVPEXPANDB, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN1 | evexZeroingEnabled, 0x62,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN1 | evexZeroingEnabled, 0x62,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN1 | evexZeroingEnabled, 0x62,
+	}},
+	{as: AVPEXPANDD, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x89,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x89,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x89,
+	}},
+	{as: AVPEXPANDQ, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x89,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x89,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x89,
+	}},
+	{as: AVPEXPANDW, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN2 | evexZeroingEnabled, 0x62,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN2 | evexZeroingEnabled, 0x62,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN2 | evexZeroingEnabled, 0x62,
+	}},
+	{as: AVPEXTRB, ytab: _yvextractps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x14,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN1, 0x14,
+	}},
+	{as: AVPEXTRD, ytab: _yvextractps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x16,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN4, 0x16,
+	}},
+	{as: AVPEXTRQ, ytab: _yvextractps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW1, 0x16,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN8, 0x16,
+	}},
+	{as: AVPEXTRW, ytab: _yvpextrw, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x15,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xC5,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN2, 0x15,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, 0, 0xC5,
+	}},
+	{as: AVPGATHERDD, ytab: _yvgatherdps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x90,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x90,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4, 0x90,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN4, 0x90,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4, 0x90,
+	}},
+	{as: AVPGATHERDQ, ytab: _yvgatherdpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x90,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0x90,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8, 0x90,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN8, 0x90,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8, 0x90,
+	}},
+	{as: AVPGATHERQD, ytab: _yvgatherqps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x91,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x91,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4, 0x91,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN4, 0x91,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4, 0x91,
+	}},
+	{as: AVPGATHERQQ, ytab: _yvgatherdps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x91,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0x91,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8, 0x91,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN8, 0x91,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8, 0x91,
+	}},
+	{as: AVPHADDD, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x02,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x02,
+	}},
+	{as: AVPHADDSW, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x03,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x03,
+	}},
+	{as: AVPHADDW, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x01,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x01,
+	}},
+	{as: AVPHMINPOSUW, ytab: _yvaesimc, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x41,
+	}},
+	{as: AVPHSUBD, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x06,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x06,
+	}},
+	{as: AVPHSUBSW, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x07,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x07,
+	}},
+	{as: AVPHSUBW, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x05,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x05,
+	}},
+	{as: AVPINSRB, ytab: _yvpinsrb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x20,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN1, 0x20,
+	}},
+	{as: AVPINSRD, ytab: _yvpinsrb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x22,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN4, 0x22,
+	}},
+	{as: AVPINSRQ, ytab: _yvpinsrb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW1, 0x22,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN8, 0x22,
+	}},
+	{as: AVPINSRW, ytab: _yvpinsrb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xC4,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN2, 0xC4,
+	}},
+	{as: AVPLZCNTD, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x44,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x44,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x44,
+	}},
+	{as: AVPLZCNTQ, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x44,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x44,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x44,
+	}},
+	{as: AVPMADD52HUQ, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xB5,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xB5,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0xB5,
+	}},
+	{as: AVPMADD52LUQ, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xB4,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xB4,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0xB4,
+	}},
+	{as: AVPMADDUBSW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x04,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x04,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x04,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x04,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexZeroingEnabled, 0x04,
+	}},
+	{as: AVPMADDWD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xF5,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xF5,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xF5,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xF5,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xF5,
+	}},
+	{as: AVPMASKMOVD, ytab: _yvmaskmovpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x8E,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x8E,
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x8C,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x8C,
+	}},
+	{as: AVPMASKMOVQ, ytab: _yvmaskmovpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x8E,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0x8E,
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x8C,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0x8C,
+	}},
+	{as: AVPMAXSB, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x3C,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x3C,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x3C,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x3C,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexZeroingEnabled, 0x3C,
+	}},
+	{as: AVPMAXSD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x3D,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x3D,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x3D,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x3D,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x3D,
+	}},
+	{as: AVPMAXSQ, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x3D,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x3D,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x3D,
+	}},
+	{as: AVPMAXSW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xEE,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xEE,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xEE,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xEE,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xEE,
+	}},
+	{as: AVPMAXUB, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xDE,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xDE,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xDE,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xDE,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xDE,
+	}},
+	{as: AVPMAXUD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x3F,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x3F,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x3F,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x3F,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x3F,
+	}},
+	{as: AVPMAXUQ, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x3F,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x3F,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x3F,
+	}},
+	{as: AVPMAXUW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x3E,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x3E,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x3E,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x3E,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexZeroingEnabled, 0x3E,
+	}},
+	{as: AVPMINSB, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x38,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x38,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x38,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x38,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexZeroingEnabled, 0x38,
+	}},
+	{as: AVPMINSD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x39,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x39,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x39,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x39,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x39,
+	}},
+	{as: AVPMINSQ, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x39,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x39,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x39,
+	}},
+	{as: AVPMINSW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xEA,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xEA,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xEA,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xEA,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xEA,
+	}},
+	{as: AVPMINUB, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xDA,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xDA,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xDA,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xDA,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xDA,
+	}},
+	{as: AVPMINUD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x3B,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x3B,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x3B,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x3B,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x3B,
+	}},
+	{as: AVPMINUQ, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x3B,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x3B,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x3B,
+	}},
+	{as: AVPMINUW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x3A,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x3A,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x3A,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x3A,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexZeroingEnabled, 0x3A,
+	}},
+	{as: AVPMOVB2M, ytab: _yvpmovb2m, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, 0, 0x29,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, 0, 0x29,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, 0, 0x29,
+	}},
+	{as: AVPMOVD2M, ytab: _yvpmovb2m, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, 0, 0x39,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, 0, 0x39,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, 0, 0x39,
+	}},
+	{as: AVPMOVDB, ytab: _yvpmovdb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x31,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x31,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x31,
+	}},
+	{as: AVPMOVDW, ytab: _yvpmovdw, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x33,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x33,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x33,
+	}},
+	{as: AVPMOVM2B, ytab: _yvpbroadcastmb2q, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, 0, 0x28,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, 0, 0x28,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, 0, 0x28,
+	}},
+	{as: AVPMOVM2D, ytab: _yvpbroadcastmb2q, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, 0, 0x38,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, 0, 0x38,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, 0, 0x38,
+	}},
+	{as: AVPMOVM2Q, ytab: _yvpbroadcastmb2q, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW1, 0, 0x38,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW1, 0, 0x38,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW1, 0, 0x38,
+	}},
+	{as: AVPMOVM2W, ytab: _yvpbroadcastmb2q, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW1, 0, 0x28,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW1, 0, 0x28,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW1, 0, 0x28,
+	}},
+	{as: AVPMOVMSKB, ytab: _yvmovmskpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xD7,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xD7,
+	}},
+	{as: AVPMOVQ2M, ytab: _yvpmovb2m, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW1, 0, 0x39,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW1, 0, 0x39,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW1, 0, 0x39,
+	}},
+	{as: AVPMOVQB, ytab: _yvpmovdb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN2 | evexZeroingEnabled, 0x32,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x32,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x32,
+	}},
+	{as: AVPMOVQD, ytab: _yvpmovdw, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x35,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x35,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x35,
+	}},
+	{as: AVPMOVQW, ytab: _yvpmovdb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x34,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x34,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x34,
+	}},
+	{as: AVPMOVSDB, ytab: _yvpmovdb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x21,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x21,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x21,
+	}},
+	{as: AVPMOVSDW, ytab: _yvpmovdw, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x23,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x23,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x23,
+	}},
+	{as: AVPMOVSQB, ytab: _yvpmovdb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN2 | evexZeroingEnabled, 0x22,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x22,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x22,
+	}},
+	{as: AVPMOVSQD, ytab: _yvpmovdw, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x25,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x25,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x25,
+	}},
+	{as: AVPMOVSQW, ytab: _yvpmovdb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x24,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x24,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x24,
+	}},
+	{as: AVPMOVSWB, ytab: _yvpmovdw, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x20,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x20,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x20,
+	}},
+	{as: AVPMOVSXBD, ytab: _yvbroadcastss, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x21,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x21,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x21,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x21,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x21,
+	}},
+	{as: AVPMOVSXBQ, ytab: _yvbroadcastss, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x22,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x22,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN2 | evexZeroingEnabled, 0x22,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x22,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x22,
+	}},
+	{as: AVPMOVSXBW, ytab: _yvcvtdq2pd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x20,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x20,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x20,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x20,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x20,
+	}},
+	{as: AVPMOVSXDQ, ytab: _yvcvtdq2pd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x25,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x25,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x25,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x25,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x25,
+	}},
+	{as: AVPMOVSXWD, ytab: _yvcvtdq2pd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x23,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x23,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x23,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x23,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x23,
+	}},
+	{as: AVPMOVSXWQ, ytab: _yvbroadcastss, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x24,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x24,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x24,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x24,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x24,
+	}},
+	{as: AVPMOVUSDB, ytab: _yvpmovdb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x11,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x11,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x11,
+	}},
+	{as: AVPMOVUSDW, ytab: _yvpmovdw, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x13,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x13,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x13,
+	}},
+	{as: AVPMOVUSQB, ytab: _yvpmovdb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN2 | evexZeroingEnabled, 0x12,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x12,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x12,
+	}},
+	{as: AVPMOVUSQD, ytab: _yvpmovdw, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x15,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x15,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x15,
+	}},
+	{as: AVPMOVUSQW, ytab: _yvpmovdb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x14,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x14,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x14,
+	}},
+	{as: AVPMOVUSWB, ytab: _yvpmovdw, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x10,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x10,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x10,
+	}},
+	{as: AVPMOVW2M, ytab: _yvpmovb2m, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW1, 0, 0x29,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW1, 0, 0x29,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW1, 0, 0x29,
+	}},
+	{as: AVPMOVWB, ytab: _yvpmovdw, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x30,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x30,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x30,
+	}},
+	{as: AVPMOVZXBD, ytab: _yvbroadcastss, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x31,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x31,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x31,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x31,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x31,
+	}},
+	{as: AVPMOVZXBQ, ytab: _yvbroadcastss, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x32,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x32,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN2 | evexZeroingEnabled, 0x32,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x32,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x32,
+	}},
+	{as: AVPMOVZXBW, ytab: _yvcvtdq2pd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x30,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x30,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x30,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x30,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x30,
+	}},
+	{as: AVPMOVZXDQ, ytab: _yvcvtdq2pd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x35,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x35,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x35,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x35,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x35,
+	}},
+	{as: AVPMOVZXWD, ytab: _yvcvtdq2pd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x33,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x33,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x33,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x33,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x33,
+	}},
+	{as: AVPMOVZXWQ, ytab: _yvbroadcastss, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x34,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x34,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x34,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN8 | evexZeroingEnabled, 0x34,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x34,
+	}},
+	{as: AVPMULDQ, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x28,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x28,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x28,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x28,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x28,
+	}},
+	{as: AVPMULHRSW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x0B,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x0B,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x0B,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x0B,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexZeroingEnabled, 0x0B,
+	}},
+	{as: AVPMULHUW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xE4,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xE4,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xE4,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xE4,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xE4,
+	}},
+	{as: AVPMULHW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xE5,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xE5,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xE5,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xE5,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xE5,
+	}},
+	{as: AVPMULLD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x40,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x40,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x40,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x40,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x40,
+	}},
+	{as: AVPMULLQ, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x40,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x40,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x40,
+	}},
+	{as: AVPMULLW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xD5,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xD5,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xD5,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xD5,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xD5,
+	}},
+	{as: AVPMULTISHIFTQB, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x83,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x83,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x83,
+	}},
+	{as: AVPMULUDQ, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xF4,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xF4,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xF4,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xF4,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0xF4,
+	}},
+	{as: AVPOPCNTB, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x54,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x54,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexZeroingEnabled, 0x54,
+	}},
+	{as: AVPOPCNTD, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x55,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x55,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x55,
+	}},
+	{as: AVPOPCNTQ, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x55,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x55,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x55,
+	}},
+	{as: AVPOPCNTW, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexZeroingEnabled, 0x54,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexZeroingEnabled, 0x54,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexZeroingEnabled, 0x54,
+	}},
+	{as: AVPOR, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xEB,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xEB,
+	}},
+	{as: AVPORD, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xEB,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xEB,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0xEB,
+	}},
+	{as: AVPORQ, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xEB,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xEB,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0xEB,
+	}},
+	{as: AVPROLD, ytab: _yvprold, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x72, 01,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x72, 01,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x72, 01,
+	}},
+	{as: AVPROLQ, ytab: _yvprold, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x72, 01,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x72, 01,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x72, 01,
+	}},
+	{as: AVPROLVD, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x15,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x15,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x15,
+	}},
+	{as: AVPROLVQ, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x15,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x15,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x15,
+	}},
+	{as: AVPRORD, ytab: _yvprold, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x72, 00,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x72, 00,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x72, 00,
+	}},
+	{as: AVPRORQ, ytab: _yvprold, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x72, 00,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x72, 00,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x72, 00,
+	}},
+	{as: AVPRORVD, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x14,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x14,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x14,
+	}},
+	{as: AVPRORVQ, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x14,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x14,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x14,
+	}},
+	{as: AVPSADBW, ytab: _yvaesdec, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xF6,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xF6,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16, 0xF6,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32, 0xF6,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64, 0xF6,
+	}},
+	{as: AVPSCATTERDD, ytab: _yvpscatterdd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4, 0xA0,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN4, 0xA0,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4, 0xA0,
+	}},
+	{as: AVPSCATTERDQ, ytab: _yvpscatterdq, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8, 0xA0,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN8, 0xA0,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8, 0xA0,
+	}},
+	{as: AVPSCATTERQD, ytab: _yvpscatterqd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4, 0xA1,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN4, 0xA1,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4, 0xA1,
+	}},
+	{as: AVPSCATTERQQ, ytab: _yvpscatterdd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8, 0xA1,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN8, 0xA1,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8, 0xA1,
+	}},
+	{as: AVPSHLDD, ytab: _yvalignd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x71,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x71,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x71,
+	}},
+	{as: AVPSHLDQ, ytab: _yvalignd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x71,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x71,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x71,
+	}},
+	{as: AVPSHLDVD, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x71,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x71,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x71,
+	}},
+	{as: AVPSHLDVQ, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x71,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x71,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x71,
+	}},
+	{as: AVPSHLDVW, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexZeroingEnabled, 0x70,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexZeroingEnabled, 0x70,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexZeroingEnabled, 0x70,
+	}},
+	{as: AVPSHLDW, ytab: _yvalignd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexZeroingEnabled, 0x70,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexZeroingEnabled, 0x70,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexZeroingEnabled, 0x70,
+	}},
+	{as: AVPSHRDD, ytab: _yvalignd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x73,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x73,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x73,
+	}},
+	{as: AVPSHRDQ, ytab: _yvalignd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x73,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x73,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x73,
+	}},
+	{as: AVPSHRDVD, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x73,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x73,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x73,
+	}},
+	{as: AVPSHRDVQ, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x73,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x73,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x73,
+	}},
+	{as: AVPSHRDVW, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexZeroingEnabled, 0x72,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexZeroingEnabled, 0x72,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexZeroingEnabled, 0x72,
+	}},
+	{as: AVPSHRDW, ytab: _yvalignd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexZeroingEnabled, 0x72,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexZeroingEnabled, 0x72,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexZeroingEnabled, 0x72,
+	}},
+	{as: AVPSHUFB, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x00,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x00,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x00,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x00,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexZeroingEnabled, 0x00,
+	}},
+	{as: AVPSHUFBITQMB, ytab: _yvpshufbitqmb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16, 0x8F,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32, 0x8F,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64, 0x8F,
+	}},
+	{as: AVPSHUFD, ytab: _yvpshufd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x70,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x70,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x70,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x70,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x70,
+	}},
+	{as: AVPSHUFHW, ytab: _yvpshufd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x70,
+		avxEscape | vex256 | vexF3 | vex0F | vexW0, 0x70,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x70,
+		avxEscape | evex256 | evexF3 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x70,
+		avxEscape | evex512 | evexF3 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x70,
+	}},
+	{as: AVPSHUFLW, ytab: _yvpshufd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x70,
+		avxEscape | vex256 | vexF2 | vex0F | vexW0, 0x70,
+		avxEscape | evex128 | evexF2 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x70,
+		avxEscape | evex256 | evexF2 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x70,
+		avxEscape | evex512 | evexF2 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x70,
+	}},
+	{as: AVPSIGNB, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x08,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x08,
+	}},
+	{as: AVPSIGND, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x0A,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x0A,
+	}},
+	{as: AVPSIGNW, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x09,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x09,
+	}},
+	{as: AVPSLLD, ytab: _yvpslld, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x72, 06,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x72, 06,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xF2,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xF2,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x72, 06,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x72, 06,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x72, 06,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xF2,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xF2,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xF2,
+	}},
+	{as: AVPSLLDQ, ytab: _yvpslldq, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x73, 07,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x73, 07,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16, 0x73, 07,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32, 0x73, 07,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64, 0x73, 07,
+	}},
+	{as: AVPSLLQ, ytab: _yvpslld, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x73, 06,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x73, 06,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xF3,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xF3,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x73, 06,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x73, 06,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x73, 06,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0xF3,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0xF3,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0xF3,
+	}},
+	{as: AVPSLLVD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x47,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x47,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x47,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x47,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x47,
+	}},
+	{as: AVPSLLVQ, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x47,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0x47,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x47,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x47,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x47,
+	}},
+	{as: AVPSLLVW, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexZeroingEnabled, 0x12,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexZeroingEnabled, 0x12,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexZeroingEnabled, 0x12,
+	}},
+	{as: AVPSLLW, ytab: _yvpslld, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x71, 06,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x71, 06,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xF1,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xF1,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x71, 06,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x71, 06,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x71, 06,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xF1,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xF1,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xF1,
+	}},
+	{as: AVPSRAD, ytab: _yvpslld, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x72, 04,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x72, 04,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xE2,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xE2,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x72, 04,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x72, 04,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x72, 04,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xE2,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xE2,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xE2,
+	}},
+	{as: AVPSRAQ, ytab: _yvpsraq, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x72, 04,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x72, 04,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x72, 04,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0xE2,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0xE2,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0xE2,
+	}},
+	{as: AVPSRAVD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x46,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x46,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x46,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x46,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x46,
+	}},
+	{as: AVPSRAVQ, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x46,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x46,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x46,
+	}},
+	{as: AVPSRAVW, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexZeroingEnabled, 0x11,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexZeroingEnabled, 0x11,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexZeroingEnabled, 0x11,
+	}},
+	{as: AVPSRAW, ytab: _yvpslld, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x71, 04,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x71, 04,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xE1,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xE1,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x71, 04,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x71, 04,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x71, 04,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xE1,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xE1,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xE1,
+	}},
+	{as: AVPSRLD, ytab: _yvpslld, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x72, 02,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x72, 02,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xD2,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xD2,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x72, 02,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x72, 02,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x72, 02,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xD2,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xD2,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xD2,
+	}},
+	{as: AVPSRLDQ, ytab: _yvpslldq, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x73, 03,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x73, 03,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16, 0x73, 03,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32, 0x73, 03,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64, 0x73, 03,
+	}},
+	{as: AVPSRLQ, ytab: _yvpslld, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x73, 02,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x73, 02,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xD3,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xD3,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x73, 02,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x73, 02,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x73, 02,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0xD3,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0xD3,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN16 | evexZeroingEnabled, 0xD3,
+	}},
+	{as: AVPSRLVD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x45,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x45,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x45,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x45,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x45,
+	}},
+	{as: AVPSRLVQ, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW1, 0x45,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW1, 0x45,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x45,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x45,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x45,
+	}},
+	{as: AVPSRLVW, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexZeroingEnabled, 0x10,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexZeroingEnabled, 0x10,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexZeroingEnabled, 0x10,
+	}},
+	{as: AVPSRLW, ytab: _yvpslld, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x71, 02,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x71, 02,
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xD1,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xD1,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x71, 02,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x71, 02,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x71, 02,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xD1,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xD1,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xD1,
+	}},
+	{as: AVPSUBB, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xF8,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xF8,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xF8,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xF8,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xF8,
+	}},
+	{as: AVPSUBD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xFA,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xFA,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xFA,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xFA,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0xFA,
+	}},
+	{as: AVPSUBQ, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xFB,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xFB,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xFB,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xFB,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0xFB,
+	}},
+	{as: AVPSUBSB, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xE8,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xE8,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xE8,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xE8,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xE8,
+	}},
+	{as: AVPSUBSW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xE9,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xE9,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xE9,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xE9,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xE9,
+	}},
+	{as: AVPSUBUSB, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xD8,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xD8,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xD8,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xD8,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xD8,
+	}},
+	{as: AVPSUBUSW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xD9,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xD9,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xD9,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xD9,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xD9,
+	}},
+	{as: AVPSUBW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xF9,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xF9,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0xF9,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0xF9,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0xF9,
+	}},
+	{as: AVPTERNLOGD, ytab: _yvalignd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x25,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x25,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x25,
+	}},
+	{as: AVPTERNLOGQ, ytab: _yvalignd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x25,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x25,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x25,
+	}},
+	{as: AVPTEST, ytab: _yvptest, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x17,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x17,
+	}},
+	{as: AVPTESTMB, ytab: _yvpshufbitqmb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16, 0x26,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32, 0x26,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64, 0x26,
+	}},
+	{as: AVPTESTMD, ytab: _yvpshufbitqmb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4, 0x27,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4, 0x27,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4, 0x27,
+	}},
+	{as: AVPTESTMQ, ytab: _yvpshufbitqmb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8, 0x27,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8, 0x27,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8, 0x27,
+	}},
+	{as: AVPTESTMW, ytab: _yvpshufbitqmb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16, 0x26,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32, 0x26,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64, 0x26,
+	}},
+	{as: AVPTESTNMB, ytab: _yvpshufbitqmb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN16, 0x26,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN32, 0x26,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN64, 0x26,
+	}},
+	{as: AVPTESTNMD, ytab: _yvpshufbitqmb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW0, evexN16 | evexBcstN4, 0x27,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW0, evexN32 | evexBcstN4, 0x27,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW0, evexN64 | evexBcstN4, 0x27,
+	}},
+	{as: AVPTESTNMQ, ytab: _yvpshufbitqmb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW1, evexN16 | evexBcstN8, 0x27,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW1, evexN32 | evexBcstN8, 0x27,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW1, evexN64 | evexBcstN8, 0x27,
+	}},
+	{as: AVPTESTNMW, ytab: _yvpshufbitqmb, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evexF3 | evex0F38 | evexW1, evexN16, 0x26,
+		avxEscape | evex256 | evexF3 | evex0F38 | evexW1, evexN32, 0x26,
+		avxEscape | evex512 | evexF3 | evex0F38 | evexW1, evexN64, 0x26,
+	}},
+	{as: AVPUNPCKHBW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x68,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x68,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x68,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x68,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x68,
+	}},
+	{as: AVPUNPCKHDQ, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x6A,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x6A,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x6A,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x6A,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x6A,
+	}},
+	{as: AVPUNPCKHQDQ, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x6D,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x6D,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x6D,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x6D,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x6D,
+	}},
+	{as: AVPUNPCKHWD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x69,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x69,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x69,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x69,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x69,
+	}},
+	{as: AVPUNPCKLBW, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x60,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x60,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x60,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x60,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x60,
+	}},
+	{as: AVPUNPCKLDQ, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x62,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x62,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x62,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x62,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x62,
+	}},
+	{as: AVPUNPCKLQDQ, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x6C,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x6C,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x6C,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x6C,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x6C,
+	}},
+	{as: AVPUNPCKLWD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x61,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x61,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x61,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x61,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x61,
+	}},
+	{as: AVPXOR, ytab: _yvaddsubpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xEF,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xEF,
+	}},
+	{as: AVPXORD, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xEF,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xEF,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0xEF,
+	}},
+	{as: AVPXORQ, ytab: _yvblendmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xEF,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xEF,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0xEF,
+	}},
+	{as: AVRANGEPD, ytab: _yvfixupimmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexSaeEnabled | evexZeroingEnabled, 0x50,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x50,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x50,
+	}},
+	{as: AVRANGEPS, ytab: _yvfixupimmpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64 | evexBcstN4 | evexSaeEnabled | evexZeroingEnabled, 0x50,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x50,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x50,
+	}},
+	{as: AVRANGESD, ytab: _yvfixupimmsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN8 | evexSaeEnabled | evexZeroingEnabled, 0x51,
+	}},
+	{as: AVRANGESS, ytab: _yvfixupimmsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN4 | evexSaeEnabled | evexZeroingEnabled, 0x51,
+	}},
+	{as: AVRCP14PD, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x4C,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x4C,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x4C,
+	}},
+	{as: AVRCP14PS, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x4C,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x4C,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x4C,
+	}},
+	{as: AVRCP14SD, ytab: _yvgetexpsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x4D,
+	}},
+	{as: AVRCP14SS, ytab: _yvgetexpsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x4D,
+	}},
+	{as: AVRCP28PD, ytab: _yvexp2pd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexSaeEnabled | evexZeroingEnabled, 0xCA,
+	}},
+	{as: AVRCP28PS, ytab: _yvexp2pd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexSaeEnabled | evexZeroingEnabled, 0xCA,
+	}},
+	{as: AVRCP28SD, ytab: _yvgetexpsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexSaeEnabled | evexZeroingEnabled, 0xCB,
+	}},
+	{as: AVRCP28SS, ytab: _yvgetexpsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexSaeEnabled | evexZeroingEnabled, 0xCB,
+	}},
+	{as: AVRCPPS, ytab: _yvptest, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x53,
+		avxEscape | vex256 | vex0F | vexW0, 0x53,
+	}},
+	{as: AVRCPSS, ytab: _yvrcpss, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x53,
+	}},
+	{as: AVREDUCEPD, ytab: _yvgetmantpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexSaeEnabled | evexZeroingEnabled, 0x56,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x56,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x56,
+	}},
+	{as: AVREDUCEPS, ytab: _yvgetmantpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64 | evexBcstN4 | evexSaeEnabled | evexZeroingEnabled, 0x56,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x56,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x56,
+	}},
+	{as: AVREDUCESD, ytab: _yvfixupimmsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN8 | evexSaeEnabled | evexZeroingEnabled, 0x57,
+	}},
+	{as: AVREDUCESS, ytab: _yvfixupimmsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN4 | evexSaeEnabled | evexZeroingEnabled, 0x57,
+	}},
+	{as: AVRNDSCALEPD, ytab: _yvgetmantpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexSaeEnabled | evexZeroingEnabled, 0x09,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x09,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x09,
+	}},
+	{as: AVRNDSCALEPS, ytab: _yvgetmantpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64 | evexBcstN4 | evexSaeEnabled | evexZeroingEnabled, 0x08,
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x08,
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x08,
+	}},
+	{as: AVRNDSCALESD, ytab: _yvfixupimmsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW1, evexN8 | evexSaeEnabled | evexZeroingEnabled, 0x0B,
+	}},
+	{as: AVRNDSCALESS, ytab: _yvfixupimmsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F3A | evexW0, evexN4 | evexSaeEnabled | evexZeroingEnabled, 0x0A,
+	}},
+	{as: AVROUNDPD, ytab: _yvroundpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x09,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x09,
+	}},
+	{as: AVROUNDPS, ytab: _yvroundpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x08,
+		avxEscape | vex256 | vex66 | vex0F3A | vexW0, 0x08,
+	}},
+	{as: AVROUNDSD, ytab: _yvdppd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x0B,
+	}},
+	{as: AVROUNDSS, ytab: _yvdppd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F3A | vexW0, 0x0A,
+	}},
+	{as: AVRSQRT14PD, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x4E,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x4E,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x4E,
+	}},
+	{as: AVRSQRT14PS, ytab: _yvexpandpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x4E,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x4E,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x4E,
+	}},
+	{as: AVRSQRT14SD, ytab: _yvgetexpsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexZeroingEnabled, 0x4F,
+	}},
+	{as: AVRSQRT14SS, ytab: _yvgetexpsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexZeroingEnabled, 0x4F,
+	}},
+	{as: AVRSQRT28PD, ytab: _yvexp2pd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexSaeEnabled | evexZeroingEnabled, 0xCC,
+	}},
+	{as: AVRSQRT28PS, ytab: _yvexp2pd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexSaeEnabled | evexZeroingEnabled, 0xCC,
+	}},
+	{as: AVRSQRT28SD, ytab: _yvgetexpsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexSaeEnabled | evexZeroingEnabled, 0xCD,
+	}},
+	{as: AVRSQRT28SS, ytab: _yvgetexpsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexSaeEnabled | evexZeroingEnabled, 0xCD,
+	}},
+	{as: AVRSQRTPS, ytab: _yvptest, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x52,
+		avxEscape | vex256 | vex0F | vexW0, 0x52,
+	}},
+	{as: AVRSQRTSS, ytab: _yvrcpss, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x52,
+	}},
+	{as: AVSCALEFPD, ytab: _yvscalefpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x2C,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x2C,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x2C,
+	}},
+	{as: AVSCALEFPS, ytab: _yvscalefpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x2C,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x2C,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x2C,
+	}},
+	{as: AVSCALEFSD, ytab: _yvgetexpsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0x2D,
+	}},
+	{as: AVSCALEFSS, ytab: _yvgetexpsd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0x2D,
+	}},
+	{as: AVSCATTERDPD, ytab: _yvpscatterdq, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8, 0xA2,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN8, 0xA2,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8, 0xA2,
+	}},
+	{as: AVSCATTERDPS, ytab: _yvpscatterdd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4, 0xA2,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN4, 0xA2,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4, 0xA2,
+	}},
+	{as: AVSCATTERPF0DPD, ytab: _yvgatherpf0dpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8, 0xC6, 05,
+	}},
+	{as: AVSCATTERPF0DPS, ytab: _yvgatherpf0dps, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4, 0xC6, 05,
+	}},
+	{as: AVSCATTERPF0QPD, ytab: _yvgatherpf0dps, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8, 0xC7, 05,
+	}},
+	{as: AVSCATTERPF0QPS, ytab: _yvgatherpf0dps, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4, 0xC7, 05,
+	}},
+	{as: AVSCATTERPF1DPD, ytab: _yvgatherpf0dpd, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8, 0xC6, 06,
+	}},
+	{as: AVSCATTERPF1DPS, ytab: _yvgatherpf0dps, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4, 0xC6, 06,
+	}},
+	{as: AVSCATTERPF1QPD, ytab: _yvgatherpf0dps, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8, 0xC7, 06,
+	}},
+	{as: AVSCATTERPF1QPS, ytab: _yvgatherpf0dps, prefix: Pavx, op: opBytes{
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4, 0xC7, 06,
+	}},
+	{as: AVSCATTERQPD, ytab: _yvpscatterdd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW1, evexN8, 0xA3,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW1, evexN8, 0xA3,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW1, evexN8, 0xA3,
+	}},
+	{as: AVSCATTERQPS, ytab: _yvpscatterqd, prefix: Pavx, op: opBytes{
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN4, 0xA3,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN4, 0xA3,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN4, 0xA3,
+	}},
+	{as: AVSHUFF32X4, ytab: _yvshuff32x4, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x23,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x23,
+	}},
+	{as: AVSHUFF64X2, ytab: _yvshuff32x4, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x23,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x23,
+	}},
+	{as: AVSHUFI32X4, ytab: _yvshuff32x4, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F3A | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x43,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x43,
+	}},
+	{as: AVSHUFI64X2, ytab: _yvshuff32x4, prefix: Pavx, op: opBytes{
+		avxEscape | evex256 | evex66 | evex0F3A | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x43,
+		avxEscape | evex512 | evex66 | evex0F3A | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x43,
+	}},
+	{as: AVSHUFPD, ytab: _yvgf2p8affineinvqb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xC6,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0xC6,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0xC6,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0xC6,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0xC6,
+	}},
+	{as: AVSHUFPS, ytab: _yvgf2p8affineinvqb, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0xC6,
+		avxEscape | vex256 | vex0F | vexW0, 0xC6,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xC6,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xC6,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0xC6,
+	}},
+	{as: AVSQRTPD, ytab: _yvcvtdq2ps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x51,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x51,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x51,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x51,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x51,
+	}},
+	{as: AVSQRTPS, ytab: _yvcvtdq2ps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x51,
+		avxEscape | vex256 | vex0F | vexW0, 0x51,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x51,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x51,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x51,
+	}},
+	{as: AVSQRTSD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x51,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0x51,
+	}},
+	{as: AVSQRTSS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x51,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0x51,
+	}},
+	{as: AVSTMXCSR, ytab: _yvldmxcsr, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0xAE, 03,
+	}},
+	{as: AVSUBPD, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x5C,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x5C,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled, 0x5C,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x5C,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x5C,
+	}},
+	{as: AVSUBPS, ytab: _yvaddpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x5C,
+		avxEscape | vex256 | vex0F | vexW0, 0x5C,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x5C,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x5C,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x5C,
+	}},
+	{as: AVSUBSD, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF2 | vex0F | vexW0, 0x5C,
+		avxEscape | evex128 | evexF2 | evex0F | evexW1, evexN8 | evexRoundingEnabled | evexZeroingEnabled, 0x5C,
+	}},
+	{as: AVSUBSS, ytab: _yvaddsd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0x5C,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN4 | evexRoundingEnabled | evexZeroingEnabled, 0x5C,
+	}},
+	{as: AVTESTPD, ytab: _yvptest, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x0F,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x0F,
+	}},
+	{as: AVTESTPS, ytab: _yvptest, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x0E,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x0E,
+	}},
+	{as: AVUCOMISD, ytab: _yvcomisd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x2E,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN8 | evexSaeEnabled, 0x2E,
+	}},
+	{as: AVUCOMISS, ytab: _yvcomisd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x2E,
+		avxEscape | evex128 | evex0F | evexW0, evexN4 | evexSaeEnabled, 0x2E,
+	}},
+	{as: AVUNPCKHPD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x15,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x15,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x15,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x15,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x15,
+	}},
+	{as: AVUNPCKHPS, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x15,
+		avxEscape | vex256 | vex0F | vexW0, 0x15,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x15,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x15,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x15,
+	}},
+	{as: AVUNPCKLPD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x14,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x14,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x14,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x14,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x14,
+	}},
+	{as: AVUNPCKLPS, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x14,
+		avxEscape | vex256 | vex0F | vexW0, 0x14,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x14,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x14,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x14,
+	}},
+	{as: AVXORPD, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x57,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x57,
+		avxEscape | evex128 | evex66 | evex0F | evexW1, evexN16 | evexBcstN8 | evexZeroingEnabled, 0x57,
+		avxEscape | evex256 | evex66 | evex0F | evexW1, evexN32 | evexBcstN8 | evexZeroingEnabled, 0x57,
+		avxEscape | evex512 | evex66 | evex0F | evexW1, evexN64 | evexBcstN8 | evexZeroingEnabled, 0x57,
+	}},
+	{as: AVXORPS, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x57,
+		avxEscape | vex256 | vex0F | vexW0, 0x57,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x57,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x57,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexZeroingEnabled, 0x57,
+	}},
+	{as: AVZEROALL, ytab: _yvzeroall, prefix: Pavx, op: opBytes{
+		avxEscape | vex256 | vex0F | vexW0, 0x77,
+	}},
+	{as: AVZEROUPPER, ytab: _yvzeroall, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x77,
+	}},
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/evex.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/evex.go
new file mode 100644
index 000000000..47932684d
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/evex.go
@@ -0,0 +1,382 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package x86
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"errors"
+	"fmt"
+	"strings"
+)
+
+// evexBits stores EVEX prefix info that is used during instruction encoding.
+type evexBits struct {
+	b1 byte // [W1mmLLpp]
+	b2 byte // [NNNbbZRS]
+
+	// Associated instruction opcode.
+	opcode byte
+}
+
+// newEVEXBits creates evexBits object from enc bytes at z position.
+func newEVEXBits(z int, enc *opBytes) evexBits {
+	return evexBits{
+		b1:     enc[z+0],
+		b2:     enc[z+1],
+		opcode: enc[z+2],
+	}
+}
+
+// P returns EVEX.pp value.
+func (evex evexBits) P() byte { return (evex.b1 & evexP) >> 0 }
+
+// L returns EVEX.L'L value.
+func (evex evexBits) L() byte { return (evex.b1 & evexL) >> 2 }
+
+// M returns EVEX.mm value.
+func (evex evexBits) M() byte { return (evex.b1 & evexM) >> 4 }
+
+// W returns EVEX.W value.
+func (evex evexBits) W() byte { return (evex.b1 & evexW) >> 7 }
+
+// BroadcastEnabled reports whether BCST suffix is permitted.
+func (evex evexBits) BroadcastEnabled() bool {
+	return evex.b2&evexBcst != 0
+}
+
+// ZeroingEnabled reports whether Z suffix is permitted.
+func (evex evexBits) ZeroingEnabled() bool {
+	return (evex.b2&evexZeroing)>>2 != 0
+}
+
+// RoundingEnabled reports whether RN_SAE, RZ_SAE, RD_SAE and RU_SAE suffixes
+// are permitted.
+func (evex evexBits) RoundingEnabled() bool {
+	return (evex.b2&evexRounding)>>1 != 0
+}
+
+// SaeEnabled reports whether SAE suffix is permitted.
+func (evex evexBits) SaeEnabled() bool {
+	return (evex.b2&evexSae)>>0 != 0
+}
+
+// DispMultiplier returns displacement multiplier that is calculated
+// based on tuple type, EVEX.W and input size.
+// If embedded broadcast is used, bcst should be true.
+func (evex evexBits) DispMultiplier(bcst bool) int32 {
+	if bcst {
+		switch evex.b2 & evexBcst {
+		case evexBcstN4:
+			return 4
+		case evexBcstN8:
+			return 8
+		}
+		return 1
+	}
+
+	switch evex.b2 & evexN {
+	case evexN1:
+		return 1
+	case evexN2:
+		return 2
+	case evexN4:
+		return 4
+	case evexN8:
+		return 8
+	case evexN16:
+		return 16
+	case evexN32:
+		return 32
+	case evexN64:
+		return 64
+	case evexN128:
+		return 128
+	}
+	return 1
+}
+
+// EVEX is described by using 2-byte sequence.
+// See evexBits for more details.
+const (
+	evexW   = 0x80 // b1[W... ....]
+	evexWIG = 0 << 7
+	evexW0  = 0 << 7
+	evexW1  = 1 << 7
+
+	evexM    = 0x30 // b2[..mm ...]
+	evex0F   = 1 << 4
+	evex0F38 = 2 << 4
+	evex0F3A = 3 << 4
+
+	evexL   = 0x0C // b1[.... LL..]
+	evexLIG = 0 << 2
+	evex128 = 0 << 2
+	evex256 = 1 << 2
+	evex512 = 2 << 2
+
+	evexP  = 0x03 // b1[.... ..pp]
+	evex66 = 1 << 0
+	evexF3 = 2 << 0
+	evexF2 = 3 << 0
+
+	// Precalculated Disp8 N value.
+	// N acts like a multiplier for 8bit displacement.
+	// Note that some N are not used, but their bits are reserved.
+	evexN    = 0xE0 // b2[NNN. ....]
+	evexN1   = 0 << 5
+	evexN2   = 1 << 5
+	evexN4   = 2 << 5
+	evexN8   = 3 << 5
+	evexN16  = 4 << 5
+	evexN32  = 5 << 5
+	evexN64  = 6 << 5
+	evexN128 = 7 << 5
+
+	// Disp8 for broadcasts.
+	evexBcst   = 0x18 // b2[...b b...]
+	evexBcstN4 = 1 << 3
+	evexBcstN8 = 2 << 3
+
+	// Flags that permit certain AVX512 features.
+	// It's semantically illegal to combine evexZeroing and evexSae.
+	evexZeroing         = 0x4 // b2[.... .Z..]
+	evexZeroingEnabled  = 1 << 2
+	evexRounding        = 0x2 // b2[.... ..R.]
+	evexRoundingEnabled = 1 << 1
+	evexSae             = 0x1 // b2[.... ...S]
+	evexSaeEnabled      = 1 << 0
+)
+
+// compressedDisp8 calculates EVEX compressed displacement, if applicable.
+func compressedDisp8(disp, elemSize int32) (disp8 byte, ok bool) {
+	if disp%elemSize == 0 {
+		v := disp / elemSize
+		if v >= -128 && v <= 127 {
+			return byte(v), true
+		}
+	}
+	return 0, false
+}
+
+// evexZcase reports whether given Z-case belongs to EVEX group.
+func evexZcase(zcase uint8) bool {
+	return zcase > Zevex_first && zcase < Zevex_last
+}
+
+// evexSuffixBits carries instruction EVEX suffix set flags.
+//
+// Examples:
+//	"RU_SAE.Z" => {rounding: 3, zeroing: true}
+//	"Z" => {zeroing: true}
+//	"BCST" => {broadcast: true}
+//	"SAE.Z" => {sae: true, zeroing: true}
+type evexSuffix struct {
+	rounding  byte
+	sae       bool
+	zeroing   bool
+	broadcast bool
+}
+
+// Rounding control values.
+// Match exact value for EVEX.L'L field (with exception of rcUnset).
+const (
+	rcRNSAE = 0 // Round towards nearest
+	rcRDSAE = 1 // Round towards -Inf
+	rcRUSAE = 2 // Round towards +Inf
+	rcRZSAE = 3 // Round towards zero
+	rcUnset = 4
+)
+
+// newEVEXSuffix returns proper zero value for evexSuffix.
+func newEVEXSuffix() evexSuffix {
+	return evexSuffix{rounding: rcUnset}
+}
+
+// evexSuffixMap maps obj.X86suffix to its decoded version.
+// Filled during init().
+var evexSuffixMap [255]evexSuffix
+
+func init() {
+	// Decode all valid suffixes for later use.
+	for i := range opSuffixTable {
+		suffix := newEVEXSuffix()
+		parts := strings.Split(opSuffixTable[i], ".")
+		for j := range parts {
+			switch parts[j] {
+			case "Z":
+				suffix.zeroing = true
+			case "BCST":
+				suffix.broadcast = true
+			case "SAE":
+				suffix.sae = true
+
+			case "RN_SAE":
+				suffix.rounding = rcRNSAE
+			case "RD_SAE":
+				suffix.rounding = rcRDSAE
+			case "RU_SAE":
+				suffix.rounding = rcRUSAE
+			case "RZ_SAE":
+				suffix.rounding = rcRZSAE
+			}
+		}
+		evexSuffixMap[i] = suffix
+	}
+}
+
+// toDisp8 tries to convert disp to proper 8-bit displacement value.
+func toDisp8(disp int32, p *obj.Prog, asmbuf *AsmBuf) (disp8 byte, ok bool) {
+	if asmbuf.evexflag {
+		bcst := evexSuffixMap[p.Scond].broadcast
+		elemSize := asmbuf.evex.DispMultiplier(bcst)
+		return compressedDisp8(disp, elemSize)
+	}
+	return byte(disp), disp >= -128 && disp < 128
+}
+
+// EncodeRegisterRange packs [reg0-reg1] list into 64-bit value that
+// is intended to be stored inside obj.Addr.Offset with TYPE_REGLIST.
+func EncodeRegisterRange(reg0, reg1 int16) int64 {
+	return (int64(reg0) << 0) |
+		(int64(reg1) << 16) |
+		obj.RegListX86Lo
+}
+
+// decodeRegisterRange unpacks [reg0-reg1] list from 64-bit value created by EncodeRegisterRange.
+func decodeRegisterRange(list int64) (reg0, reg1 int) {
+	return int((list >> 0) & 0xFFFF),
+		int((list >> 16) & 0xFFFF)
+}
+
+// ParseSuffix handles the special suffix for the 386/AMD64.
+// Suffix bits are stored into p.Scond.
+//
+// Leading "." in cond is ignored.
+func ParseSuffix(p *obj.Prog, cond string) error {
+	cond = strings.TrimPrefix(cond, ".")
+
+	suffix := newOpSuffix(cond)
+	if !suffix.IsValid() {
+		return inferSuffixError(cond)
+	}
+
+	p.Scond = uint8(suffix)
+	return nil
+}
+
+// inferSuffixError returns non-nil error that describes what could be
+// the cause of suffix parse failure.
+//
+// At the point this function is executed there is already assembly error,
+// so we can burn some clocks to construct good error message.
+//
+// Reported issues:
+//	- duplicated suffixes
+//	- illegal rounding/SAE+broadcast combinations
+//	- unknown suffixes
+//	- misplaced suffix (e.g. wrong Z suffix position)
+func inferSuffixError(cond string) error {
+	suffixSet := make(map[string]bool)  // Set for duplicates detection.
+	unknownSet := make(map[string]bool) // Set of unknown suffixes.
+	hasBcst := false
+	hasRoundSae := false
+	var msg []string // Error message parts
+
+	suffixes := strings.Split(cond, ".")
+	for i, suffix := range suffixes {
+		switch suffix {
+		case "Z":
+			if i != len(suffixes)-1 {
+				msg = append(msg, "Z suffix should be the last")
+			}
+		case "BCST":
+			hasBcst = true
+		case "SAE", "RN_SAE", "RZ_SAE", "RD_SAE", "RU_SAE":
+			hasRoundSae = true
+		default:
+			if !unknownSet[suffix] {
+				msg = append(msg, fmt.Sprintf("unknown suffix %q", suffix))
+			}
+			unknownSet[suffix] = true
+		}
+
+		if suffixSet[suffix] {
+			msg = append(msg, fmt.Sprintf("duplicate suffix %q", suffix))
+		}
+		suffixSet[suffix] = true
+	}
+
+	if hasBcst && hasRoundSae {
+		msg = append(msg, "can't combine rounding/SAE and broadcast")
+	}
+
+	if len(msg) == 0 {
+		return errors.New("bad suffix combination")
+	}
+	return errors.New(strings.Join(msg, "; "))
+}
+
+// opSuffixTable is a complete list of possible opcode suffix combinations.
+// It "maps" uint8 suffix bits to their string representation.
+// With the exception of first and last elements, order is not important.
+var opSuffixTable = [...]string{
+	"", // Map empty suffix to empty string.
+
+	"Z",
+
+	"SAE",
+	"SAE.Z",
+
+	"RN_SAE",
+	"RZ_SAE",
+	"RD_SAE",
+	"RU_SAE",
+	"RN_SAE.Z",
+	"RZ_SAE.Z",
+	"RD_SAE.Z",
+	"RU_SAE.Z",
+
+	"BCST",
+	"BCST.Z",
+
+	"<bad suffix>",
+}
+
+// opSuffix represents instruction opcode suffix.
+// Compound (multi-part) suffixes expressed with single opSuffix value.
+//
+// uint8 type is used to fit obj.Prog.Scond.
+type opSuffix uint8
+
+// badOpSuffix is used to represent all invalid suffix combinations.
+const badOpSuffix = opSuffix(len(opSuffixTable) - 1)
+
+// newOpSuffix returns opSuffix object that matches suffixes string.
+//
+// If no matching suffix is found, special "invalid" suffix is returned.
+// Use IsValid method to check against this case.
+func newOpSuffix(suffixes string) opSuffix {
+	for i := range opSuffixTable {
+		if opSuffixTable[i] == suffixes {
+			return opSuffix(i)
+		}
+	}
+	return badOpSuffix
+}
+
+// IsValid reports whether suffix is valid.
+// Empty suffixes are valid.
+func (suffix opSuffix) IsValid() bool {
+	return suffix != badOpSuffix
+}
+
+// String returns suffix printed representation.
+//
+// It matches the string that was used to create suffix with NewX86Suffix()
+// for valid suffixes.
+// For all invalid suffixes, special marker is returned.
+func (suffix opSuffix) String() string {
+	return opSuffixTable[suffix]
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/list6.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/list6.go
new file mode 100644
index 000000000..3da155fd4
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/list6.go
@@ -0,0 +1,264 @@
+// Inferno utils/6c/list.c
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6c/list.c
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package x86
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"fmt"
+)
+
+var Register = []string{
+	"AL", // [D_AL]
+	"CL",
+	"DL",
+	"BL",
+	"SPB",
+	"BPB",
+	"SIB",
+	"DIB",
+	"R8B",
+	"R9B",
+	"R10B",
+	"R11B",
+	"R12B",
+	"R13B",
+	"R14B",
+	"R15B",
+	"AX", // [D_AX]
+	"CX",
+	"DX",
+	"BX",
+	"SP",
+	"BP",
+	"SI",
+	"DI",
+	"R8",
+	"R9",
+	"R10",
+	"R11",
+	"R12",
+	"R13",
+	"R14",
+	"R15",
+	"AH",
+	"CH",
+	"DH",
+	"BH",
+	"F0", // [D_F0]
+	"F1",
+	"F2",
+	"F3",
+	"F4",
+	"F5",
+	"F6",
+	"F7",
+	"M0",
+	"M1",
+	"M2",
+	"M3",
+	"M4",
+	"M5",
+	"M6",
+	"M7",
+	"K0",
+	"K1",
+	"K2",
+	"K3",
+	"K4",
+	"K5",
+	"K6",
+	"K7",
+	"X0",
+	"X1",
+	"X2",
+	"X3",
+	"X4",
+	"X5",
+	"X6",
+	"X7",
+	"X8",
+	"X9",
+	"X10",
+	"X11",
+	"X12",
+	"X13",
+	"X14",
+	"X15",
+	"X16",
+	"X17",
+	"X18",
+	"X19",
+	"X20",
+	"X21",
+	"X22",
+	"X23",
+	"X24",
+	"X25",
+	"X26",
+	"X27",
+	"X28",
+	"X29",
+	"X30",
+	"X31",
+	"Y0",
+	"Y1",
+	"Y2",
+	"Y3",
+	"Y4",
+	"Y5",
+	"Y6",
+	"Y7",
+	"Y8",
+	"Y9",
+	"Y10",
+	"Y11",
+	"Y12",
+	"Y13",
+	"Y14",
+	"Y15",
+	"Y16",
+	"Y17",
+	"Y18",
+	"Y19",
+	"Y20",
+	"Y21",
+	"Y22",
+	"Y23",
+	"Y24",
+	"Y25",
+	"Y26",
+	"Y27",
+	"Y28",
+	"Y29",
+	"Y30",
+	"Y31",
+	"Z0",
+	"Z1",
+	"Z2",
+	"Z3",
+	"Z4",
+	"Z5",
+	"Z6",
+	"Z7",
+	"Z8",
+	"Z9",
+	"Z10",
+	"Z11",
+	"Z12",
+	"Z13",
+	"Z14",
+	"Z15",
+	"Z16",
+	"Z17",
+	"Z18",
+	"Z19",
+	"Z20",
+	"Z21",
+	"Z22",
+	"Z23",
+	"Z24",
+	"Z25",
+	"Z26",
+	"Z27",
+	"Z28",
+	"Z29",
+	"Z30",
+	"Z31",
+	"CS", // [D_CS]
+	"SS",
+	"DS",
+	"ES",
+	"FS",
+	"GS",
+	"GDTR", // [D_GDTR]
+	"IDTR", // [D_IDTR]
+	"LDTR", // [D_LDTR]
+	"MSW",  // [D_MSW]
+	"TASK", // [D_TASK]
+	"CR0",  // [D_CR]
+	"CR1",
+	"CR2",
+	"CR3",
+	"CR4",
+	"CR5",
+	"CR6",
+	"CR7",
+	"CR8",
+	"CR9",
+	"CR10",
+	"CR11",
+	"CR12",
+	"CR13",
+	"CR14",
+	"CR15",
+	"DR0", // [D_DR]
+	"DR1",
+	"DR2",
+	"DR3",
+	"DR4",
+	"DR5",
+	"DR6",
+	"DR7",
+	"TR0", // [D_TR]
+	"TR1",
+	"TR2",
+	"TR3",
+	"TR4",
+	"TR5",
+	"TR6",
+	"TR7",
+	"TLS",    // [D_TLS]
+	"MAXREG", // [MAXREG]
+}
+
+func init() {
+	obj.RegisterRegister(REG_AL, REG_AL+len(Register), rconv)
+	obj.RegisterOpcode(obj.ABaseAMD64, Anames)
+	obj.RegisterRegisterList(obj.RegListX86Lo, obj.RegListX86Hi, rlconv)
+	obj.RegisterOpSuffix("386", opSuffixString)
+	obj.RegisterOpSuffix("amd64", opSuffixString)
+}
+
+func rconv(r int) string {
+	if REG_AL <= r && r-REG_AL < len(Register) {
+		return Register[r-REG_AL]
+	}
+	return fmt.Sprintf("Rgok(%d)", r-obj.RBaseAMD64)
+}
+
+func rlconv(bits int64) string {
+	reg0, reg1 := decodeRegisterRange(bits)
+	return fmt.Sprintf("[%s-%s]", rconv(reg0), rconv(reg1))
+}
+
+func opSuffixString(s uint8) string {
+	return "." + opSuffix(s).String()
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/obj6.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/obj6.go
new file mode 100644
index 000000000..59c556421
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/obj6.go
@@ -0,0 +1,1261 @@
+// Inferno utils/6l/pass.c
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/pass.c
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package x86
+
+import (
+	"github.com/twitchyliquid64/golang-asm/obj"
+	"github.com/twitchyliquid64/golang-asm/objabi"
+	"github.com/twitchyliquid64/golang-asm/src"
+	"github.com/twitchyliquid64/golang-asm/sys"
+	"math"
+	"strings"
+)
+
+func CanUse1InsnTLS(ctxt *obj.Link) bool {
+	if isAndroid {
+		// Android uses a global variable for the tls offset.
+		return false
+	}
+
+	if ctxt.Arch.Family == sys.I386 {
+		switch ctxt.Headtype {
+		case objabi.Hlinux,
+			objabi.Hplan9,
+			objabi.Hwindows:
+			return false
+		}
+
+		return true
+	}
+
+	switch ctxt.Headtype {
+	case objabi.Hplan9, objabi.Hwindows:
+		return false
+	case objabi.Hlinux, objabi.Hfreebsd:
+		return !ctxt.Flag_shared
+	}
+
+	return true
+}
+
+func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
+	// Thread-local storage references use the TLS pseudo-register.
+	// As a register, TLS refers to the thread-local storage base, and it
+	// can only be loaded into another register:
+	//
+	//         MOVQ TLS, AX
+	//
+	// An offset from the thread-local storage base is written off(reg)(TLS*1).
+	// Semantically it is off(reg), but the (TLS*1) annotation marks this as
+	// indexing from the loaded TLS base. This emits a relocation so that
+	// if the linker needs to adjust the offset, it can. For example:
+	//
+	//         MOVQ TLS, AX
+	//         MOVQ 0(AX)(TLS*1), CX // load g into CX
+	//
+	// On systems that support direct access to the TLS memory, this
+	// pair of instructions can be reduced to a direct TLS memory reference:
+	//
+	//         MOVQ 0(TLS), CX // load g into CX
+	//
+	// The 2-instruction and 1-instruction forms correspond to the two code
+	// sequences for loading a TLS variable in the local exec model given in "ELF
+	// Handling For Thread-Local Storage".
+	//
+	// We apply this rewrite on systems that support the 1-instruction form.
+	// The decision is made using only the operating system and the -shared flag,
+	// not the link mode. If some link modes on a particular operating system
+	// require the 2-instruction form, then all builds for that operating system
+	// will use the 2-instruction form, so that the link mode decision can be
+	// delayed to link time.
+	//
+	// In this way, all supported systems use identical instructions to
+	// access TLS, and they are rewritten appropriately first here in
+	// liblink and then finally using relocations in the linker.
+	//
+	// When -shared is passed, we leave the code in the 2-instruction form but
+	// assemble (and relocate) them in different ways to generate the initial
+	// exec code sequence. It's a bit of a fluke that this is possible without
+	// rewriting the instructions more comprehensively, and it only does because
+	// we only support a single TLS variable (g).
+
+	if CanUse1InsnTLS(ctxt) {
+		// Reduce 2-instruction sequence to 1-instruction sequence.
+		// Sequences like
+		//	MOVQ TLS, BX
+		//	... off(BX)(TLS*1) ...
+		// become
+		//	NOP
+		//	... off(TLS) ...
+		//
+		// TODO(rsc): Remove the Hsolaris special case. It exists only to
+		// guarantee we are producing byte-identical binaries as before this code.
+		// But it should be unnecessary.
+		if (p.As == AMOVQ || p.As == AMOVL) && p.From.Type == obj.TYPE_REG && p.From.Reg == REG_TLS && p.To.Type == obj.TYPE_REG && REG_AX <= p.To.Reg && p.To.Reg <= REG_R15 && ctxt.Headtype != objabi.Hsolaris {
+			obj.Nopout(p)
+		}
+		if p.From.Type == obj.TYPE_MEM && p.From.Index == REG_TLS && REG_AX <= p.From.Reg && p.From.Reg <= REG_R15 {
+			p.From.Reg = REG_TLS
+			p.From.Scale = 0
+			p.From.Index = REG_NONE
+		}
+
+		if p.To.Type == obj.TYPE_MEM && p.To.Index == REG_TLS && REG_AX <= p.To.Reg && p.To.Reg <= REG_R15 {
+			p.To.Reg = REG_TLS
+			p.To.Scale = 0
+			p.To.Index = REG_NONE
+		}
+	} else {
+		// load_g_cx, below, always inserts the 1-instruction sequence. Rewrite it
+		// as the 2-instruction sequence if necessary.
+		//	MOVQ 0(TLS), BX
+		// becomes
+		//	MOVQ TLS, BX
+		//	MOVQ 0(BX)(TLS*1), BX
+		if (p.As == AMOVQ || p.As == AMOVL) && p.From.Type == obj.TYPE_MEM && p.From.Reg == REG_TLS && p.To.Type == obj.TYPE_REG && REG_AX <= p.To.Reg && p.To.Reg <= REG_R15 {
+			q := obj.Appendp(p, newprog)
+			q.As = p.As
+			q.From = p.From
+			q.From.Type = obj.TYPE_MEM
+			q.From.Reg = p.To.Reg
+			q.From.Index = REG_TLS
+			q.From.Scale = 2 // TODO: use 1
+			q.To = p.To
+			p.From.Type = obj.TYPE_REG
+			p.From.Reg = REG_TLS
+			p.From.Index = REG_NONE
+			p.From.Offset = 0
+		}
+	}
+
+	// Android uses a tls offset determined at runtime. Rewrite
+	//	MOVQ TLS, BX
+	// to
+	//	MOVQ runtime.tls_g(SB), BX
+	if isAndroid && (p.As == AMOVQ || p.As == AMOVL) && p.From.Type == obj.TYPE_REG && p.From.Reg == REG_TLS && p.To.Type == obj.TYPE_REG && REG_AX <= p.To.Reg && p.To.Reg <= REG_R15 {
+		p.From.Type = obj.TYPE_MEM
+		p.From.Name = obj.NAME_EXTERN
+		p.From.Reg = REG_NONE
+		p.From.Sym = ctxt.Lookup("runtime.tls_g")
+		p.From.Index = REG_NONE
+	}
+
+	// TODO: Remove.
+	if ctxt.Headtype == objabi.Hwindows && ctxt.Arch.Family == sys.AMD64 || ctxt.Headtype == objabi.Hplan9 {
+		if p.From.Scale == 1 && p.From.Index == REG_TLS {
+			p.From.Scale = 2
+		}
+		if p.To.Scale == 1 && p.To.Index == REG_TLS {
+			p.To.Scale = 2
+		}
+	}
+
+	// Rewrite 0 to $0 in 3rd argument to CMPPS etc.
+	// That's what the tables expect.
+	switch p.As {
+	case ACMPPD, ACMPPS, ACMPSD, ACMPSS:
+		if p.To.Type == obj.TYPE_MEM && p.To.Name == obj.NAME_NONE && p.To.Reg == REG_NONE && p.To.Index == REG_NONE && p.To.Sym == nil {
+			p.To.Type = obj.TYPE_CONST
+		}
+	}
+
+	// Rewrite CALL/JMP/RET to symbol as TYPE_BRANCH.
+	switch p.As {
+	case obj.ACALL, obj.AJMP, obj.ARET:
+		if p.To.Type == obj.TYPE_MEM && (p.To.Name == obj.NAME_EXTERN || p.To.Name == obj.NAME_STATIC) && p.To.Sym != nil {
+			p.To.Type = obj.TYPE_BRANCH
+		}
+	}
+
+	// Rewrite MOVL/MOVQ $XXX(FP/SP) as LEAL/LEAQ.
+	if p.From.Type == obj.TYPE_ADDR && (ctxt.Arch.Family == sys.AMD64 || p.From.Name != obj.NAME_EXTERN && p.From.Name != obj.NAME_STATIC) {
+		switch p.As {
+		case AMOVL:
+			p.As = ALEAL
+			p.From.Type = obj.TYPE_MEM
+		case AMOVQ:
+			p.As = ALEAQ
+			p.From.Type = obj.TYPE_MEM
+		}
+	}
+
+	// Rewrite float constants to values stored in memory.
+	switch p.As {
+	// Convert AMOVSS $(0), Xx to AXORPS Xx, Xx
+	case AMOVSS:
+		if p.From.Type == obj.TYPE_FCONST {
+			//  f == 0 can't be used here due to -0, so use Float64bits
+			if f := p.From.Val.(float64); math.Float64bits(f) == 0 {
+				if p.To.Type == obj.TYPE_REG && REG_X0 <= p.To.Reg && p.To.Reg <= REG_X15 {
+					p.As = AXORPS
+					p.From = p.To
+					break
+				}
+			}
+		}
+		fallthrough
+
+	case AFMOVF,
+		AFADDF,
+		AFSUBF,
+		AFSUBRF,
+		AFMULF,
+		AFDIVF,
+		AFDIVRF,
+		AFCOMF,
+		AFCOMFP,
+		AADDSS,
+		ASUBSS,
+		AMULSS,
+		ADIVSS,
+		ACOMISS,
+		AUCOMISS:
+		if p.From.Type == obj.TYPE_FCONST {
+			f32 := float32(p.From.Val.(float64))
+			p.From.Type = obj.TYPE_MEM
+			p.From.Name = obj.NAME_EXTERN
+			p.From.Sym = ctxt.Float32Sym(f32)
+			p.From.Offset = 0
+		}
+
+	case AMOVSD:
+		// Convert AMOVSD $(0), Xx to AXORPS Xx, Xx
+		if p.From.Type == obj.TYPE_FCONST {
+			//  f == 0 can't be used here due to -0, so use Float64bits
+			if f := p.From.Val.(float64); math.Float64bits(f) == 0 {
+				if p.To.Type == obj.TYPE_REG && REG_X0 <= p.To.Reg && p.To.Reg <= REG_X15 {
+					p.As = AXORPS
+					p.From = p.To
+					break
+				}
+			}
+		}
+		fallthrough
+
+	case AFMOVD,
+		AFADDD,
+		AFSUBD,
+		AFSUBRD,
+		AFMULD,
+		AFDIVD,
+		AFDIVRD,
+		AFCOMD,
+		AFCOMDP,
+		AADDSD,
+		ASUBSD,
+		AMULSD,
+		ADIVSD,
+		ACOMISD,
+		AUCOMISD:
+		if p.From.Type == obj.TYPE_FCONST {
+			f64 := p.From.Val.(float64)
+			p.From.Type = obj.TYPE_MEM
+			p.From.Name = obj.NAME_EXTERN
+			p.From.Sym = ctxt.Float64Sym(f64)
+			p.From.Offset = 0
+		}
+	}
+
+	if ctxt.Flag_dynlink {
+		rewriteToUseGot(ctxt, p, newprog)
+	}
+
+	if ctxt.Flag_shared && ctxt.Arch.Family == sys.I386 {
+		rewriteToPcrel(ctxt, p, newprog)
+	}
+}
+
+// Rewrite p, if necessary, to access global data via the global offset table.
+func rewriteToUseGot(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
+	var lea, mov obj.As
+	var reg int16
+	if ctxt.Arch.Family == sys.AMD64 {
+		lea = ALEAQ
+		mov = AMOVQ
+		reg = REG_R15
+	} else {
+		lea = ALEAL
+		mov = AMOVL
+		reg = REG_CX
+		if p.As == ALEAL && p.To.Reg != p.From.Reg && p.To.Reg != p.From.Index {
+			// Special case: clobber the destination register with
+			// the PC so we don't have to clobber CX.
+			// The SSA backend depends on CX not being clobbered across LEAL.
+			// See cmd/compile/internal/ssa/gen/386.rules (search for Flag_shared).
+			reg = p.To.Reg
+		}
+	}
+
+	if p.As == obj.ADUFFCOPY || p.As == obj.ADUFFZERO {
+		//     ADUFFxxx $offset
+		// becomes
+		//     $MOV runtime.duffxxx@GOT, $reg
+		//     $LEA $offset($reg), $reg
+		//     CALL $reg
+		// (we use LEAx rather than ADDx because ADDx clobbers
+		// flags and duffzero on 386 does not otherwise do so).
+		var sym *obj.LSym
+		if p.As == obj.ADUFFZERO {
+			sym = ctxt.Lookup("runtime.duffzero")
+		} else {
+			sym = ctxt.Lookup("runtime.duffcopy")
+		}
+		offset := p.To.Offset
+		p.As = mov
+		p.From.Type = obj.TYPE_MEM
+		p.From.Name = obj.NAME_GOTREF
+		p.From.Sym = sym
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = reg
+		p.To.Offset = 0
+		p.To.Sym = nil
+		p1 := obj.Appendp(p, newprog)
+		p1.As = lea
+		p1.From.Type = obj.TYPE_MEM
+		p1.From.Offset = offset
+		p1.From.Reg = reg
+		p1.To.Type = obj.TYPE_REG
+		p1.To.Reg = reg
+		p2 := obj.Appendp(p1, newprog)
+		p2.As = obj.ACALL
+		p2.To.Type = obj.TYPE_REG
+		p2.To.Reg = reg
+	}
+
+	// We only care about global data: NAME_EXTERN means a global
+	// symbol in the Go sense, and p.Sym.Local is true for a few
+	// internally defined symbols.
+	if p.As == lea && p.From.Type == obj.TYPE_MEM && p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
+		// $LEA sym, Rx becomes $MOV $sym, Rx which will be rewritten below
+		p.As = mov
+		p.From.Type = obj.TYPE_ADDR
+	}
+	if p.From.Type == obj.TYPE_ADDR && p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
+		// $MOV $sym, Rx becomes $MOV sym@GOT, Rx
+		// $MOV $sym+<off>, Rx becomes $MOV sym@GOT, Rx; $LEA <off>(Rx), Rx
+		// On 386 only, more complicated things like PUSHL $sym become $MOV sym@GOT, CX; PUSHL CX
+		cmplxdest := false
+		pAs := p.As
+		var dest obj.Addr
+		if p.To.Type != obj.TYPE_REG || pAs != mov {
+			if ctxt.Arch.Family == sys.AMD64 {
+				ctxt.Diag("do not know how to handle LEA-type insn to non-register in %v with -dynlink", p)
+			}
+			cmplxdest = true
+			dest = p.To
+			p.As = mov
+			p.To.Type = obj.TYPE_REG
+			p.To.Reg = reg
+			p.To.Sym = nil
+			p.To.Name = obj.NAME_NONE
+		}
+		p.From.Type = obj.TYPE_MEM
+		p.From.Name = obj.NAME_GOTREF
+		q := p
+		if p.From.Offset != 0 {
+			q = obj.Appendp(p, newprog)
+			q.As = lea
+			q.From.Type = obj.TYPE_MEM
+			q.From.Reg = p.To.Reg
+			q.From.Offset = p.From.Offset
+			q.To = p.To
+			p.From.Offset = 0
+		}
+		if cmplxdest {
+			q = obj.Appendp(q, newprog)
+			q.As = pAs
+			q.To = dest
+			q.From.Type = obj.TYPE_REG
+			q.From.Reg = reg
+		}
+	}
+	if p.GetFrom3() != nil && p.GetFrom3().Name == obj.NAME_EXTERN {
+		ctxt.Diag("don't know how to handle %v with -dynlink", p)
+	}
+	var source *obj.Addr
+	// MOVx sym, Ry becomes $MOV sym@GOT, R15; MOVx (R15), Ry
+	// MOVx Ry, sym becomes $MOV sym@GOT, R15; MOVx Ry, (R15)
+	// An addition may be inserted between the two MOVs if there is an offset.
+	if p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
+		if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
+			ctxt.Diag("cannot handle NAME_EXTERN on both sides in %v with -dynlink", p)
+		}
+		source = &p.From
+	} else if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
+		source = &p.To
+	} else {
+		return
+	}
+	if p.As == obj.ACALL {
+		// When dynlinking on 386, almost any call might end up being a call
+		// to a PLT, so make sure the GOT pointer is loaded into BX.
+		// RegTo2 is set on the replacement call insn to stop it being
+		// processed when it is in turn passed to progedit.
+		//
+		// We disable open-coded defers in buildssa() on 386 ONLY with shared
+		// libraries because of this extra code added before deferreturn calls.
+		if ctxt.Arch.Family == sys.AMD64 || (p.To.Sym != nil && p.To.Sym.Local()) || p.RegTo2 != 0 {
+			return
+		}
+		p1 := obj.Appendp(p, newprog)
+		p2 := obj.Appendp(p1, newprog)
+
+		p1.As = ALEAL
+		p1.From.Type = obj.TYPE_MEM
+		p1.From.Name = obj.NAME_STATIC
+		p1.From.Sym = ctxt.Lookup("_GLOBAL_OFFSET_TABLE_")
+		p1.To.Type = obj.TYPE_REG
+		p1.To.Reg = REG_BX
+
+		p2.As = p.As
+		p2.Scond = p.Scond
+		p2.From = p.From
+		if p.RestArgs != nil {
+			p2.RestArgs = append(p2.RestArgs, p.RestArgs...)
+		}
+		p2.Reg = p.Reg
+		p2.To = p.To
+		// p.To.Type was set to TYPE_BRANCH above, but that makes checkaddr
+		// in ../pass.go complain, so set it back to TYPE_MEM here, until p2
+		// itself gets passed to progedit.
+		p2.To.Type = obj.TYPE_MEM
+		p2.RegTo2 = 1
+
+		obj.Nopout(p)
+		return
+
+	}
+	if p.As == obj.ATEXT || p.As == obj.AFUNCDATA || p.As == obj.ARET || p.As == obj.AJMP {
+		return
+	}
+	if source.Type != obj.TYPE_MEM {
+		ctxt.Diag("don't know how to handle %v with -dynlink", p)
+	}
+	p1 := obj.Appendp(p, newprog)
+	p2 := obj.Appendp(p1, newprog)
+
+	p1.As = mov
+	p1.From.Type = obj.TYPE_MEM
+	p1.From.Sym = source.Sym
+	p1.From.Name = obj.NAME_GOTREF
+	p1.To.Type = obj.TYPE_REG
+	p1.To.Reg = reg
+
+	p2.As = p.As
+	p2.From = p.From
+	p2.To = p.To
+	if p.From.Name == obj.NAME_EXTERN {
+		p2.From.Reg = reg
+		p2.From.Name = obj.NAME_NONE
+		p2.From.Sym = nil
+	} else if p.To.Name == obj.NAME_EXTERN {
+		p2.To.Reg = reg
+		p2.To.Name = obj.NAME_NONE
+		p2.To.Sym = nil
+	} else {
+		return
+	}
+	obj.Nopout(p)
+}
+
+func rewriteToPcrel(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
+	// RegTo2 is set on the instructions we insert here so they don't get
+	// processed twice.
+	if p.RegTo2 != 0 {
+		return
+	}
+	if p.As == obj.ATEXT || p.As == obj.AFUNCDATA || p.As == obj.ACALL || p.As == obj.ARET || p.As == obj.AJMP {
+		return
+	}
+	// Any Prog (aside from the above special cases) with an Addr with Name ==
+	// NAME_EXTERN, NAME_STATIC or NAME_GOTREF has a CALL __x86.get_pc_thunk.XX
+	// inserted before it.
+	isName := func(a *obj.Addr) bool {
+		if a.Sym == nil || (a.Type != obj.TYPE_MEM && a.Type != obj.TYPE_ADDR) || a.Reg != 0 {
+			return false
+		}
+		if a.Sym.Type == objabi.STLSBSS {
+			return false
+		}
+		return a.Name == obj.NAME_EXTERN || a.Name == obj.NAME_STATIC || a.Name == obj.NAME_GOTREF
+	}
+
+	if isName(&p.From) && p.From.Type == obj.TYPE_ADDR {
+		// Handle things like "MOVL $sym, (SP)" or "PUSHL $sym" by rewriting
+		// to "MOVL $sym, CX; MOVL CX, (SP)" or "MOVL $sym, CX; PUSHL CX"
+		// respectively.
+		if p.To.Type != obj.TYPE_REG {
+			q := obj.Appendp(p, newprog)
+			q.As = p.As
+			q.From.Type = obj.TYPE_REG
+			q.From.Reg = REG_CX
+			q.To = p.To
+			p.As = AMOVL
+			p.To.Type = obj.TYPE_REG
+			p.To.Reg = REG_CX
+			p.To.Sym = nil
+			p.To.Name = obj.NAME_NONE
+		}
+	}
+
+	if !isName(&p.From) && !isName(&p.To) && (p.GetFrom3() == nil || !isName(p.GetFrom3())) {
+		return
+	}
+	var dst int16 = REG_CX
+	if (p.As == ALEAL || p.As == AMOVL) && p.To.Reg != p.From.Reg && p.To.Reg != p.From.Index {
+		dst = p.To.Reg
+		// Why? See the comment near the top of rewriteToUseGot above.
+		// AMOVLs might be introduced by the GOT rewrites.
+	}
+	q := obj.Appendp(p, newprog)
+	q.RegTo2 = 1
+	r := obj.Appendp(q, newprog)
+	r.RegTo2 = 1
+	q.As = obj.ACALL
+	thunkname := "__x86.get_pc_thunk." + strings.ToLower(rconv(int(dst)))
+	q.To.Sym = ctxt.LookupInit(thunkname, func(s *obj.LSym) { s.Set(obj.AttrLocal, true) })
+	q.To.Type = obj.TYPE_MEM
+	q.To.Name = obj.NAME_EXTERN
+	r.As = p.As
+	r.Scond = p.Scond
+	r.From = p.From
+	r.RestArgs = p.RestArgs
+	r.Reg = p.Reg
+	r.To = p.To
+	if isName(&p.From) {
+		r.From.Reg = dst
+	}
+	if isName(&p.To) {
+		r.To.Reg = dst
+	}
+	if p.GetFrom3() != nil && isName(p.GetFrom3()) {
+		r.GetFrom3().Reg = dst
+	}
+	obj.Nopout(p)
+}
+
+func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
+	if cursym.Func.Text == nil || cursym.Func.Text.Link == nil {
+		return
+	}
+
+	p := cursym.Func.Text
+	autoffset := int32(p.To.Offset)
+	if autoffset < 0 {
+		autoffset = 0
+	}
+
+	hasCall := false
+	for q := p; q != nil; q = q.Link {
+		if q.As == obj.ACALL || q.As == obj.ADUFFCOPY || q.As == obj.ADUFFZERO {
+			hasCall = true
+			break
+		}
+	}
+
+	var bpsize int
+	if ctxt.Arch.Family == sys.AMD64 &&
+		!p.From.Sym.NoFrame() && // (1) below
+		!(autoffset == 0 && p.From.Sym.NoSplit()) && // (2) below
+		!(autoffset == 0 && !hasCall) { // (3) below
+		// Make room to save a base pointer.
+		// There are 2 cases we must avoid:
+		// 1) If noframe is set (which we do for functions which tail call).
+		// 2) Scary runtime internals which would be all messed up by frame pointers.
+		//    We detect these using a heuristic: frameless nosplit functions.
+		//    TODO: Maybe someday we label them all with NOFRAME and get rid of this heuristic.
+		// For performance, we also want to avoid:
+		// 3) Frameless leaf functions
+		bpsize = ctxt.Arch.PtrSize
+		autoffset += int32(bpsize)
+		p.To.Offset += int64(bpsize)
+	} else {
+		bpsize = 0
+	}
+
+	textarg := int64(p.To.Val.(int32))
+	cursym.Func.Args = int32(textarg)
+	cursym.Func.Locals = int32(p.To.Offset)
+
+	// TODO(rsc): Remove.
+	if ctxt.Arch.Family == sys.I386 && cursym.Func.Locals < 0 {
+		cursym.Func.Locals = 0
+	}
+
+	// TODO(rsc): Remove 'ctxt.Arch.Family == sys.AMD64 &&'.
+	if ctxt.Arch.Family == sys.AMD64 && autoffset < objabi.StackSmall && !p.From.Sym.NoSplit() {
+		leaf := true
+	LeafSearch:
+		for q := p; q != nil; q = q.Link {
+			switch q.As {
+			case obj.ACALL:
+				// Treat common runtime calls that take no arguments
+				// the same as duffcopy and duffzero.
+				if !isZeroArgRuntimeCall(q.To.Sym) {
+					leaf = false
+					break LeafSearch
+				}
+				fallthrough
+			case obj.ADUFFCOPY, obj.ADUFFZERO:
+				if autoffset >= objabi.StackSmall-8 {
+					leaf = false
+					break LeafSearch
+				}
+			}
+		}
+
+		if leaf {
+			p.From.Sym.Set(obj.AttrNoSplit, true)
+		}
+	}
+
+	if !p.From.Sym.NoSplit() || p.From.Sym.Wrapper() {
+		p = obj.Appendp(p, newprog)
+		p = load_g_cx(ctxt, p, newprog) // load g into CX
+	}
+
+	if !cursym.Func.Text.From.Sym.NoSplit() {
+		p = stacksplit(ctxt, cursym, p, newprog, autoffset, int32(textarg)) // emit split check
+	}
+
+	// Delve debugger would like the next instruction to be noted as the end of the function prologue.
+	// TODO: are there other cases (e.g., wrapper functions) that need marking?
+	markedPrologue := false
+
+	if autoffset != 0 {
+		if autoffset%int32(ctxt.Arch.RegSize) != 0 {
+			ctxt.Diag("unaligned stack size %d", autoffset)
+		}
+		p = obj.Appendp(p, newprog)
+		p.As = AADJSP
+		p.From.Type = obj.TYPE_CONST
+		p.From.Offset = int64(autoffset)
+		p.Spadj = autoffset
+		p.Pos = p.Pos.WithXlogue(src.PosPrologueEnd)
+		markedPrologue = true
+	}
+
+	if bpsize > 0 {
+		// Save caller's BP
+		p = obj.Appendp(p, newprog)
+
+		p.As = AMOVQ
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_BP
+		p.To.Type = obj.TYPE_MEM
+		p.To.Reg = REG_SP
+		p.To.Scale = 1
+		p.To.Offset = int64(autoffset) - int64(bpsize)
+		if !markedPrologue {
+			p.Pos = p.Pos.WithXlogue(src.PosPrologueEnd)
+		}
+
+		// Move current frame to BP
+		p = obj.Appendp(p, newprog)
+
+		p.As = ALEAQ
+		p.From.Type = obj.TYPE_MEM
+		p.From.Reg = REG_SP
+		p.From.Scale = 1
+		p.From.Offset = int64(autoffset) - int64(bpsize)
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_BP
+	}
+
+	if cursym.Func.Text.From.Sym.Wrapper() {
+		// if g._panic != nil && g._panic.argp == FP {
+		//   g._panic.argp = bottom-of-frame
+		// }
+		//
+		//	MOVQ g_panic(CX), BX
+		//	TESTQ BX, BX
+		//	JNE checkargp
+		// end:
+		//	NOP
+		//  ... rest of function ...
+		// checkargp:
+		//	LEAQ (autoffset+8)(SP), DI
+		//	CMPQ panic_argp(BX), DI
+		//	JNE end
+		//  MOVQ SP, panic_argp(BX)
+		//  JMP end
+		//
+		// The NOP is needed to give the jumps somewhere to land.
+		// It is a liblink NOP, not an x86 NOP: it encodes to 0 instruction bytes.
+		//
+		// The layout is chosen to help static branch prediction:
+		// Both conditional jumps are unlikely, so they are arranged to be forward jumps.
+
+		// MOVQ g_panic(CX), BX
+		p = obj.Appendp(p, newprog)
+		p.As = AMOVQ
+		p.From.Type = obj.TYPE_MEM
+		p.From.Reg = REG_CX
+		p.From.Offset = 4 * int64(ctxt.Arch.PtrSize) // g_panic
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_BX
+		if ctxt.Arch.Family == sys.I386 {
+			p.As = AMOVL
+		}
+
+		// TESTQ BX, BX
+		p = obj.Appendp(p, newprog)
+		p.As = ATESTQ
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_BX
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_BX
+		if ctxt.Arch.Family == sys.I386 {
+			p.As = ATESTL
+		}
+
+		// JNE checkargp (checkargp to be resolved later)
+		jne := obj.Appendp(p, newprog)
+		jne.As = AJNE
+		jne.To.Type = obj.TYPE_BRANCH
+
+		// end:
+		//  NOP
+		end := obj.Appendp(jne, newprog)
+		end.As = obj.ANOP
+
+		// Fast forward to end of function.
+		var last *obj.Prog
+		for last = end; last.Link != nil; last = last.Link {
+		}
+
+		// LEAQ (autoffset+8)(SP), DI
+		p = obj.Appendp(last, newprog)
+		p.As = ALEAQ
+		p.From.Type = obj.TYPE_MEM
+		p.From.Reg = REG_SP
+		p.From.Offset = int64(autoffset) + int64(ctxt.Arch.RegSize)
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_DI
+		if ctxt.Arch.Family == sys.I386 {
+			p.As = ALEAL
+		}
+
+		// Set jne branch target.
+		jne.To.SetTarget(p)
+
+		// CMPQ panic_argp(BX), DI
+		p = obj.Appendp(p, newprog)
+		p.As = ACMPQ
+		p.From.Type = obj.TYPE_MEM
+		p.From.Reg = REG_BX
+		p.From.Offset = 0 // Panic.argp
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_DI
+		if ctxt.Arch.Family == sys.I386 {
+			p.As = ACMPL
+		}
+
+		// JNE end
+		p = obj.Appendp(p, newprog)
+		p.As = AJNE
+		p.To.Type = obj.TYPE_BRANCH
+		p.To.SetTarget(end)
+
+		// MOVQ SP, panic_argp(BX)
+		p = obj.Appendp(p, newprog)
+		p.As = AMOVQ
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_SP
+		p.To.Type = obj.TYPE_MEM
+		p.To.Reg = REG_BX
+		p.To.Offset = 0 // Panic.argp
+		if ctxt.Arch.Family == sys.I386 {
+			p.As = AMOVL
+		}
+
+		// JMP end
+		p = obj.Appendp(p, newprog)
+		p.As = obj.AJMP
+		p.To.Type = obj.TYPE_BRANCH
+		p.To.SetTarget(end)
+
+		// Reset p for following code.
+		p = end
+	}
+
+	var deltasp int32
+	for p = cursym.Func.Text; p != nil; p = p.Link {
+		pcsize := ctxt.Arch.RegSize
+		switch p.From.Name {
+		case obj.NAME_AUTO:
+			p.From.Offset += int64(deltasp) - int64(bpsize)
+		case obj.NAME_PARAM:
+			p.From.Offset += int64(deltasp) + int64(pcsize)
+		}
+		if p.GetFrom3() != nil {
+			switch p.GetFrom3().Name {
+			case obj.NAME_AUTO:
+				p.GetFrom3().Offset += int64(deltasp) - int64(bpsize)
+			case obj.NAME_PARAM:
+				p.GetFrom3().Offset += int64(deltasp) + int64(pcsize)
+			}
+		}
+		switch p.To.Name {
+		case obj.NAME_AUTO:
+			p.To.Offset += int64(deltasp) - int64(bpsize)
+		case obj.NAME_PARAM:
+			p.To.Offset += int64(deltasp) + int64(pcsize)
+		}
+
+		switch p.As {
+		default:
+			continue
+
+		case APUSHL, APUSHFL:
+			deltasp += 4
+			p.Spadj = 4
+			continue
+
+		case APUSHQ, APUSHFQ:
+			deltasp += 8
+			p.Spadj = 8
+			continue
+
+		case APUSHW, APUSHFW:
+			deltasp += 2
+			p.Spadj = 2
+			continue
+
+		case APOPL, APOPFL:
+			deltasp -= 4
+			p.Spadj = -4
+			continue
+
+		case APOPQ, APOPFQ:
+			deltasp -= 8
+			p.Spadj = -8
+			continue
+
+		case APOPW, APOPFW:
+			deltasp -= 2
+			p.Spadj = -2
+			continue
+
+		case AADJSP:
+			p.Spadj = int32(p.From.Offset)
+			deltasp += int32(p.From.Offset)
+			continue
+
+		case obj.ARET:
+			// do nothing
+		}
+
+		if autoffset != deltasp {
+			ctxt.Diag("unbalanced PUSH/POP")
+		}
+
+		if autoffset != 0 {
+			to := p.To // Keep To attached to RET for retjmp below
+			p.To = obj.Addr{}
+			if bpsize > 0 {
+				// Restore caller's BP
+				p.As = AMOVQ
+
+				p.From.Type = obj.TYPE_MEM
+				p.From.Reg = REG_SP
+				p.From.Scale = 1
+				p.From.Offset = int64(autoffset) - int64(bpsize)
+				p.To.Type = obj.TYPE_REG
+				p.To.Reg = REG_BP
+				p = obj.Appendp(p, newprog)
+			}
+
+			p.As = AADJSP
+			p.From.Type = obj.TYPE_CONST
+			p.From.Offset = int64(-autoffset)
+			p.Spadj = -autoffset
+			p = obj.Appendp(p, newprog)
+			p.As = obj.ARET
+			p.To = to
+
+			// If there are instructions following
+			// this ARET, they come from a branch
+			// with the same stackframe, so undo
+			// the cleanup.
+			p.Spadj = +autoffset
+		}
+
+		if p.To.Sym != nil { // retjmp
+			p.As = obj.AJMP
+		}
+	}
+}
+
+func isZeroArgRuntimeCall(s *obj.LSym) bool {
+	if s == nil {
+		return false
+	}
+	switch s.Name {
+	case "runtime.panicdivide", "runtime.panicwrap", "runtime.panicshift":
+		return true
+	}
+	if strings.HasPrefix(s.Name, "runtime.panicIndex") || strings.HasPrefix(s.Name, "runtime.panicSlice") {
+		// These functions do take arguments (in registers),
+		// but use no stack before they do a stack check. We
+		// should include them. See issue 31219.
+		return true
+	}
+	return false
+}
+
+func indir_cx(ctxt *obj.Link, a *obj.Addr) {
+	a.Type = obj.TYPE_MEM
+	a.Reg = REG_CX
+}
+
+// Append code to p to load g into cx.
+// Overwrites p with the first instruction (no first appendp).
+// Overwriting p is unusual but it lets use this in both the
+// prologue (caller must call appendp first) and in the epilogue.
+// Returns last new instruction.
+func load_g_cx(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) *obj.Prog {
+	p.As = AMOVQ
+	if ctxt.Arch.PtrSize == 4 {
+		p.As = AMOVL
+	}
+	p.From.Type = obj.TYPE_MEM
+	p.From.Reg = REG_TLS
+	p.From.Offset = 0
+	p.To.Type = obj.TYPE_REG
+	p.To.Reg = REG_CX
+
+	next := p.Link
+	progedit(ctxt, p, newprog)
+	for p.Link != next {
+		p = p.Link
+		progedit(ctxt, p, newprog)
+	}
+
+	if p.From.Index == REG_TLS {
+		p.From.Scale = 2
+	}
+
+	return p
+}
+
+// Append code to p to check for stack split.
+// Appends to (does not overwrite) p.
+// Assumes g is in CX.
+// Returns last new instruction.
+func stacksplit(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, newprog obj.ProgAlloc, framesize int32, textarg int32) *obj.Prog {
+	cmp := ACMPQ
+	lea := ALEAQ
+	mov := AMOVQ
+	sub := ASUBQ
+
+	if ctxt.Arch.Family == sys.I386 {
+		cmp = ACMPL
+		lea = ALEAL
+		mov = AMOVL
+		sub = ASUBL
+	}
+
+	var q1 *obj.Prog
+	if framesize <= objabi.StackSmall {
+		// small stack: SP <= stackguard
+		//	CMPQ SP, stackguard
+		p = obj.Appendp(p, newprog)
+
+		p.As = cmp
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_SP
+		indir_cx(ctxt, &p.To)
+		p.To.Offset = 2 * int64(ctxt.Arch.PtrSize) // G.stackguard0
+		if cursym.CFunc() {
+			p.To.Offset = 3 * int64(ctxt.Arch.PtrSize) // G.stackguard1
+		}
+
+		// Mark the stack bound check and morestack call async nonpreemptible.
+		// If we get preempted here, when resumed the preemption request is
+		// cleared, but we'll still call morestack, which will double the stack
+		// unnecessarily. See issue #35470.
+		p = ctxt.StartUnsafePoint(p, newprog)
+	} else if framesize <= objabi.StackBig {
+		// large stack: SP-framesize <= stackguard-StackSmall
+		//	LEAQ -xxx(SP), AX
+		//	CMPQ AX, stackguard
+		p = obj.Appendp(p, newprog)
+
+		p.As = lea
+		p.From.Type = obj.TYPE_MEM
+		p.From.Reg = REG_SP
+		p.From.Offset = -(int64(framesize) - objabi.StackSmall)
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_AX
+
+		p = obj.Appendp(p, newprog)
+		p.As = cmp
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_AX
+		indir_cx(ctxt, &p.To)
+		p.To.Offset = 2 * int64(ctxt.Arch.PtrSize) // G.stackguard0
+		if cursym.CFunc() {
+			p.To.Offset = 3 * int64(ctxt.Arch.PtrSize) // G.stackguard1
+		}
+
+		p = ctxt.StartUnsafePoint(p, newprog) // see the comment above
+	} else {
+		// Such a large stack we need to protect against wraparound.
+		// If SP is close to zero:
+		//	SP-stackguard+StackGuard <= framesize + (StackGuard-StackSmall)
+		// The +StackGuard on both sides is required to keep the left side positive:
+		// SP is allowed to be slightly below stackguard. See stack.h.
+		//
+		// Preemption sets stackguard to StackPreempt, a very large value.
+		// That breaks the math above, so we have to check for that explicitly.
+		//	MOVQ	stackguard, SI
+		//	CMPQ	SI, $StackPreempt
+		//	JEQ	label-of-call-to-morestack
+		//	LEAQ	StackGuard(SP), AX
+		//	SUBQ	SI, AX
+		//	CMPQ	AX, $(framesize+(StackGuard-StackSmall))
+
+		p = obj.Appendp(p, newprog)
+
+		p.As = mov
+		indir_cx(ctxt, &p.From)
+		p.From.Offset = 2 * int64(ctxt.Arch.PtrSize) // G.stackguard0
+		if cursym.CFunc() {
+			p.From.Offset = 3 * int64(ctxt.Arch.PtrSize) // G.stackguard1
+		}
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_SI
+
+		p = ctxt.StartUnsafePoint(p, newprog) // see the comment above
+
+		p = obj.Appendp(p, newprog)
+		p.As = cmp
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_SI
+		p.To.Type = obj.TYPE_CONST
+		p.To.Offset = objabi.StackPreempt
+		if ctxt.Arch.Family == sys.I386 {
+			p.To.Offset = int64(uint32(objabi.StackPreempt & (1<<32 - 1)))
+		}
+
+		p = obj.Appendp(p, newprog)
+		p.As = AJEQ
+		p.To.Type = obj.TYPE_BRANCH
+		q1 = p
+
+		p = obj.Appendp(p, newprog)
+		p.As = lea
+		p.From.Type = obj.TYPE_MEM
+		p.From.Reg = REG_SP
+		p.From.Offset = int64(objabi.StackGuard)
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_AX
+
+		p = obj.Appendp(p, newprog)
+		p.As = sub
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_SI
+		p.To.Type = obj.TYPE_REG
+		p.To.Reg = REG_AX
+
+		p = obj.Appendp(p, newprog)
+		p.As = cmp
+		p.From.Type = obj.TYPE_REG
+		p.From.Reg = REG_AX
+		p.To.Type = obj.TYPE_CONST
+		p.To.Offset = int64(framesize) + (int64(objabi.StackGuard) - objabi.StackSmall)
+	}
+
+	// common
+	jls := obj.Appendp(p, newprog)
+	jls.As = AJLS
+	jls.To.Type = obj.TYPE_BRANCH
+
+	end := ctxt.EndUnsafePoint(jls, newprog, -1)
+
+	var last *obj.Prog
+	for last = cursym.Func.Text; last.Link != nil; last = last.Link {
+	}
+
+	// Now we are at the end of the function, but logically
+	// we are still in function prologue. We need to fix the
+	// SP data and PCDATA.
+	spfix := obj.Appendp(last, newprog)
+	spfix.As = obj.ANOP
+	spfix.Spadj = -framesize
+
+	pcdata := ctxt.EmitEntryStackMap(cursym, spfix, newprog)
+	pcdata = ctxt.StartUnsafePoint(pcdata, newprog)
+
+	call := obj.Appendp(pcdata, newprog)
+	call.Pos = cursym.Func.Text.Pos
+	call.As = obj.ACALL
+	call.To.Type = obj.TYPE_BRANCH
+	call.To.Name = obj.NAME_EXTERN
+	morestack := "runtime.morestack"
+	switch {
+	case cursym.CFunc():
+		morestack = "runtime.morestackc"
+	case !cursym.Func.Text.From.Sym.NeedCtxt():
+		morestack = "runtime.morestack_noctxt"
+	}
+	call.To.Sym = ctxt.Lookup(morestack)
+	// When compiling 386 code for dynamic linking, the call needs to be adjusted
+	// to follow PIC rules. This in turn can insert more instructions, so we need
+	// to keep track of the start of the call (where the jump will be to) and the
+	// end (which following instructions are appended to).
+	callend := call
+	progedit(ctxt, callend, newprog)
+	for ; callend.Link != nil; callend = callend.Link {
+		progedit(ctxt, callend.Link, newprog)
+	}
+
+	pcdata = ctxt.EndUnsafePoint(callend, newprog, -1)
+
+	jmp := obj.Appendp(pcdata, newprog)
+	jmp.As = obj.AJMP
+	jmp.To.Type = obj.TYPE_BRANCH
+	jmp.To.SetTarget(cursym.Func.Text.Link)
+	jmp.Spadj = +framesize
+
+	jls.To.SetTarget(call)
+	if q1 != nil {
+		q1.To.SetTarget(call)
+	}
+
+	return end
+}
+
+var unaryDst = map[obj.As]bool{
+	ABSWAPL:     true,
+	ABSWAPQ:     true,
+	ACLDEMOTE:   true,
+	ACLFLUSH:    true,
+	ACLFLUSHOPT: true,
+	ACLWB:       true,
+	ACMPXCHG16B: true,
+	ACMPXCHG8B:  true,
+	ADECB:       true,
+	ADECL:       true,
+	ADECQ:       true,
+	ADECW:       true,
+	AFBSTP:      true,
+	AFFREE:      true,
+	AFLDENV:     true,
+	AFSAVE:      true,
+	AFSTCW:      true,
+	AFSTENV:     true,
+	AFSTSW:      true,
+	AFXSAVE64:   true,
+	AFXSAVE:     true,
+	AINCB:       true,
+	AINCL:       true,
+	AINCQ:       true,
+	AINCW:       true,
+	ANEGB:       true,
+	ANEGL:       true,
+	ANEGQ:       true,
+	ANEGW:       true,
+	ANOTB:       true,
+	ANOTL:       true,
+	ANOTQ:       true,
+	ANOTW:       true,
+	APOPL:       true,
+	APOPQ:       true,
+	APOPW:       true,
+	ARDFSBASEL:  true,
+	ARDFSBASEQ:  true,
+	ARDGSBASEL:  true,
+	ARDGSBASEQ:  true,
+	ARDRANDL:    true,
+	ARDRANDQ:    true,
+	ARDRANDW:    true,
+	ARDSEEDL:    true,
+	ARDSEEDQ:    true,
+	ARDSEEDW:    true,
+	ASETCC:      true,
+	ASETCS:      true,
+	ASETEQ:      true,
+	ASETGE:      true,
+	ASETGT:      true,
+	ASETHI:      true,
+	ASETLE:      true,
+	ASETLS:      true,
+	ASETLT:      true,
+	ASETMI:      true,
+	ASETNE:      true,
+	ASETOC:      true,
+	ASETOS:      true,
+	ASETPC:      true,
+	ASETPL:      true,
+	ASETPS:      true,
+	ASGDT:       true,
+	ASIDT:       true,
+	ASLDTL:      true,
+	ASLDTQ:      true,
+	ASLDTW:      true,
+	ASMSWL:      true,
+	ASMSWQ:      true,
+	ASMSWW:      true,
+	ASTMXCSR:    true,
+	ASTRL:       true,
+	ASTRQ:       true,
+	ASTRW:       true,
+	AXSAVE64:    true,
+	AXSAVE:      true,
+	AXSAVEC64:   true,
+	AXSAVEC:     true,
+	AXSAVEOPT64: true,
+	AXSAVEOPT:   true,
+	AXSAVES64:   true,
+	AXSAVES:     true,
+}
+
+var Linkamd64 = obj.LinkArch{
+	Arch:           sys.ArchAMD64,
+	Init:           instinit,
+	Preprocess:     preprocess,
+	Assemble:       span6,
+	Progedit:       progedit,
+	UnaryDst:       unaryDst,
+	DWARFRegisters: AMD64DWARFRegisters,
+}
+
+var Link386 = obj.LinkArch{
+	Arch:           sys.Arch386,
+	Init:           instinit,
+	Preprocess:     preprocess,
+	Assemble:       span6,
+	Progedit:       progedit,
+	UnaryDst:       unaryDst,
+	DWARFRegisters: X86DWARFRegisters,
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/ytab.go b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/ytab.go
new file mode 100644
index 000000000..7d0b75bf4
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/obj/x86/ytab.go
@@ -0,0 +1,44 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package x86
+
+// argListMax specifies upper arg count limit expected to be carried by obj.Prog.
+// Max len(obj.Prog.RestArgs) can be inferred from this to be 4.
+const argListMax int = 6
+
+type argList [argListMax]uint8
+
+type ytab struct {
+	zcase   uint8
+	zoffset uint8
+
+	// Last arg is usually destination.
+	// For unary instructions unaryDst is used to determine
+	// if single argument is a source or destination.
+	args argList
+}
+
+// Returns true if yt is compatible with args.
+//
+// Elements from args and yt.args are used
+// to index ycover table like `ycover[args[i]+yt.args[i]]`.
+// This means that args should contain values that already
+// multiplied by Ymax.
+func (yt *ytab) match(args []int) bool {
+	// Trailing Yxxx check is required to avoid a case
+	// where shorter arg list is matched.
+	// If we had exact yt.args length, it could be `yt.argc != len(args)`.
+	if len(args) < len(yt.args) && yt.args[len(args)] != Yxxx {
+		return false
+	}
+
+	for i := range args {
+		if ycover[args[i]+int(yt.args[i])] == 0 {
+			return false
+		}
+	}
+
+	return true
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/objabi/autotype.go b/vendor/github.com/twitchyliquid64/golang-asm/objabi/autotype.go
new file mode 100644
index 000000000..f9d17a3b9
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/objabi/autotype.go
@@ -0,0 +1,38 @@
+// Derived from Inferno utils/6l/l.h and related files.
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/l.h
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package objabi
+
+// Auto.name
+const (
+	A_AUTO = 1 + iota
+	A_PARAM
+	A_DELETED_AUTO
+)
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/objabi/flag.go b/vendor/github.com/twitchyliquid64/golang-asm/objabi/flag.go
new file mode 100644
index 000000000..79ad2ccf7
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/objabi/flag.go
@@ -0,0 +1,162 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package objabi
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func Flagcount(name, usage string, val *int) {
+	flag.Var((*count)(val), name, usage)
+}
+
+func Flagfn1(name, usage string, f func(string)) {
+	flag.Var(fn1(f), name, usage)
+}
+
+func Flagprint(w io.Writer) {
+	flag.CommandLine.SetOutput(w)
+	flag.PrintDefaults()
+}
+
+func Flagparse(usage func()) {
+	flag.Usage = usage
+	os.Args = expandArgs(os.Args)
+	flag.Parse()
+}
+
+// expandArgs expands "response files" arguments in the provided slice.
+//
+// A "response file" argument starts with '@' and the rest of that
+// argument is a filename with CR-or-CRLF-separated arguments. Each
+// argument in the named files can also contain response file
+// arguments. See Issue 18468.
+//
+// The returned slice 'out' aliases 'in' iff the input did not contain
+// any response file arguments.
+//
+// TODO: handle relative paths of recursive expansions in different directories?
+// Is there a spec for this? Are relative paths allowed?
+func expandArgs(in []string) (out []string) {
+	// out is nil until we see a "@" argument.
+	for i, s := range in {
+		if strings.HasPrefix(s, "@") {
+			if out == nil {
+				out = make([]string, 0, len(in)*2)
+				out = append(out, in[:i]...)
+			}
+			slurp, err := ioutil.ReadFile(s[1:])
+			if err != nil {
+				log.Fatal(err)
+			}
+			args := strings.Split(strings.TrimSpace(strings.Replace(string(slurp), "\r", "", -1)), "\n")
+			out = append(out, expandArgs(args)...)
+		} else if out != nil {
+			out = append(out, s)
+		}
+	}
+	if out == nil {
+		return in
+	}
+	return
+}
+
+func AddVersionFlag() {
+	flag.Var(versionFlag{}, "V", "print version and exit")
+}
+
+var buildID string // filled in by linker
+
+type versionFlag struct{}
+
+func (versionFlag) IsBoolFlag() bool { return true }
+func (versionFlag) Get() interface{} { return nil }
+func (versionFlag) String() string   { return "" }
+func (versionFlag) Set(s string) error {
+	name := os.Args[0]
+	name = name[strings.LastIndex(name, `/`)+1:]
+	name = name[strings.LastIndex(name, `\`)+1:]
+	name = strings.TrimSuffix(name, ".exe")
+
+	// If there's an active experiment, include that,
+	// to distinguish go1.10.2 with an experiment
+	// from go1.10.2 without an experiment.
+	p := Expstring()
+	if p == DefaultExpstring() {
+		p = ""
+	}
+	sep := ""
+	if p != "" {
+		sep = " "
+	}
+
+	// The go command invokes -V=full to get a unique identifier
+	// for this tool. It is assumed that the release version is sufficient
+	// for releases, but during development we include the full
+	// build ID of the binary, so that if the compiler is changed and
+	// rebuilt, we notice and rebuild all packages.
+	if s == "full" {
+		if strings.HasPrefix(Version, "devel") {
+			p += " buildID=" + buildID
+		}
+	}
+
+	fmt.Printf("%s version %s%s%s\n", name, Version, sep, p)
+	os.Exit(0)
+	return nil
+}
+
+// count is a flag.Value that is like a flag.Bool and a flag.Int.
+// If used as -name, it increments the count, but -name=x sets the count.
+// Used for verbose flag -v.
+type count int
+
+func (c *count) String() string {
+	return fmt.Sprint(int(*c))
+}
+
+func (c *count) Set(s string) error {
+	switch s {
+	case "true":
+		*c++
+	case "false":
+		*c = 0
+	default:
+		n, err := strconv.Atoi(s)
+		if err != nil {
+			return fmt.Errorf("invalid count %q", s)
+		}
+		*c = count(n)
+	}
+	return nil
+}
+
+func (c *count) Get() interface{} {
+	return int(*c)
+}
+
+func (c *count) IsBoolFlag() bool {
+	return true
+}
+
+func (c *count) IsCountFlag() bool {
+	return true
+}
+
+type fn1 func(string)
+
+func (f fn1) Set(s string) error {
+	f(s)
+	return nil
+}
+
+func (f fn1) String() string { return "" }
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/objabi/funcdata.go b/vendor/github.com/twitchyliquid64/golang-asm/objabi/funcdata.go
new file mode 100644
index 000000000..c9480bf2f
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/objabi/funcdata.go
@@ -0,0 +1,54 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package objabi
+
+// This file defines the IDs for PCDATA and FUNCDATA instructions
+// in Go binaries.
+//
+// These must agree with ../../../runtime/funcdata.h and
+// ../../../runtime/symtab.go.
+
+const (
+	PCDATA_RegMapIndex   = 0 // if !go115ReduceLiveness
+	PCDATA_UnsafePoint   = 0 // if go115ReduceLiveness
+	PCDATA_StackMapIndex = 1
+	PCDATA_InlTreeIndex  = 2
+
+	FUNCDATA_ArgsPointerMaps    = 0
+	FUNCDATA_LocalsPointerMaps  = 1
+	FUNCDATA_RegPointerMaps     = 2 // if !go115ReduceLiveness
+	FUNCDATA_StackObjects       = 3
+	FUNCDATA_InlTree            = 4
+	FUNCDATA_OpenCodedDeferInfo = 5
+
+	// ArgsSizeUnknown is set in Func.argsize to mark all functions
+	// whose argument size is unknown (C vararg functions, and
+	// assembly code without an explicit specification).
+	// This value is generated by the compiler, assembler, or linker.
+	ArgsSizeUnknown = -0x80000000
+)
+
+// Special PCDATA values.
+const (
+	// PCDATA_RegMapIndex values.
+	//
+	// Only if !go115ReduceLiveness.
+	PCDATA_RegMapUnsafe = PCDATA_UnsafePointUnsafe // Unsafe for async preemption
+
+	// PCDATA_UnsafePoint values.
+	PCDATA_UnsafePointSafe   = -1 // Safe for async preemption
+	PCDATA_UnsafePointUnsafe = -2 // Unsafe for async preemption
+
+	// PCDATA_Restart1(2) apply on a sequence of instructions, within
+	// which if an async preemption happens, we should back off the PC
+	// to the start of the sequence when resuming.
+	// We need two so we can distinguish the start/end of the sequence
+	// in case that two sequences are next to each other.
+	PCDATA_Restart1 = -3
+	PCDATA_Restart2 = -4
+
+	// Like PCDATA_Restart1, but back to function entry if async preempted.
+	PCDATA_RestartAtEntry = -5
+)
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/objabi/funcid.go b/vendor/github.com/twitchyliquid64/golang-asm/objabi/funcid.go
new file mode 100644
index 000000000..6c9336f31
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/objabi/funcid.go
@@ -0,0 +1,100 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package objabi
+
+// A FuncID identifies particular functions that need to be treated
+// specially by the runtime.
+// Note that in some situations involving plugins, there may be multiple
+// copies of a particular special runtime function.
+// Note: this list must match the list in runtime/symtab.go.
+type FuncID uint8
+
+const (
+	FuncID_normal FuncID = iota // not a special function
+	FuncID_runtime_main
+	FuncID_goexit
+	FuncID_jmpdefer
+	FuncID_mcall
+	FuncID_morestack
+	FuncID_mstart
+	FuncID_rt0_go
+	FuncID_asmcgocall
+	FuncID_sigpanic
+	FuncID_runfinq
+	FuncID_gcBgMarkWorker
+	FuncID_systemstack_switch
+	FuncID_systemstack
+	FuncID_cgocallback_gofunc
+	FuncID_gogo
+	FuncID_externalthreadhandler
+	FuncID_debugCallV1
+	FuncID_gopanic
+	FuncID_panicwrap
+	FuncID_handleAsyncEvent
+	FuncID_asyncPreempt
+	FuncID_wrapper // any autogenerated code (hash/eq algorithms, method wrappers, etc.)
+)
+
+// Get the function ID for the named function in the named file.
+// The function should be package-qualified.
+func GetFuncID(name string, isWrapper bool) FuncID {
+	if isWrapper {
+		return FuncID_wrapper
+	}
+	switch name {
+	case "runtime.main":
+		return FuncID_runtime_main
+	case "runtime.goexit":
+		return FuncID_goexit
+	case "runtime.jmpdefer":
+		return FuncID_jmpdefer
+	case "runtime.mcall":
+		return FuncID_mcall
+	case "runtime.morestack":
+		return FuncID_morestack
+	case "runtime.mstart":
+		return FuncID_mstart
+	case "runtime.rt0_go":
+		return FuncID_rt0_go
+	case "runtime.asmcgocall":
+		return FuncID_asmcgocall
+	case "runtime.sigpanic":
+		return FuncID_sigpanic
+	case "runtime.runfinq":
+		return FuncID_runfinq
+	case "runtime.gcBgMarkWorker":
+		return FuncID_gcBgMarkWorker
+	case "runtime.systemstack_switch":
+		return FuncID_systemstack_switch
+	case "runtime.systemstack":
+		return FuncID_systemstack
+	case "runtime.cgocallback_gofunc":
+		return FuncID_cgocallback_gofunc
+	case "runtime.gogo":
+		return FuncID_gogo
+	case "runtime.externalthreadhandler":
+		return FuncID_externalthreadhandler
+	case "runtime.debugCallV1":
+		return FuncID_debugCallV1
+	case "runtime.gopanic":
+		return FuncID_gopanic
+	case "runtime.panicwrap":
+		return FuncID_panicwrap
+	case "runtime.handleAsyncEvent":
+		return FuncID_handleAsyncEvent
+	case "runtime.asyncPreempt":
+		return FuncID_asyncPreempt
+	case "runtime.deferreturn":
+		// Don't show in the call stack (used when invoking defer functions)
+		return FuncID_wrapper
+	case "runtime.runOpenDeferFrame":
+		// Don't show in the call stack (used when invoking defer functions)
+		return FuncID_wrapper
+	case "runtime.reflectcallSave":
+		// Don't show in the call stack (used when invoking defer functions)
+		return FuncID_wrapper
+	}
+	return FuncID_normal
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/objabi/head.go b/vendor/github.com/twitchyliquid64/golang-asm/objabi/head.go
new file mode 100644
index 000000000..95b8db380
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/objabi/head.go
@@ -0,0 +1,109 @@
+// Derived from Inferno utils/6l/l.h and related files.
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/l.h
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package objabi
+
+import "fmt"
+
+// HeadType is the executable header type.
+type HeadType uint8
+
+const (
+	Hunknown HeadType = iota
+	Hdarwin
+	Hdragonfly
+	Hfreebsd
+	Hjs
+	Hlinux
+	Hnetbsd
+	Hopenbsd
+	Hplan9
+	Hsolaris
+	Hwindows
+	Haix
+)
+
+func (h *HeadType) Set(s string) error {
+	switch s {
+	case "aix":
+		*h = Haix
+	case "darwin":
+		*h = Hdarwin
+	case "dragonfly":
+		*h = Hdragonfly
+	case "freebsd":
+		*h = Hfreebsd
+	case "js":
+		*h = Hjs
+	case "linux", "android":
+		*h = Hlinux
+	case "netbsd":
+		*h = Hnetbsd
+	case "openbsd":
+		*h = Hopenbsd
+	case "plan9":
+		*h = Hplan9
+	case "illumos", "solaris":
+		*h = Hsolaris
+	case "windows":
+		*h = Hwindows
+	default:
+		return fmt.Errorf("invalid headtype: %q", s)
+	}
+	return nil
+}
+
+func (h *HeadType) String() string {
+	switch *h {
+	case Haix:
+		return "aix"
+	case Hdarwin:
+		return "darwin"
+	case Hdragonfly:
+		return "dragonfly"
+	case Hfreebsd:
+		return "freebsd"
+	case Hjs:
+		return "js"
+	case Hlinux:
+		return "linux"
+	case Hnetbsd:
+		return "netbsd"
+	case Hopenbsd:
+		return "openbsd"
+	case Hplan9:
+		return "plan9"
+	case Hsolaris:
+		return "solaris"
+	case Hwindows:
+		return "windows"
+	}
+	return fmt.Sprintf("HeadType(%d)", *h)
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/objabi/line.go b/vendor/github.com/twitchyliquid64/golang-asm/objabi/line.go
new file mode 100644
index 000000000..178c8363d
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/objabi/line.go
@@ -0,0 +1,114 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package objabi
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// WorkingDir returns the current working directory
+// (or "/???" if the directory cannot be identified),
+// with "/" as separator.
+func WorkingDir() string {
+	var path string
+	path, _ = os.Getwd()
+	if path == "" {
+		path = "/???"
+	}
+	return filepath.ToSlash(path)
+}
+
+// AbsFile returns the absolute filename for file in the given directory,
+// as rewritten by the rewrites argument.
+// For unrewritten paths, AbsFile rewrites a leading $GOROOT prefix to the literal "$GOROOT".
+// If the resulting path is the empty string, the result is "??".
+//
+// The rewrites argument is a ;-separated list of rewrites.
+// Each rewrite is of the form "prefix" or "prefix=>replace",
+// where prefix must match a leading sequence of path elements
+// and is either removed entirely or replaced by the replacement.
+func AbsFile(dir, file, rewrites string) string {
+	abs := file
+	if dir != "" && !filepath.IsAbs(file) {
+		abs = filepath.Join(dir, file)
+	}
+
+	start := 0
+	for i := 0; i <= len(rewrites); i++ {
+		if i == len(rewrites) || rewrites[i] == ';' {
+			if new, ok := applyRewrite(abs, rewrites[start:i]); ok {
+				abs = new
+				goto Rewritten
+			}
+			start = i + 1
+		}
+	}
+	if hasPathPrefix(abs, GOROOT) {
+		abs = "$GOROOT" + abs[len(GOROOT):]
+	}
+
+Rewritten:
+	if abs == "" {
+		abs = "??"
+	}
+	return abs
+}
+
+// applyRewrite applies the rewrite to the path,
+// returning the rewritten path and a boolean
+// indicating whether the rewrite applied at all.
+func applyRewrite(path, rewrite string) (string, bool) {
+	prefix, replace := rewrite, ""
+	if j := strings.LastIndex(rewrite, "=>"); j >= 0 {
+		prefix, replace = rewrite[:j], rewrite[j+len("=>"):]
+	}
+
+	if prefix == "" || !hasPathPrefix(path, prefix) {
+		return path, false
+	}
+	if len(path) == len(prefix) {
+		return replace, true
+	}
+	if replace == "" {
+		return path[len(prefix)+1:], true
+	}
+	return replace + path[len(prefix):], true
+}
+
+// Does s have t as a path prefix?
+// That is, does s == t or does s begin with t followed by a slash?
+// For portability, we allow ASCII case folding, so that hasPathPrefix("a/b/c", "A/B") is true.
+// Similarly, we allow slash folding, so that hasPathPrefix("a/b/c", "a\\b") is true.
+// We do not allow full Unicode case folding, for fear of causing more confusion
+// or harm than good. (For an example of the kinds of things that can go wrong,
+// see http://article.gmane.org/gmane.linux.kernel/1853266.)
+func hasPathPrefix(s string, t string) bool {
+	if len(t) > len(s) {
+		return false
+	}
+	var i int
+	for i = 0; i < len(t); i++ {
+		cs := int(s[i])
+		ct := int(t[i])
+		if 'A' <= cs && cs <= 'Z' {
+			cs += 'a' - 'A'
+		}
+		if 'A' <= ct && ct <= 'Z' {
+			ct += 'a' - 'A'
+		}
+		if cs == '\\' {
+			cs = '/'
+		}
+		if ct == '\\' {
+			ct = '/'
+		}
+		if cs != ct {
+			return false
+		}
+	}
+	return i >= len(s) || s[i] == '/' || s[i] == '\\'
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/objabi/path.go b/vendor/github.com/twitchyliquid64/golang-asm/objabi/path.go
new file mode 100644
index 000000000..2a42179a3
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/objabi/path.go
@@ -0,0 +1,41 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package objabi
+
+import "strings"
+
+// PathToPrefix converts raw string to the prefix that will be used in the
+// symbol table. All control characters, space, '%' and '"', as well as
+// non-7-bit clean bytes turn into %xx. The period needs escaping only in the
+// last segment of the path, and it makes for happier users if we escape that as
+// little as possible.
+func PathToPrefix(s string) string {
+	slash := strings.LastIndex(s, "/")
+	// check for chars that need escaping
+	n := 0
+	for r := 0; r < len(s); r++ {
+		if c := s[r]; c <= ' ' || (c == '.' && r > slash) || c == '%' || c == '"' || c >= 0x7F {
+			n++
+		}
+	}
+
+	// quick exit
+	if n == 0 {
+		return s
+	}
+
+	// escape
+	const hex = "0123456789abcdef"
+	p := make([]byte, 0, len(s)+2*n)
+	for r := 0; r < len(s); r++ {
+		if c := s[r]; c <= ' ' || (c == '.' && r > slash) || c == '%' || c == '"' || c >= 0x7F {
+			p = append(p, '%', hex[c>>4], hex[c&0xF])
+		} else {
+			p = append(p, c)
+		}
+	}
+
+	return string(p)
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/objabi/reloctype.go b/vendor/github.com/twitchyliquid64/golang-asm/objabi/reloctype.go
new file mode 100644
index 000000000..f029a3c39
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/objabi/reloctype.go
@@ -0,0 +1,269 @@
+// Derived from Inferno utils/6l/l.h and related files.
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/l.h
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package objabi
+
+type RelocType int16
+
+//go:generate stringer -type=RelocType
+const (
+	R_ADDR RelocType = 1 + iota
+	// R_ADDRPOWER relocates a pair of "D-form" instructions (instructions with 16-bit
+	// immediates in the low half of the instruction word), usually addis followed by
+	// another add or a load, inserting the "high adjusted" 16 bits of the address of
+	// the referenced symbol into the immediate field of the first instruction and the
+	// low 16 bits into that of the second instruction.
+	R_ADDRPOWER
+	// R_ADDRARM64 relocates an adrp, add pair to compute the address of the
+	// referenced symbol.
+	R_ADDRARM64
+	// R_ADDRMIPS (only used on mips/mips64) resolves to the low 16 bits of an external
+	// address, by encoding it into the instruction.
+	R_ADDRMIPS
+	// R_ADDROFF resolves to a 32-bit offset from the beginning of the section
+	// holding the data being relocated to the referenced symbol.
+	R_ADDROFF
+	// R_WEAKADDROFF resolves just like R_ADDROFF but is a weak relocation.
+	// A weak relocation does not make the symbol it refers to reachable,
+	// and is only honored by the linker if the symbol is in some other way
+	// reachable.
+	R_WEAKADDROFF
+	R_SIZE
+	R_CALL
+	R_CALLARM
+	R_CALLARM64
+	R_CALLIND
+	R_CALLPOWER
+	// R_CALLMIPS (only used on mips64) resolves to non-PC-relative target address
+	// of a CALL (JAL) instruction, by encoding the address into the instruction.
+	R_CALLMIPS
+	// R_CALLRISCV marks RISC-V CALLs for stack checking.
+	R_CALLRISCV
+	R_CONST
+	R_PCREL
+	// R_TLS_LE, used on 386, amd64, and ARM, resolves to the offset of the
+	// thread-local symbol from the thread local base and is used to implement the
+	// "local exec" model for tls access (r.Sym is not set on intel platforms but is
+	// set to a TLS symbol -- runtime.tlsg -- in the linker when externally linking).
+	R_TLS_LE
+	// R_TLS_IE, used 386, amd64, and ARM resolves to the PC-relative offset to a GOT
+	// slot containing the offset from the thread-local symbol from the thread local
+	// base and is used to implemented the "initial exec" model for tls access (r.Sym
+	// is not set on intel platforms but is set to a TLS symbol -- runtime.tlsg -- in
+	// the linker when externally linking).
+	R_TLS_IE
+	R_GOTOFF
+	R_PLT0
+	R_PLT1
+	R_PLT2
+	R_USEFIELD
+	// R_USETYPE resolves to an *rtype, but no relocation is created. The
+	// linker uses this as a signal that the pointed-to type information
+	// should be linked into the final binary, even if there are no other
+	// direct references. (This is used for types reachable by reflection.)
+	R_USETYPE
+	// R_METHODOFF resolves to a 32-bit offset from the beginning of the section
+	// holding the data being relocated to the referenced symbol.
+	// It is a variant of R_ADDROFF used when linking from the uncommonType of a
+	// *rtype, and may be set to zero by the linker if it determines the method
+	// text is unreachable by the linked program.
+	R_METHODOFF
+	R_POWER_TOC
+	R_GOTPCREL
+	// R_JMPMIPS (only used on mips64) resolves to non-PC-relative target address
+	// of a JMP instruction, by encoding the address into the instruction.
+	// The stack nosplit check ignores this since it is not a function call.
+	R_JMPMIPS
+
+	// R_DWARFSECREF resolves to the offset of the symbol from its section.
+	// Target of relocation must be size 4 (in current implementation).
+	R_DWARFSECREF
+
+	// R_DWARFFILEREF resolves to an index into the DWARF .debug_line
+	// file table for the specified file symbol. Must be applied to an
+	// attribute of form DW_FORM_data4.
+	R_DWARFFILEREF
+
+	// Platform dependent relocations. Architectures with fixed width instructions
+	// have the inherent issue that a 32-bit (or 64-bit!) displacement cannot be
+	// stuffed into a 32-bit instruction, so an address needs to be spread across
+	// several instructions, and in turn this requires a sequence of relocations, each
+	// updating a part of an instruction. This leads to relocation codes that are
+	// inherently processor specific.
+
+	// Arm64.
+
+	// Set a MOV[NZ] immediate field to bits [15:0] of the offset from the thread
+	// local base to the thread local variable defined by the referenced (thread
+	// local) symbol. Error if the offset does not fit into 16 bits.
+	R_ARM64_TLS_LE
+
+	// Relocates an ADRP; LD64 instruction sequence to load the offset between
+	// the thread local base and the thread local variable defined by the
+	// referenced (thread local) symbol from the GOT.
+	R_ARM64_TLS_IE
+
+	// R_ARM64_GOTPCREL relocates an adrp, ld64 pair to compute the address of the GOT
+	// slot of the referenced symbol.
+	R_ARM64_GOTPCREL
+
+	// R_ARM64_GOT resolves a GOT-relative instruction sequence, usually an adrp
+	// followed by another ld instruction.
+	R_ARM64_GOT
+
+	// R_ARM64_PCREL resolves a PC-relative addresses instruction sequence, usually an
+	// adrp followed by another add instruction.
+	R_ARM64_PCREL
+
+	// R_ARM64_LDST8 sets a LD/ST immediate value to bits [11:0] of a local address.
+	R_ARM64_LDST8
+
+	// R_ARM64_LDST32 sets a LD/ST immediate value to bits [11:2] of a local address.
+	R_ARM64_LDST32
+
+	// R_ARM64_LDST64 sets a LD/ST immediate value to bits [11:3] of a local address.
+	R_ARM64_LDST64
+
+	// R_ARM64_LDST128 sets a LD/ST immediate value to bits [11:4] of a local address.
+	R_ARM64_LDST128
+
+	// PPC64.
+
+	// R_POWER_TLS_LE is used to implement the "local exec" model for tls
+	// access. It resolves to the offset of the thread-local symbol from the
+	// thread pointer (R13) and inserts this value into the low 16 bits of an
+	// instruction word.
+	R_POWER_TLS_LE
+
+	// R_POWER_TLS_IE is used to implement the "initial exec" model for tls access. It
+	// relocates a D-form, DS-form instruction sequence like R_ADDRPOWER_DS. It
+	// inserts to the offset of GOT slot for the thread-local symbol from the TOC (the
+	// GOT slot is filled by the dynamic linker with the offset of the thread-local
+	// symbol from the thread pointer (R13)).
+	R_POWER_TLS_IE
+
+	// R_POWER_TLS marks an X-form instruction such as "MOVD 0(R13)(R31*1), g" as
+	// accessing a particular thread-local symbol. It does not affect code generation
+	// but is used by the system linker when relaxing "initial exec" model code to
+	// "local exec" model code.
+	R_POWER_TLS
+
+	// R_ADDRPOWER_DS is similar to R_ADDRPOWER above, but assumes the second
+	// instruction is a "DS-form" instruction, which has an immediate field occupying
+	// bits [15:2] of the instruction word. Bits [15:2] of the address of the
+	// relocated symbol are inserted into this field; it is an error if the last two
+	// bits of the address are not 0.
+	R_ADDRPOWER_DS
+
+	// R_ADDRPOWER_PCREL relocates a D-form, DS-form instruction sequence like
+	// R_ADDRPOWER_DS but inserts the offset of the GOT slot for the referenced symbol
+	// from the TOC rather than the symbol's address.
+	R_ADDRPOWER_GOT
+
+	// R_ADDRPOWER_PCREL relocates two D-form instructions like R_ADDRPOWER, but
+	// inserts the displacement from the place being relocated to the address of the
+	// relocated symbol instead of just its address.
+	R_ADDRPOWER_PCREL
+
+	// R_ADDRPOWER_TOCREL relocates two D-form instructions like R_ADDRPOWER, but
+	// inserts the offset from the TOC to the address of the relocated symbol
+	// rather than the symbol's address.
+	R_ADDRPOWER_TOCREL
+
+	// R_ADDRPOWER_TOCREL relocates a D-form, DS-form instruction sequence like
+	// R_ADDRPOWER_DS but inserts the offset from the TOC to the address of the
+	// relocated symbol rather than the symbol's address.
+	R_ADDRPOWER_TOCREL_DS
+
+	// RISC-V.
+
+	// R_RISCV_PCREL_ITYPE resolves a 32-bit PC-relative address using an
+	// AUIPC + I-type instruction pair.
+	R_RISCV_PCREL_ITYPE
+
+	// R_RISCV_PCREL_STYPE resolves a 32-bit PC-relative address using an
+	// AUIPC + S-type instruction pair.
+	R_RISCV_PCREL_STYPE
+
+	// R_PCRELDBL relocates s390x 2-byte aligned PC-relative addresses.
+	// TODO(mundaym): remove once variants can be serialized - see issue 14218.
+	R_PCRELDBL
+
+	// R_ADDRMIPSU (only used on mips/mips64) resolves to the sign-adjusted "upper" 16
+	// bits (bit 16-31) of an external address, by encoding it into the instruction.
+	R_ADDRMIPSU
+	// R_ADDRMIPSTLS (only used on mips64) resolves to the low 16 bits of a TLS
+	// address (offset from thread pointer), by encoding it into the instruction.
+	R_ADDRMIPSTLS
+
+	// R_ADDRCUOFF resolves to a pointer-sized offset from the start of the
+	// symbol's DWARF compile unit.
+	R_ADDRCUOFF
+
+	// R_WASMIMPORT resolves to the index of the WebAssembly function import.
+	R_WASMIMPORT
+
+	// R_XCOFFREF (only used on aix/ppc64) prevents garbage collection by ld
+	// of a symbol. This isn't a real relocation, it can be placed in anywhere
+	// in a symbol and target any symbols.
+	R_XCOFFREF
+)
+
+// IsDirectCall reports whether r is a relocation for a direct call.
+// A direct call is a CALL instruction that takes the target address
+// as an immediate. The address is embedded into the instruction, possibly
+// with limited width. An indirect call is a CALL instruction that takes
+// the target address in register or memory.
+func (r RelocType) IsDirectCall() bool {
+	switch r {
+	case R_CALL, R_CALLARM, R_CALLARM64, R_CALLMIPS, R_CALLPOWER, R_CALLRISCV:
+		return true
+	}
+	return false
+}
+
+// IsDirectJump reports whether r is a relocation for a direct jump.
+// A direct jump is a JMP instruction that takes the target address
+// as an immediate. The address is embedded into the instruction, possibly
+// with limited width. An indirect jump is a JMP instruction that takes
+// the target address in register or memory.
+func (r RelocType) IsDirectJump() bool {
+	switch r {
+	case R_JMPMIPS:
+		return true
+	}
+	return false
+}
+
+// IsDirectCallOrJump reports whether r is a relocation for a direct
+// call or a direct jump.
+func (r RelocType) IsDirectCallOrJump() bool {
+	return r.IsDirectCall() || r.IsDirectJump()
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/objabi/reloctype_string.go b/vendor/github.com/twitchyliquid64/golang-asm/objabi/reloctype_string.go
new file mode 100644
index 000000000..83dfe71e0
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/objabi/reloctype_string.go
@@ -0,0 +1,17 @@
+// Code generated by "stringer -type=RelocType"; DO NOT EDIT.
+
+package objabi
+
+import "strconv"
+
+const _RelocType_name = "R_ADDRR_ADDRPOWERR_ADDRARM64R_ADDRMIPSR_ADDROFFR_WEAKADDROFFR_SIZER_CALLR_CALLARMR_CALLARM64R_CALLINDR_CALLPOWERR_CALLMIPSR_CALLRISCVR_CONSTR_PCRELR_TLS_LER_TLS_IER_GOTOFFR_PLT0R_PLT1R_PLT2R_USEFIELDR_USETYPER_METHODOFFR_POWER_TOCR_GOTPCRELR_JMPMIPSR_DWARFSECREFR_DWARFFILEREFR_ARM64_TLS_LER_ARM64_TLS_IER_ARM64_GOTPCRELR_ARM64_GOTR_ARM64_PCRELR_ARM64_LDST8R_ARM64_LDST32R_ARM64_LDST64R_ARM64_LDST128R_POWER_TLS_LER_POWER_TLS_IER_POWER_TLSR_ADDRPOWER_DSR_ADDRPOWER_GOTR_ADDRPOWER_PCRELR_ADDRPOWER_TOCRELR_ADDRPOWER_TOCREL_DSR_RISCV_PCREL_ITYPER_RISCV_PCREL_STYPER_PCRELDBLR_ADDRMIPSUR_ADDRMIPSTLSR_ADDRCUOFFR_WASMIMPORTR_XCOFFREF"
+
+var _RelocType_index = [...]uint16{0, 6, 17, 28, 38, 47, 60, 66, 72, 81, 92, 101, 112, 122, 133, 140, 147, 155, 163, 171, 177, 183, 189, 199, 208, 219, 230, 240, 249, 262, 276, 290, 304, 320, 331, 344, 357, 371, 385, 400, 414, 428, 439, 453, 468, 485, 503, 524, 543, 562, 572, 583, 596, 607, 619, 629}
+
+func (i RelocType) String() string {
+	i -= 1
+	if i < 0 || i >= RelocType(len(_RelocType_index)-1) {
+		return "RelocType(" + strconv.FormatInt(int64(i+1), 10) + ")"
+	}
+	return _RelocType_name[_RelocType_index[i]:_RelocType_index[i+1]]
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/objabi/stack.go b/vendor/github.com/twitchyliquid64/golang-asm/objabi/stack.go
new file mode 100644
index 000000000..389de5867
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/objabi/stack.go
@@ -0,0 +1,33 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package objabi
+
+// For the linkers. Must match Go definitions.
+
+const (
+	STACKSYSTEM = 0
+	StackSystem = STACKSYSTEM
+	StackBig    = 4096
+	StackSmall  = 128
+)
+
+const (
+	StackPreempt = -1314 // 0xfff...fade
+)
+
+// Initialize StackGuard and StackLimit according to target system.
+var StackGuard = 928*stackGuardMultiplier() + StackSystem
+var StackLimit = StackGuard - StackSystem - StackSmall
+
+// stackGuardMultiplier returns a multiplier to apply to the default
+// stack guard size. Larger multipliers are used for non-optimized
+// builds that have larger stack frames or for specific targets.
+func stackGuardMultiplier() int {
+	// On AIX, a larger stack is needed for syscalls.
+	if GOOS == "aix" {
+		return 2
+	}
+	return 1
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/objabi/symkind.go b/vendor/github.com/twitchyliquid64/golang-asm/objabi/symkind.go
new file mode 100644
index 000000000..6c991121e
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/objabi/symkind.go
@@ -0,0 +1,79 @@
+// Derived from Inferno utils/6l/l.h and related files.
+// https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/l.h
+//
+//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
+//	Portions Copyright © 1997-1999 Vita Nuova Limited
+//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
+//	Portions Copyright © 2004,2006 Bruce Ellis
+//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
+//	Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
+//	Portions Copyright © 2009 The Go Authors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package objabi
+
+// A SymKind describes the kind of memory represented by a symbol.
+type SymKind uint8
+
+// Defined SymKind values.
+// These are used to index into cmd/link/internal/sym/AbiSymKindToSymKind
+//
+// TODO(rsc): Give idiomatic Go names.
+//go:generate stringer -type=SymKind
+const (
+	// An otherwise invalid zero value for the type
+	Sxxx SymKind = iota
+	// Executable instructions
+	STEXT
+	// Read only static data
+	SRODATA
+	// Static data that does not contain any pointers
+	SNOPTRDATA
+	// Static data
+	SDATA
+	// Statically data that is initially all 0s
+	SBSS
+	// Statically data that is initially all 0s and does not contain pointers
+	SNOPTRBSS
+	// Thread-local data that is initially all 0s
+	STLSBSS
+	// Debugging data
+	SDWARFCUINFO
+	SDWARFCONST
+	SDWARFFCN
+	SDWARFABSFCN
+	SDWARFTYPE
+	SDWARFVAR
+	SDWARFRANGE
+	SDWARFLOC
+	SDWARFLINES
+	// ABI alias. An ABI alias symbol is an empty symbol with a
+	// single relocation with 0 size that references the native
+	// function implementation symbol.
+	//
+	// TODO(austin): Remove this and all uses once the compiler
+	// generates real ABI wrappers rather than symbol aliases.
+	SABIALIAS
+	// Coverage instrumentation counter for libfuzzer.
+	SLIBFUZZER_EXTRA_COUNTER
+	// Update cmd/link/internal/sym/AbiSymKindToSymKind for new SymKind values.
+
+)
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/objabi/symkind_string.go b/vendor/github.com/twitchyliquid64/golang-asm/objabi/symkind_string.go
new file mode 100644
index 000000000..1b1c39403
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/objabi/symkind_string.go
@@ -0,0 +1,41 @@
+// Code generated by "stringer -type=SymKind"; DO NOT EDIT.
+
+package objabi
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[Sxxx-0]
+	_ = x[STEXT-1]
+	_ = x[SRODATA-2]
+	_ = x[SNOPTRDATA-3]
+	_ = x[SDATA-4]
+	_ = x[SBSS-5]
+	_ = x[SNOPTRBSS-6]
+	_ = x[STLSBSS-7]
+	_ = x[SDWARFCUINFO-8]
+	_ = x[SDWARFCONST-9]
+	_ = x[SDWARFFCN-10]
+	_ = x[SDWARFABSFCN-11]
+	_ = x[SDWARFTYPE-12]
+	_ = x[SDWARFVAR-13]
+	_ = x[SDWARFRANGE-14]
+	_ = x[SDWARFLOC-15]
+	_ = x[SDWARFLINES-16]
+	_ = x[SABIALIAS-17]
+	_ = x[SLIBFUZZER_EXTRA_COUNTER-18]
+}
+
+const _SymKind_name = "SxxxSTEXTSRODATASNOPTRDATASDATASBSSSNOPTRBSSSTLSBSSSDWARFCUINFOSDWARFCONSTSDWARFFCNSDWARFABSFCNSDWARFTYPESDWARFVARSDWARFRANGESDWARFLOCSDWARFLINESSABIALIASSLIBFUZZER_EXTRA_COUNTER"
+
+var _SymKind_index = [...]uint8{0, 4, 9, 16, 26, 31, 35, 44, 51, 63, 74, 83, 95, 105, 114, 125, 134, 145, 154, 178}
+
+func (i SymKind) String() string {
+	if i >= SymKind(len(_SymKind_index)-1) {
+		return "SymKind(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+	return _SymKind_name[_SymKind_index[i]:_SymKind_index[i+1]]
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/objabi/typekind.go b/vendor/github.com/twitchyliquid64/golang-asm/objabi/typekind.go
new file mode 100644
index 000000000..990ff1888
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/objabi/typekind.go
@@ -0,0 +1,40 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package objabi
+
+// Must match runtime and reflect.
+// Included by cmd/gc.
+
+const (
+	KindBool = 1 + iota
+	KindInt
+	KindInt8
+	KindInt16
+	KindInt32
+	KindInt64
+	KindUint
+	KindUint8
+	KindUint16
+	KindUint32
+	KindUint64
+	KindUintptr
+	KindFloat32
+	KindFloat64
+	KindComplex64
+	KindComplex128
+	KindArray
+	KindChan
+	KindFunc
+	KindInterface
+	KindMap
+	KindPtr
+	KindSlice
+	KindString
+	KindStruct
+	KindUnsafePointer
+	KindDirectIface = 1 << 5
+	KindGCProg      = 1 << 6
+	KindMask        = (1 << 5) - 1
+)
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/objabi/util.go b/vendor/github.com/twitchyliquid64/golang-asm/objabi/util.go
new file mode 100644
index 000000000..2c7b66e4d
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/objabi/util.go
@@ -0,0 +1,203 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package objabi
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"strings"
+)
+
+func envOr(key, value string) string {
+	if x := os.Getenv(key); x != "" {
+		return x
+	}
+	return value
+}
+
+var (
+	defaultGOROOT string // set by linker
+
+	GOROOT   = envOr("GOROOT", defaultGOROOT)
+	GOARCH   = envOr("GOARCH", "amd64")
+	GOOS     = envOr("GOOS", "linux")
+	GO386    = envOr("GO386", "")
+	GOAMD64  = goamd64()
+	GOARM    = goarm()
+	GOMIPS   = gomips()
+	GOMIPS64 = gomips64()
+	GOPPC64  = goppc64()
+	GOWASM   = gowasm()
+	GO_LDSO  = ""
+	Version  = ""
+)
+
+const (
+	ElfRelocOffset   = 256
+	MachoRelocOffset = 2048           // reserve enough space for ELF relocations
+	Go115AMD64       = "alignedjumps" // Should be "alignedjumps" or "normaljumps"; this replaces environment variable introduced in CL 219357.
+)
+
+// TODO(1.16): assuming no issues in 1.15 release, remove this and related constant.
+func goamd64() string {
+	return Go115AMD64
+}
+
+func goarm() int {
+	switch v := envOr("GOARM", "7"); v {
+	case "5":
+		return 5
+	case "6":
+		return 6
+	case "7":
+		return 7
+	}
+	// Fail here, rather than validate at multiple call sites.
+	log.Fatalf("Invalid GOARM value. Must be 5, 6, or 7.")
+	panic("unreachable")
+}
+
+func gomips() string {
+	switch v := envOr("GOMIPS", "hardfloat"); v {
+	case "hardfloat", "softfloat":
+		return v
+	}
+	log.Fatalf("Invalid GOMIPS value. Must be hardfloat or softfloat.")
+	panic("unreachable")
+}
+
+func gomips64() string {
+	switch v := envOr("GOMIPS64", "hardfloat"); v {
+	case "hardfloat", "softfloat":
+		return v
+	}
+	log.Fatalf("Invalid GOMIPS64 value. Must be hardfloat or softfloat.")
+	panic("unreachable")
+}
+
+func goppc64() int {
+	switch v := envOr("GOPPC64", "power8"); v {
+	case "power8":
+		return 8
+	case "power9":
+		return 9
+	}
+	log.Fatalf("Invalid GOPPC64 value. Must be power8 or power9.")
+	panic("unreachable")
+}
+
+type gowasmFeatures struct {
+	SignExt bool
+	SatConv bool
+}
+
+func (f gowasmFeatures) String() string {
+	var flags []string
+	if f.SatConv {
+		flags = append(flags, "satconv")
+	}
+	if f.SignExt {
+		flags = append(flags, "signext")
+	}
+	return strings.Join(flags, ",")
+}
+
+func gowasm() (f gowasmFeatures) {
+	for _, opt := range strings.Split(envOr("GOWASM", ""), ",") {
+		switch opt {
+		case "satconv":
+			f.SatConv = true
+		case "signext":
+			f.SignExt = true
+		case "":
+			// ignore
+		default:
+			log.Fatalf("Invalid GOWASM value. No such feature: " + opt)
+		}
+	}
+	return
+}
+
+func Getgoextlinkenabled() string {
+	return envOr("GO_EXTLINK_ENABLED", "")
+}
+
+func init() {
+	for _, f := range strings.Split("", ",") {
+		if f != "" {
+			addexp(f)
+		}
+	}
+
+	// regabi is only supported on amd64.
+	if GOARCH != "amd64" {
+		Regabi_enabled = 0
+	}
+}
+
+// Note: must agree with runtime.framepointer_enabled.
+var Framepointer_enabled = GOARCH == "amd64" || GOARCH == "arm64" && (GOOS == "linux" || GOOS == "darwin")
+
+func addexp(s string) {
+	// Could do general integer parsing here, but the runtime copy doesn't yet.
+	v := 1
+	name := s
+	if len(name) > 2 && name[:2] == "no" {
+		v = 0
+		name = name[2:]
+	}
+	for i := 0; i < len(exper); i++ {
+		if exper[i].name == name {
+			if exper[i].val != nil {
+				*exper[i].val = v
+			}
+			return
+		}
+	}
+
+	fmt.Printf("unknown experiment %s\n", s)
+	os.Exit(2)
+}
+
+var (
+	Fieldtrack_enabled        int
+	Preemptibleloops_enabled  int
+	Staticlockranking_enabled int
+	Regabi_enabled            int
+)
+
+// Toolchain experiments.
+// These are controlled by the GOEXPERIMENT environment
+// variable recorded when the toolchain is built.
+// This list is also known to cmd/gc.
+var exper = []struct {
+	name string
+	val  *int
+}{
+	{"fieldtrack", &Fieldtrack_enabled},
+	{"preemptibleloops", &Preemptibleloops_enabled},
+	{"staticlockranking", &Staticlockranking_enabled},
+	{"regabi", &Regabi_enabled},
+}
+
+var defaultExpstring = Expstring()
+
+func DefaultExpstring() string {
+	return defaultExpstring
+}
+
+func Expstring() string {
+	buf := "X"
+	for i := range exper {
+		if *exper[i].val != 0 {
+			buf += "," + exper[i].name
+		}
+	}
+	if buf == "X" {
+		buf += ",none"
+	}
+	return "X:" + buf[2:]
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/src/pos.go b/vendor/github.com/twitchyliquid64/golang-asm/src/pos.go
new file mode 100644
index 000000000..b6816a56e
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/src/pos.go
@@ -0,0 +1,470 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file implements the encoding of source positions.
+
+package src
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+)
+
+// A Pos encodes a source position consisting of a (line, column) number pair
+// and a position base. A zero Pos is a ready to use "unknown" position (nil
+// position base and zero line number).
+//
+// The (line, column) values refer to a position in a file independent of any
+// position base ("absolute" file position).
+//
+// The position base is used to determine the "relative" position, that is the
+// filename and line number relative to the position base. If the base refers
+// to the current file, there is no difference between absolute and relative
+// positions. If it refers to a //line directive, a relative position is relative
+// to that directive. A position base in turn contains the position at which it
+// was introduced in the current file.
+type Pos struct {
+	base *PosBase
+	lico
+}
+
+// NoPos is a valid unknown position.
+var NoPos Pos
+
+// MakePos creates a new Pos value with the given base, and (file-absolute)
+// line and column.
+func MakePos(base *PosBase, line, col uint) Pos {
+	return Pos{base, makeLico(line, col)}
+}
+
+// IsKnown reports whether the position p is known.
+// A position is known if it either has a non-nil
+// position base, or a non-zero line number.
+func (p Pos) IsKnown() bool {
+	return p.base != nil || p.Line() != 0
+}
+
+// Before reports whether the position p comes before q in the source.
+// For positions in different files, ordering is by filename.
+func (p Pos) Before(q Pos) bool {
+	n, m := p.Filename(), q.Filename()
+	return n < m || n == m && p.lico < q.lico
+}
+
+// After reports whether the position p comes after q in the source.
+// For positions in different files, ordering is by filename.
+func (p Pos) After(q Pos) bool {
+	n, m := p.Filename(), q.Filename()
+	return n > m || n == m && p.lico > q.lico
+}
+
+func (p Pos) LineNumber() string {
+	if !p.IsKnown() {
+		return "?"
+	}
+	return p.lico.lineNumber()
+}
+
+func (p Pos) LineNumberHTML() string {
+	if !p.IsKnown() {
+		return "?"
+	}
+	return p.lico.lineNumberHTML()
+}
+
+// Filename returns the name of the actual file containing this position.
+func (p Pos) Filename() string { return p.base.Pos().RelFilename() }
+
+// Base returns the position base.
+func (p Pos) Base() *PosBase { return p.base }
+
+// SetBase sets the position base.
+func (p *Pos) SetBase(base *PosBase) { p.base = base }
+
+// RelFilename returns the filename recorded with the position's base.
+func (p Pos) RelFilename() string { return p.base.Filename() }
+
+// RelLine returns the line number relative to the position's base.
+func (p Pos) RelLine() uint {
+	b := p.base
+	if b.Line() == 0 {
+		// base line is unknown => relative line is unknown
+		return 0
+	}
+	return b.Line() + (p.Line() - b.Pos().Line())
+}
+
+// RelCol returns the column number relative to the position's base.
+func (p Pos) RelCol() uint {
+	b := p.base
+	if b.Col() == 0 {
+		// base column is unknown => relative column is unknown
+		// (the current specification for line directives requires
+		// this to apply until the next PosBase/line directive,
+		// not just until the new newline)
+		return 0
+	}
+	if p.Line() == b.Pos().Line() {
+		// p on same line as p's base => column is relative to p's base
+		return b.Col() + (p.Col() - b.Pos().Col())
+	}
+	return p.Col()
+}
+
+// AbsFilename() returns the absolute filename recorded with the position's base.
+func (p Pos) AbsFilename() string { return p.base.AbsFilename() }
+
+// SymFilename() returns the absolute filename recorded with the position's base,
+// prefixed by FileSymPrefix to make it appropriate for use as a linker symbol.
+func (p Pos) SymFilename() string { return p.base.SymFilename() }
+
+func (p Pos) String() string {
+	return p.Format(true, true)
+}
+
+// Format formats a position as "filename:line" or "filename:line:column",
+// controlled by the showCol flag and if the column is known (!= 0).
+// For positions relative to line directives, the original position is
+// shown as well, as in "filename:line[origfile:origline:origcolumn] if
+// showOrig is set.
+func (p Pos) Format(showCol, showOrig bool) string {
+	buf := new(bytes.Buffer)
+	p.WriteTo(buf, showCol, showOrig)
+	return buf.String()
+}
+
+// WriteTo a position to w, formatted as Format does.
+func (p Pos) WriteTo(w io.Writer, showCol, showOrig bool) {
+	if !p.IsKnown() {
+		io.WriteString(w, "<unknown line number>")
+		return
+	}
+
+	if b := p.base; b == b.Pos().base {
+		// base is file base (incl. nil)
+		format(w, p.Filename(), p.Line(), p.Col(), showCol)
+		return
+	}
+
+	// base is relative
+	// Print the column only for the original position since the
+	// relative position's column information may be bogus (it's
+	// typically generated code and we can't say much about the
+	// original source at that point but for the file:line info
+	// that's provided via a line directive).
+	// TODO(gri) This may not be true if we have an inlining base.
+	// We may want to differentiate at some point.
+	format(w, p.RelFilename(), p.RelLine(), p.RelCol(), showCol)
+	if showOrig {
+		io.WriteString(w, "[")
+		format(w, p.Filename(), p.Line(), p.Col(), showCol)
+		io.WriteString(w, "]")
+	}
+}
+
+// format formats a (filename, line, col) tuple as "filename:line" (showCol
+// is false or col == 0) or "filename:line:column" (showCol is true and col != 0).
+func format(w io.Writer, filename string, line, col uint, showCol bool) {
+	io.WriteString(w, filename)
+	io.WriteString(w, ":")
+	fmt.Fprint(w, line)
+	// col == 0 and col == colMax are interpreted as unknown column values
+	if showCol && 0 < col && col < colMax {
+		io.WriteString(w, ":")
+		fmt.Fprint(w, col)
+	}
+}
+
+// formatstr wraps format to return a string.
+func formatstr(filename string, line, col uint, showCol bool) string {
+	buf := new(bytes.Buffer)
+	format(buf, filename, line, col, showCol)
+	return buf.String()
+}
+
+// ----------------------------------------------------------------------------
+// PosBase
+
+// A PosBase encodes a filename and base position.
+// Typically, each file and line directive introduce a PosBase.
+type PosBase struct {
+	pos         Pos    // position at which the relative position is (line, col)
+	filename    string // file name used to open source file, for error messages
+	absFilename string // absolute file name, for PC-Line tables
+	symFilename string // cached symbol file name, to avoid repeated string concatenation
+	line, col   uint   // relative line, column number at pos
+	inl         int    // inlining index (see cmd/internal/obj/inl.go)
+}
+
+// NewFileBase returns a new *PosBase for a file with the given (relative and
+// absolute) filenames.
+func NewFileBase(filename, absFilename string) *PosBase {
+	base := &PosBase{
+		filename:    filename,
+		absFilename: absFilename,
+		symFilename: FileSymPrefix + absFilename,
+		line:        1,
+		col:         1,
+		inl:         -1,
+	}
+	base.pos = MakePos(base, 1, 1)
+	return base
+}
+
+// NewLinePragmaBase returns a new *PosBase for a line directive of the form
+//      //line filename:line:col
+//      /*line filename:line:col*/
+// at position pos.
+func NewLinePragmaBase(pos Pos, filename, absFilename string, line, col uint) *PosBase {
+	return &PosBase{pos, filename, absFilename, FileSymPrefix + absFilename, line, col, -1}
+}
+
+// NewInliningBase returns a copy of the old PosBase with the given inlining
+// index. If old == nil, the resulting PosBase has no filename.
+func NewInliningBase(old *PosBase, inlTreeIndex int) *PosBase {
+	if old == nil {
+		base := &PosBase{line: 1, col: 1, inl: inlTreeIndex}
+		base.pos = MakePos(base, 1, 1)
+		return base
+	}
+	copy := *old
+	base := &copy
+	base.inl = inlTreeIndex
+	if old == old.pos.base {
+		base.pos.base = base
+	}
+	return base
+}
+
+var noPos Pos
+
+// Pos returns the position at which base is located.
+// If b == nil, the result is the zero position.
+func (b *PosBase) Pos() *Pos {
+	if b != nil {
+		return &b.pos
+	}
+	return &noPos
+}
+
+// Filename returns the filename recorded with the base.
+// If b == nil, the result is the empty string.
+func (b *PosBase) Filename() string {
+	if b != nil {
+		return b.filename
+	}
+	return ""
+}
+
+// AbsFilename returns the absolute filename recorded with the base.
+// If b == nil, the result is the empty string.
+func (b *PosBase) AbsFilename() string {
+	if b != nil {
+		return b.absFilename
+	}
+	return ""
+}
+
+const FileSymPrefix = "gofile.."
+
+// SymFilename returns the absolute filename recorded with the base,
+// prefixed by FileSymPrefix to make it appropriate for use as a linker symbol.
+// If b is nil, SymFilename returns FileSymPrefix + "??".
+func (b *PosBase) SymFilename() string {
+	if b != nil {
+		return b.symFilename
+	}
+	return FileSymPrefix + "??"
+}
+
+// Line returns the line number recorded with the base.
+// If b == nil, the result is 0.
+func (b *PosBase) Line() uint {
+	if b != nil {
+		return b.line
+	}
+	return 0
+}
+
+// Col returns the column number recorded with the base.
+// If b == nil, the result is 0.
+func (b *PosBase) Col() uint {
+	if b != nil {
+		return b.col
+	}
+	return 0
+}
+
+// InliningIndex returns the index into the global inlining
+// tree recorded with the base. If b == nil or the base has
+// not been inlined, the result is < 0.
+func (b *PosBase) InliningIndex() int {
+	if b != nil {
+		return b.inl
+	}
+	return -1
+}
+
+// ----------------------------------------------------------------------------
+// lico
+
+// A lico is a compact encoding of a LIne and COlumn number.
+type lico uint32
+
+// Layout constants: 20 bits for line, 8 bits for column, 2 for isStmt, 2 for pro/epilogue
+// (If this is too tight, we can either make lico 64b wide,
+// or we can introduce a tiered encoding where we remove column
+// information as line numbers grow bigger; similar to what gcc
+// does.)
+// The bitfield order is chosen to make IsStmt be the least significant
+// part of a position; its use is to communicate statement edges through
+// instruction scrambling in code generation, not to impose an order.
+// TODO: Prologue and epilogue are perhaps better handled as pseudo-ops for the assembler,
+// because they have almost no interaction with other uses of the position.
+const (
+	lineBits, lineMax     = 20, 1<<lineBits - 2
+	bogusLine             = 1 // Used to disrupt infinite loops to prevent debugger looping
+	isStmtBits, isStmtMax = 2, 1<<isStmtBits - 1
+	xlogueBits, xlogueMax = 2, 1<<xlogueBits - 1
+	colBits, colMax       = 32 - lineBits - xlogueBits - isStmtBits, 1<<colBits - 1
+
+	isStmtShift = 0
+	isStmtMask  = isStmtMax << isStmtShift
+	xlogueShift = isStmtBits + isStmtShift
+	xlogueMask  = xlogueMax << xlogueShift
+	colShift    = xlogueBits + xlogueShift
+	lineShift   = colBits + colShift
+)
+const (
+	// It is expected that the front end or a phase in SSA will usually generate positions tagged with
+	// PosDefaultStmt, but note statement boundaries with PosIsStmt.  Simple statements will have a single
+	// boundary; for loops with initialization may have one for their entry and one for their back edge
+	// (this depends on exactly how the loop is compiled; the intent is to provide a good experience to a
+	// user debugging a program; the goal is that a breakpoint set on the loop line fires both on entry
+	// and on iteration).  Proper treatment of non-gofmt input with multiple simple statements on a single
+	// line is TBD.
+	//
+	// Optimizing compilation will move instructions around, and some of these will become known-bad as
+	// step targets for debugging purposes (examples: register spills and reloads; code generated into
+	// the entry block; invariant code hoisted out of loops) but those instructions will still have interesting
+	// positions for profiling purposes. To reflect this these positions will be changed to PosNotStmt.
+	//
+	// When the optimizer removes an instruction marked PosIsStmt; it should attempt to find a nearby
+	// instruction with the same line marked PosDefaultStmt to be the new statement boundary.  I.e., the
+	// optimizer should make a best-effort to conserve statement boundary positions, and might be enhanced
+	// to note when a statement boundary is not conserved.
+	//
+	// Code cloning, e.g. loop unrolling or loop unswitching, is an exception to the conservation rule
+	// because a user running a debugger would expect to see breakpoints active in the copies of the code.
+	//
+	// In non-optimizing compilation there is still a role for PosNotStmt because of code generation
+	// into the entry block.  PosIsStmt statement positions should be conserved.
+	//
+	// When code generation occurs any remaining default-marked positions are replaced with not-statement
+	// positions.
+	//
+	PosDefaultStmt uint = iota // Default; position is not a statement boundary, but might be if optimization removes the designated statement boundary
+	PosIsStmt                  // Position is a statement boundary; if optimization removes the corresponding instruction, it should attempt to find a new instruction to be the boundary.
+	PosNotStmt                 // Position should not be a statement boundary, but line should be preserved for profiling and low-level debugging purposes.
+)
+
+type PosXlogue uint
+
+const (
+	PosDefaultLogue PosXlogue = iota
+	PosPrologueEnd
+	PosEpilogueBegin
+)
+
+func makeLicoRaw(line, col uint) lico {
+	return lico(line<<lineShift | col<<colShift)
+}
+
+// This is a not-position that will not be elided.
+// Depending on the debugger (gdb or delve) it may or may not be displayed.
+func makeBogusLico() lico {
+	return makeLicoRaw(bogusLine, 0).withIsStmt()
+}
+
+func makeLico(line, col uint) lico {
+	if line > lineMax {
+		// cannot represent line, use max. line so we have some information
+		line = lineMax
+	}
+	if col > colMax {
+		// cannot represent column, use max. column so we have some information
+		col = colMax
+	}
+	// default is not-sure-if-statement
+	return makeLicoRaw(line, col)
+}
+
+func (x lico) Line() uint           { return uint(x) >> lineShift }
+func (x lico) SameLine(y lico) bool { return 0 == (x^y)&^lico(1<<lineShift-1) }
+func (x lico) Col() uint            { return uint(x) >> colShift & colMax }
+func (x lico) IsStmt() uint {
+	if x == 0 {
+		return PosNotStmt
+	}
+	return uint(x) >> isStmtShift & isStmtMax
+}
+func (x lico) Xlogue() PosXlogue {
+	return PosXlogue(uint(x) >> xlogueShift & xlogueMax)
+}
+
+// withNotStmt returns a lico for the same location, but not a statement
+func (x lico) withNotStmt() lico {
+	return x.withStmt(PosNotStmt)
+}
+
+// withDefaultStmt returns a lico for the same location, with default isStmt
+func (x lico) withDefaultStmt() lico {
+	return x.withStmt(PosDefaultStmt)
+}
+
+// withIsStmt returns a lico for the same location, tagged as definitely a statement
+func (x lico) withIsStmt() lico {
+	return x.withStmt(PosIsStmt)
+}
+
+// withLogue attaches a prologue/epilogue attribute to a lico
+func (x lico) withXlogue(xlogue PosXlogue) lico {
+	if x == 0 {
+		if xlogue == 0 {
+			return x
+		}
+		// Normalize 0 to "not a statement"
+		x = lico(PosNotStmt << isStmtShift)
+	}
+	return lico(uint(x) & ^uint(xlogueMax<<xlogueShift) | (uint(xlogue) << xlogueShift))
+}
+
+// withStmt returns a lico for the same location with specified is_stmt attribute
+func (x lico) withStmt(stmt uint) lico {
+	if x == 0 {
+		return lico(0)
+	}
+	return lico(uint(x) & ^uint(isStmtMax<<isStmtShift) | (stmt << isStmtShift))
+}
+
+func (x lico) lineNumber() string {
+	return fmt.Sprintf("%d", x.Line())
+}
+
+func (x lico) lineNumberHTML() string {
+	if x.IsStmt() == PosDefaultStmt {
+		return fmt.Sprintf("%d", x.Line())
+	}
+	style, pfx := "b", "+"
+	if x.IsStmt() == PosNotStmt {
+		style = "s" // /strike not supported in HTML5
+		pfx = ""
+	}
+	return fmt.Sprintf("<%s>%s%d</%s>", style, pfx, x.Line(), style)
+}
+
+func (x lico) atColumn1() lico {
+	return makeLico(x.Line(), 1).withIsStmt()
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/src/xpos.go b/vendor/github.com/twitchyliquid64/golang-asm/src/xpos.go
new file mode 100644
index 000000000..867d0ab06
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/src/xpos.go
@@ -0,0 +1,176 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file implements the compressed encoding of source
+// positions using a lookup table.
+
+package src
+
+// XPos is a more compact representation of Pos.
+type XPos struct {
+	index int32
+	lico
+}
+
+// NoXPos is a valid unknown position.
+var NoXPos XPos
+
+// IsKnown reports whether the position p is known.
+// XPos.IsKnown() matches Pos.IsKnown() for corresponding
+// positions.
+func (p XPos) IsKnown() bool {
+	return p.index != 0 || p.Line() != 0
+}
+
+// Before reports whether the position p comes before q in the source.
+// For positions with different bases, ordering is by base index.
+func (p XPos) Before(q XPos) bool {
+	n, m := p.index, q.index
+	return n < m || n == m && p.lico < q.lico
+}
+
+// SameFile reports whether p and q are positions in the same file.
+func (p XPos) SameFile(q XPos) bool {
+	return p.index == q.index
+}
+
+// SameFileAndLine reports whether p and q are positions on the same line in the same file.
+func (p XPos) SameFileAndLine(q XPos) bool {
+	return p.index == q.index && p.lico.SameLine(q.lico)
+}
+
+// After reports whether the position p comes after q in the source.
+// For positions with different bases, ordering is by base index.
+func (p XPos) After(q XPos) bool {
+	n, m := p.index, q.index
+	return n > m || n == m && p.lico > q.lico
+}
+
+// WithNotStmt returns the same location to be marked with DWARF is_stmt=0
+func (p XPos) WithNotStmt() XPos {
+	p.lico = p.lico.withNotStmt()
+	return p
+}
+
+// WithDefaultStmt returns the same location with undetermined is_stmt
+func (p XPos) WithDefaultStmt() XPos {
+	p.lico = p.lico.withDefaultStmt()
+	return p
+}
+
+// WithIsStmt returns the same location to be marked with DWARF is_stmt=1
+func (p XPos) WithIsStmt() XPos {
+	p.lico = p.lico.withIsStmt()
+	return p
+}
+
+// WithBogusLine returns a bogus line that won't match any recorded for the source code.
+// Its use is to disrupt the statements within an infinite loop so that the debugger
+// will not itself loop infinitely waiting for the line number to change.
+// gdb chooses not to display the bogus line; delve shows it with a complaint, but the
+// alternative behavior is to hang.
+func (p XPos) WithBogusLine() XPos {
+	if p.index == 0 {
+		// See #35652
+		panic("Assigning a bogus line to XPos with no file will cause mysterious downstream failures.")
+	}
+	p.lico = makeBogusLico()
+	return p
+}
+
+// WithXlogue returns the same location but marked with DWARF function prologue/epilogue
+func (p XPos) WithXlogue(x PosXlogue) XPos {
+	p.lico = p.lico.withXlogue(x)
+	return p
+}
+
+// LineNumber returns a string for the line number, "?" if it is not known.
+func (p XPos) LineNumber() string {
+	if !p.IsKnown() {
+		return "?"
+	}
+	return p.lico.lineNumber()
+}
+
+// FileIndex returns a smallish non-negative integer corresponding to the
+// file for this source position.  Smallish is relative; it can be thousands
+// large, but not millions.
+func (p XPos) FileIndex() int32 {
+	return p.index
+}
+
+func (p XPos) LineNumberHTML() string {
+	if !p.IsKnown() {
+		return "?"
+	}
+	return p.lico.lineNumberHTML()
+}
+
+// AtColumn1 returns the same location but shifted to column 1.
+func (p XPos) AtColumn1() XPos {
+	p.lico = p.lico.atColumn1()
+	return p
+}
+
+// A PosTable tracks Pos -> XPos conversions and vice versa.
+// Its zero value is a ready-to-use PosTable.
+type PosTable struct {
+	baseList []*PosBase
+	indexMap map[*PosBase]int
+	nameMap  map[string]int // Maps file symbol name to index for debug information.
+}
+
+// XPos returns the corresponding XPos for the given pos,
+// adding pos to t if necessary.
+func (t *PosTable) XPos(pos Pos) XPos {
+	m := t.indexMap
+	if m == nil {
+		// Create new list and map and populate with nil
+		// base so that NoPos always gets index 0.
+		t.baseList = append(t.baseList, nil)
+		m = map[*PosBase]int{nil: 0}
+		t.indexMap = m
+		t.nameMap = make(map[string]int)
+	}
+	i, ok := m[pos.base]
+	if !ok {
+		i = len(t.baseList)
+		t.baseList = append(t.baseList, pos.base)
+		t.indexMap[pos.base] = i
+		if _, ok := t.nameMap[pos.base.symFilename]; !ok {
+			t.nameMap[pos.base.symFilename] = len(t.nameMap)
+		}
+	}
+	return XPos{int32(i), pos.lico}
+}
+
+// Pos returns the corresponding Pos for the given p.
+// If p cannot be translated via t, the function panics.
+func (t *PosTable) Pos(p XPos) Pos {
+	var base *PosBase
+	if p.index != 0 {
+		base = t.baseList[p.index]
+	}
+	return Pos{base, p.lico}
+}
+
+// FileIndex returns the index of the given filename(symbol) in the PosTable, or -1 if not found.
+func (t *PosTable) FileIndex(filename string) int {
+	if v, ok := t.nameMap[filename]; ok {
+		return v
+	}
+	return -1
+}
+
+// FileTable returns a slice of all files used to build this package.
+func (t *PosTable) FileTable() []string {
+	// Create a LUT of the global package level file indices. This table is what
+	// is written in the debug_lines header, the file[N] will be referenced as
+	// N+1 in the debug_lines table.
+	fileLUT := make([]string, len(t.nameMap))
+	for str, i := range t.nameMap {
+		fileLUT[i] = str
+	}
+	return fileLUT
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/sys/arch.go b/vendor/github.com/twitchyliquid64/golang-asm/sys/arch.go
new file mode 100644
index 000000000..e8687363d
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/sys/arch.go
@@ -0,0 +1,187 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package sys
+
+import "encoding/binary"
+
+// ArchFamily represents a family of one or more related architectures.
+// For example, ppc64 and ppc64le are both members of the PPC64 family.
+type ArchFamily byte
+
+const (
+	NoArch ArchFamily = iota
+	AMD64
+	ARM
+	ARM64
+	I386
+	MIPS
+	MIPS64
+	PPC64
+	RISCV64
+	S390X
+	Wasm
+)
+
+// Arch represents an individual architecture.
+type Arch struct {
+	Name   string
+	Family ArchFamily
+
+	ByteOrder binary.ByteOrder
+
+	// PtrSize is the size in bytes of pointers and the
+	// predeclared "int", "uint", and "uintptr" types.
+	PtrSize int
+
+	// RegSize is the size in bytes of general purpose registers.
+	RegSize int
+
+	// MinLC is the minimum length of an instruction code.
+	MinLC int
+}
+
+// InFamily reports whether a is a member of any of the specified
+// architecture families.
+func (a *Arch) InFamily(xs ...ArchFamily) bool {
+	for _, x := range xs {
+		if a.Family == x {
+			return true
+		}
+	}
+	return false
+}
+
+var Arch386 = &Arch{
+	Name:      "386",
+	Family:    I386,
+	ByteOrder: binary.LittleEndian,
+	PtrSize:   4,
+	RegSize:   4,
+	MinLC:     1,
+}
+
+var ArchAMD64 = &Arch{
+	Name:      "amd64",
+	Family:    AMD64,
+	ByteOrder: binary.LittleEndian,
+	PtrSize:   8,
+	RegSize:   8,
+	MinLC:     1,
+}
+
+var ArchARM = &Arch{
+	Name:      "arm",
+	Family:    ARM,
+	ByteOrder: binary.LittleEndian,
+	PtrSize:   4,
+	RegSize:   4,
+	MinLC:     4,
+}
+
+var ArchARM64 = &Arch{
+	Name:      "arm64",
+	Family:    ARM64,
+	ByteOrder: binary.LittleEndian,
+	PtrSize:   8,
+	RegSize:   8,
+	MinLC:     4,
+}
+
+var ArchMIPS = &Arch{
+	Name:      "mips",
+	Family:    MIPS,
+	ByteOrder: binary.BigEndian,
+	PtrSize:   4,
+	RegSize:   4,
+	MinLC:     4,
+}
+
+var ArchMIPSLE = &Arch{
+	Name:      "mipsle",
+	Family:    MIPS,
+	ByteOrder: binary.LittleEndian,
+	PtrSize:   4,
+	RegSize:   4,
+	MinLC:     4,
+}
+
+var ArchMIPS64 = &Arch{
+	Name:      "mips64",
+	Family:    MIPS64,
+	ByteOrder: binary.BigEndian,
+	PtrSize:   8,
+	RegSize:   8,
+	MinLC:     4,
+}
+
+var ArchMIPS64LE = &Arch{
+	Name:      "mips64le",
+	Family:    MIPS64,
+	ByteOrder: binary.LittleEndian,
+	PtrSize:   8,
+	RegSize:   8,
+	MinLC:     4,
+}
+
+var ArchPPC64 = &Arch{
+	Name:      "ppc64",
+	Family:    PPC64,
+	ByteOrder: binary.BigEndian,
+	PtrSize:   8,
+	RegSize:   8,
+	MinLC:     4,
+}
+
+var ArchPPC64LE = &Arch{
+	Name:      "ppc64le",
+	Family:    PPC64,
+	ByteOrder: binary.LittleEndian,
+	PtrSize:   8,
+	RegSize:   8,
+	MinLC:     4,
+}
+
+var ArchRISCV64 = &Arch{
+	Name:      "riscv64",
+	Family:    RISCV64,
+	ByteOrder: binary.LittleEndian,
+	PtrSize:   8,
+	RegSize:   8,
+	MinLC:     4,
+}
+
+var ArchS390X = &Arch{
+	Name:      "s390x",
+	Family:    S390X,
+	ByteOrder: binary.BigEndian,
+	PtrSize:   8,
+	RegSize:   8,
+	MinLC:     2,
+}
+
+var ArchWasm = &Arch{
+	Name:      "wasm",
+	Family:    Wasm,
+	ByteOrder: binary.LittleEndian,
+	PtrSize:   8,
+	RegSize:   8,
+	MinLC:     1,
+}
+
+var Archs = [...]*Arch{
+	Arch386,
+	ArchAMD64,
+	ArchARM,
+	ArchARM64,
+	ArchMIPS,
+	ArchMIPSLE,
+	ArchMIPS64,
+	ArchMIPS64LE,
+	ArchPPC64,
+	ArchPPC64LE,
+	ArchRISCV64,
+	ArchS390X,
+	ArchWasm,
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/sys/supported.go b/vendor/github.com/twitchyliquid64/golang-asm/sys/supported.go
new file mode 100644
index 000000000..c27b3b986
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/sys/supported.go
@@ -0,0 +1,116 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package sys
+
+// RaceDetectorSupported reports whether goos/goarch supports the race
+// detector. There is a copy of this function in cmd/dist/test.go.
+// Race detector only supports 48-bit VMA on arm64. But it will always
+// return true for arm64, because we don't have VMA size information during
+// the compile time.
+func RaceDetectorSupported(goos, goarch string) bool {
+	switch goos {
+	case "linux":
+		return goarch == "amd64" || goarch == "ppc64le" || goarch == "arm64"
+	case "darwin", "freebsd", "netbsd", "windows":
+		return goarch == "amd64"
+	default:
+		return false
+	}
+}
+
+// MSanSupported reports whether goos/goarch supports the memory
+// sanitizer option. There is a copy of this function in cmd/dist/test.go.
+func MSanSupported(goos, goarch string) bool {
+	switch goos {
+	case "linux":
+		return goarch == "amd64" || goarch == "arm64"
+	default:
+		return false
+	}
+}
+
+// MustLinkExternal reports whether goos/goarch requires external linking.
+func MustLinkExternal(goos, goarch string) bool {
+	switch goos {
+	case "android":
+		if goarch != "arm64" {
+			return true
+		}
+	case "darwin":
+		if goarch == "arm64" {
+			return true
+		}
+	}
+	return false
+}
+
+// BuildModeSupported reports whether goos/goarch supports the given build mode
+// using the given compiler.
+func BuildModeSupported(compiler, buildmode, goos, goarch string) bool {
+	if compiler == "gccgo" {
+		return true
+	}
+
+	platform := goos + "/" + goarch
+
+	switch buildmode {
+	case "archive":
+		return true
+
+	case "c-archive":
+		// TODO(bcmills): This seems dubious.
+		// Do we really support c-archive mode on js/wasm‽
+		return platform != "linux/ppc64"
+
+	case "c-shared":
+		switch platform {
+		case "linux/amd64", "linux/arm", "linux/arm64", "linux/386", "linux/ppc64le", "linux/s390x",
+			"android/amd64", "android/arm", "android/arm64", "android/386",
+			"freebsd/amd64",
+			"darwin/amd64",
+			"windows/amd64", "windows/386":
+			return true
+		}
+		return false
+
+	case "default":
+		return true
+
+	case "exe":
+		return true
+
+	case "pie":
+		switch platform {
+		case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/ppc64le", "linux/s390x",
+			"android/amd64", "android/arm", "android/arm64", "android/386",
+			"freebsd/amd64",
+			"darwin/amd64",
+			"aix/ppc64",
+			"windows/386", "windows/amd64", "windows/arm":
+			return true
+		}
+		return false
+
+	case "shared":
+		switch platform {
+		case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/ppc64le", "linux/s390x":
+			return true
+		}
+		return false
+
+	case "plugin":
+		switch platform {
+		case "linux/amd64", "linux/arm", "linux/arm64", "linux/386", "linux/s390x", "linux/ppc64le",
+			"android/amd64", "android/arm", "android/arm64", "android/386",
+			"darwin/amd64",
+			"freebsd/amd64":
+			return true
+		}
+		return false
+
+	default:
+		return false
+	}
+}
diff --git a/vendor/github.com/twitchyliquid64/golang-asm/unsafeheader/unsafeheader.go b/vendor/github.com/twitchyliquid64/golang-asm/unsafeheader/unsafeheader.go
new file mode 100644
index 000000000..6d092c629
--- /dev/null
+++ b/vendor/github.com/twitchyliquid64/golang-asm/unsafeheader/unsafeheader.go
@@ -0,0 +1,37 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package unsafeheader contains header declarations for the Go runtime's slice
+// and string implementations.
+//
+// This package allows packages that cannot import "reflect" to use types that
+// are tested to be equivalent to reflect.SliceHeader and reflect.StringHeader.
+package unsafeheader
+
+import (
+	"unsafe"
+)
+
+// Slice is the runtime representation of a slice.
+// It cannot be used safely or portably and its representation may
+// change in a later release.
+//
+// Unlike reflect.SliceHeader, its Data field is sufficient to guarantee the
+// data it references will not be garbage collected.
+type Slice struct {
+	Data unsafe.Pointer
+	Len  int
+	Cap  int
+}
+
+// String is the runtime representation of a string.
+// It cannot be used safely or portably and its representation may
+// change in a later release.
+//
+// Unlike reflect.StringHeader, its Data field is sufficient to guarantee the
+// data it references will not be garbage collected.
+type String struct {
+	Data unsafe.Pointer
+	Len  int
+}
diff --git a/vendor/github.com/ugorji/go/codec/README.md b/vendor/github.com/ugorji/go/codec/README.md
index 138a5fc9c..e4c45bc83 100644
--- a/vendor/github.com/ugorji/go/codec/README.md
+++ b/vendor/github.com/ugorji/go/codec/README.md
@@ -6,13 +6,13 @@ codec/encoding library for binc, msgpack, cbor, json.
 Supported Serialization formats are:
 
   - msgpack: https://github.com/msgpack/msgpack
-  - binc:    http://github.com/ugorji/binc
-  - cbor:    http://cbor.io http://tools.ietf.org/html/rfc7049
-  - json:    http://json.org http://tools.ietf.org/html/rfc7159
+  - binc: http://github.com/ugorji/binc
+  - cbor: http://cbor.io http://tools.ietf.org/html/rfc7049
+  - json: http://json.org http://tools.ietf.org/html/rfc7159
   - simple:
 
-This package will carefully use 'package unsafe' for performance reasons in
-specific places. You can build without unsafe use by passing the safe or
+This package will carefully use 'package unsafe' for performance reasons
+in specific places. You can build without unsafe use by passing the safe or
 appengine tag i.e. 'go install -tags=codec.safe ...'.
 
 This library works with both the standard `gc` and the `gccgo` compilers.
@@ -20,67 +20,70 @@ This library works with both the standard `gc` and the `gccgo` compilers.
 For detailed usage information, read the primer at
 http://ugorji.net/blog/go-codec-primer .
 
-The idiomatic Go support is as seen in other encoding packages in the
-standard library (ie json, xml, gob, etc).
+The idiomatic Go support is as seen in other encoding packages in the standard
+library (ie json, xml, gob, etc).
 
 Rich Feature Set includes:
 
   - Simple but extremely powerful and feature-rich API
-  - Support for go 1.4 and above, while selectively using newer APIs for later releases
+  - Support for go 1.4 and above, while selectively using newer APIs for later
+    releases
   - Excellent code coverage ( > 90% )
-  - Very High Performance.
-    Our extensive benchmarks show us outperforming Gob, Json, Bson, etc by 2-4X.
+  - Very High Performance. Our extensive benchmarks show us outperforming Gob,
+    Json, Bson, etc by 2-4X.
   - Careful selected use of 'unsafe' for targeted performance gains.
   - 100% safe mode supported, where 'unsafe' is not used at all.
   - Lock-free (sans mutex) concurrency for scaling to 100's of cores
-  - In-place updates during decode, with option to zero value in maps and slices prior to decode
-  - Coerce types where appropriate
-    e.g. decode an int in the stream into a float, decode numbers from formatted strings, etc
-  - Corner Cases:
-    Overflows, nil maps/slices, nil values in streams are handled correctly
+  - In-place updates during decode, with option to zero value in maps and slices
+    prior to decode
+  - Coerce types where appropriate e.g. decode an int in the stream into a
+    float, decode numbers from formatted strings, etc
+  - Corner Cases: Overflows, nil maps/slices, nil values in streams are handled
+    correctly
   - Standard field renaming via tags
   - Support for omitting empty fields during an encoding
-  - Encoding from any value and decoding into pointer to any value
-    (struct, slice, map, primitives, pointers, interface{}, etc)
+  - Encoding from any value and decoding into pointer to any value (struct,
+    slice, map, primitives, pointers, interface{}, etc)
   - Extensions to support efficient encoding/decoding of any named types
   - Support encoding.(Binary|Text)(M|Unm)arshaler interfaces
-  - Support using existence of `IsZero() bool` to determine if a value is a zero value.
-    Analogous to time.Time.IsZero() bool.
-  - Decoding without a schema (into a interface{}).
-    Includes Options to configure what specific map or slice type to use
-    when decoding an encoded list or map into a nil interface{}
+  - Support using existence of `IsZero() bool` to determine if a value is a zero
+    value. Analogous to time.Time.IsZero() bool.
+  - Decoding without a schema (into a interface{}). Includes Options to
+    configure what specific map or slice type to use when decoding an encoded
+    list or map into a nil interface{}
   - Mapping a non-interface type to an interface, so we can decode appropriately
     into any interface type with a correctly configured non-interface value.
-  - Encode a struct as an array, and decode struct from an array in the data stream
-  - Option to encode struct keys as numbers (instead of strings)
-    (to support structured streams with fields encoded as numeric codes)
+  - Encode a struct as an array, and decode struct from an array in the data
+    stream
+  - Option to encode struct keys as numbers (instead of strings) (to support
+    structured streams with fields encoded as numeric codes)
   - Comprehensive support for anonymous fields
   - Fast (no-reflection) encoding/decoding of common maps and slices
   - Code-generation for faster performance, supported in go 1.6+
   - Support binary (e.g. messagepack, cbor) and text (e.g. json) formats
-  - Support indefinite-length formats to enable true streaming
-    (for formats which support it e.g. json, cbor)
-  - Support canonical encoding, where a value is ALWAYS encoded as same sequence of bytes.
-    This mostly applies to maps, where iteration order is non-deterministic.
+  - Support indefinite-length formats to enable true streaming (for formats
+    which support it e.g. json, cbor)
+  - Support canonical encoding, where a value is ALWAYS encoded as same
+    sequence of bytes. This mostly applies to maps, where iteration order is
+    non-deterministic.
   - NIL in data stream decoded as zero value
-  - Never silently skip data when decoding.
-    User decides whether to return an error or silently skip data when keys or indexes
-    in the data stream do not map to fields in the struct.
-  - Detect and error when encoding a cyclic reference (instead of stack overflow shutdown)
+  - Never silently skip data when decoding. User decides whether to return an
+    error or silently skip data when keys or indexes in the data stream do not
+    map to fields in the struct.
+  - Detect and error when encoding a cyclic reference (instead of stack overflow
+    shutdown)
   - Encode/Decode from/to chan types (for iterative streaming support)
   - Drop-in replacement for encoding/json. `json:` key in struct tag supported.
   - Provides a RPC Server and Client Codec for net/rpc communication protocol.
-  - Handle unique idiosyncrasies of codecs e.g.
-    - For messagepack, configure how ambiguities in handling raw bytes are resolved
-    - For messagepack, provide rpc server/client codec to support
-      msgpack-rpc protocol defined at:
-      https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md
+  - Handle unique idiosyncrasies of codecs e.g. For messagepack,
+    configure how ambiguities in handling raw bytes are resolved and provide
+    rpc server/client codec to support msgpack-rpc protocol defined at:
+    https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md
 
+# Extension Support
 
-## Extension Support
-
-Users can register a function to handle the encoding or decoding of their
-custom types.
+Users can register a function to handle the encoding or decoding of their custom
+types.
 
 There are no restrictions on what the custom type can be. Some examples:
 
@@ -92,43 +95,44 @@ There are no restrictions on what the custom type can be. Some examples:
     type GifImage struct { ... }
 ```
 
-As an illustration, MyStructWithUnexportedFields would normally be encoded
-as an empty map because it has no exported fields, while UUID would be
-encoded as a string. However, with extension support, you can encode any of
-these however you like.
+As an illustration, MyStructWithUnexportedFields would normally be encoded as
+an empty map because it has no exported fields, while UUID would be encoded as a
+string. However, with extension support, you can encode any of these however you
+like.
 
 There is also seamless support provided for registering an extension (with a
 tag) but letting the encoding mechanism default to the standard way.
 
+# Custom Encoding and Decoding
 
-## Custom Encoding and Decoding
-
-This package maintains symmetry in the encoding and decoding halfs. We
-determine how to encode or decode by walking this decision tree
+This package maintains symmetry in the encoding and decoding halfs. We determine
+how to encode or decode by walking this decision tree
 
   - is there an extension registered for the type?
   - is type a codec.Selfer?
-  - is format binary, and is type a encoding.BinaryMarshaler and BinaryUnmarshaler?
-  - is format specifically json, and is type a encoding/json.Marshaler and Unmarshaler?
-  - is format text-based, and type an encoding.TextMarshaler and TextUnmarshaler?
-  - else we use a pair of functions based on the "kind" of the type e.g. map, slice, int64, etc
+  - is format binary, and is type a encoding.BinaryMarshaler and
+    BinaryUnmarshaler?
+  - is format specifically json, and is type a encoding/json.Marshaler and
+    Unmarshaler?
+  - is format text-based, and type an encoding.TextMarshaler and
+    TextUnmarshaler?
+  - else we use a pair of functions based on the "kind" of the type e.g. map,
+    slice, int64, etc
 
 This symmetry is important to reduce chances of issues happening because the
 encoding and decoding sides are out of sync e.g. decoded via very specific
 encoding.TextUnmarshaler but encoded via kind-specific generalized mode.
 
-Consequently, if a type only defines one-half of the symmetry (e.g. it
-implements UnmarshalJSON() but not MarshalJSON() ), then that type doesn't
+Consequently, if a type only defines one-half of the symmetry (e.g.
+it implements UnmarshalJSON() but not MarshalJSON() ), then that type doesn't
 satisfy the check and we will continue walking down the decision tree.
 
+# RPC
 
-## RPC
-
-RPC Client and Server Codecs are implemented, so the codecs can be used with
-the standard net/rpc package.
+RPC Client and Server Codecs are implemented, so the codecs can be used with the
+standard net/rpc package.
 
-
-## Usage
+# Usage
 
 The Handle is SAFE for concurrent READ, but NOT SAFE for concurrent
 modification.
@@ -137,13 +141,13 @@ The Encoder and Decoder are NOT safe for concurrent use.
 
 Consequently, the usage model is basically:
 
-  - Create and initialize the Handle before any use.
-    Once created, DO NOT modify it.
-  - Multiple Encoders or Decoders can now use the Handle concurrently.
-    They only read information off the Handle (never write).
+  - Create and initialize the Handle before any use. Once created, DO NOT modify
+    it.
+  - Multiple Encoders or Decoders can now use the Handle concurrently. They only
+    read information off the Handle (never write).
   - However, each Encoder or Decoder MUST not be used concurrently
-  - To re-use an Encoder/Decoder, call Reset(...) on it first.
-    This allows you use state maintained on the Encoder/Decoder.
+  - To re-use an Encoder/Decoder, call Reset(...) on it first. This allows you
+    use state maintained on the Encoder/Decoder.
 
 Sample usage model:
 
@@ -194,8 +198,7 @@ Sample usage model:
     client := rpc.NewClientWithCodec(rpcCodec)
 ```
 
-
-## Running Tests
+# Running Tests
 
 To run tests, use the following:
 
@@ -216,7 +219,7 @@ You can run the tag 'codec.safe' to run tests or build in safe mode. e.g.
     go test -tags "alltests codec.safe" -run Suite
 ```
 
-## Running Benchmarks
+# Running Benchmarks
 
 ```
     cd bench
@@ -225,11 +228,9 @@ You can run the tag 'codec.safe' to run tests or build in safe mode. e.g.
 
 Please see http://github.com/ugorji/go-codec-bench .
 
+# Caveats
 
-## Caveats
-
-Struct fields matching the following are ignored during encoding and
-decoding
+Struct fields matching the following are ignored during encoding and decoding
 
   - struct tag value set to -
   - func, complex numbers, unsafe pointers
@@ -239,14 +240,14 @@ decoding
 
 Every other field in a struct will be encoded/decoded.
 
-Embedded fields are encoded as if they exist in the top-level struct, with
-some caveats. See Encode documentation.
+Embedded fields are encoded as if they exist in the top-level struct, with some
+caveats. See Encode documentation.
 
 ## Exported Package API
 
 ```go
 const CborStreamBytes byte = 0x5f ...
-const GenVersion = 25
+const GenVersion = 26
 var SelfExt = &extFailWrapper{}
 var GoRpc goRpc
 var MsgpackSpecRpc msgpackSpecRpc
diff --git a/vendor/github.com/ugorji/go/codec/binc.go b/vendor/github.com/ugorji/go/codec/binc.go
index e54215dd4..9ed15a0bf 100644
--- a/vendor/github.com/ugorji/go/codec/binc.go
+++ b/vendor/github.com/ugorji/go/codec/binc.go
@@ -7,6 +7,7 @@ import (
 	"math"
 	"reflect"
 	"time"
+	"unicode/utf8"
 )
 
 // Symbol management:
@@ -555,7 +556,10 @@ func (d *bincDecDriver) decUint() (v uint64) {
 	case 1:
 		v = uint64(bigen.Uint16(d.d.decRd.readn2()))
 	case 2:
-		v = uint64(bigen.Uint32(d.d.decRd.readn3()))
+		b3 := d.d.decRd.readn3()
+		var b [4]byte
+		copy(b[1:], b3[:])
+		v = uint64(bigen.Uint32(b))
 	case 3:
 		v = uint64(bigen.Uint32(d.d.decRd.readn4()))
 	case 4, 5, 6:
@@ -789,6 +793,11 @@ func (d *bincDecDriver) DecodeStringAsBytes() (bs2 []byte) {
 	default:
 		d.d.errorf("string/bytes - %s %x-%x/%s", msgBadDesc, d.vd, d.vs, bincdesc(d.vd, d.vs))
 	}
+
+	if d.h.ValidateUnicode && !utf8.Valid(bs2) {
+		d.d.errorf("DecodeStringAsBytes: invalid UTF-8: %s", bs2)
+	}
+
 	d.bdRead = false
 	return
 }
@@ -1090,18 +1099,18 @@ func (d *bincDecDriver) nextValueBytesBdReadR(v0 []byte) (v []byte) {
 
 //------------------------------------
 
-//BincHandle is a Handle for the Binc Schema-Free Encoding Format
-//defined at https://github.com/ugorji/binc .
+// BincHandle is a Handle for the Binc Schema-Free Encoding Format
+// defined at https://github.com/ugorji/binc .
 //
-//BincHandle currently supports all Binc features with the following EXCEPTIONS:
-//  - only integers up to 64 bits of precision are supported.
-//    big integers are unsupported.
-//  - Only IEEE 754 binary32 and binary64 floats are supported (ie Go float32 and float64 types).
-//    extended precision and decimal IEEE 754 floats are unsupported.
-//  - Only UTF-8 strings supported.
-//    Unicode_Other Binc types (UTF16, UTF32) are currently unsupported.
+// BincHandle currently supports all Binc features with the following EXCEPTIONS:
+//   - only integers up to 64 bits of precision are supported.
+//     big integers are unsupported.
+//   - Only IEEE 754 binary32 and binary64 floats are supported (ie Go float32 and float64 types).
+//     extended precision and decimal IEEE 754 floats are unsupported.
+//   - Only UTF-8 strings supported.
+//     Unicode_Other Binc types (UTF16, UTF32) are currently unsupported.
 //
-//Note that these EXCEPTIONS are temporary and full support is possible and may happen soon.
+// Note that these EXCEPTIONS are temporary and full support is possible and may happen soon.
 type BincHandle struct {
 	BasicHandle
 	binaryEncodingType
@@ -1158,50 +1167,49 @@ func (h *BincHandle) newDecDriver() decDriver {
 //
 // Format Description
 //
-//   A timestamp is composed of 3 components:
-//
-//   - secs: signed integer representing seconds since unix epoch
-//   - nsces: unsigned integer representing fractional seconds as a
-//     nanosecond offset within secs, in the range 0 <= nsecs < 1e9
-//   - tz: signed integer representing timezone offset in minutes east of UTC,
-//     and a dst (daylight savings time) flag
+//	A timestamp is composed of 3 components:
 //
-//   When encoding a timestamp, the first byte is the descriptor, which
-//   defines which components are encoded and how many bytes are used to
-//   encode secs and nsecs components. *If secs/nsecs is 0 or tz is UTC, it
-//   is not encoded in the byte array explicitly*.
+//	- secs: signed integer representing seconds since unix epoch
+//	- nsces: unsigned integer representing fractional seconds as a
+//	  nanosecond offset within secs, in the range 0 <= nsecs < 1e9
+//	- tz: signed integer representing timezone offset in minutes east of UTC,
+//	  and a dst (daylight savings time) flag
 //
-//       Descriptor 8 bits are of the form `A B C DDD EE`:
-//           A:   Is secs component encoded? 1 = true
-//           B:   Is nsecs component encoded? 1 = true
-//           C:   Is tz component encoded? 1 = true
-//           DDD: Number of extra bytes for secs (range 0-7).
-//                If A = 1, secs encoded in DDD+1 bytes.
-//                    If A = 0, secs is not encoded, and is assumed to be 0.
-//                    If A = 1, then we need at least 1 byte to encode secs.
-//                    DDD says the number of extra bytes beyond that 1.
-//                    E.g. if DDD=0, then secs is represented in 1 byte.
-//                         if DDD=2, then secs is represented in 3 bytes.
-//           EE:  Number of extra bytes for nsecs (range 0-3).
-//                If B = 1, nsecs encoded in EE+1 bytes (similar to secs/DDD above)
+//	When encoding a timestamp, the first byte is the descriptor, which
+//	defines which components are encoded and how many bytes are used to
+//	encode secs and nsecs components. *If secs/nsecs is 0 or tz is UTC, it
+//	is not encoded in the byte array explicitly*.
 //
-//   Following the descriptor bytes, subsequent bytes are:
+//	    Descriptor 8 bits are of the form `A B C DDD EE`:
+//	        A:   Is secs component encoded? 1 = true
+//	        B:   Is nsecs component encoded? 1 = true
+//	        C:   Is tz component encoded? 1 = true
+//	        DDD: Number of extra bytes for secs (range 0-7).
+//	             If A = 1, secs encoded in DDD+1 bytes.
+//	                 If A = 0, secs is not encoded, and is assumed to be 0.
+//	                 If A = 1, then we need at least 1 byte to encode secs.
+//	                 DDD says the number of extra bytes beyond that 1.
+//	                 E.g. if DDD=0, then secs is represented in 1 byte.
+//	                      if DDD=2, then secs is represented in 3 bytes.
+//	        EE:  Number of extra bytes for nsecs (range 0-3).
+//	             If B = 1, nsecs encoded in EE+1 bytes (similar to secs/DDD above)
 //
-//       secs component encoded in `DDD + 1` bytes (if A == 1)
-//       nsecs component encoded in `EE + 1` bytes (if B == 1)
-//       tz component encoded in 2 bytes (if C == 1)
+//	Following the descriptor bytes, subsequent bytes are:
 //
-//   secs and nsecs components are integers encoded in a BigEndian
-//   2-complement encoding format.
+//	    secs component encoded in `DDD + 1` bytes (if A == 1)
+//	    nsecs component encoded in `EE + 1` bytes (if B == 1)
+//	    tz component encoded in 2 bytes (if C == 1)
 //
-//   tz component is encoded as 2 bytes (16 bits). Most significant bit 15 to
-//   Least significant bit 0 are described below:
+//	secs and nsecs components are integers encoded in a BigEndian
+//	2-complement encoding format.
 //
-//       Timezone offset has a range of -12:00 to +14:00 (ie -720 to +840 minutes).
-//       Bit 15 = have\_dst: set to 1 if we set the dst flag.
-//       Bit 14 = dst\_on: set to 1 if dst is in effect at the time, or 0 if not.
-//       Bits 13..0 = timezone offset in minutes. It is a signed integer in Big Endian format.
+//	tz component is encoded as 2 bytes (16 bits). Most significant bit 15 to
+//	Least significant bit 0 are described below:
 //
+//	    Timezone offset has a range of -12:00 to +14:00 (ie -720 to +840 minutes).
+//	    Bit 15 = have\_dst: set to 1 if we set the dst flag.
+//	    Bit 14 = dst\_on: set to 1 if dst is in effect at the time, or 0 if not.
+//	    Bits 13..0 = timezone offset in minutes. It is a signed integer in Big Endian format.
 func bincEncodeTime(t time.Time) []byte {
 	// t := rv2i(rv).(time.Time)
 	tsecs, tnsecs := t.Unix(), t.Nanosecond()
diff --git a/vendor/github.com/ugorji/go/codec/build.sh b/vendor/github.com/ugorji/go/codec/build.sh
index c7704f758..023faf3d4 100644
--- a/vendor/github.com/ugorji/go/codec/build.sh
+++ b/vendor/github.com/ugorji/go/codec/build.sh
@@ -307,8 +307,10 @@ _usage() {
     
     cat <<EOF
 primary usage: $0 
-    -[tesow m n l d]   -> [t=tests (e=extra, s=short, o=cover, w=wait), m=make, n=inlining diagnostics, l=mid-stack inlining, d=race detector]
-    -v                   -> v=verbose
+    -t[esow]   -> t=tests [e=extra, s=short, o=cover, w=wait]
+    -[md]      -> [m=make, d=race detector]
+    -[n l i]   -> [n=inlining diagnostics, l=mid-stack inlining, i=check inlining for path (path)]
+    -v         -> v=verbose
 EOF
     if [[ "$(type -t _usage_run)" = "function" ]]; then _usage_run ; fi
 }
@@ -329,7 +331,7 @@ _main() {
     local gocmd=${MYGOCMD:-go}
     
     OPTIND=1
-    while getopts ":cetmnrgpfvldsowkxyzb:" flag
+    while getopts ":cetmnrgpfvldsowkxyzi" flag
     do
         case "x$flag" in
             'xo') zcover=1 ;;
@@ -341,7 +343,7 @@ _main() {
             'xl') zargs+=("-gcflags"); zargs+=("-l=4") ;;
             'xn') zargs+=("-gcflags"); zargs+=("-m=2") ;;
             'xd') zargs+=("-race") ;;
-            'xb') x='b'; zbenchflags=${OPTARG} ;;
+            # 'xi') x='i'; zbenchflags=${OPTARG} ;;
             x\?) _usage; return 1 ;;
             *) x=$flag ;;
         esac
@@ -359,7 +361,7 @@ _main() {
         'xy') _analyze_debug_types "$@" ;;
         'xz') _analyze_do_inlining_and_more "$@" ;;
         'xk') _go_compiler_validation_suite ;;
-        'xb') _bench "$@" ;;
+        'xi') _check_inlining_one "$@" ;;
     esac
     # unset zforce zargs zbenchflags
 }
diff --git a/vendor/github.com/ugorji/go/codec/cbor.go b/vendor/github.com/ugorji/go/codec/cbor.go
index 45eb822b9..10944487e 100644
--- a/vendor/github.com/ugorji/go/codec/cbor.go
+++ b/vendor/github.com/ugorji/go/codec/cbor.go
@@ -7,6 +7,7 @@ import (
 	"math"
 	"reflect"
 	"time"
+	"unicode/utf8"
 )
 
 // major
@@ -629,7 +630,11 @@ func (d *cborDecDriver) DecodeBytes(bs []byte) (bsOut []byte) {
 }
 
 func (d *cborDecDriver) DecodeStringAsBytes() (s []byte) {
-	return d.DecodeBytes(nil)
+	s = d.DecodeBytes(nil)
+	if d.h.ValidateUnicode && !utf8.Valid(s) {
+		d.d.errorf("DecodeStringAsBytes: invalid UTF-8: %s", s)
+	}
+	return
 }
 
 func (d *cborDecDriver) DecodeTime() (t time.Time) {
diff --git a/vendor/github.com/ugorji/go/codec/decode.go b/vendor/github.com/ugorji/go/codec/decode.go
index d454db09c..db87f2e71 100644
--- a/vendor/github.com/ugorji/go/codec/decode.go
+++ b/vendor/github.com/ugorji/go/codec/decode.go
@@ -16,9 +16,9 @@ import (
 const msgBadDesc = "unrecognized descriptor byte"
 
 const (
-	decDefMaxDepth         = 1024            // maximum depth
-	decDefChanCap          = 64              // should be large, as cap cannot be expanded
-	decScratchByteArrayLen = (8 + 2 + 2) * 8 // around cacheLineSize ie ~64, depending on Decoder size
+	decDefMaxDepth         = 1024                // maximum depth
+	decDefChanCap          = 64                  // should be large, as cap cannot be expanded
+	decScratchByteArrayLen = (8 + 2 + 2 + 1) * 8 // around cacheLineSize ie ~64, depending on Decoder size
 
 	// MARKER: massage decScratchByteArrayLen to ensure xxxDecDriver structs fit within cacheLine*N
 
@@ -150,13 +150,11 @@ type decDriver interface {
 	// If the format doesn't prefix the length, it returns containerLenUnknown.
 	// If the expected array was a nil in the stream, it returns containerLenNil.
 	ReadArrayStart() int
-	ReadArrayEnd()
 
 	// ReadMapStart will return the length of the array.
 	// If the format doesn't prefix the length, it returns containerLenUnknown.
 	// If the expected array was a nil in the stream, it returns containerLenNil.
 	ReadMapStart() int
-	ReadMapEnd()
 
 	reset()
 
@@ -186,6 +184,8 @@ type decDriverContainerTracker interface {
 	ReadArrayElem()
 	ReadMapElemKey()
 	ReadMapElemValue()
+	ReadArrayEnd()
+	ReadMapEnd()
 }
 
 type decNegintPosintFloatNumber interface {
@@ -202,11 +202,11 @@ func (x decDriverNoopNumberHelper) decFloat() (f float64, ok bool) { panic("decF
 
 type decDriverNoopContainerReader struct{}
 
-func (x decDriverNoopContainerReader) ReadArrayStart() (v int) { panic("ReadArrayStart unsupported") }
-func (x decDriverNoopContainerReader) ReadArrayEnd()           {}
-func (x decDriverNoopContainerReader) ReadMapStart() (v int)   { panic("ReadMapStart unsupported") }
-func (x decDriverNoopContainerReader) ReadMapEnd()             {}
-func (x decDriverNoopContainerReader) CheckBreak() (v bool)    { return }
+// func (x decDriverNoopContainerReader) ReadArrayStart() (v int) { panic("ReadArrayStart unsupported") }
+// func (x decDriverNoopContainerReader) ReadMapStart() (v int)   { panic("ReadMapStart unsupported") }
+func (x decDriverNoopContainerReader) ReadArrayEnd()        {}
+func (x decDriverNoopContainerReader) ReadMapEnd()          {}
+func (x decDriverNoopContainerReader) CheckBreak() (v bool) { return }
 
 // DecodeOptions captures configuration options during decode.
 type DecodeOptions struct {
@@ -335,6 +335,12 @@ type DecodeOptions struct {
 	//
 	// This mostly impacts when we decode registered extensions.
 	PreferPointerForStructOrArray bool
+
+	// ValidateUnicode controls will cause decoding to fail if an expected unicode
+	// string is well-formed but include invalid codepoints.
+	//
+	// This could have a performance impact.
+	ValidateUnicode bool
 }
 
 // ----------------------------------------
@@ -638,7 +644,7 @@ func (d *Decoder) kInterface(f *codecFnInfo, rv reflect.Value) {
 	// decode into it, and reset the interface to that new value.
 
 	if !canDecode {
-		rvn2 := d.oneShotAddrRV(rvType(rvn), rvn.Kind())
+		rvn2 := d.oneShotAddrRV(rvn.Type(), rvn.Kind())
 		rvSetDirect(rvn2, rvn)
 		rvn = rvn2
 	}
@@ -660,6 +666,16 @@ func decStructFieldKeyNotString(dd decDriver, keyType valueType, b *[decScratchB
 	return
 }
 
+func (d *Decoder) kStructField(si *structFieldInfo, rv reflect.Value) {
+	if d.d.TryNil() {
+		if rv = si.path.field(rv); rv.IsValid() {
+			decSetNonNilRV2Zero(rv)
+		}
+		return
+	}
+	d.decodeValueNoCheckNil(si.path.fieldAlloc(rv), nil)
+}
+
 func (d *Decoder) kStruct(f *codecFnInfo, rv reflect.Value) {
 	ctyp := d.d.ContainerType()
 	ti := f.ti
@@ -691,7 +707,7 @@ func (d *Decoder) kStruct(f *codecFnInfo, rv reflect.Value) {
 			}
 			d.mapElemValue()
 			if si := ti.siForEncName(rvkencname); si != nil {
-				d.decodeValue(si.path.fieldAlloc(rv), nil)
+				d.kStructField(si, rv)
 			} else if mf != nil {
 				// store rvkencname in new []byte, as it previously shares Decoder.b, which is used in decode
 				name2 = append(name2[:0], rvkencname...)
@@ -713,38 +729,21 @@ func (d *Decoder) kStruct(f *codecFnInfo, rv reflect.Value) {
 		}
 		// Not much gain from doing it two ways for array.
 		// Arrays are not used as much for structs.
-		hasLen := containerLen >= 0
-		var checkbreak bool
 		tisfi := ti.sfi.source()
-		for j, si := range tisfi {
-			if hasLen {
-				if j == containerLen {
-					break
-				}
-			} else if d.checkBreak() {
-				checkbreak = true
-				break
-			}
+		hasLen := containerLen >= 0
+
+		// 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
+		for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 			d.arrayElem()
-			d.decodeValue(si.path.fieldAlloc(rv), nil)
-		}
-		var proceed bool
-		if hasLen {
-			proceed = containerLen > len(tisfi)
-		} else {
-			proceed = !checkbreak
-		}
-		// if (hasLen && containerLen > len(tisfi)) || (!hasLen && !checkbreak) {
-		if proceed {
-			// read remaining values and throw away
-			for j := len(tisfi); ; j++ {
-				if !d.containerNext(j, containerLen, hasLen) {
-					break
-				}
-				d.arrayElem()
+			if j < len(tisfi) {
+				d.kStructField(tisfi[j], rv)
+			} else {
 				d.structFieldNotFound(j, "")
 			}
 		}
+
 		d.arrayEnd()
 	} else {
 		d.onerror(errNeedMapOrArrayDecodeToStruct)
@@ -1215,7 +1214,7 @@ func (d *Decoder) kMap(f *codecFnInfo, rv reflect.Value) {
 			d.decodeValue(rvk, keyFn)
 			// special case if interface wrapping a byte slice
 			if ktypeIsIntf {
-				if rvk2 := rvk.Elem(); rvk2.IsValid() && rvType(rvk2) == uint8SliceTyp {
+				if rvk2 := rvk.Elem(); rvk2.IsValid() && rvk2.Type() == uint8SliceTyp {
 					kstr2bs = rvGetBytes(rvk2)
 					rvSetIntf(rvk, rv4istr(fnRvk2()))
 				}
@@ -1406,6 +1405,7 @@ func (d *Decoder) r() *decRd {
 
 func (d *Decoder) init(h Handle) {
 	initHandle(h)
+	d.cbreak = d.js || d.cbor
 	d.bytes = true
 	d.err = errDecoderNotInitialized
 	d.h = h.getBasicHandle()
@@ -1450,21 +1450,11 @@ func (d *Decoder) Reset(r io.Reader) {
 		r = &eofReader
 	}
 	d.bytes = false
-	if d.h.ReaderBufferSize > 0 {
-		if d.bi == nil {
-			d.bi = new(bufioDecReader)
-		}
-		d.bi.reset(r, d.h.ReaderBufferSize, &d.blist)
-		d.bufio = true
-		d.decReader = d.bi
-	} else {
-		if d.ri == nil {
-			d.ri = new(ioDecReader)
-		}
-		d.ri.reset(r, &d.blist)
-		d.bufio = false
-		d.decReader = d.ri
+	if d.ri == nil {
+		d.ri = new(ioDecReader)
 	}
+	d.ri.reset(r, d.h.ReaderBufferSize, &d.blist)
+	d.decReader = d.ri
 	d.resetCommon()
 }
 
@@ -1474,7 +1464,6 @@ func (d *Decoder) ResetBytes(in []byte) {
 	if in == nil {
 		in = []byte{}
 	}
-	d.bufio = false
 	d.bytes = true
 	d.decReader = &d.rb
 	d.rb.reset(in)
@@ -1505,14 +1494,15 @@ func (d *Decoder) naked() *fauxUnion {
 // We will decode and store a value in that nil interface.
 //
 // Sample usages:
-//   // Decoding into a non-nil typed value
-//   var f float32
-//   err = codec.NewDecoder(r, handle).Decode(&f)
 //
-//   // Decoding into nil interface
-//   var v interface{}
-//   dec := codec.NewDecoder(r, handle)
-//   err = dec.Decode(&v)
+//	// Decoding into a non-nil typed value
+//	var f float32
+//	err = codec.NewDecoder(r, handle).Decode(&f)
+//
+//	// Decoding into nil interface
+//	var v interface{}
+//	dec := codec.NewDecoder(r, handle)
+//	err = dec.Decode(&v)
 //
 // When decoding into a nil interface{}, we will decode into an appropriate value based
 // on the contents of the stream:
@@ -1520,6 +1510,7 @@ func (d *Decoder) naked() *fauxUnion {
 //   - Other values are decoded appropriately depending on the type:
 //     bool, string, []byte, time.Time, etc
 //   - Extensions are decoded as RawExt (if no ext function registered for the tag)
+//
 // Configurations exist on the Handle to override defaults
 // (e.g. for MapType, SliceType and how to decode raw bytes).
 //
@@ -1814,7 +1805,7 @@ PTR:
 	if rv.Kind() == reflect.Ptr {
 		rvpValid = true
 		if rvIsNil(rv) {
-			rvSetDirect(rv, reflect.New(rvType(rv).Elem()))
+			rvSetDirect(rv, reflect.New(rv.Type().Elem()))
 		}
 		rvp = rv
 		rv = rv.Elem()
@@ -1822,7 +1813,7 @@ PTR:
 	}
 
 	if fn == nil {
-		fn = d.h.fn(rvType(rv))
+		fn = d.h.fn(rv.Type())
 	}
 	if fn.i.addrD {
 		if rvpValid {
@@ -1908,9 +1899,9 @@ func (d *Decoder) rawBytes() (v []byte) {
 	// i.e. if necessary, make new copy always.
 	v = d.d.nextValueBytes([]byte{})
 	if d.bytes && !d.h.ZeroCopy {
-		v0 := v
-		v = make([]byte, len(v))
-		copy(v, v0)
+		vv := make([]byte, len(v))
+		copy(vv, v) // using copy here triggers make+copy optimization eliding memclr
+		v = vv
 	}
 	return
 }
@@ -1941,7 +1932,34 @@ func (d *Decoder) decodeFloat32() float32 {
 
 // MARKER: do not call mapEnd if mapStart returns containerLenNil.
 
+// MARKER: optimize decoding since all formats do not truly support all decDriver'ish operations.
+// - Read(Map|Array)Start is only supported by all formats.
+// - CheckBreak is only supported by json and cbor.
+// - Read(Map|Array)End is only supported by json.
+// - Read(Map|Array)Elem(Kay|Value) is only supported by json.
+// Honor these in the code, to reduce the number of interface calls (even if empty).
+
+func (d *Decoder) checkBreak() (v bool) {
+	// MARKER: jsonDecDriver.CheckBreak() cannot be inlined (over budget inlining cost).
+	// Consequently, there's no benefit in incurring the cost of this wrapping function.
+	// It is faster to just call the interface method directly.
+
+	// if d.js {
+	// 	return d.jsondriver().CheckBreak()
+	// }
+	// if d.cbor {
+	// 	return d.cbordriver().CheckBreak()
+	// }
+
+	if d.cbreak {
+		v = d.d.CheckBreak()
+	}
+	return
+}
+
 func (d *Decoder) containerNext(j, containerLen int, hasLen bool) bool {
+	// MARKER: keep in sync with gen-helper.go.tmpl
+
 	// return (hasLen && j < containerLen) || !(hasLen || slh.d.checkBreak())
 	if hasLen {
 		return j < containerLen
@@ -1972,7 +1990,10 @@ func (d *Decoder) mapElemValue() {
 }
 
 func (d *Decoder) mapEnd() {
-	d.d.ReadMapEnd()
+	if d.js {
+		d.jsondriver().ReadMapEnd()
+	}
+	// d.d.ReadMapEnd()
 	d.depthDecr()
 	d.c = 0
 }
@@ -1993,7 +2014,10 @@ func (d *Decoder) arrayElem() {
 }
 
 func (d *Decoder) arrayEnd() {
-	d.d.ReadArrayEnd()
+	if d.js {
+		d.jsondriver().ReadArrayEnd()
+	}
+	// d.d.ReadArrayEnd()
 	d.depthDecr()
 	d.c = 0
 }
@@ -2028,7 +2052,7 @@ func (d *Decoder) interfaceExtConvertAndDecode(v interface{}, ext InterfaceExt)
 
 	if !rv.CanAddr() {
 		rvk = rv.Kind()
-		rv2 = d.oneShotAddrRV(rvType(rv), rvk)
+		rv2 = d.oneShotAddrRV(rv.Type(), rvk)
 		if rvk == reflect.Interface {
 			rvSetIntf(rv2, rv)
 		} else {
@@ -2157,9 +2181,9 @@ func (x decSliceHelper) arrayCannotExpand(hasLen bool, lenv, j, containerLenS in
 // decNextValueBytesHelper helps with NextValueBytes calls.
 //
 // Typical usage:
-//    - each Handle's decDriver will implement a high level nextValueBytes,
-//      which will track the current cursor, delegate to a nextValueBytesR
-//      method, and then potentially call bytesRdV at the end.
+//   - each Handle's decDriver will implement a high level nextValueBytes,
+//     which will track the current cursor, delegate to a nextValueBytesR
+//     method, and then potentially call bytesRdV at the end.
 //
 // See simple.go for typical usage model.
 type decNextValueBytesHelper struct {
@@ -2178,6 +2202,12 @@ func (x decNextValueBytesHelper) appendN(v *[]byte, b ...byte) {
 	}
 }
 
+func (x decNextValueBytesHelper) appendS(v *[]byte, b string) {
+	if *v != nil && !x.d.bytes {
+		*v = append(*v, b...)
+	}
+}
+
 func (x decNextValueBytesHelper) bytesRdV(v *[]byte, startpos uint) {
 	if x.d.bytes {
 		*v = x.d.rb.b[startpos:x.d.rb.c]
@@ -2281,12 +2311,8 @@ func isDecodeable(rv reflect.Value) (canDecode bool, reason decNotDecodeableReas
 }
 
 func decByteSlice(r *decRd, clen, maxInitLen int, bs []byte) (bsOut []byte) {
-	if clen == 0 {
-		return zeroByteSlice
-	}
-	if len(bs) == clen {
-		bsOut = bs
-		r.readb(bsOut)
+	if clen <= 0 {
+		bsOut = zeroByteSlice
 	} else if cap(bs) >= clen {
 		bsOut = bs[:clen]
 		r.readb(bsOut)
@@ -2305,10 +2331,10 @@ func decByteSlice(r *decRd, clen, maxInitLen int, bs []byte) (bsOut []byte) {
 }
 
 // decInferLen will infer a sensible length, given the following:
-//    - clen: length wanted.
-//    - maxlen: max length to be returned.
-//      if <= 0, it is unset, and we infer it based on the unit size
-//    - unit: number of bytes for each element of the collection
+//   - clen: length wanted.
+//   - maxlen: max length to be returned.
+//     if <= 0, it is unset, and we infer it based on the unit size
+//   - unit: number of bytes for each element of the collection
 func decInferLen(clen, maxlen, unit int) int {
 	// anecdotal testing showed increase in allocation with map length of 16.
 	// We saw same typical alloc from 0-8, then a 20% increase at 16.
diff --git a/vendor/github.com/ugorji/go/codec/doc.go b/vendor/github.com/ugorji/go/codec/doc.go
index b390f9a8f..1a16bca8b 100644
--- a/vendor/github.com/ugorji/go/codec/doc.go
+++ b/vendor/github.com/ugorji/go/codec/doc.go
@@ -73,23 +73,23 @@ Rich Feature Set includes:
   - Drop-in replacement for encoding/json. `json:` key in struct tag supported.
   - Provides a RPC Server and Client Codec for net/rpc communication protocol.
   - Handle unique idiosyncrasies of codecs e.g.
-    - For messagepack, configure how ambiguities in handling raw bytes are resolved
-    - For messagepack, provide rpc server/client codec to support
-      msgpack-rpc protocol defined at:
-      https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md
+    For messagepack, configure how ambiguities in handling raw bytes are resolved and
+    provide rpc server/client codec to support
+    msgpack-rpc protocol defined at:
+    https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md
 
-Extension Support
+# Extension Support
 
 Users can register a function to handle the encoding or decoding of
 their custom types.
 
 There are no restrictions on what the custom type can be. Some examples:
 
-    type BisSet   []int
-    type BitSet64 uint64
-    type UUID     string
-    type MyStructWithUnexportedFields struct { a int; b bool; c []int; }
-    type GifImage struct { ... }
+	type BisSet   []int
+	type BitSet64 uint64
+	type UUID     string
+	type MyStructWithUnexportedFields struct { a int; b bool; c []int; }
+	type GifImage struct { ... }
 
 As an illustration, MyStructWithUnexportedFields would normally be
 encoded as an empty map because it has no exported fields, while UUID
@@ -99,7 +99,7 @@ encode any of these however you like.
 There is also seamless support provided for registering an extension (with a tag)
 but letting the encoding mechanism default to the standard way.
 
-Custom Encoding and Decoding
+# Custom Encoding and Decoding
 
 This package maintains symmetry in the encoding and decoding halfs.
 We determine how to encode or decode by walking this decision tree
@@ -120,12 +120,12 @@ Consequently, if a type only defines one-half of the symmetry
 then that type doesn't satisfy the check and we will continue walking down the
 decision tree.
 
-RPC
+# RPC
 
 RPC Client and Server Codecs are implemented, so the codecs can be used
 with the standard net/rpc package.
 
-Usage
+# Usage
 
 The Handle is SAFE for concurrent READ, but NOT SAFE for concurrent modification.
 
@@ -133,96 +133,95 @@ The Encoder and Decoder are NOT safe for concurrent use.
 
 Consequently, the usage model is basically:
 
-    - Create and initialize the Handle before any use.
-      Once created, DO NOT modify it.
-    - Multiple Encoders or Decoders can now use the Handle concurrently.
-      They only read information off the Handle (never write).
-    - However, each Encoder or Decoder MUST not be used concurrently
-    - To re-use an Encoder/Decoder, call Reset(...) on it first.
-      This allows you use state maintained on the Encoder/Decoder.
+  - Create and initialize the Handle before any use.
+    Once created, DO NOT modify it.
+  - Multiple Encoders or Decoders can now use the Handle concurrently.
+    They only read information off the Handle (never write).
+  - However, each Encoder or Decoder MUST not be used concurrently
+  - To re-use an Encoder/Decoder, call Reset(...) on it first.
+    This allows you use state maintained on the Encoder/Decoder.
 
 Sample usage model:
 
-    // create and configure Handle
-    var (
-      bh codec.BincHandle
-      mh codec.MsgpackHandle
-      ch codec.CborHandle
-    )
-
-    mh.MapType = reflect.TypeOf(map[string]interface{}(nil))
-
-    // configure extensions
-    // e.g. for msgpack, define functions and enable Time support for tag 1
-    // mh.SetExt(reflect.TypeOf(time.Time{}), 1, myExt)
-
-    // create and use decoder/encoder
-    var (
-      r io.Reader
-      w io.Writer
-      b []byte
-      h = &bh // or mh to use msgpack
-    )
-
-    dec = codec.NewDecoder(r, h)
-    dec = codec.NewDecoderBytes(b, h)
-    err = dec.Decode(&v)
-
-    enc = codec.NewEncoder(w, h)
-    enc = codec.NewEncoderBytes(&b, h)
-    err = enc.Encode(v)
-
-    //RPC Server
-    go func() {
-        for {
-            conn, err := listener.Accept()
-            rpcCodec := codec.GoRpc.ServerCodec(conn, h)
-            //OR rpcCodec := codec.MsgpackSpecRpc.ServerCodec(conn, h)
-            rpc.ServeCodec(rpcCodec)
-        }
-    }()
-
-    //RPC Communication (client side)
-    conn, err = net.Dial("tcp", "localhost:5555")
-    rpcCodec := codec.GoRpc.ClientCodec(conn, h)
-    //OR rpcCodec := codec.MsgpackSpecRpc.ClientCodec(conn, h)
-    client := rpc.NewClientWithCodec(rpcCodec)
-
-Running Tests
+	// create and configure Handle
+	var (
+	  bh codec.BincHandle
+	  mh codec.MsgpackHandle
+	  ch codec.CborHandle
+	)
+
+	mh.MapType = reflect.TypeOf(map[string]interface{}(nil))
+
+	// configure extensions
+	// e.g. for msgpack, define functions and enable Time support for tag 1
+	// mh.SetExt(reflect.TypeOf(time.Time{}), 1, myExt)
+
+	// create and use decoder/encoder
+	var (
+	  r io.Reader
+	  w io.Writer
+	  b []byte
+	  h = &bh // or mh to use msgpack
+	)
+
+	dec = codec.NewDecoder(r, h)
+	dec = codec.NewDecoderBytes(b, h)
+	err = dec.Decode(&v)
+
+	enc = codec.NewEncoder(w, h)
+	enc = codec.NewEncoderBytes(&b, h)
+	err = enc.Encode(v)
+
+	//RPC Server
+	go func() {
+	    for {
+	        conn, err := listener.Accept()
+	        rpcCodec := codec.GoRpc.ServerCodec(conn, h)
+	        //OR rpcCodec := codec.MsgpackSpecRpc.ServerCodec(conn, h)
+	        rpc.ServeCodec(rpcCodec)
+	    }
+	}()
+
+	//RPC Communication (client side)
+	conn, err = net.Dial("tcp", "localhost:5555")
+	rpcCodec := codec.GoRpc.ClientCodec(conn, h)
+	//OR rpcCodec := codec.MsgpackSpecRpc.ClientCodec(conn, h)
+	client := rpc.NewClientWithCodec(rpcCodec)
+
+# Running Tests
 
 To run tests, use the following:
 
-    go test
+	go test
 
 To run the full suite of tests, use the following:
 
-    go test -tags alltests -run Suite
+	go test -tags alltests -run Suite
 
 You can run the tag 'codec.safe' to run tests or build in safe mode. e.g.
 
-    go test -tags codec.safe -run Json
-    go test -tags "alltests codec.safe" -run Suite
+	go test -tags codec.safe -run Json
+	go test -tags "alltests codec.safe" -run Suite
 
 Running Benchmarks
 
-    cd bench
-    go test -bench . -benchmem -benchtime 1s
+	cd bench
+	go test -bench . -benchmem -benchtime 1s
 
 Please see http://github.com/ugorji/go-codec-bench .
 
-Caveats
+# Caveats
 
 Struct fields matching the following are ignored during encoding and decoding
-    - struct tag value set to -
-    - func, complex numbers, unsafe pointers
-    - unexported and not embedded
-    - unexported and embedded and not struct kind
-    - unexported and embedded pointers (from go1.10)
+  - struct tag value set to -
+  - func, complex numbers, unsafe pointers
+  - unexported and not embedded
+  - unexported and embedded and not struct kind
+  - unexported and embedded pointers (from go1.10)
 
 Every other field in a struct will be encoded/decoded.
 
 Embedded fields are encoded as if they exist in the top-level struct,
 with some caveats. See Encode documentation.
-
 */
 package codec
diff --git a/vendor/github.com/ugorji/go/codec/encode.go b/vendor/github.com/ugorji/go/codec/encode.go
index e411bdb81..53389b085 100644
--- a/vendor/github.com/ugorji/go/codec/encode.go
+++ b/vendor/github.com/ugorji/go/codec/encode.go
@@ -686,15 +686,11 @@ func (e *Encoder) kMap(f *codecFnInfo, rv reflect.Value) {
 
 	var rvv = mapAddrLoopvarRV(f.ti.elem, vtypeKind)
 
-	if e.h.Canonical {
-		e.kMapCanonical(f.ti, rv, rvv, valFn)
-		e.mapEnd()
-		return
-	}
-
 	rtkey := f.ti.key
 	var keyTypeIsString = stringTypId == rt2id(rtkey) // rtkeyid
-	if !keyTypeIsString {
+	if keyTypeIsString {
+		keyFn = e.h.fn(rtkey)
+	} else {
 		for rtkey.Kind() == reflect.Ptr {
 			rtkey = rtkey.Elem()
 		}
@@ -703,6 +699,12 @@ func (e *Encoder) kMap(f *codecFnInfo, rv reflect.Value) {
 		}
 	}
 
+	if e.h.Canonical {
+		e.kMapCanonical(f.ti, rv, rvv, keyFn, valFn)
+		e.mapEnd()
+		return
+	}
+
 	var rvk = mapAddrLoopvarRV(f.ti.key, ktypeKind)
 
 	var it mapIter
@@ -723,11 +725,14 @@ func (e *Encoder) kMap(f *codecFnInfo, rv reflect.Value) {
 	e.mapEnd()
 }
 
-func (e *Encoder) kMapCanonical(ti *typeInfo, rv, rvv reflect.Value, valFn *codecFn) {
-	// we previously did out-of-band if an extension was registered.
-	// This is not necessary, as the natural kind is sufficient for ordering.
-
+func (e *Encoder) kMapCanonical(ti *typeInfo, rv, rvv reflect.Value, keyFn, valFn *codecFn) {
+	// The base kind of the type of the map key is sufficient for ordering.
+	// We only do out of band if that kind is not ordered (number or string), bool or time.Time.
+	// If the key is a predeclared type, directly call methods on encDriver e.g. EncodeString
+	// but if not, call encodeValue, in case it has an extension registered or otherwise.
 	rtkey := ti.key
+	rtkeydecl := rtkey.PkgPath() == "" && rtkey.Name() != "" // key type is predeclared
+
 	mks := rv.MapKeys()
 	rtkeyKind := rtkey.Kind()
 	kfast := mapKeyFastKindFor(rtkeyKind)
@@ -736,18 +741,24 @@ func (e *Encoder) kMapCanonical(ti *typeInfo, rv, rvv reflect.Value, valFn *code
 
 	switch rtkeyKind {
 	case reflect.Bool:
-		mksv := make([]boolRv, len(mks))
-		for i, k := range mks {
-			v := &mksv[i]
-			v.r = k
-			v.v = k.Bool()
+		// though bool keys make no sense in a map, it *could* happen.
+		// in that case, we MUST support it in reflection mode,
+		// as that is the fallback for even codecgen and others.
+
+		// sort the keys so that false comes before true
+		// ie if 2 keys in order (true, false), then swap them
+		if len(mks) == 2 && mks[0].Bool() {
+			mks[0], mks[1] = mks[1], mks[0]
 		}
-		sort.Sort(boolRvSlice(mksv))
-		for i := range mksv {
+		for i := range mks {
 			e.mapElemKey()
-			e.e.EncodeBool(mksv[i].v)
+			if rtkeydecl {
+				e.e.EncodeBool(mks[i].Bool())
+			} else {
+				e.encodeValueNonNil(mks[i], keyFn)
+			}
 			e.mapElemValue()
-			e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
+			e.encodeValue(mapGet(rv, mks[i], rvv, kfast, visindirect, visref), valFn)
 		}
 	case reflect.String:
 		mksv := make([]stringRv, len(mks))
@@ -759,7 +770,11 @@ func (e *Encoder) kMapCanonical(ti *typeInfo, rv, rvv reflect.Value, valFn *code
 		sort.Sort(stringRvSlice(mksv))
 		for i := range mksv {
 			e.mapElemKey()
-			e.e.EncodeString(mksv[i].v)
+			if rtkeydecl {
+				e.e.EncodeString(mksv[i].v)
+			} else {
+				e.encodeValueNonNil(mksv[i].r, keyFn)
+			}
 			e.mapElemValue()
 			e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
 		}
@@ -773,7 +788,11 @@ func (e *Encoder) kMapCanonical(ti *typeInfo, rv, rvv reflect.Value, valFn *code
 		sort.Sort(uint64RvSlice(mksv))
 		for i := range mksv {
 			e.mapElemKey()
-			e.e.EncodeUint(mksv[i].v)
+			if rtkeydecl {
+				e.e.EncodeUint(mksv[i].v)
+			} else {
+				e.encodeValueNonNil(mksv[i].r, keyFn)
+			}
 			e.mapElemValue()
 			e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
 		}
@@ -787,7 +806,11 @@ func (e *Encoder) kMapCanonical(ti *typeInfo, rv, rvv reflect.Value, valFn *code
 		sort.Sort(int64RvSlice(mksv))
 		for i := range mksv {
 			e.mapElemKey()
-			e.e.EncodeInt(mksv[i].v)
+			if rtkeydecl {
+				e.e.EncodeInt(mksv[i].v)
+			} else {
+				e.encodeValueNonNil(mksv[i].r, keyFn)
+			}
 			e.mapElemValue()
 			e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
 		}
@@ -801,7 +824,11 @@ func (e *Encoder) kMapCanonical(ti *typeInfo, rv, rvv reflect.Value, valFn *code
 		sort.Sort(float64RvSlice(mksv))
 		for i := range mksv {
 			e.mapElemKey()
-			e.e.EncodeFloat32(float32(mksv[i].v))
+			if rtkeydecl {
+				e.e.EncodeFloat32(float32(mksv[i].v))
+			} else {
+				e.encodeValueNonNil(mksv[i].r, keyFn)
+			}
 			e.mapElemValue()
 			e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
 		}
@@ -815,11 +842,15 @@ func (e *Encoder) kMapCanonical(ti *typeInfo, rv, rvv reflect.Value, valFn *code
 		sort.Sort(float64RvSlice(mksv))
 		for i := range mksv {
 			e.mapElemKey()
-			e.e.EncodeFloat64(mksv[i].v)
+			if rtkeydecl {
+				e.e.EncodeFloat64(mksv[i].v)
+			} else {
+				e.encodeValueNonNil(mksv[i].r, keyFn)
+			}
 			e.mapElemValue()
 			e.encodeValue(mapGet(rv, mksv[i].r, rvv, kfast, visindirect, visref), valFn)
 		}
-	case reflect.Struct:
+	default:
 		if rtkey == timeTyp {
 			mksv := make([]timeRv, len(mks))
 			for i, k := range mks {
@@ -836,8 +867,7 @@ func (e *Encoder) kMapCanonical(ti *typeInfo, rv, rvv reflect.Value, valFn *code
 			}
 			break
 		}
-		fallthrough
-	default:
+
 		// out-of-band
 		// first encode each key to a []byte first, then sort them, then record
 		bs0 := e.blist.get(len(mks) * 16)
@@ -1010,16 +1040,17 @@ func (e *Encoder) ResetBytes(out *[]byte) {
 // To set an option on all fields (e.g. omitempty on all fields), you
 // can create a field called _struct, and set flags on it. The options
 // which can be set on _struct are:
-//    - omitempty: so all fields are omitted if empty
-//    - toarray: so struct is encoded as an array
-//    - int: so struct key names are encoded as signed integers (instead of strings)
-//    - uint: so struct key names are encoded as unsigned integers (instead of strings)
-//    - float: so struct key names are encoded as floats (instead of strings)
+//   - omitempty: so all fields are omitted if empty
+//   - toarray: so struct is encoded as an array
+//   - int: so struct key names are encoded as signed integers (instead of strings)
+//   - uint: so struct key names are encoded as unsigned integers (instead of strings)
+//   - float: so struct key names are encoded as floats (instead of strings)
+//
 // More details on these below.
 //
 // Struct values "usually" encode as maps. Each exported struct field is encoded unless:
-//    - the field's tag is "-", OR
-//    - the field is empty (empty or the zero value) and its tag specifies the "omitempty" option.
+//   - the field's tag is "-", OR
+//   - the field is empty (empty or the zero value) and its tag specifies the "omitempty" option.
 //
 // When encoding as a map, the first string in the tag (before the comma)
 // is the map key string to use when encoding.
@@ -1032,8 +1063,9 @@ func (e *Encoder) ResetBytes(out *[]byte) {
 // This is done with the int,uint or float option on the _struct field (see above).
 //
 // However, struct values may encode as arrays. This happens when:
-//    - StructToArray Encode option is set, OR
-//    - the tag on the _struct field sets the "toarray" option
+//   - StructToArray Encode option is set, OR
+//   - the tag on the _struct field sets the "toarray" option
+//
 // Note that omitempty is ignored when encoding struct values as arrays,
 // as an entry must be encoded for each field, to maintain its position.
 //
@@ -1043,33 +1075,33 @@ func (e *Encoder) ResetBytes(out *[]byte) {
 // or interface value, and any array, slice, map, or string of length zero.
 //
 // Anonymous fields are encoded inline except:
-//    - the struct tag specifies a replacement name (first value)
-//    - the field is of an interface type
+//   - the struct tag specifies a replacement name (first value)
+//   - the field is of an interface type
 //
 // Examples:
 //
-//      // NOTE: 'json:' can be used as struct tag key, in place 'codec:' below.
-//      type MyStruct struct {
-//          _struct bool    `codec:",omitempty"`   //set omitempty for every field
-//          Field1 string   `codec:"-"`            //skip this field
-//          Field2 int      `codec:"myName"`       //Use key "myName" in encode stream
-//          Field3 int32    `codec:",omitempty"`   //use key "Field3". Omit if empty.
-//          Field4 bool     `codec:"f4,omitempty"` //use key "f4". Omit if empty.
-//          io.Reader                              //use key "Reader".
-//          MyStruct        `codec:"my1"           //use key "my1".
-//          MyStruct                               //inline it
-//          ...
-//      }
+//	// NOTE: 'json:' can be used as struct tag key, in place 'codec:' below.
+//	type MyStruct struct {
+//	    _struct bool    `codec:",omitempty"`   //set omitempty for every field
+//	    Field1 string   `codec:"-"`            //skip this field
+//	    Field2 int      `codec:"myName"`       //Use key "myName" in encode stream
+//	    Field3 int32    `codec:",omitempty"`   //use key "Field3". Omit if empty.
+//	    Field4 bool     `codec:"f4,omitempty"` //use key "f4". Omit if empty.
+//	    io.Reader                              //use key "Reader".
+//	    MyStruct        `codec:"my1"           //use key "my1".
+//	    MyStruct                               //inline it
+//	    ...
+//	}
 //
-//      type MyStruct struct {
-//          _struct bool    `codec:",toarray"`     //encode struct as an array
-//      }
+//	type MyStruct struct {
+//	    _struct bool    `codec:",toarray"`     //encode struct as an array
+//	}
 //
-//      type MyStruct struct {
-//          _struct bool    `codec:",uint"`        //encode struct with "unsigned integer" keys
-//          Field1 string   `codec:"1"`            //encode Field1 key using: EncodeInt(1)
-//          Field2 string   `codec:"2"`            //encode Field2 key using: EncodeInt(2)
-//      }
+//	type MyStruct struct {
+//	    _struct bool    `codec:",uint"`        //encode struct with "unsigned integer" keys
+//	    Field1 string   `codec:"1"`            //encode Field1 key using: EncodeInt(1)
+//	    Field2 string   `codec:"2"`            //encode Field2 key using: EncodeInt(2)
+//	}
 //
 // The mode of encoding is based on the type of the value. When a value is seen:
 //   - If a Selfer, call its CodecEncodeSelf method
@@ -1293,7 +1325,7 @@ TOP:
 	}
 
 	if fn == nil {
-		fn = e.h.fn(rvType(rv))
+		fn = e.h.fn(rv.Type())
 	}
 
 	if !fn.i.addrE { // typically, addrE = false, so check it first
@@ -1310,6 +1342,19 @@ TOP:
 	}
 }
 
+// encodeValueNonNil can encode a number, bool, or string
+// OR non-nil values of kind map, slice and chan.
+func (e *Encoder) encodeValueNonNil(rv reflect.Value, fn *codecFn) {
+	if fn == nil {
+		fn = e.h.fn(rv.Type())
+	}
+
+	if fn.i.addrE { // typically, addrE = false, so check it first
+		rv = e.addrRV(rv, fn.i.ti.rt, fn.i.ti.ptr)
+	}
+	fn.fe(e, &fn.i, rv)
+}
+
 // addrRV returns a addressable value which may be readonly
 func (e *Encoder) addrRV(rv reflect.Value, typ, ptrType reflect.Type) (rva reflect.Value) {
 	if rv.CanAddr() {
diff --git a/vendor/github.com/ugorji/go/codec/fast-path.generated.go b/vendor/github.com/ugorji/go/codec/fast-path.generated.go
index a2c258196..941ef798f 100644
--- a/vendor/github.com/ugorji/go/codec/fast-path.generated.go
+++ b/vendor/github.com/ugorji/go/codec/fast-path.generated.go
@@ -3019,7 +3019,7 @@ func (fastpathT) DecSliceIntfY(v []interface{}, d *Decoder) (v2 []interface{}, c
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j == 0 && len(v) == 0 { // means hasLen == false
 			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
 			v = make([]interface{}, uint(xlen))
@@ -3052,7 +3052,7 @@ func (fastpathT) DecSliceIntfN(v []interface{}, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j >= len(v) {
 			slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
 			return
@@ -3118,7 +3118,7 @@ func (fastpathT) DecSliceStringY(v []string, d *Decoder) (v2 []string, changed b
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j == 0 && len(v) == 0 { // means hasLen == false
 			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 16)
 			v = make([]string, uint(xlen))
@@ -3151,7 +3151,7 @@ func (fastpathT) DecSliceStringN(v []string, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j >= len(v) {
 			slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
 			return
@@ -3217,7 +3217,7 @@ func (fastpathT) DecSliceBytesY(v [][]byte, d *Decoder) (v2 [][]byte, changed bo
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j == 0 && len(v) == 0 { // means hasLen == false
 			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 24)
 			v = make([][]byte, uint(xlen))
@@ -3250,7 +3250,7 @@ func (fastpathT) DecSliceBytesN(v [][]byte, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j >= len(v) {
 			slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
 			return
@@ -3316,7 +3316,7 @@ func (fastpathT) DecSliceFloat32Y(v []float32, d *Decoder) (v2 []float32, change
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j == 0 && len(v) == 0 { // means hasLen == false
 			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
 			v = make([]float32, uint(xlen))
@@ -3349,7 +3349,7 @@ func (fastpathT) DecSliceFloat32N(v []float32, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j >= len(v) {
 			slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
 			return
@@ -3415,7 +3415,7 @@ func (fastpathT) DecSliceFloat64Y(v []float64, d *Decoder) (v2 []float64, change
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j == 0 && len(v) == 0 { // means hasLen == false
 			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
 			v = make([]float64, uint(xlen))
@@ -3448,7 +3448,7 @@ func (fastpathT) DecSliceFloat64N(v []float64, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j >= len(v) {
 			slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
 			return
@@ -3522,7 +3522,7 @@ func (fastpathT) DecSliceUint8Y(v []uint8, d *Decoder) (v2 []uint8, changed bool
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j == 0 && len(v) == 0 { // means hasLen == false
 			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
 			v = make([]uint8, uint(xlen))
@@ -3565,7 +3565,7 @@ func (fastpathT) DecSliceUint8N(v []uint8, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j >= len(v) {
 			slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
 			return
@@ -3631,7 +3631,7 @@ func (fastpathT) DecSliceUint64Y(v []uint64, d *Decoder) (v2 []uint64, changed b
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j == 0 && len(v) == 0 { // means hasLen == false
 			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
 			v = make([]uint64, uint(xlen))
@@ -3664,7 +3664,7 @@ func (fastpathT) DecSliceUint64N(v []uint64, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j >= len(v) {
 			slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
 			return
@@ -3730,7 +3730,7 @@ func (fastpathT) DecSliceIntY(v []int, d *Decoder) (v2 []int, changed bool) {
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j == 0 && len(v) == 0 { // means hasLen == false
 			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
 			v = make([]int, uint(xlen))
@@ -3763,7 +3763,7 @@ func (fastpathT) DecSliceIntN(v []int, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j >= len(v) {
 			slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
 			return
@@ -3829,7 +3829,7 @@ func (fastpathT) DecSliceInt32Y(v []int32, d *Decoder) (v2 []int32, changed bool
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j == 0 && len(v) == 0 { // means hasLen == false
 			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 4)
 			v = make([]int32, uint(xlen))
@@ -3862,7 +3862,7 @@ func (fastpathT) DecSliceInt32N(v []int32, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j >= len(v) {
 			slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
 			return
@@ -3928,7 +3928,7 @@ func (fastpathT) DecSliceInt64Y(v []int64, d *Decoder) (v2 []int64, changed bool
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j == 0 && len(v) == 0 { // means hasLen == false
 			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 8)
 			v = make([]int64, uint(xlen))
@@ -3961,7 +3961,7 @@ func (fastpathT) DecSliceInt64N(v []int64, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j >= len(v) {
 			slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
 			return
@@ -4027,7 +4027,7 @@ func (fastpathT) DecSliceBoolY(v []bool, d *Decoder) (v2 []bool, changed bool) {
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j == 0 && len(v) == 0 { // means hasLen == false
 			xlen = decInferLen(containerLenS, d.h.MaxInitLen, 1)
 			v = make([]bool, uint(xlen))
@@ -4060,7 +4060,7 @@ func (fastpathT) DecSliceBoolN(v []bool, d *Decoder) {
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j >= len(v) {
 			slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
 			return
@@ -4108,7 +4108,7 @@ func (fastpathT) DecMapStringIntfL(v map[string]interface{}, containerLen int, d
 	var mk string
 	var mv interface{}
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.stringZC(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -4158,7 +4158,7 @@ func (fastpathT) DecMapStringStringL(v map[string]string, containerLen int, d *D
 	var mk string
 	var mv string
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.stringZC(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -4204,7 +4204,7 @@ func (fastpathT) DecMapStringBytesL(v map[string][]byte, containerLen int, d *De
 	var mk string
 	var mv []byte
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.stringZC(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -4254,7 +4254,7 @@ func (fastpathT) DecMapStringUint8L(v map[string]uint8, containerLen int, d *Dec
 	var mk string
 	var mv uint8
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.stringZC(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -4299,7 +4299,7 @@ func (fastpathT) DecMapStringUint64L(v map[string]uint64, containerLen int, d *D
 	var mk string
 	var mv uint64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.stringZC(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -4344,7 +4344,7 @@ func (fastpathT) DecMapStringIntL(v map[string]int, containerLen int, d *Decoder
 	var mk string
 	var mv int
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.stringZC(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -4389,7 +4389,7 @@ func (fastpathT) DecMapStringInt32L(v map[string]int32, containerLen int, d *Dec
 	var mk string
 	var mv int32
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.stringZC(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -4434,7 +4434,7 @@ func (fastpathT) DecMapStringFloat64L(v map[string]float64, containerLen int, d
 	var mk string
 	var mv float64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.stringZC(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -4479,7 +4479,7 @@ func (fastpathT) DecMapStringBoolL(v map[string]bool, containerLen int, d *Decod
 	var mk string
 	var mv bool
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.stringZC(d.d.DecodeStringAsBytes())
 		d.mapElemValue()
@@ -4525,7 +4525,7 @@ func (fastpathT) DecMapUint8IntfL(v map[uint8]interface{}, containerLen int, d *
 	var mk uint8
 	var mv interface{}
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -4575,7 +4575,7 @@ func (fastpathT) DecMapUint8StringL(v map[uint8]string, containerLen int, d *Dec
 	var mk uint8
 	var mv string
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -4621,7 +4621,7 @@ func (fastpathT) DecMapUint8BytesL(v map[uint8][]byte, containerLen int, d *Deco
 	var mk uint8
 	var mv []byte
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -4671,7 +4671,7 @@ func (fastpathT) DecMapUint8Uint8L(v map[uint8]uint8, containerLen int, d *Decod
 	var mk uint8
 	var mv uint8
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -4716,7 +4716,7 @@ func (fastpathT) DecMapUint8Uint64L(v map[uint8]uint64, containerLen int, d *Dec
 	var mk uint8
 	var mv uint64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -4761,7 +4761,7 @@ func (fastpathT) DecMapUint8IntL(v map[uint8]int, containerLen int, d *Decoder)
 	var mk uint8
 	var mv int
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -4806,7 +4806,7 @@ func (fastpathT) DecMapUint8Int32L(v map[uint8]int32, containerLen int, d *Decod
 	var mk uint8
 	var mv int32
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -4851,7 +4851,7 @@ func (fastpathT) DecMapUint8Float64L(v map[uint8]float64, containerLen int, d *D
 	var mk uint8
 	var mv float64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -4896,7 +4896,7 @@ func (fastpathT) DecMapUint8BoolL(v map[uint8]bool, containerLen int, d *Decoder
 	var mk uint8
 	var mv bool
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))
 		d.mapElemValue()
@@ -4942,7 +4942,7 @@ func (fastpathT) DecMapUint64IntfL(v map[uint64]interface{}, containerLen int, d
 	var mk uint64
 	var mv interface{}
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -4992,7 +4992,7 @@ func (fastpathT) DecMapUint64StringL(v map[uint64]string, containerLen int, d *D
 	var mk uint64
 	var mv string
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -5038,7 +5038,7 @@ func (fastpathT) DecMapUint64BytesL(v map[uint64][]byte, containerLen int, d *De
 	var mk uint64
 	var mv []byte
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -5088,7 +5088,7 @@ func (fastpathT) DecMapUint64Uint8L(v map[uint64]uint8, containerLen int, d *Dec
 	var mk uint64
 	var mv uint8
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -5133,7 +5133,7 @@ func (fastpathT) DecMapUint64Uint64L(v map[uint64]uint64, containerLen int, d *D
 	var mk uint64
 	var mv uint64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -5178,7 +5178,7 @@ func (fastpathT) DecMapUint64IntL(v map[uint64]int, containerLen int, d *Decoder
 	var mk uint64
 	var mv int
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -5223,7 +5223,7 @@ func (fastpathT) DecMapUint64Int32L(v map[uint64]int32, containerLen int, d *Dec
 	var mk uint64
 	var mv int32
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -5268,7 +5268,7 @@ func (fastpathT) DecMapUint64Float64L(v map[uint64]float64, containerLen int, d
 	var mk uint64
 	var mv float64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -5313,7 +5313,7 @@ func (fastpathT) DecMapUint64BoolL(v map[uint64]bool, containerLen int, d *Decod
 	var mk uint64
 	var mv bool
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = d.d.DecodeUint64()
 		d.mapElemValue()
@@ -5359,7 +5359,7 @@ func (fastpathT) DecMapIntIntfL(v map[int]interface{}, containerLen int, d *Deco
 	var mk int
 	var mv interface{}
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -5409,7 +5409,7 @@ func (fastpathT) DecMapIntStringL(v map[int]string, containerLen int, d *Decoder
 	var mk int
 	var mv string
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -5455,7 +5455,7 @@ func (fastpathT) DecMapIntBytesL(v map[int][]byte, containerLen int, d *Decoder)
 	var mk int
 	var mv []byte
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -5505,7 +5505,7 @@ func (fastpathT) DecMapIntUint8L(v map[int]uint8, containerLen int, d *Decoder)
 	var mk int
 	var mv uint8
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -5550,7 +5550,7 @@ func (fastpathT) DecMapIntUint64L(v map[int]uint64, containerLen int, d *Decoder
 	var mk int
 	var mv uint64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -5595,7 +5595,7 @@ func (fastpathT) DecMapIntIntL(v map[int]int, containerLen int, d *Decoder) {
 	var mk int
 	var mv int
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -5640,7 +5640,7 @@ func (fastpathT) DecMapIntInt32L(v map[int]int32, containerLen int, d *Decoder)
 	var mk int
 	var mv int32
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -5685,7 +5685,7 @@ func (fastpathT) DecMapIntFloat64L(v map[int]float64, containerLen int, d *Decod
 	var mk int
 	var mv float64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -5730,7 +5730,7 @@ func (fastpathT) DecMapIntBoolL(v map[int]bool, containerLen int, d *Decoder) {
 	var mk int
 	var mv bool
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))
 		d.mapElemValue()
@@ -5776,7 +5776,7 @@ func (fastpathT) DecMapInt32IntfL(v map[int32]interface{}, containerLen int, d *
 	var mk int32
 	var mv interface{}
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
 		d.mapElemValue()
@@ -5826,7 +5826,7 @@ func (fastpathT) DecMapInt32StringL(v map[int32]string, containerLen int, d *Dec
 	var mk int32
 	var mv string
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
 		d.mapElemValue()
@@ -5872,7 +5872,7 @@ func (fastpathT) DecMapInt32BytesL(v map[int32][]byte, containerLen int, d *Deco
 	var mk int32
 	var mv []byte
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
 		d.mapElemValue()
@@ -5922,7 +5922,7 @@ func (fastpathT) DecMapInt32Uint8L(v map[int32]uint8, containerLen int, d *Decod
 	var mk int32
 	var mv uint8
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
 		d.mapElemValue()
@@ -5967,7 +5967,7 @@ func (fastpathT) DecMapInt32Uint64L(v map[int32]uint64, containerLen int, d *Dec
 	var mk int32
 	var mv uint64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
 		d.mapElemValue()
@@ -6012,7 +6012,7 @@ func (fastpathT) DecMapInt32IntL(v map[int32]int, containerLen int, d *Decoder)
 	var mk int32
 	var mv int
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
 		d.mapElemValue()
@@ -6057,7 +6057,7 @@ func (fastpathT) DecMapInt32Int32L(v map[int32]int32, containerLen int, d *Decod
 	var mk int32
 	var mv int32
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
 		d.mapElemValue()
@@ -6102,7 +6102,7 @@ func (fastpathT) DecMapInt32Float64L(v map[int32]float64, containerLen int, d *D
 	var mk int32
 	var mv float64
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
 		d.mapElemValue()
@@ -6147,7 +6147,7 @@ func (fastpathT) DecMapInt32BoolL(v map[int32]bool, containerLen int, d *Decoder
 	var mk int32
 	var mv bool
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+	for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		mk = int32(chkOvf.IntV(d.d.DecodeInt64(), 32))
 		d.mapElemValue()
diff --git a/vendor/github.com/ugorji/go/codec/fast-path.go.tmpl b/vendor/github.com/ugorji/go/codec/fast-path.go.tmpl
index 56801ee5c..1a1cb95c6 100644
--- a/vendor/github.com/ugorji/go/codec/fast-path.go.tmpl
+++ b/vendor/github.com/ugorji/go/codec/fast-path.go.tmpl
@@ -409,7 +409,7 @@ func (fastpathT) {{ .MethodNamePfx "Dec" false }}Y(v []{{ .Elem }}, d *Decoder)
 		}
 	}
 	var j int
-	for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+    for j = 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		if j == 0 && len(v) == 0 { // means hasLen == false
 			xlen = decInferLen(containerLenS, d.h.MaxInitLen, {{ .Size }}) {{/* xlen = decDefSliceCap */}}
 			v = make([]{{ .Elem }}, uint(xlen))
@@ -455,7 +455,7 @@ func (fastpathT) {{ .MethodNamePfx "Dec" false }}N(v []{{ .Elem }}, d *Decoder)
 		return
 	}
 	hasLen := containerLenS > 0
-	for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
+    for j := 0; d.containerNext(j, containerLenS, hasLen); j++ {
 		{{/* // if indefinite, etc, then expand the slice if necessary */ -}}
 		if j >= len(v) {
 			slh.arrayCannotExpand(hasLen, len(v), j, containerLenS)
@@ -531,7 +531,7 @@ func (fastpathT) {{ .MethodNamePfx "Dec" false }}L(v map[{{ .MapKey }}]{{ .Elem
     var mk {{ .MapKey }}
 	var mv {{ .Elem }}
 	hasLen := containerLen > 0
-	for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
+    for j := 0; d.containerNext(j, containerLen, hasLen); j++ {
 		d.mapElemKey()
 		{{ if eq .MapKey "interface{}" }}mk = nil 
 		d.decode(&mk)
diff --git a/vendor/github.com/ugorji/go/codec/gen-dec-array.go.tmpl b/vendor/github.com/ugorji/go/codec/gen-dec-array.go.tmpl
index e92175059..5e119e715 100644
--- a/vendor/github.com/ugorji/go/codec/gen-dec-array.go.tmpl
+++ b/vendor/github.com/ugorji/go/codec/gen-dec-array.go.tmpl
@@ -42,8 +42,8 @@ if {{var "l"}} == 0 {
 	}
     {{end -}}
 	var {{var "j"}} int 
-    {{/* // var {{var "dn"}} bool */ -}}
-	for {{var "j"}} = 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || z.DecCheckBreak()); {{var "j"}}++ { // bounds-check-elimination
+	{{/* // var {{var "dn"}} bool */ -}}
+	for {{var "j"}} = 0; z.DecContainerNext({{var "j"}}, {{var "l"}}, {{var "hl"}}); {{var "j"}}++ {
 		{{if not isArray}} if {{var "j"}} == 0 && {{var "v"}} == nil {
 			if {{var "hl"}} {
 				{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
diff --git a/vendor/github.com/ugorji/go/codec/gen-dec-map.go.tmpl b/vendor/github.com/ugorji/go/codec/gen-dec-map.go.tmpl
index a7ce62b59..b32ade2e1 100644
--- a/vendor/github.com/ugorji/go/codec/gen-dec-map.go.tmpl
+++ b/vendor/github.com/ugorji/go/codec/gen-dec-map.go.tmpl
@@ -19,7 +19,7 @@ if z.DecBasicHandle().MapValueReset {
 	{{end}} }
 if {{var "l"}} != 0 {
 	{{var "hl"}} := {{var "l"}} > 0 
-	for {{var "j"}} := 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || z.DecCheckBreak()); {{var "j"}}++ {
+	for {{var "j"}} := 0; z.DecContainerNext({{var "j"}}, {{var "l"}}, {{var "hl"}}); {{var "j"}}++ {
 	z.DecReadMapElemKey()
 	{{ if eq .KTyp "string" -}}
 		{{ decLineVarK $mk -}}{{- /* decLineVarKStrZC $mk */ -}}
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 5643b6af9..676203daf 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 = 25
+const GenVersion = 26
 
 // 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
@@ -66,6 +66,11 @@ func (f genHelperEncoder) EncBasicHandle() *BasicHandle {
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncWr() *encWr {
+	return f.e.w()
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncBinary() bool {
 	return f.e.be // f.e.hh.isBinaryEncoding()
 }
@@ -113,11 +118,6 @@ func (f genHelperEncoder) EncExtension(v interface{}, xfFn *extTypeTagFn) {
 }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) WriteStr(s string) {
-	f.e.w().writestr(s)
-}
-
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncWriteMapStart(length int) { f.e.mapStart(length) }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
@@ -148,9 +148,19 @@ func (f genHelperEncoder) EncEncodeComplex128(v complex128) { f.e.encodeComplex1
 func (f genHelperEncoder) EncEncode(v interface{}) { f.e.encode(v) }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncFnGivenAddr(v interface{}) *codecFn {
+	return f.e.h.fn(reflect.TypeOf(v).Elem())
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncEncodeNumBoolStrKindGivenAddr(v interface{}, encFn *codecFn) {
+	f.e.encodeValueNonNil(reflect.ValueOf(v).Elem(), encFn)
+}
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncEncodeMapNonNil(v interface{}) {
 	if skipFastpathTypeSwitchInDirectCall || !fastpathEncodeTypeSwitch(v, f.e) {
-		f.e.encodeValue(reflect.ValueOf(v), nil)
+		f.e.encodeValueNonNil(reflect.ValueOf(v), nil)
 	}
 }
 
@@ -268,10 +278,17 @@ func (f genHelperDecoder) DecReadMapElemValue() { f.d.mapElemValue() }
 func (f genHelperDecoder) DecDecodeFloat32() float32 { return f.d.decodeFloat32() }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecCheckBreak() bool { return f.d.checkBreak() }
-
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecStringZC(v []byte) string { return f.d.stringZC(v) }
 
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecodeBytesInto(v []byte) []byte { return f.d.decodeBytesInto(v) }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecContainerNext(j, containerLen int, hasLen bool) bool {
+	// return f.d.containerNext(j, containerLen, hasLen)
+	// rewriting so it can be inlined
+	if hasLen {
+		return j < containerLen
+	}
+	return !f.d.checkBreak()
+}
diff --git a/vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl b/vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl
index 1f1339684..bf824ebdd 100644
--- a/vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl
+++ b/vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl
@@ -73,6 +73,10 @@ func (f genHelperEncoder) EncBasicHandle() *BasicHandle {
 	return f.e.h
 }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncWr() *encWr {
+	return f.e.w()
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncBinary() bool {
 	return f.e.be // f.e.hh.isBinaryEncoding()
 }
@@ -111,10 +115,7 @@ func (f genHelperEncoder) Extension(v interface{}) (xfn *extTypeTagFn) {
 func (f genHelperEncoder) EncExtension(v interface{}, xfFn *extTypeTagFn) {
 	f.e.e.EncodeExt(v, xfFn.rt, xfFn.tag, xfFn.ext)
 }
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperEncoder) WriteStr(s string) {
-	f.e.w().writestr(s)
-}
+
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncWriteMapStart(length int) { f.e.mapStart(length) }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
@@ -136,9 +137,15 @@ func (f genHelperEncoder) EncEncodeComplex128(v complex128) { f.e.encodeComplex1
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncEncode(v interface{}) { f.e.encode(v) }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncFnGivenAddr(v interface{}) *codecFn { return f.e.h.fn(reflect.TypeOf(v).Elem()) }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperEncoder) EncEncodeNumBoolStrKindGivenAddr(v interface{}, encFn *codecFn) {
+     f.e.encodeValueNonNil(reflect.ValueOf(v).Elem(), encFn)
+}
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperEncoder) EncEncodeMapNonNil(v interface{}) {
 	if skipFastpathTypeSwitchInDirectCall || !fastpathEncodeTypeSwitch(v, f.e) {
-		f.e.encodeValue(reflect.ValueOf(v), nil)
+		f.e.encodeValueNonNil(reflect.ValueOf(v), nil)
 	}
 }
 
@@ -205,12 +212,6 @@ func (f genHelperDecoder) DecRaw() []byte {	return f.d.rawBytes() }
 func (f genHelperDecoder) IsJSONHandle() bool {
 	return f.d.js 
 }
-{{/*
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) I2Rtid(v interface{}) uintptr {
-	return i2rtid(v)
-}
-*/ -}}
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) Extension(v interface{}) (xfn *extTypeTagFn) {
 	return f.d.h.getExtForI(v)
@@ -242,8 +243,31 @@ func (f genHelperDecoder) DecReadMapElemValue() { f.d.mapElemValue() }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecDecodeFloat32() float32 { return f.d.decodeFloat32() }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
-func (f genHelperDecoder) DecCheckBreak() bool { return f.d.checkBreak() }
-// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecStringZC(v []byte) string { return f.d.stringZC(v) }
 // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
 func (f genHelperDecoder) DecodeBytesInto(v []byte) []byte { return f.d.decodeBytesInto(v) }
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) DecContainerNext(j, containerLen int, hasLen bool) bool {
+	// return f.d.containerNext(j, containerLen, hasLen)
+	// rewriting so it can be inlined
+	if hasLen {
+		return j < containerLen
+	}
+	return !f.d.checkBreak()
+}
+
+{{/*
+// MARKER: remove WriteStr, as it cannot be inlined as of 20230201.
+// Instead, generated code calls (*encWr).WriteStr directly.
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+// func (f genHelperEncoder) WriteStr(s string) {
+//     f.e.encWr.writestr(s)
+// }
+
+// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
+func (f genHelperDecoder) I2Rtid(v interface{}) uintptr {
+	return i2rtid(v)
+}
+
+*/ -}}
diff --git a/vendor/github.com/ugorji/go/codec/gen.generated.go b/vendor/github.com/ugorji/go/codec/gen.generated.go
index 0ea79e75d..277180a01 100644
--- a/vendor/github.com/ugorji/go/codec/gen.generated.go
+++ b/vendor/github.com/ugorji/go/codec/gen.generated.go
@@ -29,7 +29,7 @@ if z.DecBasicHandle().MapValueReset {
 	{{end}} }
 if {{var "l"}} != 0 {
 	{{var "hl"}} := {{var "l"}} > 0 
-	for {{var "j"}} := 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || z.DecCheckBreak()); {{var "j"}}++ {
+	for {{var "j"}} := 0; z.DecContainerNext({{var "j"}}, {{var "l"}}, {{var "hl"}}); {{var "j"}}++ {
 	z.DecReadMapElemKey()
 	{{ if eq .KTyp "string" -}}
 		{{ decLineVarK $mk -}}{{- /* decLineVarKStrZC $mk */ -}}
@@ -113,8 +113,8 @@ if {{var "l"}} == 0 {
 	}
     {{end -}}
 	var {{var "j"}} int 
-    {{/* // var {{var "dn"}} bool */ -}}
-	for {{var "j"}} = 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || z.DecCheckBreak()); {{var "j"}}++ { // bounds-check-elimination
+	{{/* // var {{var "dn"}} bool */ -}}
+	for {{var "j"}} = 0; z.DecContainerNext({{var "j"}}, {{var "l"}}, {{var "hl"}}); {{var "j"}}++ {
 		{{if not isArray}} if {{var "j"}} == 0 && {{var "v"}} == nil {
 			if {{var "hl"}} {
 				{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
diff --git a/vendor/github.com/ugorji/go/codec/gen.go b/vendor/github.com/ugorji/go/codec/gen.go
index 8c5bbf201..d0cec1972 100644
--- a/vendor/github.com/ugorji/go/codec/gen.go
+++ b/vendor/github.com/ugorji/go/codec/gen.go
@@ -43,15 +43,17 @@ import (
 //
 // However, note following codecgen caveats:
 //   - Canonical option.
-//     If Canonical=true, codecgen'ed code will delegate encoding maps to reflection-based code.
+//     If Canonical=true, codecgen'ed code may delegate encoding maps to reflection-based code.
 //     This is due to the runtime work needed to marshal a map in canonical mode.
+//     However, if map key is a pre-defined/builtin numeric or string type, codecgen
+//     will try to write it out itself
 //   - CheckCircularRef option.
 //     When encoding a struct, a circular reference can lead to a stack overflow.
 //     If CheckCircularRef=true, codecgen'ed code will delegate encoding structs to reflection-based code.
 //   - MissingFielder implementation.
 //     If a type implements MissingFielder, a Selfer is not generated (with a warning message).
-//     Statically reproducing the runtime work needed to extract the missing fields and marshal them along with the struct fields,
-//     while handling the Canonical=true special case, was onerous to implement.
+//     Statically reproducing the runtime work needed to extract the missing fields and marshal them
+//     along with the struct fields, while handling the Canonical=true special case, was onerous to implement.
 //
 // During encode/decode, Selfer takes precedence.
 // A type implementing Selfer will know how to encode/decode itself statically.
@@ -125,14 +127,13 @@ import (
 //
 // v1: Initial Version
 // v2: -
-// v3: Changes for Kubernetes:
-//     changes in signature of some unpublished helper methods and codecgen cmdline arguments.
+// v3: For Kubernetes: changes in signature of some unpublished helper methods and codecgen cmdline arguments.
 // v4: Removed separator support from (en|de)cDriver, and refactored codec(gen)
 // v5: changes to support faster json decoding. Let encoder/decoder maintain state of collections.
 // v6: removed unsafe from gen, and now uses codecgen.exec tag
 // v7: -
 // v8: current - we now maintain compatibility with old generated code.
-// v9: skipped
+// v9: - skipped
 // v10: modified encDriver and decDriver interfaces.
 // v11: remove deprecated methods of encDriver and decDriver.
 // v12: removed deprecated methods from genHelper and changed container tracking logic
@@ -149,7 +150,8 @@ import (
 // v23: 20210203 changed slice/map types for which we generate fast-path functions
 // 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
-const genVersion = 25
+// v26: 20230201 genHelper changes for more inlining and consequent performance
+const genVersion = 26
 
 const (
 	genCodecPkg        = "codec1978" // MARKER: keep in sync with codecgen/gen.go
@@ -160,16 +162,9 @@ const (
 	// This is because nil can appear anywhere, so we should always check.
 	genAnythingCanBeNil = true
 
-	// if genUseOneFunctionForDecStructMap, make a single codecDecodeSelferFromMap function;
-	// else make codecDecodeSelferFromMap{LenPrefix,CheckBreak} so that conditionals
-	// are not executed a lot.
-	//
-	// From testing, it didn't make much difference in runtime, so keep as true (one function only)
-	genUseOneFunctionForDecStructMap = true
-
 	// genStructCanonical configures whether we generate 2 paths based on Canonical flag
 	// when encoding struct fields.
-	genStructCanonical = false
+	genStructCanonical = true
 
 	// genFastpathCanonical configures whether we support Canonical in fast path.
 	// The savings is not much.
@@ -179,15 +174,8 @@ const (
 
 	// genFastpathTrimTypes configures whether we trim uncommon fastpath types.
 	genFastpathTrimTypes = true
-
-	// genDecStructArrayInlineLoopCheck configures whether we create a next function
-	// for each iteration in the loop and call it, or just inline it.
-	//
-	// with inlining, we get better performance but about 10% larger files.
-	genDecStructArrayInlineLoopCheck = true
 )
 
-type genStructMapStyle uint8
 type genStringDecAsBytes string
 type genStringDecZC string
 
@@ -195,12 +183,6 @@ var genStringDecAsBytesTyp = reflect.TypeOf(genStringDecAsBytes(""))
 var genStringDecZCTyp = reflect.TypeOf(genStringDecZC(""))
 var genFormats = []string{"Json", "Cbor", "Msgpack", "Binc", "Simple"}
 
-const (
-	genStructMapStyleConsolidated genStructMapStyle = iota
-	genStructMapStyleLenPrefix
-	genStructMapStyleCheckBreak
-)
-
 var (
 	errGenAllTypesSamePkg        = errors.New("All types must be in the same package")
 	errGenExpectArrayOrMap       = errors.New("unexpected type - expecting array/map/slice")
@@ -390,7 +372,7 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, noExtensions bool,
 		}
 	}
 	// add required packages
-	for _, k := range [...]string{"runtime", "errors", "strconv"} { // "reflect", "fmt"
+	for _, k := range [...]string{"runtime", "errors", "strconv", "sort"} { // "reflect", "fmt"
 		if _, ok := x.im[k]; !ok {
 			x.line("\"" + k + "\"")
 		}
@@ -416,6 +398,7 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, noExtensions bool,
 	x.line(")")
 	x.line("var (")
 	x.line("errCodecSelferOnlyMapOrArrayEncodeToStruct" + x.xs + " = " + "errors.New(`only encoded map or array can be decoded into a struct`)")
+	x.line("_ sort.Interface = nil")
 	x.line(")")
 	x.line("")
 
@@ -425,6 +408,16 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, noExtensions bool,
 	x.linef("func %sFalse() bool { return false }", x.hn)
 	x.linef("func %sTrue() bool { return true }", x.hn)
 	x.line("")
+
+	// add types for sorting canonical
+	for _, s := range []string{"string", "uint64", "int64", "float64"} {
+		x.linef("type %s%sSlice []%s", x.hn, s, s)
+		x.linef("func (p %s%sSlice) Len() int      { return len(p) }", x.hn, s)
+		x.linef("func (p %s%sSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }", x.hn, s)
+		x.linef("func (p %s%sSlice) Less(i, j int) bool { return p[uint(i)] < p[uint(j)] }", x.hn, s)
+	}
+
+	x.line("")
 	x.varsfxreset()
 	x.line("func init() {")
 	x.linef("if %sGenVersion != %v {", x.cpfx, genVersion)
@@ -759,28 +752,12 @@ func (x *genRunner) selfer(encode bool) {
 	}
 
 	// write is containerMap
-	if genUseOneFunctionForDecStructMap {
-		x.out(fnSigPfx)
-		x.line(") codecDecodeSelfFromMap(l int, d *" + x.cpfx + "Decoder) {")
-		x.genRequiredMethodVars(false)
-		x.decStructMap(genTopLevelVarName, "l", rt2id(t0), t0, genStructMapStyleConsolidated)
-		x.line("}")
-		x.line("")
-	} else {
-		x.out(fnSigPfx)
-		x.line(") codecDecodeSelfFromMapLenPrefix(l int, d *" + x.cpfx + "Decoder) {")
-		x.genRequiredMethodVars(false)
-		x.decStructMap(genTopLevelVarName, "l", rt2id(t0), t0, genStructMapStyleLenPrefix)
-		x.line("}")
-		x.line("")
-
-		x.out(fnSigPfx)
-		x.line(") codecDecodeSelfFromMapCheckBreak(l int, d *" + x.cpfx + "Decoder) {")
-		x.genRequiredMethodVars(false)
-		x.decStructMap(genTopLevelVarName, "l", rt2id(t0), t0, genStructMapStyleCheckBreak)
-		x.line("}")
-		x.line("")
-	}
+	x.out(fnSigPfx)
+	x.line(") codecDecodeSelfFromMap(l int, d *" + x.cpfx + "Decoder) {")
+	x.genRequiredMethodVars(false)
+	x.decStructMap(genTopLevelVarName, "l", rt2id(t0), t0)
+	x.line("}")
+	x.line("")
 
 	// write containerArray
 	x.out(fnSigPfx)
@@ -942,9 +919,14 @@ func (x *genRunner) enc(varname string, t reflect.Type, isptr bool) {
 		if ti2.flagSelfer {
 			x.linef("%s %s.CodecEncodeSelf(e)", hasIf.c(true), varname)
 			return
-		} else if ti2.flagSelferPtr {
-			x.linef("%s %ssf%s := &%s", hasIf.c(true), genTempVarPfx, mi, varname)
-			x.linef("%ssf%s.CodecEncodeSelf(e)", genTempVarPfx, mi)
+		}
+		if ti2.flagSelferPtr {
+			if isptr {
+				x.linef("%s %s.CodecEncodeSelf(e)", hasIf.c(true), varname)
+			} else {
+				x.linef("%s %ssf%s := &%s", hasIf.c(true), genTempVarPfx, mi, varname)
+				x.linef("%ssf%s.CodecEncodeSelf(e)", genTempVarPfx, mi)
+			}
 			return
 		}
 
@@ -1134,7 +1116,7 @@ func (x *genRunner) doEncOmitEmptyLine(t2 reflect.StructField, varname string, b
 func (x *genRunner) encOmitEmptyLine(t2 reflect.StructField, varname string, buf *genBuf) {
 	// xdebugf("calling encOmitEmptyLine on: %v", t2.Type)
 	// smartly check omitEmpty on a struct type, as it may contain uncomparable map/slice/etc.
-	// also, for maps/slices/arrays, check if len ! 0 (not if == zero value)
+	// also, for maps/slices, check if len ! 0 (not if == zero value)
 	varname2 := varname + "." + t2.Name
 	switch t2.Type.Kind() {
 	case reflect.Struct:
@@ -1169,9 +1151,9 @@ func (x *genRunner) encOmitEmptyLine(t2 reflect.StructField, varname string, buf
 			buf.s(varname2).s(" != ").s(x.genZeroValueR(t2.Type))
 			break
 		}
-		// fmt.Printf("???? !!!! We shouldn't get to this point !!!! ???? - for type: %v\n", t2.Type)
 		// buf.s("(")
 		buf.s(x.sayFalse()) // buf.s("false")
+		var wrote bool
 		for i, n := 0, t2.Type.NumField(); i < n; i++ {
 			f := t2.Type.Field(i)
 			if f.PkgPath != "" { // unexported
@@ -1179,12 +1161,27 @@ func (x *genRunner) encOmitEmptyLine(t2 reflect.StructField, varname string, buf
 			}
 			buf.s(" || ")
 			x.encOmitEmptyLine(f, varname2, buf)
+			wrote = true
+		}
+		if !wrote {
+			buf.s(" || ").s(x.sayTrue())
 		}
 		//buf.s(")")
 	case reflect.Bool:
 		buf.s("bool(").s(varname2).s(")")
-	case reflect.Map, reflect.Slice, reflect.Array, reflect.Chan:
+	case reflect.Map, reflect.Slice, reflect.Chan:
 		buf.s("len(").s(varname2).s(") != 0")
+	case reflect.Array:
+		tlen := t2.Type.Len()
+		if tlen == 0 {
+			buf.s(x.sayFalse())
+		} else if t2.Type.Comparable() {
+			buf.s(varname2).s(" != ").s(x.genZeroValueR(t2.Type))
+		} else { // then we cannot even compare the individual values
+			// TODO use playground to check if you can compare to a
+			// zero value of an array, even if array not comparable.
+			buf.s(x.sayTrue())
+		}
 	default:
 		buf.s(varname2).s(" != ").s(x.genZeroValueR(t2.Type))
 	}
@@ -1214,7 +1211,10 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 	}
 
 	genFQNs := make([]genFQN, len(tisfi))
+	si2Pos := make(map[*structFieldInfo]int) // stores position in sorted structFieldInfos
+
 	for j, si := range tisfi {
+		si2Pos[si] = j
 		q := &genFQNs[j]
 		q.i = x.varsfx()
 		q.nilVar = genTempVarPfx + "n" + q.i
@@ -1329,11 +1329,13 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 		}
 
 		fn := func(tisfi []*structFieldInfo) {
-			for j, si := range tisfi {
-				q := &genFQNs[j]
+			// tisfi here may be source or sorted, so use the src position stored elsewhere
+			for _, si := range tisfi {
+				pos := si2Pos[si]
+				q := &genFQNs[pos]
 				doOmitEmptyCheck := (omitEmptySometimes && si.path.omitEmpty) || omitEmptyAlways
 				if doOmitEmptyCheck {
-					x.linef("if %s[%v] {", numfieldsvar, j)
+					x.linef("if %s[%v] {", numfieldsvar, pos)
 				}
 				x.linef("z.EncWriteMapElemKey()")
 
@@ -1348,7 +1350,7 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 				default: // string
 					if x.jsonOnlyWhen == nil {
 						if si.path.encNameAsciiAlphaNum {
-							x.linef(`if z.IsJSONHandle() { z.WriteStr("\"%s\"") } else { `, si.encName)
+							x.linef(`if z.IsJSONHandle() { z.EncWr().WriteStr("\"%s\"") } else { `, si.encName)
 						}
 						x.linef("r.EncodeString(`%s`)", si.encName)
 						if si.path.encNameAsciiAlphaNum {
@@ -1356,7 +1358,7 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 						}
 					} else if *(x.jsonOnlyWhen) {
 						if si.path.encNameAsciiAlphaNum {
-							x.linef(`z.WriteStr("\"%s\"")`, si.encName)
+							x.linef(`z.EncWr().WriteStr("\"%s\"")`, si.encName)
 						} else {
 							x.linef("r.EncodeString(`%s`)", si.encName)
 						}
@@ -1381,7 +1383,7 @@ func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
 		if genStructCanonical {
 			x.linef("if z.EncBasicHandle().Canonical {") // if Canonical block
 			fn(ti.sfi.sorted())
-			x.linef("} else {") // else !cononical block
+			x.linef("} else {") // else !Canonical block
 			fn(ti.sfi.source())
 			x.linef("}") // end if Canonical block
 		} else {
@@ -1445,9 +1447,109 @@ func (x *genRunner) encListFallback(varname string, t reflect.Type) {
 
 func (x *genRunner) encMapFallback(varname string, t reflect.Type) {
 	x.linef("if %s == nil { r.EncodeNil()", varname)
-	x.linef("} else if z.EncBasicHandle().Canonical { z.EncEncodeMapNonNil(%s)", varname)
+	x.line("} else if z.EncBasicHandle().Canonical {")
+
+	// Solve for easy case accomodated by sort package without reflection i.e.
+	// map keys of type: float, int, string (pre-defined/builtin types).
+	//
+	// To do this, we will get the keys into an array of uint64|float64|string,
+	// sort them, then write them out, and grab the value and encode it appropriately
+	tkey := t.Key()
+	tkind := tkey.Kind()
+	// tkeybase := tkey
+	// for tkeybase.Kind() == reflect.Ptr {
+	// 	tkeybase = tkeybase.Elem()
+	// }
+	// tikey := x.ti.get(rt2id(tkeybase), tkeybase)
+
+	// pre-defined types have a name and no pkgpath and appropriate kind
+	predeclared := tkey.PkgPath() == "" && tkey.Name() != ""
+
+	canonSortKind := reflect.Invalid
+	switch tkind {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		canonSortKind = reflect.Int64
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		canonSortKind = reflect.Uint64
+	case reflect.Float32, reflect.Float64:
+		canonSortKind = reflect.Float64
+	case reflect.String:
+		canonSortKind = reflect.String
+	}
+
+	var i string = x.varsfx()
+
+	fnCanonNumBoolStrKind := func() {
+		if !predeclared {
+			x.linef("var %svv%s %s", genTempVarPfx, i, x.genTypeName(tkey))
+			x.linef("%sencfn%s := z.EncFnGivenAddr(&%svv%s)", genTempVarPfx, i, genTempVarPfx, i)
+		}
+		// get the type, get the slice type its mapped to, and complete the code
+		x.linef("%ss%s := make([]%s, 0, len(%s))", genTempVarPfx, i, canonSortKind, varname)
+		x.linef("for k, _ := range %s {", varname)
+		x.linef("  %ss%s = append(%ss%s, %s(k))", genTempVarPfx, i, genTempVarPfx, i, canonSortKind)
+		x.linef("}")
+		x.linef("sort.Sort(%s%sSlice(%ss%s))", x.hn, canonSortKind, genTempVarPfx, i)
+		x.linef("z.EncWriteMapStart(len(%s))", varname)
+		x.linef("for _, %sv%s := range %ss%s {", genTempVarPfx, i, genTempVarPfx, i)
+		x.linef("  z.EncWriteMapElemKey()")
+		if predeclared {
+			switch tkind {
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32:
+				x.linef("r.EncodeInt(int64(%sv%s))", genTempVarPfx, i)
+			case reflect.Int64:
+				x.linef("r.EncodeInt(%sv%s)", genTempVarPfx, i)
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uintptr:
+				x.linef("r.EncodeUint(%sv%s)", genTempVarPfx, i)
+			case reflect.Uint64:
+				x.linef("r.EncodeUint(uint64(%sv%s))", genTempVarPfx, i)
+			case reflect.Float32:
+				x.linef("r.EncodeFloat32(float32(%sv%s))", genTempVarPfx, i)
+			case reflect.Float64:
+				x.linef("r.EncodeFloat64(%sv%s)", genTempVarPfx, i)
+			case reflect.String:
+				x.linef("r.EncodeString(%sv%s)", genTempVarPfx, i)
+			}
+		} else {
+			x.linef("%svv%s = %s(%sv%s)", genTempVarPfx, i, x.genTypeName(tkey), genTempVarPfx, i)
+			x.linef("z.EncEncodeNumBoolStrKindGivenAddr(&%svv%s, %sencfn%s)", genTempVarPfx, i, genTempVarPfx, i)
+		}
+		x.linef("  z.EncWriteMapElemValue()")
+		vname := genTempVarPfx + "e" + i
+		if predeclared {
+			x.linef("%s := %s[%s(%sv%s)]", vname, varname, x.genTypeName(tkey), genTempVarPfx, i)
+		} else {
+			x.linef("%s := %s[%svv%s]", vname, varname, genTempVarPfx, i)
+		}
+		x.encVar(vname, t.Elem())
+		x.linef("}")
+
+		x.line("z.EncWriteMapEnd()")
+
+	}
+
+	// if canonSortKind != reflect.Invalid && !tikey.flagMarshalInterface {
+	// 	if predeclared {
+	// 		fnCanonNumBoolStrKind()
+	// 	} else {
+	// 		// handle if an extension
+	// 		x.linef("if z.Extension(%s(%s)) != nil { z.EncEncodeMapNonNil(%s) } else {",
+	// 			x.genTypeName(tkey), x.genZeroValueR(tkey), varname)
+	// 		fnCanonNumBoolStrKind()
+	// 		x.line("}")
+	// 	}
+	// } else {
+	// 	x.linef("z.EncEncodeMapNonNil(%s)", varname)
+	// }
+
+	if canonSortKind != reflect.Invalid {
+		fnCanonNumBoolStrKind()
+	} else {
+		x.linef("z.EncEncodeMapNonNil(%s)", varname)
+	}
+
 	x.line("} else {")
-	i := x.varsfx()
+
 	x.linef("z.EncWriteMapStart(len(%s))", varname)
 	x.linef("for %sk%s, %sv%s := range %s {", genTempVarPfx, i, genTempVarPfx, i, varname)
 	x.linef("z.EncWriteMapElemKey()")
@@ -1456,6 +1558,7 @@ func (x *genRunner) encMapFallback(varname string, t reflect.Type) {
 	x.encVar(genTempVarPfx+"v"+i, t.Elem())
 	x.line("}")
 	x.line("z.EncWriteMapEnd()")
+
 	x.line("}")
 }
 
@@ -1947,23 +2050,16 @@ func (x *genRunner) decStructMapSwitch(kName string, varname string, rtid uintpt
 	x.linef("} // end switch %s", kName)
 }
 
-func (x *genRunner) decStructMap(varname, lenvarname string, rtid uintptr, t reflect.Type, style genStructMapStyle) {
+func (x *genRunner) decStructMap(varname, lenvarname string, rtid uintptr, t reflect.Type) {
 	tpfx := genTempVarPfx
 	ti := x.ti.get(rtid, t)
 	i := x.varsfx()
 	kName := tpfx + "s" + i
 
-	switch style {
-	case genStructMapStyleLenPrefix:
-		x.linef("for %sj%s := 0; %sj%s < %s; %sj%s++ {", tpfx, i, tpfx, i, lenvarname, tpfx, i)
-	case genStructMapStyleCheckBreak:
-		x.linef("for %sj%s := 0; !z.DecCheckBreak(); %sj%s++ {", tpfx, i, tpfx, i)
-	default: // 0, otherwise.
-		x.linef("var %shl%s bool = %s >= 0", tpfx, i, lenvarname) // has length
-		x.linef("for %sj%s := 0; ; %sj%s++ {", tpfx, i, tpfx, i)
-		x.linef("if %shl%s { if %sj%s >= %s { break }", tpfx, i, tpfx, i, lenvarname)
-		x.line("} else { if z.DecCheckBreak() { break }; }")
-	}
+	x.linef("var %shl%s bool = %s >= 0", tpfx, i, lenvarname) // has length
+	x.linef("for %sj%s := 0; z.DecContainerNext(%sj%s, %s, %shl%s); %sj%s++ {",
+		tpfx, i, tpfx, i, lenvarname, tpfx, i, tpfx, i)
+
 	x.line("z.DecReadMapElemKey()")
 
 	// emulate decstructfieldkey
@@ -1992,24 +2088,11 @@ func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid
 	x.linef("var %sj%s int", tpfx, i)
 	x.linef("var %sb%s bool", tpfx, i)                        // break
 	x.linef("var %shl%s bool = %s >= 0", tpfx, i, lenvarname) // has length
-	if !genDecStructArrayInlineLoopCheck {
-		x.linef("var %sfn%s = func() bool { ", tpfx, i)
-		x.linef("%sj%s++; if %shl%s { %sb%s = %sj%s > %s } else { %sb%s = z.DecCheckBreak() };",
-			tpfx, i, tpfx, i, tpfx, i,
-			tpfx, i, lenvarname, tpfx, i)
-		x.linef("if %sb%s { z.DecReadArrayEnd(); return true }; return false", tpfx, i)
-		x.linef("} // end func %sfn%s", tpfx, i)
-	}
 	var newbuf, nilbuf genBuf
 	for _, si := range tisfi {
-		if genDecStructArrayInlineLoopCheck {
-			x.linef("%sj%s++; if %shl%s { %sb%s = %sj%s > %s } else { %sb%s = z.DecCheckBreak() }",
-				tpfx, i, tpfx, i, tpfx, i,
-				tpfx, i, lenvarname, tpfx, i)
-			x.linef("if %sb%s { z.DecReadArrayEnd(); %s }", tpfx, i, breakString)
-		} else {
-			x.linef("if %sfn%s() { %s }", tpfx, i, breakString)
-		}
+		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()")
 		newbuf.reset()
 		nilbuf.reset()
@@ -2023,11 +2106,8 @@ func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid
 		}
 	}
 	// read remaining values and throw away.
-	x.line("for {")
-	x.linef("%sj%s++; if %shl%s { %sb%s = %sj%s > %s } else { %sb%s = z.DecCheckBreak() }",
-		tpfx, i, tpfx, i, tpfx, i,
-		tpfx, i, lenvarname, tpfx, i)
-	x.linef("if %sb%s { break }", tpfx, i)
+	x.linef("for %sj%s++; z.DecContainerNext(%sj%s, %s, %shl%s); %sj%s++ {",
+		tpfx, i, tpfx, i, lenvarname, tpfx, i, tpfx, i)
 	x.line("z.DecReadArrayElem()")
 	x.linef(`z.DecStructFieldNotFound(%sj%s - 1, "")`, tpfx, i)
 	x.line("}")
@@ -2042,15 +2122,10 @@ func (x *genRunner) decStruct(varname string, rtid uintptr, t reflect.Type) {
 	x.linef("} else if %sct%s == codecSelferValueTypeMap%s {", genTempVarPfx, i, x.xs)
 	x.line(genTempVarPfx + "l" + i + " := z.DecReadMapStart()")
 	x.linef("if %sl%s == 0 {", genTempVarPfx, i)
-	if genUseOneFunctionForDecStructMap {
-		x.line("} else { ")
-		x.linef("%s.codecDecodeSelfFromMap(%sl%s, d)", varname, genTempVarPfx, i)
-	} else {
-		x.line("} else if " + genTempVarPfx + "l" + i + " > 0 { ")
-		x.line(varname + ".codecDecodeSelfFromMapLenPrefix(" + genTempVarPfx + "l" + i + ", d)")
-		x.line("} else {")
-		x.line(varname + ".codecDecodeSelfFromMapCheckBreak(" + genTempVarPfx + "l" + i + ", d)")
-	}
+
+	x.line("} else { ")
+	x.linef("%s.codecDecodeSelfFromMap(%sl%s, d)", varname, genTempVarPfx, i)
+
 	x.line("}")
 	x.line("z.DecReadMapEnd()")
 
@@ -2684,7 +2759,7 @@ func genInternalSortableTypes() []string {
 // that are used for reflection-based canonical's encoding of maps.
 //
 // For now, we only support the highest sizes for
-// int64, uint64, float64, bool, string, bytes.
+// int64, uint64, float64, string, bytes.
 func genInternalSortablePlusTypes() []string {
 	return []string{
 		"string",
@@ -2692,7 +2767,7 @@ func genInternalSortablePlusTypes() []string {
 		"uint64",
 		// "uintptr",
 		"int64",
-		"bool",
+		// "bool",
 		"time",
 		"bytes",
 	}
diff --git a/vendor/github.com/ugorji/go/codec/goversion_growslice_unsafe_gte_go120.go b/vendor/github.com/ugorji/go/codec/goversion_growslice_unsafe_gte_go120.go
new file mode 100644
index 000000000..d5fed78e2
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/goversion_growslice_unsafe_gte_go120.go
@@ -0,0 +1,28 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build go1.20 && !safe && !codec.safe && !appengine
+// +build go1.20,!safe,!codec.safe,!appengine
+
+package codec
+
+import (
+	_ "reflect" // needed for go linkname(s)
+	"unsafe"
+)
+
+func growslice(typ unsafe.Pointer, old unsafeSlice, num int) (s unsafeSlice) {
+	// culled from GOROOT/runtime/slice.go
+	num -= old.Cap - old.Len
+	s = rtgrowslice(old.Data, old.Cap+num, old.Cap, num, typ)
+	s.Len = old.Len
+	return
+}
+
+//go:linkname rtgrowslice runtime.growslice
+//go:noescape
+func rtgrowslice(oldPtr unsafe.Pointer, newLen, oldCap, num int, typ unsafe.Pointer) unsafeSlice
+
+// //go:linkname growslice reflect.growslice
+// //go:noescape
+// func growslice(typ unsafe.Pointer, old unsafeSlice, cap int) unsafeSlice
diff --git a/vendor/github.com/ugorji/go/codec/goversion_growslice_unsafe_lt_go120.go b/vendor/github.com/ugorji/go/codec/goversion_growslice_unsafe_lt_go120.go
new file mode 100644
index 000000000..550c5d9e0
--- /dev/null
+++ b/vendor/github.com/ugorji/go/codec/goversion_growslice_unsafe_lt_go120.go
@@ -0,0 +1,16 @@
+// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
+// Use of this source code is governed by a MIT license found in the LICENSE file.
+
+//go:build go1.9 && !go1.20 && !safe && !codec.safe && !appengine
+// +build go1.9,!go1.20,!safe,!codec.safe,!appengine
+
+package codec
+
+import (
+	_ "runtime" // needed for go linkname(s)
+	"unsafe"
+)
+
+//go:linkname growslice runtime.growslice
+//go:noescape
+func growslice(typ unsafe.Pointer, old unsafeSlice, num int) unsafeSlice
diff --git a/vendor/github.com/ugorji/go/codec/helper.go b/vendor/github.com/ugorji/go/codec/helper.go
index dc485a5ef..19df27b60 100644
--- a/vendor/github.com/ugorji/go/codec/helper.go
+++ b/vendor/github.com/ugorji/go/codec/helper.go
@@ -215,7 +215,8 @@ import (
 // Note: Negative tests that check for errors will fail, so only use this
 // when debugging, and run only one test at a time preferably.
 //
-// Note: RPC tests espeially fail, as they depend on getting the error from an Encode/Decode call.
+// Note: RPC tests depend on getting the error from an Encode/Decode call.
+// Consequently, they will always fail if debugging = true.
 const debugging = false
 
 const (
@@ -617,6 +618,10 @@ func (e *codecError) Cause() error {
 	return e.err
 }
 
+func (e *codecError) Unwrap() error {
+	return e.err
+}
+
 func (e *codecError) Error() string {
 	if e.encode {
 		return fmt.Sprintf("%s encode error: %v", e.name, e.err)
@@ -715,9 +720,10 @@ var SelfExt = &extFailWrapper{}
 // By definition, it is not allowed for a Selfer to directly call Encode or Decode on itself.
 // If that is done, Encode/Decode will rightfully fail with a Stack Overflow style error.
 // For example, the snippet below will cause such an error.
-//     type testSelferRecur struct{}
-//     func (s *testSelferRecur) CodecEncodeSelf(e *Encoder) { e.MustEncode(s) }
-//     func (s *testSelferRecur) CodecDecodeSelf(d *Decoder) { d.MustDecode(s) }
+//
+//	type testSelferRecur struct{}
+//	func (s *testSelferRecur) CodecEncodeSelf(e *Encoder) { e.MustEncode(s) }
+//	func (s *testSelferRecur) CodecDecodeSelf(d *Decoder) { d.MustDecode(s) }
 //
 // Note: *the first set of bytes of any value MUST NOT represent nil in the format*.
 // This is because, during each decode, we first check the the next set of bytes
@@ -761,13 +767,14 @@ type MissingFielder interface {
 // This affords storing a map in a specific sequence in the stream.
 //
 // Example usage:
-//    type T1 []string         // or []int or []Point or any other "slice" type
-//    func (_ T1) MapBySlice{} // T1 now implements MapBySlice, and will be encoded as a map
-//    type T2 struct { KeyValues T1 }
 //
-//    var kvs = []string{"one", "1", "two", "2", "three", "3"}
-//    var v2 = T2{ KeyValues: T1(kvs) }
-//    // v2 will be encoded like the map: {"KeyValues": {"one": "1", "two": "2", "three": "3"} }
+//	type T1 []string         // or []int or []Point or any other "slice" type
+//	func (_ T1) MapBySlice{} // T1 now implements MapBySlice, and will be encoded as a map
+//	type T2 struct { KeyValues T1 }
+//
+//	var kvs = []string{"one", "1", "two", "2", "three", "3"}
+//	var v2 = T2{ KeyValues: T1(kvs) }
+//	// v2 will be encoded like the map: {"KeyValues": {"one": "1", "two": "2", "three": "3"} }
 //
 // The support of MapBySlice affords the following:
 //   - A slice or array type which implements MapBySlice will be encoded as a map
@@ -969,6 +976,7 @@ func (x *basicHandleRuntimeState) setExt(rt reflect.Type, tag uint64, ext Ext) (
 
 // initHandle should be called only from codec.initHandle global function.
 // make it uninlineable, as it is called at most once for each handle.
+//
 //go:noinline
 func (x *BasicHandle) initHandle(hh Handle) {
 	handleInitMu.Lock()
@@ -1554,6 +1562,10 @@ func (z bigenHelper) writeUint16(w *encWr, v uint16) {
 }
 
 func (z bigenHelper) writeUint32(w *encWr, v uint32) {
+	// w.writeb((z.PutUint32(v))[:])
+	// x := z.PutUint32(v)
+	// w.writeb(x[:])
+	// w.writen4(x[0], x[1], x[2], x[3])
 	w.writen4(z.PutUint32(v))
 }
 
@@ -1731,7 +1743,7 @@ func (path *structFieldInfoPathNode) fieldAlloc(v reflect.Value) (rv2 reflect.Va
 		v = parent.fieldAlloc(v)
 		for j, k := uint8(0), parent.numderef; j < k; j++ {
 			if rvIsNil(v) {
-				rvSetDirect(v, reflect.New(rvType(v).Elem()))
+				rvSetDirect(v, reflect.New(v.Type().Elem()))
 			}
 			v = v.Elem()
 		}
@@ -1863,10 +1875,10 @@ type typeInfo struct {
 	keykind, elemkind uint8
 
 	flagHasPkgPath   bool // Type.PackagePath != ""
-	flagCustom       bool // does this have custom implementation?
 	flagComparable   bool
 	flagCanTransient bool
 
+	flagMarshalInterface  bool // does this have custom (un)marshal implementation?
 	flagSelferViaCodecgen bool
 
 	// custom implementation flags
@@ -2128,7 +2140,6 @@ func (x *TypeInfos) load(rt reflect.Type) (pti *typeInfo) {
 	bset := func(when bool, b *bool) {
 		if when {
 			*b = true
-			ti.flagCustom = true
 		}
 	}
 
@@ -2168,6 +2179,15 @@ func (x *TypeInfos) load(rt reflect.Type) (pti *typeInfo) {
 	b1, b2 = implIntf(rt, isSelferViaCodecgenerTyp)
 	ti.flagSelferViaCodecgen = b1 || b2
 
+	ti.flagMarshalInterface = ti.flagSelfer || ti.flagSelferPtr ||
+		ti.flagSelferViaCodecgen ||
+		ti.flagBinaryMarshaler || ti.flagBinaryMarshalerPtr ||
+		ti.flagBinaryUnmarshaler || ti.flagBinaryUnmarshalerPtr ||
+		ti.flagTextMarshaler || ti.flagTextMarshalerPtr ||
+		ti.flagTextUnmarshaler || ti.flagTextUnmarshalerPtr ||
+		ti.flagJsonMarshaler || ti.flagJsonMarshalerPtr ||
+		ti.flagJsonUnmarshaler || ti.flagJsonUnmarshalerPtr
+
 	b1 = rt.Comparable()
 	// bset(b1, &ti.flagComparable)
 	ti.flagComparable = b1
@@ -2443,6 +2463,14 @@ func implIntf(rt, iTyp reflect.Type) (base bool, indir bool) {
 	return
 }
 
+func bool2int(b bool) (v uint8) {
+	// MARKER: optimized to be a single instruction
+	if b {
+		v = 1
+	}
+	return
+}
+
 func isSliceBoundsError(s string) bool {
 	return strings.Contains(s, "index out of range") ||
 		strings.Contains(s, "slice bounds out of range")
@@ -2581,17 +2609,22 @@ func (checkOverflow) Uint2Int(v uint64, neg bool) (overflow bool) {
 
 func (checkOverflow) SignedInt(v uint64) (overflow bool) {
 	//e.g. -127 to 128 for int8
-	pos := (v >> 63) == 0
-	ui2 := v & 0x7fffffffffffffff
-	if pos {
-		if ui2 > math.MaxInt64 {
-			overflow = true
-		}
-	} else {
-		if ui2 > math.MaxInt64-1 {
-			overflow = true
-		}
-	}
+	// pos := (v >> 63) == 0
+	// ui2 := v & 0x7fffffffffffffff
+	// if pos {
+	// 	if ui2 > math.MaxInt64 {
+	// 		overflow = true
+	// 	}
+	// } else {
+	// 	if ui2 > math.MaxInt64-1 {
+	// 		overflow = true
+	// 	}
+	// }
+
+	// a signed integer has overflow if the sign (first) bit is 1 (negative)
+	// and the numbers after the sign bit is > maxint64 - 1
+	overflow = (v>>63) != 0 && v&0x7fffffffffffffff > math.MaxInt64-1
+
 	return
 }
 
@@ -2774,22 +2807,23 @@ func freelistCapacity(length int) (capacity int) {
 // without bounds checking is sufficient.
 //
 // Typical usage model:
-//   peek may go together with put, iff pop=true. peek gets largest byte slice temporarily.
-//   check is used to switch a []byte if necessary
-//   get/put go together
+//
+//	peek may go together with put, iff pop=true. peek gets largest byte slice temporarily.
+//	check is used to switch a []byte if necessary
+//	get/put go together
 //
 // Given that folks may get a []byte, and then append to it a lot which may re-allocate
 // a new []byte, we should try to return both (one received from blist and new one allocated).
 //
 // Typical usage model for get/put, when we don't know whether we may need more than requested
-//   v0 := blist.get()
-//   v1 := v0
-//   ... use v1 ...
-//   blist.put(v1)
-//   if byteSliceAddr(v0) != byteSliceAddr(v1) {
-//     blist.put(v0)
-//   }
 //
+//	v0 := blist.get()
+//	v1 := v0
+//	... use v1 ...
+//	blist.put(v1)
+//	if byteSliceAddr(v0) != byteSliceAddr(v1) {
+//	  blist.put(v0)
+//	}
 type bytesFreelist [][]byte
 
 // peek returns a slice of possibly non-zero'ed bytes, with len=0,
diff --git a/vendor/github.com/ugorji/go/codec/helper_not_unsafe.go b/vendor/github.com/ugorji/go/codec/helper_not_unsafe.go
index 57a3fe26d..10034b86f 100644
--- a/vendor/github.com/ugorji/go/codec/helper_not_unsafe.go
+++ b/vendor/github.com/ugorji/go/codec/helper_not_unsafe.go
@@ -22,6 +22,22 @@ const safeMode = true
 const transientSizeMax = 0
 const transientValueHasStringSlice = true
 
+func byteAt(b []byte, index uint) byte {
+	return b[index]
+}
+
+func setByteAt(b []byte, index uint, val byte) {
+	b[index] = val
+}
+
+func byteSliceOf(b []byte, start, end uint) []byte {
+	return b[start:end]
+}
+
+// func byteSliceWithLen(b []byte, length uint) []byte {
+// 	return b[:length]
+// }
+
 func stringView(v []byte) string {
 	return string(v)
 }
@@ -34,8 +50,13 @@ func byteSliceSameData(v1 []byte, v2 []byte) bool {
 	return cap(v1) != 0 && cap(v2) != 0 && &(v1[:1][0]) == &(v2[:1][0])
 }
 
-func okBytes3(b []byte) (v [4]byte) {
-	copy(v[1:], b)
+func okBytes2(b []byte) (v [2]byte) {
+	copy(v[:], b)
+	return
+}
+
+func okBytes3(b []byte) (v [3]byte) {
+	copy(v[:], b)
 	return
 }
 
@@ -114,8 +135,19 @@ func isEmptyValue(v reflect.Value, tinfos *TypeInfos, recursive bool) bool {
 	switch v.Kind() {
 	case reflect.Invalid:
 		return true
-	case reflect.Array, reflect.String:
+	case reflect.String:
 		return v.Len() == 0
+	case reflect.Array:
+		// zero := reflect.Zero(v.Type().Elem())
+		// can I just check if the whole value is equal to zeros? seems not.
+		// can I just check if the whole value is equal to its zero value? no.
+		// Well, then we check if each value is empty without recursive.
+		for i, vlen := 0, v.Len(); i < vlen; i++ {
+			if !isEmptyValue(v.Index(i), tinfos, false) {
+				return false
+			}
+		}
+		return true
 	case reflect.Map, reflect.Slice, reflect.Chan:
 		return v.IsNil() || v.Len() == 0
 	case reflect.Bool:
@@ -144,16 +176,16 @@ func isEmptyValue(v reflect.Value, tinfos *TypeInfos, recursive bool) bool {
 }
 
 // isEmptyStruct is only called from isEmptyValue, and checks if a struct is empty:
-//    - does it implement IsZero() bool
-//    - is it comparable, and can i compare directly using ==
-//    - if checkStruct, then walk through the encodable fields
-//      and check if they are empty or not.
+//   - does it implement IsZero() bool
+//   - is it comparable, and can i compare directly using ==
+//   - if checkStruct, then walk through the encodable fields
+//     and check if they are empty or not.
 func isEmptyStruct(v reflect.Value, tinfos *TypeInfos, recursive bool) bool {
 	// v is a struct kind - no need to check again.
 	// We only check isZero on a struct kind, to reduce the amount of times
 	// that we lookup the rtid and typeInfo for each type as we walk the tree.
 
-	vt := rvType(v)
+	vt := v.Type()
 	rtid := rt2id(vt)
 	if tinfos == nil {
 		tinfos = defTypeInfos
@@ -505,7 +537,7 @@ func rvGetArrayBytes(rv reflect.Value, scratch []byte) (bs []byte) {
 }
 
 func rvGetArray4Slice(rv reflect.Value) (v reflect.Value) {
-	v = rvZeroAddrK(reflectArrayOf(rvLenSlice(rv), rvType(rv).Elem()), reflect.Array)
+	v = rvZeroAddrK(reflectArrayOf(rvLenSlice(rv), rv.Type().Elem()), reflect.Array)
 	reflect.Copy(v, rv)
 	return
 }
@@ -615,6 +647,14 @@ func rvLenMap(rv reflect.Value) int {
 	return rv.Len()
 }
 
+// func copybytes(to, from []byte) int {
+// 	return copy(to, from)
+// }
+
+// func copybytestr(to []byte, from string) int {
+// 	return copy(to, from)
+// }
+
 // func rvLenArray(rv reflect.Value) int {	return rv.Len() }
 
 // ------------ map range and map indexing ----------
@@ -645,10 +685,6 @@ func (e *Encoder) jsondriver() *jsonEncDriver {
 
 // ---------- DECODER optimized ---------------
 
-func (d *Decoder) checkBreak() bool {
-	return d.d.CheckBreak()
-}
-
 func (d *Decoder) jsondriver() *jsonDecDriver {
 	return d.d.(*jsonDecDriver)
 }
diff --git a/vendor/github.com/ugorji/go/codec/helper_not_unsafe_not_gc.go b/vendor/github.com/ugorji/go/codec/helper_not_unsafe_not_gc.go
index e3fdc8854..502bc6086 100644
--- a/vendor/github.com/ugorji/go/codec/helper_not_unsafe_not_gc.go
+++ b/vendor/github.com/ugorji/go/codec/helper_not_unsafe_not_gc.go
@@ -6,7 +6,7 @@
 
 package codec
 
-import "reflect"
+// import "reflect"
 
 // This files contains safe versions of the code where the unsafe versions are not supported
 // in either gccgo or gollvm.
@@ -14,6 +14,8 @@ import "reflect"
 // - rvType:
 //   reflect.toType is not supported in gccgo, gollvm.
 
-func rvType(rv reflect.Value) reflect.Type {
-	return rv.Type()
-}
+// func rvType(rv reflect.Value) reflect.Type {
+// 	return rv.Type()
+// }
+
+var _ = 0
diff --git a/vendor/github.com/ugorji/go/codec/helper_unsafe.go b/vendor/github.com/ugorji/go/codec/helper_unsafe.go
index 34cda6e27..4e29b030b 100644
--- a/vendor/github.com/ugorji/go/codec/helper_unsafe.go
+++ b/vendor/github.com/ugorji/go/codec/helper_unsafe.go
@@ -51,11 +51,9 @@ import (
 //      - IsNil
 
 // MARKER: Some functions here will not be hit during code coverage runs due to optimizations, e.g.
-//   - rvCopySlice:      decode calls it if rvGrowSlice didn't set the new slice into the pointer to the orig slice.
-//                       however, helper_unsafe sets it, so there's no need to call rvCopySlice later
+//   - rvCopySlice:      called by decode if rvGrowSlice did not set new slice into pointer to orig slice.
+//                       however, helper_unsafe sets it, so no need to call rvCopySlice later
 //   - rvSlice:          same as above
-//   - rvGetArray4Bytes: only called within kArray for []byte, but that is now handled
-//                       within the fast-path directly
 
 const safeMode = false
 
@@ -177,6 +175,32 @@ func (encPerType) AddressableRO(v reflect.Value) reflect.Value {
 	return rvAddressableReadonly(v)
 }
 
+// byteAt returns the byte given an index which is guaranteed
+// to be within the bounds of the slice i.e. we defensively
+// already verified that the index is less than the length of the slice.
+func byteAt(b []byte, index uint) byte {
+	// return b[index]
+	return *(*byte)(unsafe.Pointer(uintptr((*unsafeSlice)(unsafe.Pointer(&b)).Data) + uintptr(index)))
+}
+
+func byteSliceOf(b []byte, start, end uint) []byte {
+	s := (*unsafeSlice)(unsafe.Pointer(&b))
+	s.Data = unsafe.Pointer(uintptr(s.Data) + uintptr(start))
+	s.Len = int(end - start)
+	s.Cap -= int(start)
+	return b
+}
+
+// func byteSliceWithLen(b []byte, length uint) []byte {
+// 	(*unsafeSlice)(unsafe.Pointer(&b)).Len = int(length)
+// 	return b
+// }
+
+func setByteAt(b []byte, index uint, val byte) {
+	// b[index] = val
+	*(*byte)(unsafe.Pointer(uintptr((*unsafeSlice)(unsafe.Pointer(&b)).Data) + uintptr(index))) = val
+}
+
 // stringView returns a view of the []byte as a string.
 // In unsafe mode, it doesn't incur allocation and copying caused by conversion.
 // In regular safe mode, it is an allocation and copy.
@@ -199,12 +223,15 @@ func byteSliceSameData(v1 []byte, v2 []byte) bool {
 }
 
 // MARKER: okBytesN functions will copy N bytes into the top slots of the return array.
-// These functions expect that the bounds are valid, and have been checked before this is called.
+// These functions expect that the bound check already occured and are are valid.
 // copy(...) does a number of checks which are unnecessary in this situation when in bounds.
 
-func okBytes3(b []byte) (v [4]byte) {
-	*(*[3]byte)(unsafe.Pointer(&v[1])) = *((*[3]byte)(((*unsafeSlice)(unsafe.Pointer(&b))).Data))
-	return
+func okBytes2(b []byte) [2]byte {
+	return *((*[2]byte)(((*unsafeSlice)(unsafe.Pointer(&b))).Data))
+}
+
+func okBytes3(b []byte) [3]byte {
+	return *((*[3]byte)(((*unsafeSlice)(unsafe.Pointer(&b))).Data))
 }
 
 func okBytes4(b []byte) [4]byte {
@@ -446,7 +473,7 @@ func isEmptyValueFallbackRecur(urv *unsafeReflectValue, v reflect.Value, tinfos
 		}
 		ti := tinfos.find(uintptr(urv.typ))
 		if ti == nil {
-			ti = tinfos.load(rvType(v))
+			ti = tinfos.load(v.Type())
 		}
 		return unsafeCmpZero(urv.ptr, int(ti.size))
 	case reflect.Interface, reflect.Ptr:
@@ -463,7 +490,11 @@ func isEmptyValueFallbackRecur(urv *unsafeReflectValue, v reflect.Value, tinfos
 	case reflect.Map:
 		return urv.ptr == nil || len_map(rvRefPtr(urv)) == 0
 	case reflect.Array:
-		return v.Len() == 0
+		return v.Len() == 0 ||
+			urv.ptr == nil ||
+			urv.typ == nil ||
+			rtsize2(urv.typ) == 0 ||
+			unsafeCmpZero(urv.ptr, int(rtsize2(urv.typ)))
 	}
 	return false
 }
@@ -858,7 +889,7 @@ func rvGetArray4Slice(rv reflect.Value) (v reflect.Value) {
 	//
 	// Consequently, we use rvLenSlice, not rvCapSlice.
 
-	t := reflectArrayOf(rvLenSlice(rv), rvType(rv).Elem())
+	t := reflectArrayOf(rvLenSlice(rv), rv.Type().Elem())
 	// v = rvZeroAddrK(t, reflect.Array)
 
 	uv := (*unsafeReflectValue)(unsafe.Pointer(&v))
@@ -996,6 +1027,32 @@ func rvLenMap(rv reflect.Value) int {
 	return len_map(rvRefPtr((*unsafeReflectValue)(unsafe.Pointer(&rv))))
 }
 
+// copy is an intrinsic, which may use asm if length is small,
+// or make a runtime call to runtime.memmove if length is large.
+// Performance suffers when you always call runtime.memmove function.
+//
+// Consequently, there's no value in a copybytes call - just call copy() directly
+
+// func copybytes(to, from []byte) (n int) {
+// 	n = (*unsafeSlice)(unsafe.Pointer(&from)).Len
+// 	memmove(
+// 		(*unsafeSlice)(unsafe.Pointer(&to)).Data,
+// 		(*unsafeSlice)(unsafe.Pointer(&from)).Data,
+// 		uintptr(n),
+// 	)
+// 	return
+// }
+
+// func copybytestr(to []byte, from string) (n int) {
+// 	n = (*unsafeSlice)(unsafe.Pointer(&from)).Len
+// 	memmove(
+// 		(*unsafeSlice)(unsafe.Pointer(&to)).Data,
+// 		(*unsafeSlice)(unsafe.Pointer(&from)).Data,
+// 		uintptr(n),
+// 	)
+// 	return
+// }
+
 // Note: it is hard to find len(...) of an array type,
 // as that is a field in the arrayType representing the array, and hard to introspect.
 //
@@ -1159,7 +1216,10 @@ func (d *Decoder) zerocopystate() bool {
 }
 
 func (d *Decoder) stringZC(v []byte) (s string) {
-	if d.zerocopystate() {
+	// MARKER: inline zerocopystate directly so genHelper forwarding function fits within inlining cost
+
+	// if d.zerocopystate() {
+	if d.decByteState == decByteStateZerocopy && d.h.ZeroCopy {
 		return stringView(v)
 	}
 	return d.string(v)
@@ -1178,22 +1238,6 @@ func (d *Decoder) mapKeyString(callFnRvk *bool, kstrbs, kstr2bs *[]byte) string
 
 // ---------- DECODER optimized ---------------
 
-func (d *Decoder) checkBreak() bool {
-	// MARKER: jsonDecDriver.CheckBreak() costs over 80, and this isn't inlined.
-	// Consequently, there's no benefit in incurring the cost of this
-	// wrapping function checkBreak.
-	//
-	// It is faster to just call the interface method directly.
-
-	// if d.js {
-	// 	return d.jsondriver().CheckBreak()
-	// }
-	// if d.cbor {
-	// 	return d.cbordriver().CheckBreak()
-	// }
-	return d.d.CheckBreak()
-}
-
 func (d *Decoder) jsondriver() *jsonDecDriver {
 	return (*jsonDecDriver)((*unsafeIntf)(unsafe.Pointer(&d.d)).ptr)
 }
@@ -1255,6 +1299,10 @@ func unsafeNew(typ unsafe.Pointer) unsafe.Pointer {
 // failing with "error: undefined reference" error.
 // however, runtime.{mallocgc, newarray} are supported, so use that instead.
 
+//go:linkname memmove runtime.memmove
+//go:noescape
+func memmove(to, from unsafe.Pointer, n uintptr)
+
 //go:linkname mallocgc runtime.mallocgc
 //go:noescape
 func mallocgc(size uintptr, typ unsafe.Pointer, needzero bool) unsafe.Pointer
diff --git a/vendor/github.com/ugorji/go/codec/helper_unsafe_compiler_gc.go b/vendor/github.com/ugorji/go/codec/helper_unsafe_compiler_gc.go
index 1cbce9d22..a5c7d59a0 100644
--- a/vendor/github.com/ugorji/go/codec/helper_unsafe_compiler_gc.go
+++ b/vendor/github.com/ugorji/go/codec/helper_unsafe_compiler_gc.go
@@ -13,9 +13,10 @@ import (
 )
 
 // keep in sync with
-//    $GOROOT/src/cmd/compile/internal/gc/reflect.go: MAXKEYSIZE, MAXELEMSIZE
-//    $GOROOT/src/runtime/map.go: maxKeySize, maxElemSize
-//    $GOROOT/src/reflect/type.go: maxKeySize, maxElemSize
+//
+//	$GOROOT/src/cmd/compile/internal/gc/reflect.go: MAXKEYSIZE, MAXELEMSIZE
+//	$GOROOT/src/runtime/map.go: maxKeySize, maxElemSize
+//	$GOROOT/src/reflect/type.go: maxKeySize, maxElemSize
 //
 // We use these to determine whether the type is stored indirectly in the map or not.
 const (
@@ -27,9 +28,10 @@ func unsafeGrowslice(typ unsafe.Pointer, old unsafeSlice, cap, incr int) (v unsa
 	return growslice(typ, old, cap+incr)
 }
 
-func rvType(rv reflect.Value) reflect.Type {
-	return rvPtrToType(((*unsafeReflectValue)(unsafe.Pointer(&rv))).typ) // rv.Type()
-}
+// func rvType(rv reflect.Value) reflect.Type {
+// 	return rvPtrToType(((*unsafeReflectValue)(unsafe.Pointer(&rv))).typ)
+// 	// return rv.Type()
+// }
 
 // mapStoresElemIndirect tells if the element type is stored indirectly in the map.
 //
@@ -130,13 +132,9 @@ func mapGet(m, k, v reflect.Value, keyFastKind mapKeyFastKind, valIsIndirect, va
 //go:linkname unsafeZeroArr runtime.zeroVal
 var unsafeZeroArr [1024]byte
 
-//go:linkname rvPtrToType reflect.toType
-//go:noescape
-func rvPtrToType(typ unsafe.Pointer) reflect.Type
-
-//go:linkname growslice runtime.growslice
-//go:noescape
-func growslice(typ unsafe.Pointer, old unsafeSlice, cap int) unsafeSlice
+// //go:linkname rvPtrToType reflect.toType
+// //go:noescape
+// func rvPtrToType(typ unsafe.Pointer) reflect.Type
 
 //go:linkname mapassign_fast32 runtime.mapassign_fast32
 //go:noescape
diff --git a/vendor/github.com/ugorji/go/codec/json.go b/vendor/github.com/ugorji/go/codec/json.go
index 8bd151f90..f7d2343e5 100644
--- a/vendor/github.com/ugorji/go/codec/json.go
+++ b/vendor/github.com/ugorji/go/codec/json.go
@@ -17,7 +17,6 @@ package codec
 // We cannot use strconv.(Q|Unq)uote because json quotes/unquotes differently.
 
 import (
-	"bytes"
 	"encoding/base64"
 	"math"
 	"reflect"
@@ -30,35 +29,34 @@ import (
 
 //--------------------------------
 
-var jsonLiterals = [...]byte{
-	'"', 't', 'r', 'u', 'e', '"',
-	'"', 'f', 'a', 'l', 's', 'e', '"',
-	'"', 'n', 'u', 'l', 'l', '"',
-}
+// jsonLits and jsonLitb are defined at the package level,
+// so they are guaranteed to be stored efficiently, making
+// for better append/string comparison/etc.
+//
+// (anecdotal evidence from some benchmarking on go 1.20 devel in 20220104)
+const jsonLits = `"true"false"null"`
+
+var jsonLitb = []byte(jsonLits)
 
 const (
-	jsonLitTrueQ  = 0
-	jsonLitTrue   = 1
-	jsonLitFalseQ = 6
-	jsonLitFalse  = 7
-	jsonLitNullQ  = 13
-	jsonLitNull   = 14
+	jsonLitT = 1
+	jsonLitF = 6
+	jsonLitN = 12
 )
 
-var (
-	// jsonLiteralTrueQ  = jsonLiterals[jsonLitTrueQ : jsonLitTrueQ+6]
-	// jsonLiteralFalseQ = jsonLiterals[jsonLitFalseQ : jsonLitFalseQ+7]
-	// jsonLiteralNullQ  = jsonLiterals[jsonLitNullQ : jsonLitNullQ+6]
-
-	jsonLiteralTrue  = jsonLiterals[jsonLitTrue : jsonLitTrue+4]
-	jsonLiteralFalse = jsonLiterals[jsonLitFalse : jsonLitFalse+5]
-	jsonLiteralNull  = jsonLiterals[jsonLitNull : jsonLitNull+4]
-
-	// these are used, after consuming the first char
-	jsonLiteral4True  = jsonLiterals[jsonLitTrue+1 : jsonLitTrue+4]
-	jsonLiteral4False = jsonLiterals[jsonLitFalse+1 : jsonLitFalse+5]
-	jsonLiteral4Null  = jsonLiterals[jsonLitNull+1 : jsonLitNull+4]
-)
+const jsonEncodeUintSmallsString = "" +
+	"00010203040506070809" +
+	"10111213141516171819" +
+	"20212223242526272829" +
+	"30313233343536373839" +
+	"40414243444546474849" +
+	"50515253545556575859" +
+	"60616263646566676869" +
+	"70717273747576777879" +
+	"80818283848586878889" +
+	"90919293949596979899"
+
+var jsonEncodeUintSmallsStringBytes = []byte(jsonEncodeUintSmallsString)
 
 const (
 	jsonU4Chk2 = '0'
@@ -82,6 +80,11 @@ const (
 	// Both technically valid JSON, but bomb on JSONP, so fix here unconditionally.
 	jsonEscapeMultiByteUnicodeSep = true
 
+	// jsonRecognizeBoolNullInQuotedStr is used during decoding into a blank interface{}
+	// to control whether we detect quoted values of bools and null where a map key is expected,
+	// and treat as nil, true or false.
+	jsonNakedBoolNullInQuotedStr = true
+
 	// jsonManualInlineDecRdInHotZones controls whether we manually inline some decReader calls.
 	//
 	// encode performance is at par with libraries that just iterate over bytes directly,
@@ -186,7 +189,7 @@ type jsonEncDriver struct {
 	//    -xxx.yyyyyyyyyyyye-zzz
 	// Consequently, 35 characters should be sufficient for encoding time, integers or floats.
 	// We use up all the remaining bytes to make this use full cache lines.
-	b [56]byte
+	b [48]byte
 
 	e Encoder
 }
@@ -240,11 +243,9 @@ func (e *jsonEncDriver) WriteMapElemValue() {
 
 func (e *jsonEncDriver) EncodeNil() {
 	// We always encode nil as just null (never in quotes)
-	// This allows us to easily decode if a nil in the json stream
-	// ie if initial token is n.
+	// so we can easily decode if a nil in the json stream ie if initial token is n.
 
-	// e.e.encWr.writeb(jsonLiteralNull)
-	e.e.encWr.writen4([4]byte{'n', 'u', 'l', 'l'})
+	e.e.encWr.writestr(jsonLits[jsonLitN : jsonLitN+4])
 }
 
 func (e *jsonEncDriver) EncodeTime(t time.Time) {
@@ -280,30 +281,32 @@ func (e *jsonEncDriver) EncodeRawExt(re *RawExt) {
 	}
 }
 
-func (e *jsonEncDriver) EncodeBool(b bool) {
-	// Use writen with an array instead of writeb with a slice
-	// i.e. in place of e.e.encWr.writeb(jsonLiteralTrueQ)
-	//      OR jsonLiteralTrue, jsonLiteralFalse, jsonLiteralFalseQ, etc
-
-	if e.ks && e.e.c == containerMapKey {
-		if b {
-			e.e.encWr.writen4([4]byte{'"', 't', 'r', 'u'})
-			e.e.encWr.writen2('e', '"')
-		} else {
-			e.e.encWr.writen4([4]byte{'"', 'f', 'a', 'l'})
-			e.e.encWr.writen2('s', 'e')
-			e.e.encWr.writen1('"')
-		}
-	} else {
-		if b {
-			e.e.encWr.writen4([4]byte{'t', 'r', 'u', 'e'})
-		} else {
-			e.e.encWr.writen4([4]byte{'f', 'a', 'l', 's'})
-			e.e.encWr.writen1('e')
-		}
-	}
+var jsonEncBoolStrs = [2][2]string{
+	{jsonLits[jsonLitF : jsonLitF+5], jsonLits[jsonLitT : jsonLitT+4]},
+	{jsonLits[jsonLitF-1 : jsonLitF+6], jsonLits[jsonLitT-1 : jsonLitT+5]},
 }
 
+func (e *jsonEncDriver) EncodeBool(b bool) {
+	e.e.encWr.writestr(
+		jsonEncBoolStrs[bool2int(e.ks && e.e.c == containerMapKey)%2][bool2int(b)%2])
+}
+
+// func (e *jsonEncDriver) EncodeBool(b bool) {
+// 	if e.ks && e.e.c == containerMapKey {
+// 		if b {
+// 			e.e.encWr.writestr(jsonLits[jsonLitT-1 : jsonLitT+5])
+// 		} else {
+// 			e.e.encWr.writestr(jsonLits[jsonLitF-1 : jsonLitF+6])
+// 		}
+// 	} else {
+// 		if b {
+// 			e.e.encWr.writestr(jsonLits[jsonLitT : jsonLitT+4])
+// 		} else {
+// 			e.e.encWr.writestr(jsonLits[jsonLitF : jsonLitF+5])
+// 		}
+// 	}
+// }
+
 func (e *jsonEncDriver) encodeFloat(f float64, bitsize, fmt byte, prec int8) {
 	var blen uint
 	if e.ks && e.e.c == containerMapKey {
@@ -339,25 +342,18 @@ func (e *jsonEncDriver) encodeUint(neg bool, quotes bool, u uint64) {
 	// copied mostly from std library: strconv
 	// this should only be called on 64bit OS.
 
-	const smallsString = "00010203040506070809" +
-		"10111213141516171819" +
-		"20212223242526272829" +
-		"30313233343536373839" +
-		"40414243444546474849" +
-		"50515253545556575859" +
-		"60616263646566676869" +
-		"70717273747576777879" +
-		"80818283848586878889" +
-		"90919293949596979899"
+	// const smallsString = jsonEncodeUintSmallsString
+	var ss = jsonEncodeUintSmallsStringBytes
 
 	// typically, 19 or 20 bytes sufficient for decimal encoding a uint64
 	// var a [24]byte
 	var a = e.b[0:24]
-	var i = uint8(len(a))
+	var i = uint(len(a))
 
 	if quotes {
 		i--
-		a[i] = '"'
+		setByteAt(a, i, '"')
+		// a[i] = '"'
 	}
 	// u guaranteed to fit into a uint (as we are not 32bit OS)
 	var is uint
@@ -366,25 +362,31 @@ func (e *jsonEncDriver) encodeUint(neg bool, quotes bool, u uint64) {
 		is = us % 100 * 2
 		us /= 100
 		i -= 2
-		a[i+1] = smallsString[is+1]
-		a[i+0] = smallsString[is+0]
+		setByteAt(a, i+1, byteAt(ss, is+1))
+		setByteAt(a, i, byteAt(ss, is))
+		// a[i+1] = smallsString[is+1]
+		// a[i+0] = smallsString[is+0]
 	}
 
 	// us < 100
 	is = us * 2
 	i--
-	a[i] = smallsString[is+1]
+	setByteAt(a, i, byteAt(ss, is+1))
+	// a[i] = smallsString[is+1]
 	if us >= 10 {
 		i--
-		a[i] = smallsString[is]
+		setByteAt(a, i, byteAt(ss, is))
+		// a[i] = smallsString[is]
 	}
 	if neg {
 		i--
-		a[i] = '-'
+		setByteAt(a, i, '-')
+		// a[i] = '-'
 	}
 	if quotes {
 		i--
-		a[i] = '"'
+		setByteAt(a, i, '"')
+		// a[i] = '"'
 	}
 	e.e.encWr.writeb(a[i:])
 }
@@ -413,7 +415,8 @@ func (e *jsonEncDriver) EncodeInt(v int64) {
 }
 
 func (e *jsonEncDriver) EncodeUint(v uint64) {
-	quotes := e.is == 'A' || e.is == 'L' && v > 1<<53 || (e.ks && e.e.c == containerMapKey)
+	quotes := e.is == 'A' || e.is == 'L' && v > 1<<53 ||
+		(e.ks && e.e.c == containerMapKey)
 
 	if cpu32Bit {
 		// use strconv directly, as optimized encodeUint only works on 64-bit alone
@@ -461,11 +464,12 @@ func (e *jsonEncDriver) EncodeStringBytesRaw(v []byte) {
 	// bs := e.e.blist.check(*e.buf, n)[:slen]
 	// *e.buf = bs
 
-	bs := e.e.blist.peek(slen, false)[:slen]
+	bs := e.e.blist.peek(slen, false)
+	bs = bs[:slen]
 
-	bs[0] = '"'
 	base64.StdEncoding.Encode(bs[1:], v)
 	bs[len(bs)-1] = '"'
+	bs[0] = '"'
 	e.e.encWr.writeb(bs)
 }
 
@@ -632,7 +636,7 @@ func (d *jsonDecDriver) decoder() *Decoder {
 func (d *jsonDecDriver) ReadMapStart() int {
 	d.advance()
 	if d.tok == 'n' {
-		d.readLit4Null(d.d.decRd.readn3())
+		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
 		return containerLenNil
 	}
 	if d.tok != '{' {
@@ -645,7 +649,7 @@ func (d *jsonDecDriver) ReadMapStart() int {
 func (d *jsonDecDriver) ReadArrayStart() int {
 	d.advance()
 	if d.tok == 'n' {
-		d.readLit4Null(d.d.decRd.readn3())
+		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
 		return containerLenNil
 	}
 	if d.tok != '[' {
@@ -655,6 +659,12 @@ func (d *jsonDecDriver) ReadArrayStart() int {
 	return containerLenUnknown
 }
 
+// MARKER:
+// We attempted making sure CheckBreak can be inlined, by moving the skipWhitespace
+// call to an explicit (noinline) function call.
+// However, this forces CheckBreak to always incur a function call if there was whitespace,
+// with no clear benefit.
+
 func (d *jsonDecDriver) CheckBreak() bool {
 	d.advance()
 	return d.tok == '}' || d.tok == ']'
@@ -713,40 +723,31 @@ func (d *jsonDecDriver) readDelimError(xc uint8) {
 	d.d.errorf("read json delimiter - expect char '%c' but got char '%c'", xc, d.tok)
 }
 
-// MARKER: readLit4XXX takes the readn(3|4) as a parameter so they can be inlined.
+// MARKER: checkLit takes the readn(3|4) result as a parameter so they can be inlined.
 // We pass the array directly to errorf, as passing slice pushes past inlining threshold,
 // and passing slice also might cause allocation of the bs array on the heap.
 
-func (d *jsonDecDriver) readLit4True(bs [4]byte) {
-	// bs := d.d.decRd.readn3()
+func (d *jsonDecDriver) checkLit3(got, expect [3]byte) {
 	d.tok = 0
-	if jsonValidateSymbols && bs != [...]byte{0, 'r', 'u', 'e'} { // !Equal jsonLiteral4True
-		// d.d.errorf("expecting %s: got %s", jsonLiteral4True, bs[:])
-		d.d.errorf("expecting true: got t%s", bs)
+	if jsonValidateSymbols && got != expect {
+		d.d.errorf("expecting %s: got %s", expect, got)
 	}
 }
 
-func (d *jsonDecDriver) readLit4False(bs [4]byte) {
-	// bs := d.d.decRd.readn4()
+func (d *jsonDecDriver) checkLit4(got, expect [4]byte) {
 	d.tok = 0
-	if jsonValidateSymbols && bs != [4]byte{'a', 'l', 's', 'e'} { // !Equal jsonLiteral4False
-		// d.d.errorf("expecting %s: got %s", jsonLiteral4False, bs)
-		d.d.errorf("expecting false: got f%s", bs)
+	if jsonValidateSymbols && got != expect {
+		d.d.errorf("expecting %s: got %s", expect, got)
 	}
 }
 
-func (d *jsonDecDriver) readLit4Null(bs [4]byte) {
-	// bs := d.d.decRd.readn3() // readx(3)
-	d.tok = 0
-	if jsonValidateSymbols && bs != [...]byte{0, 'u', 'l', 'l'} { // !Equal jsonLiteral4Null
-		// d.d.errorf("expecting %s: got %s", jsonLiteral4Null, bs[:])
-		d.d.errorf("expecting null: got n%s", bs)
-	}
+func (d *jsonDecDriver) skipWhitespace() {
+	d.tok = d.d.decRd.skipWhitespace()
 }
 
 func (d *jsonDecDriver) advance() {
 	if d.tok == 0 {
-		d.tok = d.d.decRd.skipWhitespace() // skip(&whitespaceCharBitset)
+		d.skipWhitespace()
 	}
 }
 
@@ -779,14 +780,14 @@ func (d *jsonDecDriver) nextValueBytesR(v0 []byte) (v []byte, cursor uint) {
 	default:
 		h.appendN(&v, dr.jsonReadNum()...)
 	case 'n':
-		d.readLit4Null(d.d.decRd.readn3())
-		h.appendN(&v, jsonLiteralNull...)
+		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
+		h.appendS(&v, jsonLits[jsonLitN:jsonLitN+4])
 	case 'f':
-		d.readLit4False(d.d.decRd.readn4())
-		h.appendN(&v, jsonLiteralFalse...)
+		d.checkLit4([4]byte{'a', 'l', 's', 'e'}, d.d.decRd.readn4())
+		h.appendS(&v, jsonLits[jsonLitF:jsonLitF+5])
 	case 't':
-		d.readLit4True(d.d.decRd.readn3())
-		h.appendN(&v, jsonLiteralTrue...)
+		d.checkLit3([3]byte{'r', 'u', 'e'}, d.d.decRd.readn3())
+		h.appendS(&v, jsonLits[jsonLitT:jsonLitT+4])
 	case '"':
 		h.append1(&v, '"')
 		consumeString()
@@ -820,7 +821,7 @@ func (d *jsonDecDriver) TryNil() bool {
 	// we shouldn't try to see if quoted "null" was here, right?
 	// only the plain string: `null` denotes a nil (ie not quotes)
 	if d.tok == 'n' {
-		d.readLit4Null(d.d.decRd.readn3())
+		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
 		return true
 	}
 	return false
@@ -828,21 +829,21 @@ func (d *jsonDecDriver) TryNil() bool {
 
 func (d *jsonDecDriver) DecodeBool() (v bool) {
 	d.advance()
-	if d.tok == 'n' {
-		d.readLit4Null(d.d.decRd.readn3())
-		return
-	}
+	// bool can be in quotes if and only if it's a map key
 	fquot := d.d.c == containerMapKey && d.tok == '"'
 	if fquot {
 		d.tok = d.d.decRd.readn1()
 	}
 	switch d.tok {
 	case 'f':
-		d.readLit4False(d.d.decRd.readn4())
+		d.checkLit4([4]byte{'a', 'l', 's', 'e'}, d.d.decRd.readn4())
 		// v = false
 	case 't':
-		d.readLit4True(d.d.decRd.readn3())
+		d.checkLit3([3]byte{'r', 'u', 'e'}, d.d.decRd.readn3())
 		v = true
+	case 'n':
+		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
+		// v = false
 	default:
 		d.d.errorf("decode bool: got first char %c", d.tok)
 		// v = false // "unreachable"
@@ -857,7 +858,7 @@ func (d *jsonDecDriver) DecodeTime() (t time.Time) {
 	// read string, and pass the string into json.unmarshal
 	d.advance()
 	if d.tok == 'n' {
-		d.readLit4Null(d.d.decRd.readn3())
+		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
 		return
 	}
 	d.ensureReadingString()
@@ -881,7 +882,7 @@ func (d *jsonDecDriver) ContainerType() (vt valueType) {
 	} else if d.tok == '[' {
 		return valueTypeArray
 	} else if d.tok == 'n' {
-		d.readLit4Null(d.d.decRd.readn3())
+		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
 		return valueTypeNil
 	} else if d.tok == '"' {
 		return valueTypeString
@@ -895,13 +896,11 @@ func (d *jsonDecDriver) decNumBytes() (bs []byte) {
 	if d.tok == '"' {
 		bs = dr.readUntil('"')
 	} else if d.tok == 'n' {
-		d.readLit4Null(d.d.decRd.readn3())
+		d.checkLit3([3]byte{'u', 'l', 'l'}, dr.readn3())
 	} else {
 		if jsonManualInlineDecRdInHotZones {
 			if dr.bytes {
 				bs = dr.rb.jsonReadNum()
-			} else if dr.bufio {
-				bs = dr.bi.jsonReadNum()
 			} else {
 				bs = dr.ri.jsonReadNum()
 			}
@@ -967,7 +966,7 @@ func (d *jsonDecDriver) DecodeFloat32() (f float32) {
 func (d *jsonDecDriver) DecodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
 	d.advance()
 	if d.tok == 'n' {
-		d.readLit4Null(d.d.decRd.readn3())
+		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
 		return
 	}
 	if ext == nil {
@@ -982,9 +981,7 @@ func (d *jsonDecDriver) DecodeExt(rv interface{}, basetype reflect.Type, xtag ui
 }
 
 func (d *jsonDecDriver) decBytesFromArray(bs []byte) []byte {
-	if bs == nil {
-		bs = []byte{}
-	} else {
+	if bs != nil {
 		bs = bs[:0]
 	}
 	d.tok = 0
@@ -1006,7 +1003,7 @@ func (d *jsonDecDriver) DecodeBytes(bs []byte) (bsOut []byte) {
 	d.d.decByteState = decByteStateNone
 	d.advance()
 	if d.tok == 'n' {
-		d.readLit4Null(d.d.decRd.readn3())
+		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
 		return nil
 	}
 	// if decoding into raw bytes, and the RawBytesExt is configured, use it to decode.
@@ -1037,7 +1034,8 @@ func (d *jsonDecDriver) DecodeBytes(bs []byte) (bsOut []byte) {
 		bsOut = bs[:slen]
 	} else if bs == nil {
 		d.d.decByteState = decByteStateReuseBuf
-		bsOut = d.d.blist.check(*d.buf, slen)[:slen]
+		bsOut = d.d.blist.check(*d.buf, slen)
+		bsOut = bsOut[:slen]
 		*d.buf = bsOut
 	} else {
 		bsOut = make([]byte, slen)
@@ -1056,7 +1054,7 @@ func (d *jsonDecDriver) DecodeStringAsBytes() (s []byte) {
 	d.d.decByteState = decByteStateNone
 	d.advance()
 
-	// common case
+	// common case - hoist outside the switch statement
 	if d.tok == '"' {
 		return d.dblQuoteStringAsBytes()
 	}
@@ -1064,19 +1062,19 @@ func (d *jsonDecDriver) DecodeStringAsBytes() (s []byte) {
 	// handle non-string scalar: null, true, false or a number
 	switch d.tok {
 	case 'n':
-		d.readLit4Null(d.d.decRd.readn3())
+		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
 		return nil // []byte{}
 	case 'f':
-		d.readLit4False(d.d.decRd.readn4())
-		return jsonLiteralFalse
+		d.checkLit4([4]byte{'a', 'l', 's', 'e'}, d.d.decRd.readn4())
+		return jsonLitb[jsonLitF : jsonLitF+5]
 	case 't':
-		d.readLit4True(d.d.decRd.readn3())
-		return jsonLiteralTrue
+		d.checkLit3([3]byte{'r', 'u', 'e'}, d.d.decRd.readn3())
+		return jsonLitb[jsonLitT : jsonLitT+4]
+	default:
+		// try to parse a valid number
+		d.tok = 0
+		return d.d.decRd.jsonReadNum()
 	}
-
-	// try to parse a valid number
-	d.tok = 0
-	return d.d.decRd.jsonReadNum()
 }
 
 func (d *jsonDecDriver) ensureReadingString() {
@@ -1093,6 +1091,7 @@ func (d *jsonDecDriver) readUnescapedString() (bs []byte) {
 }
 
 func (d *jsonDecDriver) dblQuoteStringAsBytes() (buf []byte) {
+	checkUtf8 := d.h.ValidateUnicode
 	d.d.decByteState = decByteStateNone
 	// use a local buf variable, so we don't do pointer chasing within loop
 	buf = (*d.buf)[:0]
@@ -1119,8 +1118,6 @@ func (d *jsonDecDriver) dblQuoteStringAsBytes() (buf []byte) {
 		if jsonManualInlineDecRdInHotZones {
 			if dr.bytes {
 				bs = dr.rb.jsonReadAsisChars()
-			} else if dr.bufio {
-				bs = dr.bi.jsonReadAsisChars()
 			} else {
 				bs = dr.ri.jsonReadAsisChars()
 			}
@@ -1129,6 +1126,7 @@ func (d *jsonDecDriver) dblQuoteStringAsBytes() (buf []byte) {
 		}
 
 	APPEND:
+		_ = bs[0] // bounds check hint - slice must be > 0 elements
 		buf = append(buf, bs[:len(bs)-1]...)
 		c = bs[len(bs)-1]
 
@@ -1153,7 +1151,11 @@ func (d *jsonDecDriver) dblQuoteStringAsBytes() (buf []byte) {
 		case 't':
 			buf = append(buf, '\t')
 		case 'u':
-			buf = append(buf, d.bstr[:utf8.EncodeRune(d.bstr[:], d.appendStringAsBytesSlashU())]...)
+			rr := d.appendStringAsBytesSlashU()
+			if checkUtf8 && rr == unicode.ReplacementChar {
+				d.d.errorf("invalid UTF-8 character found after: %s", buf)
+			}
+			buf = append(buf, d.bstr[:utf8.EncodeRune(d.bstr[:], rr)]...)
 		default:
 			*d.buf = buf
 			d.d.errorf("unsupported escaped value: %c", c)
@@ -1221,14 +1223,14 @@ func (d *jsonDecDriver) DecodeNaked() {
 	var bs []byte
 	switch d.tok {
 	case 'n':
-		d.readLit4Null(d.d.decRd.readn3())
+		d.checkLit3([3]byte{'u', 'l', 'l'}, d.d.decRd.readn3())
 		z.v = valueTypeNil
 	case 'f':
-		d.readLit4False(d.d.decRd.readn4())
+		d.checkLit4([4]byte{'a', 'l', 's', 'e'}, d.d.decRd.readn4())
 		z.v = valueTypeBool
 		z.b = false
 	case 't':
-		d.readLit4True(d.d.decRd.readn3())
+		d.checkLit3([3]byte{'r', 'u', 'e'}, d.d.decRd.readn3())
 		z.v = valueTypeBool
 		z.b = true
 	case '{':
@@ -1236,18 +1238,20 @@ func (d *jsonDecDriver) DecodeNaked() {
 	case '[':
 		z.v = valueTypeArray // don't consume. kInterfaceNaked will call ReadArrayStart
 	case '"':
-		// if a string, and MapKeyAsString, then try to decode it as a nil, bool or number first
+		// if a string, and MapKeyAsString, then try to decode it as a bool or number first
 		bs = d.dblQuoteStringAsBytes()
-		if len(bs) > 0 && d.d.c == containerMapKey && d.h.MapKeyAsString {
-			if bytes.Equal(bs, jsonLiteralNull) {
-				z.v = valueTypeNil
-			} else if bytes.Equal(bs, jsonLiteralTrue) {
+		if jsonNakedBoolNullInQuotedStr &&
+			d.h.MapKeyAsString && len(bs) > 0 && d.d.c == containerMapKey {
+			switch string(bs) {
+			// case "null": // nil is never quoted
+			// 	z.v = valueTypeNil
+			case "true":
 				z.v = valueTypeBool
 				z.b = true
-			} else if bytes.Equal(bs, jsonLiteralFalse) {
+			case "false":
 				z.v = valueTypeBool
 				z.b = false
-			} else {
+			default:
 				// check if a number: float, int or uint
 				if err := d.nakedNum(z, bs); err != nil {
 					z.v = valueTypeString
@@ -1275,13 +1279,13 @@ func (d *jsonDecDriver) DecodeNaked() {
 // JsonHandle is a handle for JSON encoding format.
 //
 // Json is comprehensively supported:
-//    - decodes numbers into interface{} as int, uint or float64
-//      based on how the number looks and some config parameters e.g. PreferFloat, SignedInt, etc.
-//    - decode integers from float formatted numbers e.g. 1.27e+8
-//    - decode any json value (numbers, bool, etc) from quoted strings
-//    - configurable way to encode/decode []byte .
-//      by default, encodes and decodes []byte using base64 Std Encoding
-//    - UTF-8 support for encoding and decoding
+//   - decodes numbers into interface{} as int, uint or float64
+//     based on how the number looks and some config parameters e.g. PreferFloat, SignedInt, etc.
+//   - decode integers from float formatted numbers e.g. 1.27e+8
+//   - decode any json value (numbers, bool, etc) from quoted strings
+//   - configurable way to encode/decode []byte .
+//     by default, encodes and decodes []byte using base64 Std Encoding
+//   - UTF-8 support for encoding and decoding
 //
 // It has better performance than the json library in the standard library,
 // by leveraging the performance improvements of the codec library.
@@ -1453,5 +1457,4 @@ func jsonFloatStrconvFmtPrec32(f float32) (fmt byte, prec int8) {
 var _ decDriverContainerTracker = (*jsonDecDriver)(nil)
 var _ encDriverContainerTracker = (*jsonEncDriver)(nil)
 var _ decDriver = (*jsonDecDriver)(nil)
-
 var _ encDriver = (*jsonEncDriver)(nil)
diff --git a/vendor/github.com/ugorji/go/codec/msgpack.go b/vendor/github.com/ugorji/go/codec/msgpack.go
index dc25530e7..c8b539d4e 100644
--- a/vendor/github.com/ugorji/go/codec/msgpack.go
+++ b/vendor/github.com/ugorji/go/codec/msgpack.go
@@ -24,6 +24,7 @@ import (
 	"net/rpc"
 	"reflect"
 	"time"
+	"unicode/utf8"
 )
 
 const (
@@ -872,7 +873,11 @@ func (d *msgpackDecDriver) DecodeBytes(bs []byte) (bsOut []byte) {
 }
 
 func (d *msgpackDecDriver) DecodeStringAsBytes() (s []byte) {
-	return d.DecodeBytes(nil)
+	s = d.DecodeBytes(nil)
+	if d.h.ValidateUnicode && !utf8.Valid(s) {
+		d.d.errorf("DecodeStringAsBytes: invalid UTF-8: %s", s)
+	}
+	return
 }
 
 func (d *msgpackDecDriver) descBd() string {
@@ -1071,7 +1076,7 @@ func (d *msgpackDecDriver) decodeExtV(verifyTag bool, tag byte) (xbs []byte, xta
 
 //--------------------------------------------------
 
-//MsgpackHandle is a Handle for the Msgpack Schema-Free Encoding Format.
+// MsgpackHandle is a Handle for the Msgpack Schema-Free Encoding Format.
 type MsgpackHandle struct {
 	binaryEncodingType
 	BasicHandle
diff --git a/vendor/github.com/ugorji/go/codec/reader.go b/vendor/github.com/ugorji/go/codec/reader.go
index a683d9a2a..3fea9f4c7 100644
--- a/vendor/github.com/ugorji/go/codec/reader.go
+++ b/vendor/github.com/ugorji/go/codec/reader.go
@@ -3,7 +3,12 @@
 
 package codec
 
-import "io"
+import (
+	"bufio"
+	"bytes"
+	"io"
+	"strings"
+)
 
 // decReader abstracts the reading source, allowing implementations that can
 // read from an io.Reader or directly off a byte slice with zero-copying.
@@ -17,8 +22,7 @@ type decReader interface {
 
 	readn1() byte
 	readn2() [2]byte
-	// readn3 will read 3 bytes into the top-most elements of a 4-byte array
-	readn3() [4]byte
+	readn3() [3]byte
 	readn4() [4]byte
 	readn8() [8]byte
 	// readn1eof() (v uint8, eof bool)
@@ -62,55 +66,57 @@ const (
 	unreadByteCanUnread
 )
 
+// const defBufReaderSize = 4096
+
 // --------------------
 
-type ioDecReaderCommon struct {
-	r io.Reader // the reader passed in
+// ioReaderByteScanner contains the io.Reader and io.ByteScanner interfaces
+type ioReaderByteScanner interface {
+	io.Reader
+	io.ByteScanner
+	// ReadByte() (byte, error)
+	// UnreadByte() error
+	// Read(p []byte) (n int, err error)
+}
 
-	n uint // num read
+// ioReaderByteScannerT does a simple wrapper of a io.ByteScanner
+// over a io.Reader
+type ioReaderByteScannerT struct {
+	r io.Reader
 
 	l  byte             // last byte
 	ls unreadByteStatus // last byte status
 
-	b [6]byte // tiny buffer for reading single bytes
-
-	blist *bytesFreelist
-
-	bufr []byte // buffer for readTo/readUntil
+	_ [2]byte // padding
+	b [4]byte // tiny buffer for reading single bytes
 }
 
-func (z *ioDecReaderCommon) reset(r io.Reader, blist *bytesFreelist) {
-	z.blist = blist
-	z.r = r
-	z.ls = unreadByteUndefined
-	z.l, z.n = 0, 0
-	z.bufr = z.blist.check(z.bufr, 256)
-}
-
-func (z *ioDecReaderCommon) numread() uint {
-	return z.n
-}
-
-// ------------------------------------------
-
-// ioDecReader is a decReader that reads off an io.Reader.
-//
-// It also has a fallback implementation of ByteScanner if needed.
-type ioDecReader struct {
-	ioDecReaderCommon
-
-	br io.ByteScanner
-
-	x [64 + 48]byte // for: get struct field name, swallow valueTypeBytes, etc
+func (z *ioReaderByteScannerT) ReadByte() (c byte, err error) {
+	if z.ls == unreadByteCanRead {
+		z.ls = unreadByteCanUnread
+		c = z.l
+	} else {
+		_, err = z.Read(z.b[:1])
+		c = z.b[0]
+	}
+	return
 }
 
-func (z *ioDecReader) reset(r io.Reader, blist *bytesFreelist) {
-	z.ioDecReaderCommon.reset(r, blist)
-
-	z.br, _ = r.(io.ByteScanner)
+func (z *ioReaderByteScannerT) UnreadByte() (err error) {
+	switch z.ls {
+	case unreadByteCanUnread:
+		z.ls = unreadByteCanRead
+	case unreadByteCanRead:
+		err = errDecUnreadByteLastByteNotRead
+	case unreadByteUndefined:
+		err = errDecUnreadByteNothingToRead
+	default:
+		err = errDecUnreadByteUnknown
+	}
+	return
 }
 
-func (z *ioDecReader) Read(p []byte) (n int, err error) {
+func (z *ioReaderByteScannerT) Read(p []byte) (n int, err error) {
 	if len(p) == 0 {
 		return
 	}
@@ -139,45 +145,79 @@ func (z *ioDecReader) Read(p []byte) (n int, err error) {
 	return
 }
 
-func (z *ioDecReader) ReadByte() (c byte, err error) {
-	if z.br != nil {
-		c, err = z.br.ReadByte()
-		if err == nil {
-			z.l = c
-			z.ls = unreadByteCanUnread
+func (z *ioReaderByteScannerT) reset(r io.Reader) {
+	z.r = r
+	z.ls = unreadByteUndefined
+	z.l = 0
+}
+
+// ioDecReader is a decReader that reads off an io.Reader.
+type ioDecReader struct {
+	rr ioReaderByteScannerT // the reader passed in, wrapped into a reader+bytescanner
+
+	n uint // num read
+
+	blist *bytesFreelist
+
+	bufr []byte              // buffer for readTo/readUntil
+	br   ioReaderByteScanner // main reader used for Read|ReadByte|UnreadByte
+	bb   *bufio.Reader       // created internally, and reused on reset if needed
+
+	x [64 + 40]byte // for: get struct field name, swallow valueTypeBytes, etc
+}
+
+func (z *ioDecReader) reset(r io.Reader, bufsize int, blist *bytesFreelist) {
+	z.blist = blist
+	z.n = 0
+	z.bufr = z.blist.check(z.bufr, 256)
+	z.br = nil
+
+	var ok bool
+
+	if bufsize <= 0 {
+		z.br, ok = r.(ioReaderByteScanner)
+		if !ok {
+			z.rr.reset(r)
+			z.br = &z.rr
 		}
 		return
 	}
 
-	n, err := z.Read(z.b[:1])
-	if n == 1 {
-		c = z.b[0]
-		if err == io.EOF {
-			err = nil // read was successful, so postpone EOF (till next time)
+	// bufsize > 0 ...
+
+	// if bytes.[Buffer|Reader], no value in adding extra buffer
+	// if bufio.Reader, no value in extra buffer unless size changes
+	switch bb := r.(type) {
+	case *strings.Reader:
+		z.br = bb
+	case *bytes.Buffer:
+		z.br = bb
+	case *bytes.Reader:
+		z.br = bb
+	case *bufio.Reader:
+		if bb.Size() == bufsize {
+			z.br = bb
 		}
 	}
-	return
-}
 
-func (z *ioDecReader) UnreadByte() (err error) {
-	if z.br != nil {
-		err = z.br.UnreadByte()
-		if err == nil {
-			z.ls = unreadByteCanRead
+	if z.br == nil {
+		if z.bb != nil && z.bb.Size() == bufsize {
+			z.bb.Reset(r)
+		} else {
+			z.bb = bufio.NewReaderSize(r, bufsize)
 		}
-		return
+		z.br = z.bb
 	}
+}
 
-	switch z.ls {
-	case unreadByteCanUnread:
-		z.ls = unreadByteCanRead
-	case unreadByteCanRead:
-		err = errDecUnreadByteLastByteNotRead
-	case unreadByteUndefined:
-		err = errDecUnreadByteNothingToRead
-	default:
-		err = errDecUnreadByteUnknown
-	}
+func (z *ioDecReader) numread() uint {
+	return z.n
+}
+
+func (z *ioDecReader) readn1() (b uint8) {
+	b, err := z.br.ReadByte()
+	halt.onerror(err)
+	z.n++
 	return
 }
 
@@ -186,8 +226,8 @@ func (z *ioDecReader) readn2() (bs [2]byte) {
 	return
 }
 
-func (z *ioDecReader) readn3() (bs [4]byte) {
-	z.readb(bs[1:])
+func (z *ioDecReader) readn3() (bs [3]byte) {
+	z.readb(bs[:])
 	return
 }
 
@@ -203,16 +243,16 @@ func (z *ioDecReader) readn8() (bs [8]byte) {
 
 func (z *ioDecReader) readx(n uint) (bs []byte) {
 	if n == 0 {
-		return
+		return zeroByteSlice
 	}
 	if n < uint(len(z.x)) {
 		bs = z.x[:n]
 	} else {
 		bs = make([]byte, n)
 	}
-	_, err := readFull(z.r, bs)
+	nn, err := readFull(z.br, bs)
+	z.n += nn
 	halt.onerror(err)
-	z.n += uint(len(bs))
 	return
 }
 
@@ -220,38 +260,36 @@ func (z *ioDecReader) readb(bs []byte) {
 	if len(bs) == 0 {
 		return
 	}
-	_, err := readFull(z.r, bs)
+	nn, err := readFull(z.br, bs)
+	z.n += nn
 	halt.onerror(err)
-	z.n += uint(len(bs))
 }
 
-func (z *ioDecReader) readn1() (b uint8) {
-	b, err := z.ReadByte()
-	halt.onerror(err)
-	z.n++
-	return
-}
-
-func (z *ioDecReader) readn1eof() (b uint8, eof bool) {
-	b, err := z.ReadByte()
-	if err == nil {
-		z.n++
-	} else if err == io.EOF {
-		eof = true
-	} else {
-		halt.onerror(err)
-	}
-	return
-}
+// func (z *ioDecReader) readn1eof() (b uint8, eof bool) {
+// 	b, err := z.br.ReadByte()
+// 	if err == nil {
+// 		z.n++
+// 	} else if err == io.EOF {
+// 		eof = true
+// 	} else {
+// 		halt.onerror(err)
+// 	}
+// 	return
+// }
 
 func (z *ioDecReader) jsonReadNum() (bs []byte) {
 	z.unreadn1()
 	z.bufr = z.bufr[:0]
 LOOP:
-	i, eof := z.readn1eof()
-	if eof {
+	// i, eof := z.readn1eof()
+	i, err := z.br.ReadByte()
+	if err == io.EOF {
 		return z.bufr
 	}
+	if err != nil {
+		halt.onerror(err)
+	}
+	z.n++
 	if isNumberChar(i) {
 		z.bufr = append(z.bufr, i)
 		goto LOOP
@@ -280,307 +318,45 @@ LOOP:
 	return
 }
 
+// func (z *ioDecReader) readUntil(stop byte) []byte {
+// 	z.bufr = z.bufr[:0]
+// LOOP:
+// 	token := z.readn1()
+// 	z.bufr = append(z.bufr, token)
+// 	if token == stop {
+// 		return z.bufr[:len(z.bufr)-1]
+// 	}
+// 	goto LOOP
+// }
+
 func (z *ioDecReader) readUntil(stop byte) []byte {
 	z.bufr = z.bufr[:0]
 LOOP:
 	token := z.readn1()
-	z.bufr = append(z.bufr, token)
 	if token == stop {
-		return z.bufr[:len(z.bufr)-1]
+		return z.bufr
 	}
+	z.bufr = append(z.bufr, token)
 	goto LOOP
 }
 
 func (z *ioDecReader) unreadn1() {
-	err := z.UnreadByte()
+	err := z.br.UnreadByte()
 	halt.onerror(err)
 	z.n--
 }
 
 // ------------------------------------
 
-type bufioDecReader struct {
-	ioDecReaderCommon
-
-	c   uint // cursor
-	buf []byte
-}
-
-func (z *bufioDecReader) reset(r io.Reader, bufsize int, blist *bytesFreelist) {
-	z.ioDecReaderCommon.reset(r, blist)
-	z.c = 0
-	if cap(z.buf) < bufsize {
-		z.buf = blist.get(bufsize)
-	} else {
-		z.buf = z.buf[:0]
-	}
-}
-
-func (z *bufioDecReader) readb(p []byte) {
-	var n = uint(copy(p, z.buf[z.c:]))
-	z.n += n
-	z.c += n
-	if len(p) != int(n) {
-		z.readbFill(p, n, true, false)
-	}
-}
-
-func readbFillHandleErr(err error, must, eof bool) (isEOF bool) {
-	if err == io.EOF {
-		isEOF = true
-	}
-	if must && !(eof && isEOF) {
-		halt.onerror(err)
-	}
-	return
-}
-
-func (z *bufioDecReader) readbFill(p0 []byte, n uint, must, eof bool) (isEOF bool, err error) {
-	// at this point, there's nothing in z.buf to read (z.buf is fully consumed)
-	var p []byte
-	if p0 != nil {
-		p = p0[n:]
-	}
-	var n2 uint
-	if len(p) > cap(z.buf) {
-		n2, err = readFull(z.r, p)
-		if err != nil {
-			isEOF = readbFillHandleErr(err, must, eof)
-			return
-		}
-		n += n2
-		z.n += n2
-		// always keep last byte in z.buf
-		z.buf = z.buf[:1]
-		z.buf[0] = p[len(p)-1]
-		z.c = 1
-		return
-	}
-	// z.c is now 0, and len(p) <= cap(z.buf)
-	var n1 int
-LOOP:
-	// for len(p) > 0 && z.err == nil {
-	z.buf = z.buf[0:cap(z.buf)]
-	n1, err = z.r.Read(z.buf)
-	n2 = uint(n1)
-	if n2 == 0 && err != nil {
-		isEOF = readbFillHandleErr(err, must, eof)
-		return
-	}
-	err = nil
-	z.buf = z.buf[:n2]
-	z.c = 0
-	if len(p) > 0 {
-		n2 = uint(copy(p, z.buf))
-		z.c = n2
-		n += n2
-		z.n += n2
-		p = p[n2:]
-		if len(p) > 0 {
-			goto LOOP
-		}
-		if z.c == 0 {
-			z.buf = z.buf[:1]
-			z.buf[0] = p[len(p)-1]
-			z.c = 1
-		}
-	}
-	return
-}
-
-func (z *bufioDecReader) readn1() (b byte) {
-	if z.c >= uint(len(z.buf)) {
-		z.readbFill(nil, 0, true, false)
-	}
-	b = z.buf[z.c]
-	z.c++
-	z.n++
-	return
-}
-
-func (z *bufioDecReader) readn1eof() (b byte, eof bool) {
-	if z.c >= uint(len(z.buf)) {
-		eof, _ = z.readbFill(nil, 0, true, true)
-		if eof {
-			return
-		}
-	}
-	b = z.buf[z.c]
-	z.c++
-	z.n++
-	return
-}
-
-func (z *bufioDecReader) unreadn1() {
-	if z.c == 0 {
-		halt.onerror(errDecUnreadByteNothingToRead)
-	}
-	z.c--
-	z.n--
-}
-
-func (z *bufioDecReader) readn2() (bs [2]byte) {
-	z.readb(bs[:])
-	return
-}
-
-func (z *bufioDecReader) readn3() (bs [4]byte) {
-	z.readb(bs[1:])
-	return
-}
-
-func (z *bufioDecReader) readn4() (bs [4]byte) {
-	z.readb(bs[:])
-	return
-}
-
-func (z *bufioDecReader) readn8() (bs [8]byte) {
-	z.readb(bs[:])
-	return
-}
-
-func (z *bufioDecReader) readx(n uint) (bs []byte) {
-	if n == 0 {
-		// return
-	} else if z.c+n <= uint(len(z.buf)) {
-		bs = z.buf[z.c : z.c+n]
-		z.n += n
-		z.c += n
-	} else {
-		bs = make([]byte, n)
-		// n no longer used - can reuse
-		n = uint(copy(bs, z.buf[z.c:]))
-		z.n += n
-		z.c += n
-		z.readbFill(bs, n, true, false)
-	}
-	return
-}
-
-func (z *bufioDecReader) jsonReadNum() (bs []byte) {
-	z.unreadn1()
-	z.bufr = z.bufr[:0]
-LOOP:
-	i, eof := z.readn1eof()
-	if eof {
-		return z.bufr
-	}
-	if isNumberChar(i) {
-		z.bufr = append(z.bufr, i)
-		goto LOOP
-	}
-	z.unreadn1()
-	return z.bufr
-}
-
-func (z *bufioDecReader) jsonReadAsisChars() (bs []byte) {
-	z.bufr = z.bufr[:0]
-LOOP:
-	i := z.readn1()
-	z.bufr = append(z.bufr, i)
-	if i == '"' || i == '\\' {
-		return z.bufr
-	}
-	goto LOOP
-}
-
-func (z *bufioDecReader) skipWhitespace() (token byte) {
-	i := z.c
-LOOP:
-	if i < uint(len(z.buf)) {
-		// inline z.skipLoopFn(i) and refactor, so cost is within inline budget
-		token = z.buf[i]
-		i++
-		if isWhitespaceChar(token) {
-			goto LOOP
-		}
-		z.n += i - 2 - z.c
-		z.c = i
-		return
-	}
-	return z.skipFillWhitespace()
-}
-
-func (z *bufioDecReader) skipFillWhitespace() (token byte) {
-	z.n += uint(len(z.buf)) - z.c
-	var i, n2 int
-	var err error
-	for {
-		z.c = 0
-		z.buf = z.buf[0:cap(z.buf)]
-		n2, err = z.r.Read(z.buf)
-		if n2 == 0 {
-			halt.onerror(err)
-		}
-		z.buf = z.buf[:n2]
-		for i, token = range z.buf {
-			if !isWhitespaceChar(token) {
-				z.n += (uint(i) - z.c) - 1
-				z.loopFn(uint(i + 1))
-				return
-			}
-		}
-		z.n += uint(n2)
-	}
-}
-
-func (z *bufioDecReader) loopFn(i uint) {
-	z.c = i
-}
-
-func (z *bufioDecReader) readUntil(stop byte) (out []byte) {
-	i := z.c
-LOOP:
-	if i < uint(len(z.buf)) {
-		if z.buf[i] == stop {
-			z.n += (i - z.c) - 1
-			i++
-			out = z.buf[z.c:i]
-			z.c = i
-			goto FINISH
-		}
-		i++
-		goto LOOP
-	}
-	out = z.readUntilFill(stop)
-FINISH:
-	return out[:len(out)-1]
-}
-
-func (z *bufioDecReader) readUntilFill(stop byte) []byte {
-	z.bufr = z.bufr[:0]
-	z.n += uint(len(z.buf)) - z.c
-	z.bufr = append(z.bufr, z.buf[z.c:]...)
-	for {
-		z.c = 0
-		z.buf = z.buf[0:cap(z.buf)]
-		n1, err := z.r.Read(z.buf)
-		if n1 == 0 {
-			halt.onerror(err)
-		}
-		n2 := uint(n1)
-		z.buf = z.buf[:n2]
-		for i, token := range z.buf {
-			if token == stop {
-				z.n += (uint(i) - z.c) - 1
-				z.bufr = append(z.bufr, z.buf[z.c:i+1]...)
-				z.loopFn(uint(i + 1))
-				return z.bufr
-			}
-		}
-		z.bufr = append(z.bufr, z.buf...)
-		z.n += n2
-	}
-}
-
-// ------------------------------------
-
 // bytesDecReader is a decReader that reads off a byte slice with zero copying
 //
 // Note: we do not try to convert index'ing out of bounds to an io.EOF.
 // instead, we let it bubble up to the exported Encode/Decode method
 // and recover it as an io.EOF.
 //
+// Every function here MUST defensively check bounds either explicitly
+// or via a bounds check.
+//
 // see panicValToErr(...) function in helper.go.
 type bytesDecReader struct {
 	b []byte // data
@@ -601,9 +377,11 @@ func (z *bytesDecReader) numread() uint {
 // However, we do it only once, and it's better than reslicing both z.b and return value.
 
 func (z *bytesDecReader) readx(n uint) (bs []byte) {
-	x := z.c + n
-	bs = z.b[z.c:x]
-	z.c = x
+	// x := z.c + n
+	// bs = z.b[z.c:x]
+	// z.c = x
+	bs = z.b[z.c : z.c+n]
+	z.c += n
 	return
 }
 
@@ -630,23 +408,26 @@ func (z *bytesDecReader) readb(bs []byte) {
 // 	return z.b[z.c-1]
 // }
 
+// MARKER: readn{1,2,3,4,8} should throw an out of bounds error if past length.
+// MARKER: readn1: explicitly ensure bounds check is done
+// MARKER: readn{2,3,4,8}: ensure you slice z.b completely so we get bounds error if past end.
+
 func (z *bytesDecReader) readn1() (v uint8) {
 	v = z.b[z.c]
 	z.c++
 	return
 }
 
-// MARKER: for readn{2,3,4,8}, ensure you slice z.b completely so we get bounds error if past end.
-
 func (z *bytesDecReader) readn2() (bs [2]byte) {
 	// copy(bs[:], z.b[z.c:z.c+2])
-	bs[1] = z.b[z.c+1]
-	bs[0] = z.b[z.c]
+	// bs[1] = z.b[z.c+1]
+	// bs[0] = z.b[z.c]
+	bs = okBytes2(z.b[z.c : z.c+2])
 	z.c += 2
 	return
 }
 
-func (z *bytesDecReader) readn3() (bs [4]byte) {
+func (z *bytesDecReader) readn3() (bs [3]byte) {
 	// copy(bs[1:], z.b[z.c:z.c+3])
 	bs = okBytes3(z.b[z.c : z.c+3])
 	z.c += 3
@@ -668,14 +449,17 @@ func (z *bytesDecReader) readn8() (bs [8]byte) {
 }
 
 func (z *bytesDecReader) jsonReadNum() []byte {
-	z.c--
+	z.c-- // unread
 	i := z.c
 LOOP:
+	// gracefully handle end of slice, as end of stream is meaningful here
 	if i < uint(len(z.b)) && isNumberChar(z.b[i]) {
 		i++
 		goto LOOP
 	}
 	z.c, i = i, z.c
+	// MARKER: 20230103: byteSliceOf here prevents inlining of jsonReadNum
+	// return byteSliceOf(z.b, i, z.c)
 	return z.b[i:z.c]
 }
 
@@ -686,7 +470,8 @@ LOOP:
 	i++
 	if token == '"' || token == '\\' {
 		z.c, i = i, z.c
-		return z.b[i:z.c]
+		return byteSliceOf(z.b, i, z.c)
+		// return z.b[i:z.c]
 	}
 	goto LOOP
 }
@@ -707,7 +492,8 @@ func (z *bytesDecReader) readUntil(stop byte) (out []byte) {
 	i := z.c
 LOOP:
 	if z.b[i] == stop {
-		out = z.b[z.c:i]
+		out = byteSliceOf(z.b, z.c, i)
+		// out = z.b[z.c:i]
 		z.c = i + 1
 		return
 	}
@@ -718,6 +504,16 @@ LOOP:
 // --------------
 
 type decRd struct {
+	rb bytesDecReader
+	ri *ioDecReader
+
+	decReader
+
+	bytes bool // is bytes reader
+
+	// MARKER: these fields below should belong directly in Encoder.
+	// we pack them here for space efficiency and cache-line optimization.
+
 	mtr bool // is maptype a known type?
 	str bool // is slicetype a known type?
 
@@ -726,73 +522,66 @@ type decRd struct {
 	jsms bool // is json handle, and MapKeyAsString
 	cbor bool // is cbor handle
 
-	bytes bool // is bytes reader
-	bufio bool // is this a bufioDecReader?
-
-	rb bytesDecReader
-	ri *ioDecReader
-	bi *bufioDecReader
+	cbreak bool // is a check breaker
 
-	decReader
 }
 
-// From out benchmarking, we see the following in terms of performance:
-//
-// - interface calls
-// - branch that can inline what it calls
+// From out benchmarking, we see the following impact performance:
 //
-// the if/else-if/else block is expensive to inline.
-// Each node of this construct costs a lot and dominates the budget.
-// Best to only do an if fast-path else block (so fast-path is inlined).
-// This is irrespective of inlineExtraCallCost set in $GOROOT/src/cmd/compile/internal/gc/inl.go
+// - functions that are too big to inline
+// - interface calls (as no inlining can occur)
 //
-// In decRd methods below, we delegate all IO functions into their own methods.
-// This allows for the inlining of the common path when z.bytes=true.
-// Go 1.12+ supports inlining methods with up to 1 inlined function (or 2 if no other constructs).
+// decRd is designed to embed a decReader, and then re-implement some of the decReader
+// methods using a conditional branch.
 //
-// However, up through Go 1.13, decRd's readXXX, skip and unreadXXX methods are not inlined.
-// Consequently, there is no benefit to do the xxxIO methods for decRd at this time.
-// Instead, we have a if/else-if/else block so that IO calls do not have to jump through
-// a second unnecessary function call.
+// We only override the ones where the bytes version is inlined AND the wrapper method
+// (containing the bytes version alongside a conditional branch) is also inlined.
 //
-// If golang inlining gets better and bytesDecReader methods can be inlined,
-// then we can revert to using these 2 functions so the bytesDecReader
-// methods are inlined and the IO paths call out to a function.
+// We use ./run.sh -z to check.
 //
-// decRd is designed to embed a decReader, and then re-implement some of the decReader
-// methods using a conditional branch. We only override the ones that have a bytes version
-// that is small enough to be inlined. We use ./run.sh -z to check.
-// Right now, only numread and readn1 can be inlined.
+// Right now, only numread and "carefully crafted" readn1 can be inlined.
 
 func (z *decRd) numread() uint {
 	if z.bytes {
 		return z.rb.numread()
-	} else if z.bufio {
-		return z.bi.numread()
-	} else {
-		return z.ri.numread()
 	}
+	return z.ri.numread()
 }
 
 func (z *decRd) readn1() (v uint8) {
 	if z.bytes {
-		// MARKER: manually inline, else this function is not inlined.
-		// Keep in sync with bytesDecReader.readn1
 		// return z.rb.readn1()
+		// MARKER: calling z.rb.readn1() prevents decRd.readn1 from being inlined.
+		// copy code, to manually inline and explicitly return here.
+		// Keep in sync with bytesDecReader.readn1
 		v = z.rb.b[z.rb.c]
 		z.rb.c++
-	} else {
-		v = z.readn1IO()
-	}
-	return
-}
-func (z *decRd) readn1IO() uint8 {
-	if z.bufio {
-		return z.bi.readn1()
+		return
 	}
 	return z.ri.readn1()
 }
 
+// func (z *decRd) readn4() [4]byte {
+// 	if z.bytes {
+// 		return z.rb.readn4()
+// 	}
+// 	return z.ri.readn4()
+// }
+
+// func (z *decRd) readn3() [3]byte {
+// 	if z.bytes {
+// 		return z.rb.readn3()
+// 	}
+// 	return z.ri.readn3()
+// }
+
+// func (z *decRd) skipWhitespace() byte {
+// 	if z.bytes {
+// 		return z.rb.skipWhitespace()
+// 	}
+// 	return z.ri.skipWhitespace()
+// }
+
 type devNullReader struct{}
 
 func (devNullReader) Read(p []byte) (int, error) { return 0, io.EOF }
diff --git a/vendor/github.com/ugorji/go/codec/rpc.go b/vendor/github.com/ugorji/go/codec/rpc.go
index cf72377c7..0da8ad577 100644
--- a/vendor/github.com/ugorji/go/codec/rpc.go
+++ b/vendor/github.com/ugorji/go/codec/rpc.go
@@ -198,29 +198,31 @@ type goRpc struct{}
 // This ensures we use an adequate buffer during reading and writing.
 // If not configured, we will internally initialize and use a buffer during reads and writes.
 // This can be turned off via the RPCNoBuffer option on the Handle.
-//   var handle codec.JsonHandle
-//   handle.RPCNoBuffer = true // turns off attempt by rpc module to initialize a buffer
+//
+//	var handle codec.JsonHandle
+//	handle.RPCNoBuffer = true // turns off attempt by rpc module to initialize a buffer
 //
 // Example 1: one way of configuring buffering explicitly:
-//   var handle codec.JsonHandle // codec handle
-//   handle.ReaderBufferSize = 1024
-//   handle.WriterBufferSize = 1024
-//   var conn io.ReadWriteCloser // connection got from a socket
-//   var serverCodec = GoRpc.ServerCodec(conn, handle)
-//   var clientCodec = GoRpc.ClientCodec(conn, handle)
+//
+//	var handle codec.JsonHandle // codec handle
+//	handle.ReaderBufferSize = 1024
+//	handle.WriterBufferSize = 1024
+//	var conn io.ReadWriteCloser // connection got from a socket
+//	var serverCodec = GoRpc.ServerCodec(conn, handle)
+//	var clientCodec = GoRpc.ClientCodec(conn, handle)
 //
 // Example 2: you can also explicitly create a buffered connection yourself,
 // and not worry about configuring the buffer sizes in the Handle.
-//   var handle codec.Handle     // codec handle
-//   var conn io.ReadWriteCloser // connection got from a socket
-//   var bufconn = struct {      // bufconn here is a buffered io.ReadWriteCloser
-//       io.Closer
-//       *bufio.Reader
-//       *bufio.Writer
-//   }{conn, bufio.NewReader(conn), bufio.NewWriter(conn)}
-//   var serverCodec = GoRpc.ServerCodec(bufconn, handle)
-//   var clientCodec = GoRpc.ClientCodec(bufconn, handle)
 //
+//	var handle codec.Handle     // codec handle
+//	var conn io.ReadWriteCloser // connection got from a socket
+//	var bufconn = struct {      // bufconn here is a buffered io.ReadWriteCloser
+//	    io.Closer
+//	    *bufio.Reader
+//	    *bufio.Writer
+//	}{conn, bufio.NewReader(conn), bufio.NewWriter(conn)}
+//	var serverCodec = GoRpc.ServerCodec(bufconn, handle)
+//	var clientCodec = GoRpc.ClientCodec(bufconn, handle)
 var GoRpc goRpc
 
 func (x goRpc) ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec {
diff --git a/vendor/github.com/ugorji/go/codec/sort-slice.generated.go b/vendor/github.com/ugorji/go/codec/sort-slice.generated.go
index 0c43bdaae..a755a02af 100644
--- a/vendor/github.com/ugorji/go/codec/sort-slice.generated.go
+++ b/vendor/github.com/ugorji/go/codec/sort-slice.generated.go
@@ -5,9 +5,11 @@
 
 package codec
 
-import "time"
-import "reflect"
-import "bytes"
+import (
+	"bytes"
+	"reflect"
+	"time"
+)
 
 type stringSlice []string
 
@@ -109,18 +111,6 @@ func (p int64RvSlice) Less(i, j int) bool {
 	return p[uint(i)].v < p[uint(j)].v
 }
 
-type boolRv struct {
-	v bool
-	r reflect.Value
-}
-type boolRvSlice []boolRv
-
-func (p boolRvSlice) Len() int      { return len(p) }
-func (p boolRvSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
-func (p boolRvSlice) Less(i, j int) bool {
-	return !p[uint(i)].v && p[uint(j)].v
-}
-
 type timeRv struct {
 	v time.Time
 	r reflect.Value
diff --git a/vendor/github.com/ugorji/go/codec/sort-slice.go.tmpl b/vendor/github.com/ugorji/go/codec/sort-slice.go.tmpl
index 81bf4b488..98209603e 100644
--- a/vendor/github.com/ugorji/go/codec/sort-slice.go.tmpl
+++ b/vendor/github.com/ugorji/go/codec/sort-slice.go.tmpl
@@ -20,9 +20,11 @@ With the parameters passed in sortables or sortablesplus,
 
 package codec
 
-import "time"
-import "reflect"
-import "bytes"
+import (
+	"time"
+	"reflect"
+	"bytes"
+)
 
 {{/* func init() { _ = time.Unix } */}}
 
diff --git a/vendor/github.com/ugorji/go/codec/writer.go b/vendor/github.com/ugorji/go/codec/writer.go
index 4d2c9fe10..b6e4813f8 100644
--- a/vendor/github.com/ugorji/go/codec/writer.go
+++ b/vendor/github.com/ugorji/go/codec/writer.go
@@ -106,7 +106,8 @@ func (z *bufioEncWriter) writeqstr(s string) {
 	if z.n+len(s)+2 > len(z.buf) {
 		z.flush()
 	}
-	z.buf[z.n] = '"'
+	setByteAt(z.buf, uint(z.n), '"')
+	// z.buf[z.n] = '"'
 	z.n++
 LOOP:
 	a := len(z.buf) - z.n
@@ -117,7 +118,8 @@ LOOP:
 		goto LOOP
 	}
 	z.n += copy(z.buf[z.n:], s)
-	z.buf[z.n] = '"'
+	setByteAt(z.buf, uint(z.n), '"')
+	// z.buf[z.n] = '"'
 	z.n++
 }
 
@@ -125,21 +127,29 @@ func (z *bufioEncWriter) writen1(b1 byte) {
 	if 1 > len(z.buf)-z.n {
 		z.flush()
 	}
-	z.buf[z.n] = b1
+	setByteAt(z.buf, uint(z.n), b1)
+	// z.buf[z.n] = b1
 	z.n++
 }
 func (z *bufioEncWriter) writen2(b1, b2 byte) {
 	if 2 > len(z.buf)-z.n {
 		z.flush()
 	}
-	z.buf[z.n+1] = b2
-	z.buf[z.n] = b1
+	setByteAt(z.buf, uint(z.n+1), b2)
+	setByteAt(z.buf, uint(z.n), b1)
+	// z.buf[z.n+1] = b2
+	// z.buf[z.n] = b1
 	z.n += 2
 }
+
 func (z *bufioEncWriter) writen4(b [4]byte) {
 	if 4 > len(z.buf)-z.n {
 		z.flush()
 	}
+	// setByteAt(z.buf, uint(z.n+3), b4)
+	// setByteAt(z.buf, uint(z.n+2), b3)
+	// setByteAt(z.buf, uint(z.n+1), b2)
+	// setByteAt(z.buf, uint(z.n), b1)
 	copy(z.buf[z.n:], b[:])
 	z.n += 4
 }
@@ -185,14 +195,17 @@ func (z *bytesEncAppender) writen1(b1 byte) {
 func (z *bytesEncAppender) writen2(b1, b2 byte) {
 	z.b = append(z.b, b1, b2)
 }
+
 func (z *bytesEncAppender) writen4(b [4]byte) {
 	z.b = append(z.b, b[:]...)
-	// z.b = append(z.b, b[0], b[1], b[2], b[3]) // prevents inlining encWr.writen4
+	// z.b = append(z.b, b1, b2, b3, b4) // prevents inlining encWr.writen4
 }
+
 func (z *bytesEncAppender) writen8(b [8]byte) {
 	z.b = append(z.b, b[:]...)
 	// z.b = append(z.b, b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]) // prevents inlining encWr.writen4
 }
+
 func (z *bytesEncAppender) endErr() error {
 	*(z.out) = z.b
 	return nil
@@ -205,16 +218,21 @@ func (z *bytesEncAppender) reset(in []byte, out *[]byte) {
 // --------------------------------------------------
 
 type encWr struct {
+	wb bytesEncAppender
+	wf *bufioEncWriter
+
 	bytes bool // encoding to []byte
-	js    bool // is json encoder?
-	be    bool // is binary encoder?
+
+	// MARKER: these fields below should belong directly in Encoder.
+	// we pack them here for space efficiency and cache-line optimization.
+
+	js bool // is json encoder?
+	be bool // is binary encoder?
 
 	c containerState
 
 	calls uint16
 	seq   uint16 // sequencer (e.g. used by binc for symbols, etc)
-	wb    bytesEncAppender
-	wf    *bufioEncWriter
 }
 
 // MARKER: manually inline bytesEncAppender.writenx/writeqstr methods,
@@ -229,21 +247,25 @@ func (z *encWr) writeb(s []byte) {
 		z.wf.writeb(s)
 	}
 }
-func (z *encWr) writeqstr(s string) {
+func (z *encWr) writestr(s string) {
 	if z.bytes {
-		// MARKER: z.wb.writeqstr(s)
-		z.wb.b = append(append(append(z.wb.b, '"'), s...), '"')
+		z.wb.writestr(s)
 	} else {
-		z.wf.writeqstr(s)
+		z.wf.writestr(s)
 	}
 }
-func (z *encWr) writestr(s string) {
+
+// MARKER: Add WriteStr to be called directly by generated code without a genHelper forwarding function.
+// Go's inlining model adds cost for forwarding functions, preventing inlining (cost goes above 80 budget).
+
+func (z *encWr) WriteStr(s string) {
 	if z.bytes {
 		z.wb.writestr(s)
 	} else {
 		z.wf.writestr(s)
 	}
 }
+
 func (z *encWr) writen1(b1 byte) {
 	if z.bytes {
 		z.wb.writen1(b1)
@@ -260,21 +282,34 @@ func (z *encWr) writen2(b1, b2 byte) {
 		z.wf.writen2(b1, b2)
 	}
 }
+
 func (z *encWr) writen4(b [4]byte) {
 	if z.bytes {
-		z.wb.writen4(b)
+		// MARKER: z.wb.writen4(b1, b2, b3, b4)
+		z.wb.b = append(z.wb.b, b[:]...)
+		// z.wb.writen4(b)
 	} else {
 		z.wf.writen4(b)
 	}
 }
 func (z *encWr) writen8(b [8]byte) {
 	if z.bytes {
+		// z.wb.b = append(z.wb.b, b[:]...)
 		z.wb.writen8(b)
 	} else {
 		z.wf.writen8(b)
 	}
 }
 
+func (z *encWr) writeqstr(s string) {
+	if z.bytes {
+		// MARKER: z.wb.writeqstr(s)
+		z.wb.b = append(append(append(z.wb.b, '"'), s...), '"')
+	} else {
+		z.wf.writeqstr(s)
+	}
+}
+
 func (z *encWr) endErr() error {
 	if z.bytes {
 		return z.wb.endErr()
diff --git a/vendor/golang.org/x/arch/AUTHORS b/vendor/golang.org/x/arch/AUTHORS
new file mode 100644
index 000000000..2b00ddba0
--- /dev/null
+++ b/vendor/golang.org/x/arch/AUTHORS
@@ -0,0 +1,3 @@
+# 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
new file mode 100644
index 000000000..1fbd3e976
--- /dev/null
+++ b/vendor/golang.org/x/arch/CONTRIBUTORS
@@ -0,0 +1,3 @@
+# 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/LICENSE b/vendor/golang.org/x/arch/LICENSE
new file mode 100644
index 000000000..d29b37261
--- /dev/null
+++ b/vendor/golang.org/x/arch/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2015 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/golang.org/x/arch/PATENTS b/vendor/golang.org/x/arch/PATENTS
new file mode 100644
index 000000000..733099041
--- /dev/null
+++ b/vendor/golang.org/x/arch/PATENTS
@@ -0,0 +1,22 @@
+Additional IP Rights Grant (Patents)
+
+"This implementation" means the copyrightable works distributed by
+Google as part of the Go project.
+
+Google hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section)
+patent license to make, have made, use, offer to sell, sell, import,
+transfer and otherwise run, modify and propagate the contents of this
+implementation of Go, where such license applies only to those patent
+claims, both currently owned or controlled by Google and acquired in
+the future, licensable by Google that are necessarily infringed by this
+implementation of Go.  This grant does not include claims that would be
+infringed only as a consequence of further modification of this
+implementation.  If you or your agent or exclusive licensee institute or
+order or agree to the institution of patent litigation against any
+entity (including a cross-claim or counterclaim in a lawsuit) alleging
+that this implementation of Go or any code incorporated within this
+implementation of Go constitutes direct or contributory patent
+infringement, or inducement of patent infringement, then any patent
+rights granted to you under this License for this implementation of Go
+shall terminate as of the date such litigation is filed.
diff --git a/vendor/golang.org/x/arch/x86/x86asm/Makefile b/vendor/golang.org/x/arch/x86/x86asm/Makefile
new file mode 100644
index 000000000..9eb4557c1
--- /dev/null
+++ b/vendor/golang.org/x/arch/x86/x86asm/Makefile
@@ -0,0 +1,3 @@
+tables.go: ../x86map/map.go ../x86.csv 
+	go run ../x86map/map.go -fmt=decoder ../x86.csv >_tables.go && gofmt _tables.go >tables.go && rm _tables.go
+
diff --git a/vendor/golang.org/x/arch/x86/x86asm/decode.go b/vendor/golang.org/x/arch/x86/x86asm/decode.go
new file mode 100644
index 000000000..8c984970b
--- /dev/null
+++ b/vendor/golang.org/x/arch/x86/x86asm/decode.go
@@ -0,0 +1,1724 @@
+// Copyright 2014 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Table-driven decoding of x86 instructions.
+
+package x86asm
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"runtime"
+)
+
+// Set trace to true to cause the decoder to print the PC sequence
+// of the executed instruction codes. This is typically only useful
+// when you are running a test of a single input case.
+const trace = false
+
+// A decodeOp is a single instruction in the decoder bytecode program.
+//
+// The decodeOps correspond to consuming and conditionally branching
+// on input bytes, consuming additional fields, and then interpreting
+// consumed data as instruction arguments. The names of the xRead and xArg
+// operations are taken from the Intel manual conventions, for example
+// Volume 2, Section 3.1.1, page 487 of
+// http://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-manual-325462.pdf
+//
+// The actual decoding program is generated by ../x86map.
+//
+// TODO(rsc): We may be able to merge various of the memory operands
+// since we don't care about, say, the distinction between m80dec and m80bcd.
+// Similarly, mm and mm1 have identical meaning, as do xmm and xmm1.
+
+type decodeOp uint16
+
+const (
+	xFail  decodeOp = iota // invalid instruction (return)
+	xMatch                 // completed match
+	xJump                  // jump to pc
+
+	xCondByte     // switch on instruction byte value
+	xCondSlashR   // read and switch on instruction /r value
+	xCondPrefix   // switch on presence of instruction prefix
+	xCondIs64     // switch on 64-bit processor mode
+	xCondDataSize // switch on operand size
+	xCondAddrSize // switch on address size
+	xCondIsMem    // switch on memory vs register argument
+
+	xSetOp // set instruction opcode
+
+	xReadSlashR // read /r
+	xReadIb     // read ib
+	xReadIw     // read iw
+	xReadId     // read id
+	xReadIo     // read io
+	xReadCb     // read cb
+	xReadCw     // read cw
+	xReadCd     // read cd
+	xReadCp     // read cp
+	xReadCm     // read cm
+
+	xArg1            // arg 1
+	xArg3            // arg 3
+	xArgAL           // arg AL
+	xArgAX           // arg AX
+	xArgCL           // arg CL
+	xArgCR0dashCR7   // arg CR0-CR7
+	xArgCS           // arg CS
+	xArgDR0dashDR7   // arg DR0-DR7
+	xArgDS           // arg DS
+	xArgDX           // arg DX
+	xArgEAX          // arg EAX
+	xArgEDX          // arg EDX
+	xArgES           // arg ES
+	xArgFS           // arg FS
+	xArgGS           // arg GS
+	xArgImm16        // arg imm16
+	xArgImm32        // arg imm32
+	xArgImm64        // arg imm64
+	xArgImm8         // arg imm8
+	xArgImm8u        // arg imm8 but record as unsigned
+	xArgImm16u       // arg imm8 but record as unsigned
+	xArgM            // arg m
+	xArgM128         // arg m128
+	xArgM256         // arg m256
+	xArgM1428byte    // arg m14/28byte
+	xArgM16          // arg m16
+	xArgM16and16     // arg m16&16
+	xArgM16and32     // arg m16&32
+	xArgM16and64     // arg m16&64
+	xArgM16colon16   // arg m16:16
+	xArgM16colon32   // arg m16:32
+	xArgM16colon64   // arg m16:64
+	xArgM16int       // arg m16int
+	xArgM2byte       // arg m2byte
+	xArgM32          // arg m32
+	xArgM32and32     // arg m32&32
+	xArgM32fp        // arg m32fp
+	xArgM32int       // arg m32int
+	xArgM512byte     // arg m512byte
+	xArgM64          // arg m64
+	xArgM64fp        // arg m64fp
+	xArgM64int       // arg m64int
+	xArgM8           // arg m8
+	xArgM80bcd       // arg m80bcd
+	xArgM80dec       // arg m80dec
+	xArgM80fp        // arg m80fp
+	xArgM94108byte   // arg m94/108byte
+	xArgMm           // arg mm
+	xArgMm1          // arg mm1
+	xArgMm2          // arg mm2
+	xArgMm2M64       // arg mm2/m64
+	xArgMmM32        // arg mm/m32
+	xArgMmM64        // arg mm/m64
+	xArgMem          // arg mem
+	xArgMoffs16      // arg moffs16
+	xArgMoffs32      // arg moffs32
+	xArgMoffs64      // arg moffs64
+	xArgMoffs8       // arg moffs8
+	xArgPtr16colon16 // arg ptr16:16
+	xArgPtr16colon32 // arg ptr16:32
+	xArgR16          // arg r16
+	xArgR16op        // arg r16 with +rw in opcode
+	xArgR32          // arg r32
+	xArgR32M16       // arg r32/m16
+	xArgR32M8        // arg r32/m8
+	xArgR32op        // arg r32 with +rd in opcode
+	xArgR64          // arg r64
+	xArgR64M16       // arg r64/m16
+	xArgR64op        // arg r64 with +rd in opcode
+	xArgR8           // arg r8
+	xArgR8op         // arg r8 with +rb in opcode
+	xArgRAX          // arg RAX
+	xArgRDX          // arg RDX
+	xArgRM           // arg r/m
+	xArgRM16         // arg r/m16
+	xArgRM32         // arg r/m32
+	xArgRM64         // arg r/m64
+	xArgRM8          // arg r/m8
+	xArgReg          // arg reg
+	xArgRegM16       // arg reg/m16
+	xArgRegM32       // arg reg/m32
+	xArgRegM8        // arg reg/m8
+	xArgRel16        // arg rel16
+	xArgRel32        // arg rel32
+	xArgRel8         // arg rel8
+	xArgSS           // arg SS
+	xArgST           // arg ST, aka ST(0)
+	xArgSTi          // arg ST(i) with +i in opcode
+	xArgSreg         // arg Sreg
+	xArgTR0dashTR7   // arg TR0-TR7
+	xArgXmm          // arg xmm
+	xArgXMM0         // arg <XMM0>
+	xArgXmm1         // arg xmm1
+	xArgXmm2         // arg xmm2
+	xArgXmm2M128     // arg xmm2/m128
+	xArgYmm2M256     // arg ymm2/m256
+	xArgXmm2M16      // arg xmm2/m16
+	xArgXmm2M32      // arg xmm2/m32
+	xArgXmm2M64      // arg xmm2/m64
+	xArgXmmM128      // arg xmm/m128
+	xArgXmmM32       // arg xmm/m32
+	xArgXmmM64       // arg xmm/m64
+	xArgYmm1         // arg ymm1
+	xArgRmf16        // arg r/m16 but force mod=3
+	xArgRmf32        // arg r/m32 but force mod=3
+	xArgRmf64        // arg r/m64 but force mod=3
+)
+
+// instPrefix returns an Inst describing just one prefix byte.
+// It is only used if there is a prefix followed by an unintelligible
+// or invalid instruction byte sequence.
+func instPrefix(b byte, mode int) (Inst, error) {
+	// When tracing it is useful to see what called instPrefix to report an error.
+	if trace {
+		_, file, line, _ := runtime.Caller(1)
+		fmt.Printf("%s:%d\n", file, line)
+	}
+	p := Prefix(b)
+	switch p {
+	case PrefixDataSize:
+		if mode == 16 {
+			p = PrefixData32
+		} else {
+			p = PrefixData16
+		}
+	case PrefixAddrSize:
+		if mode == 32 {
+			p = PrefixAddr16
+		} else {
+			p = PrefixAddr32
+		}
+	}
+	// Note: using composite literal with Prefix key confuses 'bundle' tool.
+	inst := Inst{Len: 1}
+	inst.Prefix = Prefixes{p}
+	return inst, nil
+}
+
+// truncated reports a truncated instruction.
+// For now we use instPrefix but perhaps later we will return
+// a specific error here.
+func truncated(src []byte, mode int) (Inst, error) {
+	if len(src) == 0 {
+		return Inst{}, ErrTruncated
+	}
+	return instPrefix(src[0], mode) // too long
+}
+
+// These are the errors returned by Decode.
+var (
+	ErrInvalidMode  = errors.New("invalid x86 mode in Decode")
+	ErrTruncated    = errors.New("truncated instruction")
+	ErrUnrecognized = errors.New("unrecognized instruction")
+)
+
+// decoderCover records coverage information for which parts
+// of the byte code have been executed.
+var decoderCover []bool
+
+// Decode decodes the leading bytes in src as a single instruction.
+// The mode arguments specifies the assumed processor mode:
+// 16, 32, or 64 for 16-, 32-, and 64-bit execution modes.
+func Decode(src []byte, mode int) (inst Inst, err error) {
+	return decode1(src, mode, false)
+}
+
+// decode1 is the implementation of Decode but takes an extra
+// gnuCompat flag to cause it to change its behavior to mimic
+// bugs (or at least unique features) of GNU libopcodes as used
+// by objdump. We don't believe that logic is the right thing to do
+// in general, but when testing against libopcodes it simplifies the
+// comparison if we adjust a few small pieces of logic.
+// The affected logic is in the conditional branch for "mandatory" prefixes,
+// case xCondPrefix.
+func decode1(src []byte, mode int, gnuCompat bool) (Inst, error) {
+	switch mode {
+	case 16, 32, 64:
+		// ok
+		// TODO(rsc): 64-bit mode not tested, probably not working.
+	default:
+		return Inst{}, ErrInvalidMode
+	}
+
+	// Maximum instruction size is 15 bytes.
+	// If we need to read more, return 'truncated instruction.
+	if len(src) > 15 {
+		src = src[:15]
+	}
+
+	var (
+		// prefix decoding information
+		pos           = 0    // position reading src
+		nprefix       = 0    // number of prefixes
+		lockIndex     = -1   // index of LOCK prefix in src and inst.Prefix
+		repIndex      = -1   // index of REP/REPN prefix in src and inst.Prefix
+		segIndex      = -1   // index of Group 2 prefix in src and inst.Prefix
+		dataSizeIndex = -1   // index of Group 3 prefix in src and inst.Prefix
+		addrSizeIndex = -1   // index of Group 4 prefix in src and inst.Prefix
+		rex           Prefix // rex byte if present (or 0)
+		rexUsed       Prefix // bits used in rex byte
+		rexIndex      = -1   // index of rex byte
+		vex           Prefix // use vex encoding
+		vexIndex      = -1   // index of vex prefix
+
+		addrMode = mode // address mode (width in bits)
+		dataMode = mode // operand mode (width in bits)
+
+		// decoded ModR/M fields
+		haveModrm bool
+		modrm     int
+		mod       int
+		regop     int
+		rm        int
+
+		// if ModR/M is memory reference, Mem form
+		mem     Mem
+		haveMem bool
+
+		// decoded SIB fields
+		haveSIB bool
+		sib     int
+		scale   int
+		index   int
+		base    int
+		displen int
+		dispoff int
+
+		// decoded immediate values
+		imm     int64
+		imm8    int8
+		immc    int64
+		immcpos int
+
+		// output
+		opshift int
+		inst    Inst
+		narg    int // number of arguments written to inst
+	)
+
+	if mode == 64 {
+		dataMode = 32
+	}
+
+	// Prefixes are certainly the most complex and underspecified part of
+	// decoding x86 instructions. Although the manuals say things like
+	// up to four prefixes, one from each group, nearly everyone seems to
+	// agree that in practice as many prefixes as possible, including multiple
+	// from a particular group or repetitions of a given prefix, can be used on
+	// an instruction, provided the total instruction length including prefixes
+	// does not exceed the agreed-upon maximum of 15 bytes.
+	// Everyone also agrees that if one of these prefixes is the LOCK prefix
+	// and the instruction is not one of the instructions that can be used with
+	// the LOCK prefix or if the destination is not a memory operand,
+	// then the instruction is invalid and produces the #UD exception.
+	// However, that is the end of any semblance of agreement.
+	//
+	// What happens if prefixes are given that conflict with other prefixes?
+	// For example, the memory segment overrides CS, DS, ES, FS, GS, SS
+	// conflict with each other: only one segment can be in effect.
+	// Disassemblers seem to agree that later prefixes take priority over
+	// earlier ones. I have not taken the time to write assembly programs
+	// to check to see if the hardware agrees.
+	//
+	// What happens if prefixes are given that have no meaning for the
+	// specific instruction to which they are attached? It depends.
+	// If they really have no meaning, they are ignored. However, a future
+	// processor may assign a different meaning. As a disassembler, we
+	// don't really know whether we're seeing a meaningless prefix or one
+	// whose meaning we simply haven't been told yet.
+	//
+	// Combining the two questions, what happens when conflicting
+	// extension prefixes are given? No one seems to know for sure.
+	// For example, MOVQ is 66 0F D6 /r, MOVDQ2Q is F2 0F D6 /r,
+	// and MOVQ2DQ is F3 0F D6 /r. What is '66 F2 F3 0F D6 /r'?
+	// Which prefix wins? See the xCondPrefix prefix for more.
+	//
+	// Writing assembly test cases to divine which interpretation the
+	// CPU uses might clarify the situation, but more likely it would
+	// make the situation even less clear.
+
+	// Read non-REX prefixes.
+ReadPrefixes:
+	for ; pos < len(src); pos++ {
+		p := Prefix(src[pos])
+		switch p {
+		default:
+			nprefix = pos
+			break ReadPrefixes
+
+		// Group 1 - lock and repeat prefixes
+		// According to Intel, there should only be one from this set,
+		// but according to AMD both can be present.
+		case 0xF0:
+			if lockIndex >= 0 {
+				inst.Prefix[lockIndex] |= PrefixIgnored
+			}
+			lockIndex = pos
+		case 0xF2, 0xF3:
+			if repIndex >= 0 {
+				inst.Prefix[repIndex] |= PrefixIgnored
+			}
+			repIndex = pos
+
+		// Group 2 - segment override / branch hints
+		case 0x26, 0x2E, 0x36, 0x3E:
+			if mode == 64 {
+				p |= PrefixIgnored
+				break
+			}
+			fallthrough
+		case 0x64, 0x65:
+			if segIndex >= 0 {
+				inst.Prefix[segIndex] |= PrefixIgnored
+			}
+			segIndex = pos
+
+		// Group 3 - operand size override
+		case 0x66:
+			if mode == 16 {
+				dataMode = 32
+				p = PrefixData32
+			} else {
+				dataMode = 16
+				p = PrefixData16
+			}
+			if dataSizeIndex >= 0 {
+				inst.Prefix[dataSizeIndex] |= PrefixIgnored
+			}
+			dataSizeIndex = pos
+
+		// Group 4 - address size override
+		case 0x67:
+			if mode == 32 {
+				addrMode = 16
+				p = PrefixAddr16
+			} else {
+				addrMode = 32
+				p = PrefixAddr32
+			}
+			if addrSizeIndex >= 0 {
+				inst.Prefix[addrSizeIndex] |= PrefixIgnored
+			}
+			addrSizeIndex = pos
+
+		//Group 5 - Vex encoding
+		case 0xC5:
+			if pos == 0 && pos+1 < len(src) && (mode == 64 || (mode == 32 && src[pos+1]&0xc0 == 0xc0)) {
+				vex = p
+				vexIndex = pos
+				inst.Prefix[pos] = p
+				inst.Prefix[pos+1] = Prefix(src[pos+1])
+				pos += 1
+				continue
+			} else {
+				nprefix = pos
+				break ReadPrefixes
+			}
+		case 0xC4:
+			if pos == 0 && pos+2 < len(src) && (mode == 64 || (mode == 32 && src[pos+1]&0xc0 == 0xc0)) {
+				vex = p
+				vexIndex = pos
+				inst.Prefix[pos] = p
+				inst.Prefix[pos+1] = Prefix(src[pos+1])
+				inst.Prefix[pos+2] = Prefix(src[pos+2])
+				pos += 2
+				continue
+			} else {
+				nprefix = pos
+				break ReadPrefixes
+			}
+		}
+
+		if pos >= len(inst.Prefix) {
+			return instPrefix(src[0], mode) // too long
+		}
+
+		inst.Prefix[pos] = p
+	}
+
+	// Read REX prefix.
+	if pos < len(src) && mode == 64 && Prefix(src[pos]).IsREX() && vex == 0 {
+		rex = Prefix(src[pos])
+		rexIndex = pos
+		if pos >= len(inst.Prefix) {
+			return instPrefix(src[0], mode) // too long
+		}
+		inst.Prefix[pos] = rex
+		pos++
+		if rex&PrefixREXW != 0 {
+			dataMode = 64
+			if dataSizeIndex >= 0 {
+				inst.Prefix[dataSizeIndex] |= PrefixIgnored
+			}
+		}
+	}
+
+	// Decode instruction stream, interpreting decoding instructions.
+	// opshift gives the shift to use when saving the next
+	// opcode byte into inst.Opcode.
+	opshift = 24
+
+	// Decode loop, executing decoder program.
+	var oldPC, prevPC int
+Decode:
+	for pc := 1; ; { // TODO uint
+		oldPC = prevPC
+		prevPC = pc
+		if trace {
+			println("run", pc)
+		}
+		x := decoder[pc]
+		if decoderCover != nil {
+			decoderCover[pc] = true
+		}
+		pc++
+
+		// Read and decode ModR/M if needed by opcode.
+		switch decodeOp(x) {
+		case xCondSlashR, xReadSlashR:
+			if haveModrm {
+				return Inst{Len: pos}, errInternal
+			}
+			haveModrm = true
+			if pos >= len(src) {
+				return truncated(src, mode)
+			}
+			modrm = int(src[pos])
+			pos++
+			if opshift >= 0 {
+				inst.Opcode |= uint32(modrm) << uint(opshift)
+				opshift -= 8
+			}
+			mod = modrm >> 6
+			regop = (modrm >> 3) & 07
+			rm = modrm & 07
+			if rex&PrefixREXR != 0 {
+				rexUsed |= PrefixREXR
+				regop |= 8
+			}
+			if addrMode == 16 {
+				// 16-bit modrm form
+				if mod != 3 {
+					haveMem = true
+					mem = addr16[rm]
+					if rm == 6 && mod == 0 {
+						mem.Base = 0
+					}
+
+					// Consume disp16 if present.
+					if mod == 0 && rm == 6 || mod == 2 {
+						if pos+2 > len(src) {
+							return truncated(src, mode)
+						}
+						mem.Disp = int64(binary.LittleEndian.Uint16(src[pos:]))
+						pos += 2
+					}
+
+					// Consume disp8 if present.
+					if mod == 1 {
+						if pos >= len(src) {
+							return truncated(src, mode)
+						}
+						mem.Disp = int64(int8(src[pos]))
+						pos++
+					}
+				}
+			} else {
+				haveMem = mod != 3
+
+				// 32-bit or 64-bit form
+				// Consume SIB encoding if present.
+				if rm == 4 && mod != 3 {
+					haveSIB = true
+					if pos >= len(src) {
+						return truncated(src, mode)
+					}
+					sib = int(src[pos])
+					pos++
+					if opshift >= 0 {
+						inst.Opcode |= uint32(sib) << uint(opshift)
+						opshift -= 8
+					}
+					scale = sib >> 6
+					index = (sib >> 3) & 07
+					base = sib & 07
+					if rex&PrefixREXB != 0 || vex == 0xC4 && inst.Prefix[vexIndex+1]&0x20 == 0 {
+						rexUsed |= PrefixREXB
+						base |= 8
+					}
+					if rex&PrefixREXX != 0 || vex == 0xC4 && inst.Prefix[vexIndex+1]&0x40 == 0 {
+						rexUsed |= PrefixREXX
+						index |= 8
+					}
+
+					mem.Scale = 1 << uint(scale)
+					if index == 4 {
+						// no mem.Index
+					} else {
+						mem.Index = baseRegForBits(addrMode) + Reg(index)
+					}
+					if base&7 == 5 && mod == 0 {
+						// no mem.Base
+					} else {
+						mem.Base = baseRegForBits(addrMode) + Reg(base)
+					}
+				} else {
+					if rex&PrefixREXB != 0 {
+						rexUsed |= PrefixREXB
+						rm |= 8
+					}
+					if mod == 0 && rm&7 == 5 || rm&7 == 4 {
+						// base omitted
+					} else if mod != 3 {
+						mem.Base = baseRegForBits(addrMode) + Reg(rm)
+					}
+				}
+
+				// Consume disp32 if present.
+				if mod == 0 && (rm&7 == 5 || haveSIB && base&7 == 5) || mod == 2 {
+					if pos+4 > len(src) {
+						return truncated(src, mode)
+					}
+					dispoff = pos
+					displen = 4
+					mem.Disp = int64(binary.LittleEndian.Uint32(src[pos:]))
+					pos += 4
+				}
+
+				// Consume disp8 if present.
+				if mod == 1 {
+					if pos >= len(src) {
+						return truncated(src, mode)
+					}
+					dispoff = pos
+					displen = 1
+					mem.Disp = int64(int8(src[pos]))
+					pos++
+				}
+
+				// In 64-bit, mod=0 rm=5 is PC-relative instead of just disp.
+				// See Vol 2A. Table 2-7.
+				if mode == 64 && mod == 0 && rm&7 == 5 {
+					if addrMode == 32 {
+						mem.Base = EIP
+					} else {
+						mem.Base = RIP
+					}
+				}
+			}
+
+			if segIndex >= 0 {
+				mem.Segment = prefixToSegment(inst.Prefix[segIndex])
+			}
+		}
+
+		// Execute single opcode.
+		switch decodeOp(x) {
+		default:
+			println("bad op", x, "at", pc-1, "from", oldPC)
+			return Inst{Len: pos}, errInternal
+
+		case xFail:
+			inst.Op = 0
+			break Decode
+
+		case xMatch:
+			break Decode
+
+		case xJump:
+			pc = int(decoder[pc])
+
+		// Conditional branches.
+
+		case xCondByte:
+			if pos >= len(src) {
+				return truncated(src, mode)
+			}
+			b := src[pos]
+			n := int(decoder[pc])
+			pc++
+			for i := 0; i < n; i++ {
+				xb, xpc := decoder[pc], int(decoder[pc+1])
+				pc += 2
+				if b == byte(xb) {
+					pc = xpc
+					pos++
+					if opshift >= 0 {
+						inst.Opcode |= uint32(b) << uint(opshift)
+						opshift -= 8
+					}
+					continue Decode
+				}
+			}
+			// xCondByte is the only conditional with a fall through,
+			// so that it can be used to pick off special cases before
+			// an xCondSlash. If the fallthrough instruction is xFail,
+			// advance the position so that the decoded instruction
+			// size includes the byte we just compared against.
+			if decodeOp(decoder[pc]) == xJump {
+				pc = int(decoder[pc+1])
+			}
+			if decodeOp(decoder[pc]) == xFail {
+				pos++
+			}
+
+		case xCondIs64:
+			if mode == 64 {
+				pc = int(decoder[pc+1])
+			} else {
+				pc = int(decoder[pc])
+			}
+
+		case xCondIsMem:
+			mem := haveMem
+			if !haveModrm {
+				if pos >= len(src) {
+					return instPrefix(src[0], mode) // too long
+				}
+				mem = src[pos]>>6 != 3
+			}
+			if mem {
+				pc = int(decoder[pc+1])
+			} else {
+				pc = int(decoder[pc])
+			}
+
+		case xCondDataSize:
+			switch dataMode {
+			case 16:
+				if dataSizeIndex >= 0 {
+					inst.Prefix[dataSizeIndex] |= PrefixImplicit
+				}
+				pc = int(decoder[pc])
+			case 32:
+				if dataSizeIndex >= 0 {
+					inst.Prefix[dataSizeIndex] |= PrefixImplicit
+				}
+				pc = int(decoder[pc+1])
+			case 64:
+				rexUsed |= PrefixREXW
+				pc = int(decoder[pc+2])
+			}
+
+		case xCondAddrSize:
+			switch addrMode {
+			case 16:
+				if addrSizeIndex >= 0 {
+					inst.Prefix[addrSizeIndex] |= PrefixImplicit
+				}
+				pc = int(decoder[pc])
+			case 32:
+				if addrSizeIndex >= 0 {
+					inst.Prefix[addrSizeIndex] |= PrefixImplicit
+				}
+				pc = int(decoder[pc+1])
+			case 64:
+				pc = int(decoder[pc+2])
+			}
+
+		case xCondPrefix:
+			// Conditional branch based on presence or absence of prefixes.
+			// The conflict cases here are completely undocumented and
+			// differ significantly between GNU libopcodes and Intel xed.
+			// I have not written assembly code to divine what various CPUs
+			// do, but it wouldn't surprise me if they are not consistent either.
+			//
+			// The basic idea is to switch on the presence of a prefix, so that
+			// for example:
+			//
+			//	xCondPrefix, 4
+			//	0xF3, 123,
+			//	0xF2, 234,
+			//	0x66, 345,
+			//	0, 456
+			//
+			// branch to 123 if the F3 prefix is present, 234 if the F2 prefix
+			// is present, 66 if the 345 prefix is present, and 456 otherwise.
+			// The prefixes are given in descending order so that the 0 will be last.
+			//
+			// It is unclear what should happen if multiple conditions are
+			// satisfied: what if F2 and F3 are both present, or if 66 and F2
+			// are present, or if all three are present? The one chosen becomes
+			// part of the opcode and the others do not. Perhaps the answer
+			// depends on the specific opcodes in question.
+			//
+			// The only clear example is that CRC32 is F2 0F 38 F1 /r, and
+			// it comes in 16-bit and 32-bit forms based on the 66 prefix,
+			// so 66 F2 0F 38 F1 /r should be treated as F2 taking priority,
+			// with the 66 being only an operand size override, and probably
+			// F2 66 0F 38 F1 /r should be treated the same.
+			// Perhaps that rule is specific to the case of CRC32, since no
+			// 66 0F 38 F1 instruction is defined (today) (that we know of).
+			// However, both libopcodes and xed seem to generalize this
+			// example and choose F2/F3 in preference to 66, and we
+			// do the same.
+			//
+			// Next, what if both F2 and F3 are present? Which wins?
+			// The Intel xed rule, and ours, is that the one that occurs last wins.
+			// The GNU libopcodes rule, which we implement only in gnuCompat mode,
+			// is that F3 beats F2 unless F3 has no special meaning, in which
+			// case F3 can be a modified on an F2 special meaning.
+			//
+			// Concretely,
+			//	66 0F D6 /r is MOVQ
+			//	F2 0F D6 /r is MOVDQ2Q
+			//	F3 0F D6 /r is MOVQ2DQ.
+			//
+			//	F2 66 0F D6 /r is 66 + MOVDQ2Q always.
+			//	66 F2 0F D6 /r is 66 + MOVDQ2Q always.
+			//	F3 66 0F D6 /r is 66 + MOVQ2DQ always.
+			//	66 F3 0F D6 /r is 66 + MOVQ2DQ always.
+			//	F2 F3 0F D6 /r is F2 + MOVQ2DQ always.
+			//	F3 F2 0F D6 /r is F3 + MOVQ2DQ in Intel xed, but F2 + MOVQ2DQ in GNU libopcodes.
+			//	Adding 66 anywhere in the prefix section of the
+			//	last two cases does not change the outcome.
+			//
+			// Finally, what if there is a variant in which 66 is a mandatory
+			// prefix rather than an operand size override, but we know of
+			// no corresponding F2/F3 form, and we see both F2/F3 and 66.
+			// Does F2/F3 still take priority, so that the result is an unknown
+			// instruction, or does the 66 take priority, so that the extended
+			// 66 instruction should be interpreted as having a REP/REPN prefix?
+			// Intel xed does the former and GNU libopcodes does the latter.
+			// We side with Intel xed, unless we are trying to match libopcodes
+			// more closely during the comparison-based test suite.
+			//
+			// In 64-bit mode REX.W is another valid prefix to test for, but
+			// there is less ambiguity about that. When present, REX.W is
+			// always the first entry in the table.
+			n := int(decoder[pc])
+			pc++
+			sawF3 := false
+			for j := 0; j < n; j++ {
+				prefix := Prefix(decoder[pc+2*j])
+				if prefix.IsREX() {
+					rexUsed |= prefix
+					if rex&prefix == prefix {
+						pc = int(decoder[pc+2*j+1])
+						continue Decode
+					}
+					continue
+				}
+				ok := false
+				if prefix == 0 {
+					ok = true
+				} else if prefix.IsREX() {
+					rexUsed |= prefix
+					if rex&prefix == prefix {
+						ok = true
+					}
+				} else if prefix == 0xC5 || prefix == 0xC4 {
+					if vex == prefix {
+						ok = true
+					}
+				} else if vex != 0 && (prefix == 0x0F || prefix == 0x0F38 || prefix == 0x0F3A ||
+					prefix == 0x66 || prefix == 0xF2 || prefix == 0xF3) {
+					var vexM, vexP Prefix
+					if vex == 0xC5 {
+						vexM = 1 // 2 byte vex always implies 0F
+						vexP = inst.Prefix[vexIndex+1]
+					} else {
+						vexM = inst.Prefix[vexIndex+1]
+						vexP = inst.Prefix[vexIndex+2]
+					}
+					switch prefix {
+					case 0x66:
+						ok = vexP&3 == 1
+					case 0xF3:
+						ok = vexP&3 == 2
+					case 0xF2:
+						ok = vexP&3 == 3
+					case 0x0F:
+						ok = vexM&3 == 1
+					case 0x0F38:
+						ok = vexM&3 == 2
+					case 0x0F3A:
+						ok = vexM&3 == 3
+					}
+				} else {
+					if prefix == 0xF3 {
+						sawF3 = true
+					}
+					switch prefix {
+					case PrefixLOCK:
+						if lockIndex >= 0 {
+							inst.Prefix[lockIndex] |= PrefixImplicit
+							ok = true
+						}
+					case PrefixREP, PrefixREPN:
+						if repIndex >= 0 && inst.Prefix[repIndex]&0xFF == prefix {
+							inst.Prefix[repIndex] |= PrefixImplicit
+							ok = true
+						}
+						if gnuCompat && !ok && prefix == 0xF3 && repIndex >= 0 && (j+1 >= n || decoder[pc+2*(j+1)] != 0xF2) {
+							// Check to see if earlier prefix F3 is present.
+							for i := repIndex - 1; i >= 0; i-- {
+								if inst.Prefix[i]&0xFF == prefix {
+									inst.Prefix[i] |= PrefixImplicit
+									ok = true
+								}
+							}
+						}
+						if gnuCompat && !ok && prefix == 0xF2 && repIndex >= 0 && !sawF3 && inst.Prefix[repIndex]&0xFF == 0xF3 {
+							// Check to see if earlier prefix F2 is present.
+							for i := repIndex - 1; i >= 0; i-- {
+								if inst.Prefix[i]&0xFF == prefix {
+									inst.Prefix[i] |= PrefixImplicit
+									ok = true
+								}
+							}
+						}
+					case PrefixCS, PrefixDS, PrefixES, PrefixFS, PrefixGS, PrefixSS:
+						if segIndex >= 0 && inst.Prefix[segIndex]&0xFF == prefix {
+							inst.Prefix[segIndex] |= PrefixImplicit
+							ok = true
+						}
+					case PrefixDataSize:
+						// Looking for 66 mandatory prefix.
+						// The F2/F3 mandatory prefixes take priority when both are present.
+						// If we got this far in the xCondPrefix table and an F2/F3 is present,
+						// it means the table didn't have any entry for that prefix. But if 66 has
+						// special meaning, perhaps F2/F3 have special meaning that we don't know.
+						// Intel xed works this way, treating the F2/F3 as inhibiting the 66.
+						// GNU libopcodes allows the 66 to match. We do what Intel xed does
+						// except in gnuCompat mode.
+						if repIndex >= 0 && !gnuCompat {
+							inst.Op = 0
+							break Decode
+						}
+						if dataSizeIndex >= 0 {
+							inst.Prefix[dataSizeIndex] |= PrefixImplicit
+							ok = true
+						}
+					case PrefixAddrSize:
+						if addrSizeIndex >= 0 {
+							inst.Prefix[addrSizeIndex] |= PrefixImplicit
+							ok = true
+						}
+					}
+				}
+				if ok {
+					pc = int(decoder[pc+2*j+1])
+					continue Decode
+				}
+			}
+			inst.Op = 0
+			break Decode
+
+		case xCondSlashR:
+			pc = int(decoder[pc+regop&7])
+
+		// Input.
+
+		case xReadSlashR:
+			// done above
+
+		case xReadIb:
+			if pos >= len(src) {
+				return truncated(src, mode)
+			}
+			imm8 = int8(src[pos])
+			pos++
+
+		case xReadIw:
+			if pos+2 > len(src) {
+				return truncated(src, mode)
+			}
+			imm = int64(binary.LittleEndian.Uint16(src[pos:]))
+			pos += 2
+
+		case xReadId:
+			if pos+4 > len(src) {
+				return truncated(src, mode)
+			}
+			imm = int64(binary.LittleEndian.Uint32(src[pos:]))
+			pos += 4
+
+		case xReadIo:
+			if pos+8 > len(src) {
+				return truncated(src, mode)
+			}
+			imm = int64(binary.LittleEndian.Uint64(src[pos:]))
+			pos += 8
+
+		case xReadCb:
+			if pos >= len(src) {
+				return truncated(src, mode)
+			}
+			immcpos = pos
+			immc = int64(src[pos])
+			pos++
+
+		case xReadCw:
+			if pos+2 > len(src) {
+				return truncated(src, mode)
+			}
+			immcpos = pos
+			immc = int64(binary.LittleEndian.Uint16(src[pos:]))
+			pos += 2
+
+		case xReadCm:
+			immcpos = pos
+			if addrMode == 16 {
+				if pos+2 > len(src) {
+					return truncated(src, mode)
+				}
+				immc = int64(binary.LittleEndian.Uint16(src[pos:]))
+				pos += 2
+			} else if addrMode == 32 {
+				if pos+4 > len(src) {
+					return truncated(src, mode)
+				}
+				immc = int64(binary.LittleEndian.Uint32(src[pos:]))
+				pos += 4
+			} else {
+				if pos+8 > len(src) {
+					return truncated(src, mode)
+				}
+				immc = int64(binary.LittleEndian.Uint64(src[pos:]))
+				pos += 8
+			}
+		case xReadCd:
+			immcpos = pos
+			if pos+4 > len(src) {
+				return truncated(src, mode)
+			}
+			immc = int64(binary.LittleEndian.Uint32(src[pos:]))
+			pos += 4
+
+		case xReadCp:
+			immcpos = pos
+			if pos+6 > len(src) {
+				return truncated(src, mode)
+			}
+			w := binary.LittleEndian.Uint32(src[pos:])
+			w2 := binary.LittleEndian.Uint16(src[pos+4:])
+			immc = int64(w2)<<32 | int64(w)
+			pos += 6
+
+		// Output.
+
+		case xSetOp:
+			inst.Op = Op(decoder[pc])
+			pc++
+
+		case xArg1,
+			xArg3,
+			xArgAL,
+			xArgAX,
+			xArgCL,
+			xArgCS,
+			xArgDS,
+			xArgDX,
+			xArgEAX,
+			xArgEDX,
+			xArgES,
+			xArgFS,
+			xArgGS,
+			xArgRAX,
+			xArgRDX,
+			xArgSS,
+			xArgST,
+			xArgXMM0:
+			inst.Args[narg] = fixedArg[x]
+			narg++
+
+		case xArgImm8:
+			inst.Args[narg] = Imm(imm8)
+			narg++
+
+		case xArgImm8u:
+			inst.Args[narg] = Imm(uint8(imm8))
+			narg++
+
+		case xArgImm16:
+			inst.Args[narg] = Imm(int16(imm))
+			narg++
+
+		case xArgImm16u:
+			inst.Args[narg] = Imm(uint16(imm))
+			narg++
+
+		case xArgImm32:
+			inst.Args[narg] = Imm(int32(imm))
+			narg++
+
+		case xArgImm64:
+			inst.Args[narg] = Imm(imm)
+			narg++
+
+		case xArgM,
+			xArgM128,
+			xArgM256,
+			xArgM1428byte,
+			xArgM16,
+			xArgM16and16,
+			xArgM16and32,
+			xArgM16and64,
+			xArgM16colon16,
+			xArgM16colon32,
+			xArgM16colon64,
+			xArgM16int,
+			xArgM2byte,
+			xArgM32,
+			xArgM32and32,
+			xArgM32fp,
+			xArgM32int,
+			xArgM512byte,
+			xArgM64,
+			xArgM64fp,
+			xArgM64int,
+			xArgM8,
+			xArgM80bcd,
+			xArgM80dec,
+			xArgM80fp,
+			xArgM94108byte,
+			xArgMem:
+			if !haveMem {
+				inst.Op = 0
+				break Decode
+			}
+			inst.Args[narg] = mem
+			inst.MemBytes = int(memBytes[decodeOp(x)])
+			if mem.Base == RIP {
+				inst.PCRel = displen
+				inst.PCRelOff = dispoff
+			}
+			narg++
+
+		case xArgPtr16colon16:
+			inst.Args[narg] = Imm(immc >> 16)
+			inst.Args[narg+1] = Imm(immc & (1<<16 - 1))
+			narg += 2
+
+		case xArgPtr16colon32:
+			inst.Args[narg] = Imm(immc >> 32)
+			inst.Args[narg+1] = Imm(immc & (1<<32 - 1))
+			narg += 2
+
+		case xArgMoffs8, xArgMoffs16, xArgMoffs32, xArgMoffs64:
+			// TODO(rsc): Can address be 64 bits?
+			mem = Mem{Disp: int64(immc)}
+			if segIndex >= 0 {
+				mem.Segment = prefixToSegment(inst.Prefix[segIndex])
+				inst.Prefix[segIndex] |= PrefixImplicit
+			}
+			inst.Args[narg] = mem
+			inst.MemBytes = int(memBytes[decodeOp(x)])
+			if mem.Base == RIP {
+				inst.PCRel = displen
+				inst.PCRelOff = dispoff
+			}
+			narg++
+
+		case xArgYmm1:
+			base := baseReg[x]
+			index := Reg(regop)
+			if inst.Prefix[vexIndex+1]&0x80 == 0 {
+				index += 8
+			}
+			inst.Args[narg] = base + index
+			narg++
+
+		case xArgR8, xArgR16, xArgR32, xArgR64, xArgXmm, xArgXmm1, xArgDR0dashDR7:
+			base := baseReg[x]
+			index := Reg(regop)
+			if rex != 0 && base == AL && index >= 4 {
+				rexUsed |= PrefixREX
+				index -= 4
+				base = SPB
+			}
+			inst.Args[narg] = base + index
+			narg++
+
+		case xArgMm, xArgMm1, xArgTR0dashTR7:
+			inst.Args[narg] = baseReg[x] + Reg(regop&7)
+			narg++
+
+		case xArgCR0dashCR7:
+			// AMD documents an extension that the LOCK prefix
+			// can be used in place of a REX prefix in order to access
+			// CR8 from 32-bit mode. The LOCK prefix is allowed in
+			// all modes, provided the corresponding CPUID bit is set.
+			if lockIndex >= 0 {
+				inst.Prefix[lockIndex] |= PrefixImplicit
+				regop += 8
+			}
+			inst.Args[narg] = CR0 + Reg(regop)
+			narg++
+
+		case xArgSreg:
+			regop &= 7
+			if regop >= 6 {
+				inst.Op = 0
+				break Decode
+			}
+			inst.Args[narg] = ES + Reg(regop)
+			narg++
+
+		case xArgRmf16, xArgRmf32, xArgRmf64:
+			base := baseReg[x]
+			index := Reg(modrm & 07)
+			if rex&PrefixREXB != 0 {
+				rexUsed |= PrefixREXB
+				index += 8
+			}
+			inst.Args[narg] = base + index
+			narg++
+
+		case xArgR8op, xArgR16op, xArgR32op, xArgR64op, xArgSTi:
+			n := inst.Opcode >> uint(opshift+8) & 07
+			base := baseReg[x]
+			index := Reg(n)
+			if rex&PrefixREXB != 0 && decodeOp(x) != xArgSTi {
+				rexUsed |= PrefixREXB
+				index += 8
+			}
+			if rex != 0 && base == AL && index >= 4 {
+				rexUsed |= PrefixREX
+				index -= 4
+				base = SPB
+			}
+			inst.Args[narg] = base + index
+			narg++
+		case xArgRM8, xArgRM16, xArgRM32, xArgRM64, xArgR32M16, xArgR32M8, xArgR64M16,
+			xArgMmM32, xArgMmM64, xArgMm2M64,
+			xArgXmm2M16, xArgXmm2M32, xArgXmm2M64, xArgXmmM64, xArgXmmM128, xArgXmmM32, xArgXmm2M128,
+			xArgYmm2M256:
+			if haveMem {
+				inst.Args[narg] = mem
+				inst.MemBytes = int(memBytes[decodeOp(x)])
+				if mem.Base == RIP {
+					inst.PCRel = displen
+					inst.PCRelOff = dispoff
+				}
+			} else {
+				base := baseReg[x]
+				index := Reg(rm)
+				switch decodeOp(x) {
+				case xArgMmM32, xArgMmM64, xArgMm2M64:
+					// There are only 8 MMX registers, so these ignore the REX.X bit.
+					index &= 7
+				case xArgRM8:
+					if rex != 0 && index >= 4 {
+						rexUsed |= PrefixREX
+						index -= 4
+						base = SPB
+					}
+				case xArgYmm2M256:
+					if vex == 0xC4 && inst.Prefix[vexIndex+1]&0x40 == 0x40 {
+						index += 8
+					}
+				}
+				inst.Args[narg] = base + index
+			}
+			narg++
+
+		case xArgMm2: // register only; TODO(rsc): Handle with tag modrm_regonly tag
+			if haveMem {
+				inst.Op = 0
+				break Decode
+			}
+			inst.Args[narg] = baseReg[x] + Reg(rm&7)
+			narg++
+
+		case xArgXmm2: // register only; TODO(rsc): Handle with tag modrm_regonly tag
+			if haveMem {
+				inst.Op = 0
+				break Decode
+			}
+			inst.Args[narg] = baseReg[x] + Reg(rm)
+			narg++
+
+		case xArgRel8:
+			inst.PCRelOff = immcpos
+			inst.PCRel = 1
+			inst.Args[narg] = Rel(int8(immc))
+			narg++
+
+		case xArgRel16:
+			inst.PCRelOff = immcpos
+			inst.PCRel = 2
+			inst.Args[narg] = Rel(int16(immc))
+			narg++
+
+		case xArgRel32:
+			inst.PCRelOff = immcpos
+			inst.PCRel = 4
+			inst.Args[narg] = Rel(int32(immc))
+			narg++
+		}
+	}
+
+	if inst.Op == 0 {
+		// Invalid instruction.
+		if nprefix > 0 {
+			return instPrefix(src[0], mode) // invalid instruction
+		}
+		return Inst{Len: pos}, ErrUnrecognized
+	}
+
+	// Matched! Hooray!
+
+	// 90 decodes as XCHG EAX, EAX but is NOP.
+	// 66 90 decodes as XCHG AX, AX and is NOP too.
+	// 48 90 decodes as XCHG RAX, RAX and is NOP too.
+	// 43 90 decodes as XCHG R8D, EAX and is *not* NOP.
+	// F3 90 decodes as REP XCHG EAX, EAX but is PAUSE.
+	// It's all too special to handle in the decoding tables, at least for now.
+	if inst.Op == XCHG && inst.Opcode>>24 == 0x90 {
+		if inst.Args[0] == RAX || inst.Args[0] == EAX || inst.Args[0] == AX {
+			inst.Op = NOP
+			if dataSizeIndex >= 0 {
+				inst.Prefix[dataSizeIndex] &^= PrefixImplicit
+			}
+			inst.Args[0] = nil
+			inst.Args[1] = nil
+		}
+		if repIndex >= 0 && inst.Prefix[repIndex] == 0xF3 {
+			inst.Prefix[repIndex] |= PrefixImplicit
+			inst.Op = PAUSE
+			inst.Args[0] = nil
+			inst.Args[1] = nil
+		} else if gnuCompat {
+			for i := nprefix - 1; i >= 0; i-- {
+				if inst.Prefix[i]&0xFF == 0xF3 {
+					inst.Prefix[i] |= PrefixImplicit
+					inst.Op = PAUSE
+					inst.Args[0] = nil
+					inst.Args[1] = nil
+					break
+				}
+			}
+		}
+	}
+
+	// defaultSeg returns the default segment for an implicit
+	// memory reference: the final override if present, or else DS.
+	defaultSeg := func() Reg {
+		if segIndex >= 0 {
+			inst.Prefix[segIndex] |= PrefixImplicit
+			return prefixToSegment(inst.Prefix[segIndex])
+		}
+		return DS
+	}
+
+	// Add implicit arguments not present in the tables.
+	// Normally we shy away from making implicit arguments explicit,
+	// following the Intel manuals, but adding the arguments seems
+	// the best way to express the effect of the segment override prefixes.
+	// TODO(rsc): Perhaps add these to the tables and
+	// create bytecode instructions for them.
+	usedAddrSize := false
+	switch inst.Op {
+	case INSB, INSW, INSD:
+		inst.Args[0] = Mem{Segment: ES, Base: baseRegForBits(addrMode) + DI - AX}
+		inst.Args[1] = DX
+		usedAddrSize = true
+
+	case OUTSB, OUTSW, OUTSD:
+		inst.Args[0] = DX
+		inst.Args[1] = Mem{Segment: defaultSeg(), Base: baseRegForBits(addrMode) + SI - AX}
+		usedAddrSize = true
+
+	case MOVSB, MOVSW, MOVSD, MOVSQ:
+		inst.Args[0] = Mem{Segment: ES, Base: baseRegForBits(addrMode) + DI - AX}
+		inst.Args[1] = Mem{Segment: defaultSeg(), Base: baseRegForBits(addrMode) + SI - AX}
+		usedAddrSize = true
+
+	case CMPSB, CMPSW, CMPSD, CMPSQ:
+		inst.Args[0] = Mem{Segment: defaultSeg(), Base: baseRegForBits(addrMode) + SI - AX}
+		inst.Args[1] = Mem{Segment: ES, Base: baseRegForBits(addrMode) + DI - AX}
+		usedAddrSize = true
+
+	case LODSB, LODSW, LODSD, LODSQ:
+		switch inst.Op {
+		case LODSB:
+			inst.Args[0] = AL
+		case LODSW:
+			inst.Args[0] = AX
+		case LODSD:
+			inst.Args[0] = EAX
+		case LODSQ:
+			inst.Args[0] = RAX
+		}
+		inst.Args[1] = Mem{Segment: defaultSeg(), Base: baseRegForBits(addrMode) + SI - AX}
+		usedAddrSize = true
+
+	case STOSB, STOSW, STOSD, STOSQ:
+		inst.Args[0] = Mem{Segment: ES, Base: baseRegForBits(addrMode) + DI - AX}
+		switch inst.Op {
+		case STOSB:
+			inst.Args[1] = AL
+		case STOSW:
+			inst.Args[1] = AX
+		case STOSD:
+			inst.Args[1] = EAX
+		case STOSQ:
+			inst.Args[1] = RAX
+		}
+		usedAddrSize = true
+
+	case SCASB, SCASW, SCASD, SCASQ:
+		inst.Args[1] = Mem{Segment: ES, Base: baseRegForBits(addrMode) + DI - AX}
+		switch inst.Op {
+		case SCASB:
+			inst.Args[0] = AL
+		case SCASW:
+			inst.Args[0] = AX
+		case SCASD:
+			inst.Args[0] = EAX
+		case SCASQ:
+			inst.Args[0] = RAX
+		}
+		usedAddrSize = true
+
+	case XLATB:
+		inst.Args[0] = Mem{Segment: defaultSeg(), Base: baseRegForBits(addrMode) + BX - AX}
+		usedAddrSize = true
+	}
+
+	// If we used the address size annotation to construct the
+	// argument list, mark that prefix as implicit: it doesn't need
+	// to be shown when printing the instruction.
+	if haveMem || usedAddrSize {
+		if addrSizeIndex >= 0 {
+			inst.Prefix[addrSizeIndex] |= PrefixImplicit
+		}
+	}
+
+	// Similarly, if there's some memory operand, the segment
+	// will be shown there and doesn't need to be shown as an
+	// explicit prefix.
+	if haveMem {
+		if segIndex >= 0 {
+			inst.Prefix[segIndex] |= PrefixImplicit
+		}
+	}
+
+	// Branch predict prefixes are overloaded segment prefixes,
+	// since segment prefixes don't make sense on conditional jumps.
+	// Rewrite final instance to prediction prefix.
+	// The set of instructions to which the prefixes apply (other then the
+	// Jcc conditional jumps) is not 100% clear from the manuals, but
+	// the disassemblers seem to agree about the LOOP and JCXZ instructions,
+	// so we'll follow along.
+	// TODO(rsc): Perhaps this instruction class should be derived from the CSV.
+	if isCondJmp[inst.Op] || isLoop[inst.Op] || inst.Op == JCXZ || inst.Op == JECXZ || inst.Op == JRCXZ {
+	PredictLoop:
+		for i := nprefix - 1; i >= 0; i-- {
+			p := inst.Prefix[i]
+			switch p & 0xFF {
+			case PrefixCS:
+				inst.Prefix[i] = PrefixPN
+				break PredictLoop
+			case PrefixDS:
+				inst.Prefix[i] = PrefixPT
+				break PredictLoop
+			}
+		}
+	}
+
+	// The BND prefix is part of the Intel Memory Protection Extensions (MPX).
+	// A REPN applied to certain control transfers is a BND prefix to bound
+	// the range of possible destinations. There's surprisingly little documentation
+	// about this, so we just do what libopcodes and xed agree on.
+	// In particular, it's unclear why a REPN applied to LOOP or JCXZ instructions
+	// does not turn into a BND.
+	// TODO(rsc): Perhaps this instruction class should be derived from the CSV.
+	if isCondJmp[inst.Op] || inst.Op == JMP || inst.Op == CALL || inst.Op == RET {
+		for i := nprefix - 1; i >= 0; i-- {
+			p := inst.Prefix[i]
+			if p&^PrefixIgnored == PrefixREPN {
+				inst.Prefix[i] = PrefixBND
+				break
+			}
+		}
+	}
+
+	// The LOCK prefix only applies to certain instructions, and then only
+	// to instances of the instruction with a memory destination.
+	// Other uses of LOCK are invalid and cause a processor exception,
+	// in contrast to the "just ignore it" spirit applied to all other prefixes.
+	// Mark invalid lock prefixes.
+	hasLock := false
+	if lockIndex >= 0 && inst.Prefix[lockIndex]&PrefixImplicit == 0 {
+		switch inst.Op {
+		// TODO(rsc): Perhaps this instruction class should be derived from the CSV.
+		case ADD, ADC, AND, BTC, BTR, BTS, CMPXCHG, CMPXCHG8B, CMPXCHG16B, DEC, INC, NEG, NOT, OR, SBB, SUB, XOR, XADD, XCHG:
+			if isMem(inst.Args[0]) {
+				hasLock = true
+				break
+			}
+			fallthrough
+		default:
+			inst.Prefix[lockIndex] |= PrefixInvalid
+		}
+	}
+
+	// In certain cases, all of which require a memory destination,
+	// the REPN and REP prefixes are interpreted as XACQUIRE and XRELEASE
+	// from the Intel Transactional Synchroniation Extensions (TSX).
+	//
+	// The specific rules are:
+	// (1) Any instruction with a valid LOCK prefix can have XACQUIRE or XRELEASE.
+	// (2) Any XCHG, which always has an implicit LOCK, can have XACQUIRE or XRELEASE.
+	// (3) Any 0x88-, 0x89-, 0xC6-, or 0xC7-opcode MOV can have XRELEASE.
+	if isMem(inst.Args[0]) {
+		if inst.Op == XCHG {
+			hasLock = true
+		}
+
+		for i := len(inst.Prefix) - 1; i >= 0; i-- {
+			p := inst.Prefix[i] &^ PrefixIgnored
+			switch p {
+			case PrefixREPN:
+				if hasLock {
+					inst.Prefix[i] = inst.Prefix[i]&PrefixIgnored | PrefixXACQUIRE
+				}
+
+			case PrefixREP:
+				if hasLock {
+					inst.Prefix[i] = inst.Prefix[i]&PrefixIgnored | PrefixXRELEASE
+				}
+
+				if inst.Op == MOV {
+					op := (inst.Opcode >> 24) &^ 1
+					if op == 0x88 || op == 0xC6 {
+						inst.Prefix[i] = inst.Prefix[i]&PrefixIgnored | PrefixXRELEASE
+					}
+				}
+			}
+		}
+	}
+
+	// If REP is used on a non-REP-able instruction, mark the prefix as ignored.
+	if repIndex >= 0 {
+		switch inst.Prefix[repIndex] {
+		case PrefixREP, PrefixREPN:
+			switch inst.Op {
+			// According to the manuals, the REP/REPE prefix applies to all of these,
+			// while the REPN applies only to some of them. However, both libopcodes
+			// and xed show both prefixes explicitly for all instructions, so we do the same.
+			// TODO(rsc): Perhaps this instruction class should be derived from the CSV.
+			case INSB, INSW, INSD,
+				MOVSB, MOVSW, MOVSD, MOVSQ,
+				OUTSB, OUTSW, OUTSD,
+				LODSB, LODSW, LODSD, LODSQ,
+				CMPSB, CMPSW, CMPSD, CMPSQ,
+				SCASB, SCASW, SCASD, SCASQ,
+				STOSB, STOSW, STOSD, STOSQ:
+				// ok
+			default:
+				inst.Prefix[repIndex] |= PrefixIgnored
+			}
+		}
+	}
+
+	// If REX was present, mark implicit if all the 1 bits were consumed.
+	if rexIndex >= 0 {
+		if rexUsed != 0 {
+			rexUsed |= PrefixREX
+		}
+		if rex&^rexUsed == 0 {
+			inst.Prefix[rexIndex] |= PrefixImplicit
+		}
+	}
+
+	inst.DataSize = dataMode
+	inst.AddrSize = addrMode
+	inst.Mode = mode
+	inst.Len = pos
+	return inst, nil
+}
+
+var errInternal = errors.New("internal error")
+
+// addr16 records the eight 16-bit addressing modes.
+var addr16 = [8]Mem{
+	{Base: BX, Scale: 1, Index: SI},
+	{Base: BX, Scale: 1, Index: DI},
+	{Base: BP, Scale: 1, Index: SI},
+	{Base: BP, Scale: 1, Index: DI},
+	{Base: SI},
+	{Base: DI},
+	{Base: BP},
+	{Base: BX},
+}
+
+// baseReg returns the base register for a given register size in bits.
+func baseRegForBits(bits int) Reg {
+	switch bits {
+	case 8:
+		return AL
+	case 16:
+		return AX
+	case 32:
+		return EAX
+	case 64:
+		return RAX
+	}
+	return 0
+}
+
+// baseReg records the base register for argument types that specify
+// a range of registers indexed by op, regop, or rm.
+var baseReg = [...]Reg{
+	xArgDR0dashDR7: DR0,
+	xArgMm1:        M0,
+	xArgMm2:        M0,
+	xArgMm2M64:     M0,
+	xArgMm:         M0,
+	xArgMmM32:      M0,
+	xArgMmM64:      M0,
+	xArgR16:        AX,
+	xArgR16op:      AX,
+	xArgR32:        EAX,
+	xArgR32M16:     EAX,
+	xArgR32M8:      EAX,
+	xArgR32op:      EAX,
+	xArgR64:        RAX,
+	xArgR64M16:     RAX,
+	xArgR64op:      RAX,
+	xArgR8:         AL,
+	xArgR8op:       AL,
+	xArgRM16:       AX,
+	xArgRM32:       EAX,
+	xArgRM64:       RAX,
+	xArgRM8:        AL,
+	xArgRmf16:      AX,
+	xArgRmf32:      EAX,
+	xArgRmf64:      RAX,
+	xArgSTi:        F0,
+	xArgTR0dashTR7: TR0,
+	xArgXmm1:       X0,
+	xArgYmm1:       X0,
+	xArgXmm2:       X0,
+	xArgXmm2M128:   X0,
+	xArgYmm2M256:   X0,
+	xArgXmm2M16:    X0,
+	xArgXmm2M32:    X0,
+	xArgXmm2M64:    X0,
+	xArgXmm:        X0,
+	xArgXmmM128:    X0,
+	xArgXmmM32:     X0,
+	xArgXmmM64:     X0,
+}
+
+// prefixToSegment returns the segment register
+// corresponding to a particular segment prefix.
+func prefixToSegment(p Prefix) Reg {
+	switch p &^ PrefixImplicit {
+	case PrefixCS:
+		return CS
+	case PrefixDS:
+		return DS
+	case PrefixES:
+		return ES
+	case PrefixFS:
+		return FS
+	case PrefixGS:
+		return GS
+	case PrefixSS:
+		return SS
+	}
+	return 0
+}
+
+// fixedArg records the fixed arguments corresponding to the given bytecodes.
+var fixedArg = [...]Arg{
+	xArg1:    Imm(1),
+	xArg3:    Imm(3),
+	xArgAL:   AL,
+	xArgAX:   AX,
+	xArgDX:   DX,
+	xArgEAX:  EAX,
+	xArgEDX:  EDX,
+	xArgRAX:  RAX,
+	xArgRDX:  RDX,
+	xArgCL:   CL,
+	xArgCS:   CS,
+	xArgDS:   DS,
+	xArgES:   ES,
+	xArgFS:   FS,
+	xArgGS:   GS,
+	xArgSS:   SS,
+	xArgST:   F0,
+	xArgXMM0: X0,
+}
+
+// memBytes records the size of the memory pointed at
+// by a memory argument of the given form.
+var memBytes = [...]int8{
+	xArgM128:       128 / 8,
+	xArgM256:       256 / 8,
+	xArgM16:        16 / 8,
+	xArgM16and16:   (16 + 16) / 8,
+	xArgM16colon16: (16 + 16) / 8,
+	xArgM16colon32: (16 + 32) / 8,
+	xArgM16int:     16 / 8,
+	xArgM2byte:     2,
+	xArgM32:        32 / 8,
+	xArgM32and32:   (32 + 32) / 8,
+	xArgM32fp:      32 / 8,
+	xArgM32int:     32 / 8,
+	xArgM64:        64 / 8,
+	xArgM64fp:      64 / 8,
+	xArgM64int:     64 / 8,
+	xArgMm2M64:     64 / 8,
+	xArgMmM32:      32 / 8,
+	xArgMmM64:      64 / 8,
+	xArgMoffs16:    16 / 8,
+	xArgMoffs32:    32 / 8,
+	xArgMoffs64:    64 / 8,
+	xArgMoffs8:     8 / 8,
+	xArgR32M16:     16 / 8,
+	xArgR32M8:      8 / 8,
+	xArgR64M16:     16 / 8,
+	xArgRM16:       16 / 8,
+	xArgRM32:       32 / 8,
+	xArgRM64:       64 / 8,
+	xArgRM8:        8 / 8,
+	xArgXmm2M128:   128 / 8,
+	xArgYmm2M256:   256 / 8,
+	xArgXmm2M16:    16 / 8,
+	xArgXmm2M32:    32 / 8,
+	xArgXmm2M64:    64 / 8,
+	xArgXmm:        128 / 8,
+	xArgXmmM128:    128 / 8,
+	xArgXmmM32:     32 / 8,
+	xArgXmmM64:     64 / 8,
+}
+
+// isCondJmp records the conditional jumps.
+var isCondJmp = [maxOp + 1]bool{
+	JA:  true,
+	JAE: true,
+	JB:  true,
+	JBE: true,
+	JE:  true,
+	JG:  true,
+	JGE: true,
+	JL:  true,
+	JLE: true,
+	JNE: true,
+	JNO: true,
+	JNP: true,
+	JNS: true,
+	JO:  true,
+	JP:  true,
+	JS:  true,
+}
+
+// isLoop records the loop operators.
+var isLoop = [maxOp + 1]bool{
+	LOOP:   true,
+	LOOPE:  true,
+	LOOPNE: true,
+	JECXZ:  true,
+	JRCXZ:  true,
+}
diff --git a/vendor/golang.org/x/arch/x86/x86asm/gnu.go b/vendor/golang.org/x/arch/x86/x86asm/gnu.go
new file mode 100644
index 000000000..75cff72b0
--- /dev/null
+++ b/vendor/golang.org/x/arch/x86/x86asm/gnu.go
@@ -0,0 +1,956 @@
+// Copyright 2014 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package x86asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// GNUSyntax returns the GNU assembler syntax for the instruction, as defined by GNU binutils.
+// This general form is often called ``AT&T syntax'' as a reference to AT&T System V Unix.
+func GNUSyntax(inst Inst, pc uint64, symname SymLookup) string {
+	// Rewrite instruction to mimic GNU peculiarities.
+	// Note that inst has been passed by value and contains
+	// no pointers, so any changes we make here are local
+	// and will not propagate back out to the caller.
+
+	if symname == nil {
+		symname = func(uint64) (string, uint64) { return "", 0 }
+	}
+
+	// Adjust opcode [sic].
+	switch inst.Op {
+	case FDIV, FDIVR, FSUB, FSUBR, FDIVP, FDIVRP, FSUBP, FSUBRP:
+		// DC E0, DC F0: libopcodes swaps FSUBR/FSUB and FDIVR/FDIV, at least
+		// if you believe the Intel manual is correct (the encoding is irregular as given;
+		// libopcodes uses the more regular expected encoding).
+		// TODO(rsc): Test to ensure Intel manuals are correct and report to libopcodes maintainers?
+		// NOTE: iant thinks this is deliberate, but we can't find the history.
+		_, reg1 := inst.Args[0].(Reg)
+		_, reg2 := inst.Args[1].(Reg)
+		if reg1 && reg2 && (inst.Opcode>>24 == 0xDC || inst.Opcode>>24 == 0xDE) {
+			switch inst.Op {
+			case FDIV:
+				inst.Op = FDIVR
+			case FDIVR:
+				inst.Op = FDIV
+			case FSUB:
+				inst.Op = FSUBR
+			case FSUBR:
+				inst.Op = FSUB
+			case FDIVP:
+				inst.Op = FDIVRP
+			case FDIVRP:
+				inst.Op = FDIVP
+			case FSUBP:
+				inst.Op = FSUBRP
+			case FSUBRP:
+				inst.Op = FSUBP
+			}
+		}
+
+	case MOVNTSD:
+		// MOVNTSD is F2 0F 2B /r.
+		// MOVNTSS is F3 0F 2B /r (supposedly; not in manuals).
+		// Usually inner prefixes win for display,
+		// so that F3 F2 0F 2B 11 is REP MOVNTSD
+		// and F2 F3 0F 2B 11 is REPN MOVNTSS.
+		// Libopcodes always prefers MOVNTSS regardless of prefix order.
+		if countPrefix(&inst, 0xF3) > 0 {
+			found := false
+			for i := len(inst.Prefix) - 1; i >= 0; i-- {
+				switch inst.Prefix[i] & 0xFF {
+				case 0xF3:
+					if !found {
+						found = true
+						inst.Prefix[i] |= PrefixImplicit
+					}
+				case 0xF2:
+					inst.Prefix[i] &^= PrefixImplicit
+				}
+			}
+			inst.Op = MOVNTSS
+		}
+	}
+
+	// Add implicit arguments.
+	switch inst.Op {
+	case MONITOR:
+		inst.Args[0] = EDX
+		inst.Args[1] = ECX
+		inst.Args[2] = EAX
+		if inst.AddrSize == 16 {
+			inst.Args[2] = AX
+		}
+
+	case MWAIT:
+		if inst.Mode == 64 {
+			inst.Args[0] = RCX
+			inst.Args[1] = RAX
+		} else {
+			inst.Args[0] = ECX
+			inst.Args[1] = EAX
+		}
+	}
+
+	// Adjust which prefixes will be displayed.
+	// The rule is to display all the prefixes not implied by
+	// the usual instruction display, that is, all the prefixes
+	// except the ones with PrefixImplicit set.
+	// However, of course, there are exceptions to the rule.
+	switch inst.Op {
+	case CRC32:
+		// CRC32 has a mandatory F2 prefix.
+		// If there are multiple F2s and no F3s, the extra F2s do not print.
+		// (And Decode has already marked them implicit.)
+		// However, if there is an F3 anywhere, then the extra F2s do print.
+		// If there are multiple F2 prefixes *and* an (ignored) F3,
+		// then libopcodes prints the extra F2s as REPNs.
+		if countPrefix(&inst, 0xF2) > 1 {
+			unmarkImplicit(&inst, 0xF2)
+			markLastImplicit(&inst, 0xF2)
+		}
+
+		// An unused data size override should probably be shown,
+		// to distinguish DATA16 CRC32B from plain CRC32B,
+		// but libopcodes always treats the final override as implicit
+		// and the others as explicit.
+		unmarkImplicit(&inst, PrefixDataSize)
+		markLastImplicit(&inst, PrefixDataSize)
+
+	case CVTSI2SD, CVTSI2SS:
+		if !isMem(inst.Args[1]) {
+			markLastImplicit(&inst, PrefixDataSize)
+		}
+
+	case CVTSD2SI, CVTSS2SI, CVTTSD2SI, CVTTSS2SI,
+		ENTER, FLDENV, FNSAVE, FNSTENV, FRSTOR, LGDT, LIDT, LRET,
+		POP, PUSH, RET, SGDT, SIDT, SYSRET, XBEGIN:
+		markLastImplicit(&inst, PrefixDataSize)
+
+	case LOOP, LOOPE, LOOPNE, MONITOR:
+		markLastImplicit(&inst, PrefixAddrSize)
+
+	case MOV:
+		// The 16-bit and 32-bit forms of MOV Sreg, dst and MOV src, Sreg
+		// cannot be distinguished when src or dst refers to memory, because
+		// Sreg is always a 16-bit value, even when we're doing a 32-bit
+		// instruction. Because the instruction tables distinguished these two,
+		// any operand size prefix has been marked as used (to decide which
+		// branch to take). Unmark it, so that it will show up in disassembly,
+		// so that the reader can tell the size of memory operand.
+		// up with the same arguments
+		dst, _ := inst.Args[0].(Reg)
+		src, _ := inst.Args[1].(Reg)
+		if ES <= src && src <= GS && isMem(inst.Args[0]) || ES <= dst && dst <= GS && isMem(inst.Args[1]) {
+			unmarkImplicit(&inst, PrefixDataSize)
+		}
+
+	case MOVDQU:
+		if countPrefix(&inst, 0xF3) > 1 {
+			unmarkImplicit(&inst, 0xF3)
+			markLastImplicit(&inst, 0xF3)
+		}
+
+	case MOVQ2DQ:
+		markLastImplicit(&inst, PrefixDataSize)
+
+	case SLDT, SMSW, STR, FXRSTOR, XRSTOR, XSAVE, XSAVEOPT, CMPXCHG8B:
+		if isMem(inst.Args[0]) {
+			unmarkImplicit(&inst, PrefixDataSize)
+		}
+
+	case SYSEXIT:
+		unmarkImplicit(&inst, PrefixDataSize)
+	}
+
+	if isCondJmp[inst.Op] || isLoop[inst.Op] || inst.Op == JCXZ || inst.Op == JECXZ || inst.Op == JRCXZ {
+		if countPrefix(&inst, PrefixCS) > 0 && countPrefix(&inst, PrefixDS) > 0 {
+			for i, p := range inst.Prefix {
+				switch p & 0xFFF {
+				case PrefixPN, PrefixPT:
+					inst.Prefix[i] &= 0xF0FF // cut interpretation bits, producing original segment prefix
+				}
+			}
+		}
+	}
+
+	// XACQUIRE/XRELEASE adjustment.
+	if inst.Op == MOV {
+		// MOV into memory is a candidate for turning REP into XRELEASE.
+		// However, if the REP is followed by a REPN, that REPN blocks the
+		// conversion.
+		haveREPN := false
+		for i := len(inst.Prefix) - 1; i >= 0; i-- {
+			switch inst.Prefix[i] &^ PrefixIgnored {
+			case PrefixREPN:
+				haveREPN = true
+			case PrefixXRELEASE:
+				if haveREPN {
+					inst.Prefix[i] = PrefixREP
+				}
+			}
+		}
+	}
+
+	// We only format the final F2/F3 as XRELEASE/XACQUIRE.
+	haveXA := false
+	haveXR := false
+	for i := len(inst.Prefix) - 1; i >= 0; i-- {
+		switch inst.Prefix[i] &^ PrefixIgnored {
+		case PrefixXRELEASE:
+			if !haveXR {
+				haveXR = true
+			} else {
+				inst.Prefix[i] = PrefixREP
+			}
+
+		case PrefixXACQUIRE:
+			if !haveXA {
+				haveXA = true
+			} else {
+				inst.Prefix[i] = PrefixREPN
+			}
+		}
+	}
+
+	// Determine opcode.
+	op := strings.ToLower(inst.Op.String())
+	if alt := gnuOp[inst.Op]; alt != "" {
+		op = alt
+	}
+
+	// Determine opcode suffix.
+	// Libopcodes omits the suffix if the width of the operation
+	// can be inferred from a register arguments. For example,
+	// add $1, %ebx has no suffix because you can tell from the
+	// 32-bit register destination that it is a 32-bit add,
+	// but in addl $1, (%ebx), the destination is memory, so the
+	// size is not evident without the l suffix.
+	needSuffix := true
+SuffixLoop:
+	for i, a := range inst.Args {
+		if a == nil {
+			break
+		}
+		switch a := a.(type) {
+		case Reg:
+			switch inst.Op {
+			case MOVSX, MOVZX:
+				continue
+
+			case SHL, SHR, RCL, RCR, ROL, ROR, SAR:
+				if i == 1 {
+					// shift count does not tell us operand size
+					continue
+				}
+
+			case CRC32:
+				// The source argument does tell us operand size,
+				// but libopcodes still always puts a suffix on crc32.
+				continue
+
+			case PUSH, POP:
+				// Even though segment registers are 16-bit, push and pop
+				// can save/restore them from 32-bit slots, so they
+				// do not imply operand size.
+				if ES <= a && a <= GS {
+					continue
+				}
+
+			case CVTSI2SD, CVTSI2SS:
+				// The integer register argument takes priority.
+				if X0 <= a && a <= X15 {
+					continue
+				}
+			}
+
+			if AL <= a && a <= R15 || ES <= a && a <= GS || X0 <= a && a <= X15 || M0 <= a && a <= M7 {
+				needSuffix = false
+				break SuffixLoop
+			}
+		}
+	}
+
+	if needSuffix {
+		switch inst.Op {
+		case CMPXCHG8B, FLDCW, FNSTCW, FNSTSW, LDMXCSR, LLDT, LMSW, LTR, PCLMULQDQ,
+			SETA, SETAE, SETB, SETBE, SETE, SETG, SETGE, SETL, SETLE, SETNE, SETNO, SETNP, SETNS, SETO, SETP, SETS,
+			SLDT, SMSW, STMXCSR, STR, VERR, VERW:
+			// For various reasons, libopcodes emits no suffix for these instructions.
+
+		case CRC32:
+			op += byteSizeSuffix(argBytes(&inst, inst.Args[1]))
+
+		case LGDT, LIDT, SGDT, SIDT:
+			op += byteSizeSuffix(inst.DataSize / 8)
+
+		case MOVZX, MOVSX:
+			// Integer size conversions get two suffixes.
+			op = op[:4] + byteSizeSuffix(argBytes(&inst, inst.Args[1])) + byteSizeSuffix(argBytes(&inst, inst.Args[0]))
+
+		case LOOP, LOOPE, LOOPNE:
+			// Add w suffix to indicate use of CX register instead of ECX.
+			if inst.AddrSize == 16 {
+				op += "w"
+			}
+
+		case CALL, ENTER, JMP, LCALL, LEAVE, LJMP, LRET, RET, SYSRET, XBEGIN:
+			// Add w suffix to indicate use of 16-bit target.
+			// Exclude JMP rel8.
+			if inst.Opcode>>24 == 0xEB {
+				break
+			}
+			if inst.DataSize == 16 && inst.Mode != 16 {
+				markLastImplicit(&inst, PrefixDataSize)
+				op += "w"
+			} else if inst.Mode == 64 {
+				op += "q"
+			}
+
+		case FRSTOR, FNSAVE, FNSTENV, FLDENV:
+			// Add s suffix to indicate shortened FPU state (I guess).
+			if inst.DataSize == 16 {
+				op += "s"
+			}
+
+		case PUSH, POP:
+			if markLastImplicit(&inst, PrefixDataSize) {
+				op += byteSizeSuffix(inst.DataSize / 8)
+			} else if inst.Mode == 64 {
+				op += "q"
+			} else {
+				op += byteSizeSuffix(inst.MemBytes)
+			}
+
+		default:
+			if isFloat(inst.Op) {
+				// I can't explain any of this, but it's what libopcodes does.
+				switch inst.MemBytes {
+				default:
+					if (inst.Op == FLD || inst.Op == FSTP) && isMem(inst.Args[0]) {
+						op += "t"
+					}
+				case 4:
+					if isFloatInt(inst.Op) {
+						op += "l"
+					} else {
+						op += "s"
+					}
+				case 8:
+					if isFloatInt(inst.Op) {
+						op += "ll"
+					} else {
+						op += "l"
+					}
+				}
+				break
+			}
+
+			op += byteSizeSuffix(inst.MemBytes)
+		}
+	}
+
+	// Adjust special case opcodes.
+	switch inst.Op {
+	case 0:
+		if inst.Prefix[0] != 0 {
+			return strings.ToLower(inst.Prefix[0].String())
+		}
+
+	case INT:
+		if inst.Opcode>>24 == 0xCC {
+			inst.Args[0] = nil
+			op = "int3"
+		}
+
+	case CMPPS, CMPPD, CMPSD_XMM, CMPSS:
+		imm, ok := inst.Args[2].(Imm)
+		if ok && 0 <= imm && imm < 8 {
+			inst.Args[2] = nil
+			op = cmppsOps[imm] + op[3:]
+		}
+
+	case PCLMULQDQ:
+		imm, ok := inst.Args[2].(Imm)
+		if ok && imm&^0x11 == 0 {
+			inst.Args[2] = nil
+			op = pclmulqOps[(imm&0x10)>>3|(imm&1)]
+		}
+
+	case XLATB:
+		if markLastImplicit(&inst, PrefixAddrSize) {
+			op = "xlat" // not xlatb
+		}
+	}
+
+	// Build list of argument strings.
+	var (
+		usedPrefixes bool     // segment prefixes consumed by Mem formatting
+		args         []string // formatted arguments
+	)
+	for i, a := range inst.Args {
+		if a == nil {
+			break
+		}
+		switch inst.Op {
+		case MOVSB, MOVSW, MOVSD, MOVSQ, OUTSB, OUTSW, OUTSD:
+			if i == 0 {
+				usedPrefixes = true // disable use of prefixes for first argument
+			} else {
+				usedPrefixes = false
+			}
+		}
+		if a == Imm(1) && (inst.Opcode>>24)&^1 == 0xD0 {
+			continue
+		}
+		args = append(args, gnuArg(&inst, pc, symname, a, &usedPrefixes))
+	}
+
+	// The default is to print the arguments in reverse Intel order.
+	// A few instructions inhibit this behavior.
+	switch inst.Op {
+	case BOUND, LCALL, ENTER, LJMP:
+		// no reverse
+	default:
+		// reverse args
+		for i, j := 0, len(args)-1; i < j; i, j = i+1, j-1 {
+			args[i], args[j] = args[j], args[i]
+		}
+	}
+
+	// Build prefix string.
+	// Must be after argument formatting, which can turn off segment prefixes.
+	var (
+		prefix       = "" // output string
+		numAddr      = 0
+		numData      = 0
+		implicitData = false
+	)
+	for _, p := range inst.Prefix {
+		if p&0xFF == PrefixDataSize && p&PrefixImplicit != 0 {
+			implicitData = true
+		}
+	}
+	for _, p := range inst.Prefix {
+		if p == 0 || p.IsVEX() {
+			break
+		}
+		if p&PrefixImplicit != 0 {
+			continue
+		}
+		switch p &^ (PrefixIgnored | PrefixInvalid) {
+		default:
+			if p.IsREX() {
+				if p&0xFF == PrefixREX {
+					prefix += "rex "
+				} else {
+					prefix += "rex." + p.String()[4:] + " "
+				}
+				break
+			}
+			prefix += strings.ToLower(p.String()) + " "
+
+		case PrefixPN:
+			op += ",pn"
+			continue
+
+		case PrefixPT:
+			op += ",pt"
+			continue
+
+		case PrefixAddrSize, PrefixAddr16, PrefixAddr32:
+			// For unknown reasons, if the addr16 prefix is repeated,
+			// libopcodes displays all but the last as addr32, even though
+			// the addressing form used in a memory reference is clearly
+			// still 16-bit.
+			n := 32
+			if inst.Mode == 32 {
+				n = 16
+			}
+			numAddr++
+			if countPrefix(&inst, PrefixAddrSize) > numAddr {
+				n = inst.Mode
+			}
+			prefix += fmt.Sprintf("addr%d ", n)
+			continue
+
+		case PrefixData16, PrefixData32:
+			if implicitData && countPrefix(&inst, PrefixDataSize) > 1 {
+				// Similar to the addr32 logic above, but it only kicks in
+				// when something used the data size prefix (one is implicit).
+				n := 16
+				if inst.Mode == 16 {
+					n = 32
+				}
+				numData++
+				if countPrefix(&inst, PrefixDataSize) > numData {
+					if inst.Mode == 16 {
+						n = 16
+					} else {
+						n = 32
+					}
+				}
+				prefix += fmt.Sprintf("data%d ", n)
+				continue
+			}
+			prefix += strings.ToLower(p.String()) + " "
+		}
+	}
+
+	// Finally! Put it all together.
+	text := prefix + op
+	if args != nil {
+		text += " "
+		// Indirect call/jmp gets a star to distinguish from direct jump address.
+		if (inst.Op == CALL || inst.Op == JMP || inst.Op == LJMP || inst.Op == LCALL) && (isMem(inst.Args[0]) || isReg(inst.Args[0])) {
+			text += "*"
+		}
+		text += strings.Join(args, ",")
+	}
+	return text
+}
+
+// gnuArg returns the GNU syntax for the argument x from the instruction inst.
+// If *usedPrefixes is false and x is a Mem, then the formatting
+// includes any segment prefixes and sets *usedPrefixes to true.
+func gnuArg(inst *Inst, pc uint64, symname SymLookup, x Arg, usedPrefixes *bool) string {
+	if x == nil {
+		return "<nil>"
+	}
+	switch x := x.(type) {
+	case Reg:
+		switch inst.Op {
+		case CVTSI2SS, CVTSI2SD, CVTSS2SI, CVTSD2SI, CVTTSD2SI, CVTTSS2SI:
+			if inst.DataSize == 16 && EAX <= x && x <= R15L {
+				x -= EAX - AX
+			}
+
+		case IN, INSB, INSW, INSD, OUT, OUTSB, OUTSW, OUTSD:
+			// DX is the port, but libopcodes prints it as if it were a memory reference.
+			if x == DX {
+				return "(%dx)"
+			}
+		case VMOVDQA, VMOVDQU, VMOVNTDQA, VMOVNTDQ:
+			return strings.Replace(gccRegName[x], "xmm", "ymm", -1)
+		}
+		return gccRegName[x]
+	case Mem:
+		if s, disp := memArgToSymbol(x, pc, inst.Len, symname); s != "" {
+			suffix := ""
+			if disp != 0 {
+				suffix = fmt.Sprintf("%+d", disp)
+			}
+			return fmt.Sprintf("%s%s", s, suffix)
+		}
+		seg := ""
+		var haveCS, haveDS, haveES, haveFS, haveGS, haveSS bool
+		switch x.Segment {
+		case CS:
+			haveCS = true
+		case DS:
+			haveDS = true
+		case ES:
+			haveES = true
+		case FS:
+			haveFS = true
+		case GS:
+			haveGS = true
+		case SS:
+			haveSS = true
+		}
+		switch inst.Op {
+		case INSB, INSW, INSD, STOSB, STOSW, STOSD, STOSQ, SCASB, SCASW, SCASD, SCASQ:
+			// These do not accept segment prefixes, at least in the GNU rendering.
+		default:
+			if *usedPrefixes {
+				break
+			}
+			for i := len(inst.Prefix) - 1; i >= 0; i-- {
+				p := inst.Prefix[i] &^ PrefixIgnored
+				if p == 0 {
+					continue
+				}
+				switch p {
+				case PrefixCS:
+					if !haveCS {
+						haveCS = true
+						inst.Prefix[i] |= PrefixImplicit
+					}
+				case PrefixDS:
+					if !haveDS {
+						haveDS = true
+						inst.Prefix[i] |= PrefixImplicit
+					}
+				case PrefixES:
+					if !haveES {
+						haveES = true
+						inst.Prefix[i] |= PrefixImplicit
+					}
+				case PrefixFS:
+					if !haveFS {
+						haveFS = true
+						inst.Prefix[i] |= PrefixImplicit
+					}
+				case PrefixGS:
+					if !haveGS {
+						haveGS = true
+						inst.Prefix[i] |= PrefixImplicit
+					}
+				case PrefixSS:
+					if !haveSS {
+						haveSS = true
+						inst.Prefix[i] |= PrefixImplicit
+					}
+				}
+			}
+			*usedPrefixes = true
+		}
+		if haveCS {
+			seg += "%cs:"
+		}
+		if haveDS {
+			seg += "%ds:"
+		}
+		if haveSS {
+			seg += "%ss:"
+		}
+		if haveES {
+			seg += "%es:"
+		}
+		if haveFS {
+			seg += "%fs:"
+		}
+		if haveGS {
+			seg += "%gs:"
+		}
+		disp := ""
+		if x.Disp != 0 {
+			disp = fmt.Sprintf("%#x", x.Disp)
+		}
+		if x.Scale == 0 || x.Index == 0 && x.Scale == 1 && (x.Base == ESP || x.Base == RSP || x.Base == 0 && inst.Mode == 64) {
+			if x.Base == 0 {
+				return seg + disp
+			}
+			return fmt.Sprintf("%s%s(%s)", seg, disp, gccRegName[x.Base])
+		}
+		base := gccRegName[x.Base]
+		if x.Base == 0 {
+			base = ""
+		}
+		index := gccRegName[x.Index]
+		if x.Index == 0 {
+			if inst.AddrSize == 64 {
+				index = "%riz"
+			} else {
+				index = "%eiz"
+			}
+		}
+		if AX <= x.Base && x.Base <= DI {
+			// 16-bit addressing - no scale
+			return fmt.Sprintf("%s%s(%s,%s)", seg, disp, base, index)
+		}
+		return fmt.Sprintf("%s%s(%s,%s,%d)", seg, disp, base, index, x.Scale)
+	case Rel:
+		if pc == 0 {
+			return fmt.Sprintf(".%+#x", int64(x))
+		} else {
+			addr := pc + uint64(inst.Len) + uint64(x)
+			if s, base := symname(addr); s != "" && addr == base {
+				return fmt.Sprintf("%s", s)
+			} else {
+				addr := pc + uint64(inst.Len) + uint64(x)
+				return fmt.Sprintf("%#x", addr)
+			}
+		}
+	case Imm:
+		if s, base := symname(uint64(x)); s != "" {
+			suffix := ""
+			if uint64(x) != base {
+				suffix = fmt.Sprintf("%+d", uint64(x)-base)
+			}
+			return fmt.Sprintf("$%s%s", s, suffix)
+		}
+		if inst.Mode == 32 {
+			return fmt.Sprintf("$%#x", uint32(x))
+		}
+		return fmt.Sprintf("$%#x", int64(x))
+	}
+	return x.String()
+}
+
+var gccRegName = [...]string{
+	0:    "REG0",
+	AL:   "%al",
+	CL:   "%cl",
+	BL:   "%bl",
+	DL:   "%dl",
+	AH:   "%ah",
+	CH:   "%ch",
+	BH:   "%bh",
+	DH:   "%dh",
+	SPB:  "%spl",
+	BPB:  "%bpl",
+	SIB:  "%sil",
+	DIB:  "%dil",
+	R8B:  "%r8b",
+	R9B:  "%r9b",
+	R10B: "%r10b",
+	R11B: "%r11b",
+	R12B: "%r12b",
+	R13B: "%r13b",
+	R14B: "%r14b",
+	R15B: "%r15b",
+	AX:   "%ax",
+	CX:   "%cx",
+	BX:   "%bx",
+	DX:   "%dx",
+	SP:   "%sp",
+	BP:   "%bp",
+	SI:   "%si",
+	DI:   "%di",
+	R8W:  "%r8w",
+	R9W:  "%r9w",
+	R10W: "%r10w",
+	R11W: "%r11w",
+	R12W: "%r12w",
+	R13W: "%r13w",
+	R14W: "%r14w",
+	R15W: "%r15w",
+	EAX:  "%eax",
+	ECX:  "%ecx",
+	EDX:  "%edx",
+	EBX:  "%ebx",
+	ESP:  "%esp",
+	EBP:  "%ebp",
+	ESI:  "%esi",
+	EDI:  "%edi",
+	R8L:  "%r8d",
+	R9L:  "%r9d",
+	R10L: "%r10d",
+	R11L: "%r11d",
+	R12L: "%r12d",
+	R13L: "%r13d",
+	R14L: "%r14d",
+	R15L: "%r15d",
+	RAX:  "%rax",
+	RCX:  "%rcx",
+	RDX:  "%rdx",
+	RBX:  "%rbx",
+	RSP:  "%rsp",
+	RBP:  "%rbp",
+	RSI:  "%rsi",
+	RDI:  "%rdi",
+	R8:   "%r8",
+	R9:   "%r9",
+	R10:  "%r10",
+	R11:  "%r11",
+	R12:  "%r12",
+	R13:  "%r13",
+	R14:  "%r14",
+	R15:  "%r15",
+	IP:   "%ip",
+	EIP:  "%eip",
+	RIP:  "%rip",
+	F0:   "%st",
+	F1:   "%st(1)",
+	F2:   "%st(2)",
+	F3:   "%st(3)",
+	F4:   "%st(4)",
+	F5:   "%st(5)",
+	F6:   "%st(6)",
+	F7:   "%st(7)",
+	M0:   "%mm0",
+	M1:   "%mm1",
+	M2:   "%mm2",
+	M3:   "%mm3",
+	M4:   "%mm4",
+	M5:   "%mm5",
+	M6:   "%mm6",
+	M7:   "%mm7",
+	X0:   "%xmm0",
+	X1:   "%xmm1",
+	X2:   "%xmm2",
+	X3:   "%xmm3",
+	X4:   "%xmm4",
+	X5:   "%xmm5",
+	X6:   "%xmm6",
+	X7:   "%xmm7",
+	X8:   "%xmm8",
+	X9:   "%xmm9",
+	X10:  "%xmm10",
+	X11:  "%xmm11",
+	X12:  "%xmm12",
+	X13:  "%xmm13",
+	X14:  "%xmm14",
+	X15:  "%xmm15",
+	CS:   "%cs",
+	SS:   "%ss",
+	DS:   "%ds",
+	ES:   "%es",
+	FS:   "%fs",
+	GS:   "%gs",
+	GDTR: "%gdtr",
+	IDTR: "%idtr",
+	LDTR: "%ldtr",
+	MSW:  "%msw",
+	TASK: "%task",
+	CR0:  "%cr0",
+	CR1:  "%cr1",
+	CR2:  "%cr2",
+	CR3:  "%cr3",
+	CR4:  "%cr4",
+	CR5:  "%cr5",
+	CR6:  "%cr6",
+	CR7:  "%cr7",
+	CR8:  "%cr8",
+	CR9:  "%cr9",
+	CR10: "%cr10",
+	CR11: "%cr11",
+	CR12: "%cr12",
+	CR13: "%cr13",
+	CR14: "%cr14",
+	CR15: "%cr15",
+	DR0:  "%db0",
+	DR1:  "%db1",
+	DR2:  "%db2",
+	DR3:  "%db3",
+	DR4:  "%db4",
+	DR5:  "%db5",
+	DR6:  "%db6",
+	DR7:  "%db7",
+	TR0:  "%tr0",
+	TR1:  "%tr1",
+	TR2:  "%tr2",
+	TR3:  "%tr3",
+	TR4:  "%tr4",
+	TR5:  "%tr5",
+	TR6:  "%tr6",
+	TR7:  "%tr7",
+}
+
+var gnuOp = map[Op]string{
+	CBW:       "cbtw",
+	CDQ:       "cltd",
+	CMPSD:     "cmpsl",
+	CMPSD_XMM: "cmpsd",
+	CWD:       "cwtd",
+	CWDE:      "cwtl",
+	CQO:       "cqto",
+	INSD:      "insl",
+	IRET:      "iretw",
+	IRETD:     "iret",
+	IRETQ:     "iretq",
+	LODSB:     "lods",
+	LODSD:     "lods",
+	LODSQ:     "lods",
+	LODSW:     "lods",
+	MOVSD:     "movsl",
+	MOVSD_XMM: "movsd",
+	OUTSD:     "outsl",
+	POPA:      "popaw",
+	POPAD:     "popa",
+	POPF:      "popfw",
+	POPFD:     "popf",
+	PUSHA:     "pushaw",
+	PUSHAD:    "pusha",
+	PUSHF:     "pushfw",
+	PUSHFD:    "pushf",
+	SCASB:     "scas",
+	SCASD:     "scas",
+	SCASQ:     "scas",
+	SCASW:     "scas",
+	STOSB:     "stos",
+	STOSD:     "stos",
+	STOSQ:     "stos",
+	STOSW:     "stos",
+	XLATB:     "xlat",
+}
+
+var cmppsOps = []string{
+	"cmpeq",
+	"cmplt",
+	"cmple",
+	"cmpunord",
+	"cmpneq",
+	"cmpnlt",
+	"cmpnle",
+	"cmpord",
+}
+
+var pclmulqOps = []string{
+	"pclmullqlqdq",
+	"pclmulhqlqdq",
+	"pclmullqhqdq",
+	"pclmulhqhqdq",
+}
+
+func countPrefix(inst *Inst, target Prefix) int {
+	n := 0
+	for _, p := range inst.Prefix {
+		if p&0xFF == target&0xFF {
+			n++
+		}
+	}
+	return n
+}
+
+func markLastImplicit(inst *Inst, prefix Prefix) bool {
+	for i := len(inst.Prefix) - 1; i >= 0; i-- {
+		p := inst.Prefix[i]
+		if p&0xFF == prefix {
+			inst.Prefix[i] |= PrefixImplicit
+			return true
+		}
+	}
+	return false
+}
+
+func unmarkImplicit(inst *Inst, prefix Prefix) {
+	for i := len(inst.Prefix) - 1; i >= 0; i-- {
+		p := inst.Prefix[i]
+		if p&0xFF == prefix {
+			inst.Prefix[i] &^= PrefixImplicit
+		}
+	}
+}
+
+func byteSizeSuffix(b int) string {
+	switch b {
+	case 1:
+		return "b"
+	case 2:
+		return "w"
+	case 4:
+		return "l"
+	case 8:
+		return "q"
+	}
+	return ""
+}
+
+func argBytes(inst *Inst, arg Arg) int {
+	if isMem(arg) {
+		return inst.MemBytes
+	}
+	return regBytes(arg)
+}
+
+func isFloat(op Op) bool {
+	switch op {
+	case FADD, FCOM, FCOMP, FDIV, FDIVR, FIADD, FICOM, FICOMP, FIDIV, FIDIVR, FILD, FIMUL, FIST, FISTP, FISTTP, FISUB, FISUBR, FLD, FMUL, FST, FSTP, FSUB, FSUBR:
+		return true
+	}
+	return false
+}
+
+func isFloatInt(op Op) bool {
+	switch op {
+	case FIADD, FICOM, FICOMP, FIDIV, FIDIVR, FILD, FIMUL, FIST, FISTP, FISTTP, FISUB, FISUBR:
+		return true
+	}
+	return false
+}
diff --git a/vendor/golang.org/x/arch/x86/x86asm/inst.go b/vendor/golang.org/x/arch/x86/x86asm/inst.go
new file mode 100644
index 000000000..4632b5064
--- /dev/null
+++ b/vendor/golang.org/x/arch/x86/x86asm/inst.go
@@ -0,0 +1,649 @@
+// Copyright 2014 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package x86asm implements decoding of x86 machine code.
+package x86asm
+
+import (
+	"bytes"
+	"fmt"
+)
+
+// An Inst is a single instruction.
+type Inst struct {
+	Prefix   Prefixes // Prefixes applied to the instruction.
+	Op       Op       // Opcode mnemonic
+	Opcode   uint32   // Encoded opcode bits, left aligned (first byte is Opcode>>24, etc)
+	Args     Args     // Instruction arguments, in Intel order
+	Mode     int      // processor mode in bits: 16, 32, or 64
+	AddrSize int      // address size in bits: 16, 32, or 64
+	DataSize int      // operand size in bits: 16, 32, or 64
+	MemBytes int      // size of memory argument in bytes: 1, 2, 4, 8, 16, and so on.
+	Len      int      // length of encoded instruction in bytes
+	PCRel    int      // length of PC-relative address in instruction encoding
+	PCRelOff int      // index of start of PC-relative address in instruction encoding
+}
+
+// Prefixes is an array of prefixes associated with a single instruction.
+// The prefixes are listed in the same order as found in the instruction:
+// each prefix byte corresponds to one slot in the array. The first zero
+// in the array marks the end of the prefixes.
+type Prefixes [14]Prefix
+
+// A Prefix represents an Intel instruction prefix.
+// The low 8 bits are the actual prefix byte encoding,
+// and the top 8 bits contain distinguishing bits and metadata.
+type Prefix uint16
+
+const (
+	// Metadata about the role of a prefix in an instruction.
+	PrefixImplicit Prefix = 0x8000 // prefix is implied by instruction text
+	PrefixIgnored  Prefix = 0x4000 // prefix is ignored: either irrelevant or overridden by a later prefix
+	PrefixInvalid  Prefix = 0x2000 // prefix makes entire instruction invalid (bad LOCK)
+
+	// Memory segment overrides.
+	PrefixES Prefix = 0x26 // ES segment override
+	PrefixCS Prefix = 0x2E // CS segment override
+	PrefixSS Prefix = 0x36 // SS segment override
+	PrefixDS Prefix = 0x3E // DS segment override
+	PrefixFS Prefix = 0x64 // FS segment override
+	PrefixGS Prefix = 0x65 // GS segment override
+
+	// Branch prediction.
+	PrefixPN Prefix = 0x12E // predict not taken (conditional branch only)
+	PrefixPT Prefix = 0x13E // predict taken (conditional branch only)
+
+	// Size attributes.
+	PrefixDataSize Prefix = 0x66 // operand size override
+	PrefixData16   Prefix = 0x166
+	PrefixData32   Prefix = 0x266
+	PrefixAddrSize Prefix = 0x67 // address size override
+	PrefixAddr16   Prefix = 0x167
+	PrefixAddr32   Prefix = 0x267
+
+	// One of a kind.
+	PrefixLOCK     Prefix = 0xF0 // lock
+	PrefixREPN     Prefix = 0xF2 // repeat not zero
+	PrefixXACQUIRE Prefix = 0x1F2
+	PrefixBND      Prefix = 0x2F2
+	PrefixREP      Prefix = 0xF3 // repeat
+	PrefixXRELEASE Prefix = 0x1F3
+
+	// The REX prefixes must be in the range [PrefixREX, PrefixREX+0x10).
+	// the other bits are set or not according to the intended use.
+	PrefixREX       Prefix = 0x40 // REX 64-bit extension prefix
+	PrefixREXW      Prefix = 0x08 // extension bit W (64-bit instruction width)
+	PrefixREXR      Prefix = 0x04 // extension bit R (r field in modrm)
+	PrefixREXX      Prefix = 0x02 // extension bit X (index field in sib)
+	PrefixREXB      Prefix = 0x01 // extension bit B (r/m field in modrm or base field in sib)
+	PrefixVEX2Bytes Prefix = 0xC5 // Short form of vex prefix
+	PrefixVEX3Bytes Prefix = 0xC4 // Long form of vex prefix
+)
+
+// IsREX reports whether p is a REX prefix byte.
+func (p Prefix) IsREX() bool {
+	return p&0xF0 == PrefixREX
+}
+
+func (p Prefix) IsVEX() bool {
+	return p&0xFF == PrefixVEX2Bytes || p&0xFF == PrefixVEX3Bytes
+}
+
+func (p Prefix) String() string {
+	p &^= PrefixImplicit | PrefixIgnored | PrefixInvalid
+	if s := prefixNames[p]; s != "" {
+		return s
+	}
+
+	if p.IsREX() {
+		s := "REX."
+		if p&PrefixREXW != 0 {
+			s += "W"
+		}
+		if p&PrefixREXR != 0 {
+			s += "R"
+		}
+		if p&PrefixREXX != 0 {
+			s += "X"
+		}
+		if p&PrefixREXB != 0 {
+			s += "B"
+		}
+		return s
+	}
+
+	return fmt.Sprintf("Prefix(%#x)", int(p))
+}
+
+// An Op is an x86 opcode.
+type Op uint32
+
+func (op Op) String() string {
+	i := int(op)
+	if i < 0 || i >= len(opNames) || opNames[i] == "" {
+		return fmt.Sprintf("Op(%d)", i)
+	}
+	return opNames[i]
+}
+
+// An Args holds the instruction arguments.
+// If an instruction has fewer than 4 arguments,
+// the final elements in the array are nil.
+type Args [4]Arg
+
+// An Arg is a single instruction argument,
+// one of these types: Reg, Mem, Imm, Rel.
+type Arg interface {
+	String() string
+	isArg()
+}
+
+// Note that the implements of Arg that follow are all sized
+// so that on a 64-bit machine the data can be inlined in
+// the interface value instead of requiring an allocation.
+
+// A Reg is a single register.
+// The zero Reg value has no name but indicates ``no register.''
+type Reg uint8
+
+const (
+	_ Reg = iota
+
+	// 8-bit
+	AL
+	CL
+	DL
+	BL
+	AH
+	CH
+	DH
+	BH
+	SPB
+	BPB
+	SIB
+	DIB
+	R8B
+	R9B
+	R10B
+	R11B
+	R12B
+	R13B
+	R14B
+	R15B
+
+	// 16-bit
+	AX
+	CX
+	DX
+	BX
+	SP
+	BP
+	SI
+	DI
+	R8W
+	R9W
+	R10W
+	R11W
+	R12W
+	R13W
+	R14W
+	R15W
+
+	// 32-bit
+	EAX
+	ECX
+	EDX
+	EBX
+	ESP
+	EBP
+	ESI
+	EDI
+	R8L
+	R9L
+	R10L
+	R11L
+	R12L
+	R13L
+	R14L
+	R15L
+
+	// 64-bit
+	RAX
+	RCX
+	RDX
+	RBX
+	RSP
+	RBP
+	RSI
+	RDI
+	R8
+	R9
+	R10
+	R11
+	R12
+	R13
+	R14
+	R15
+
+	// Instruction pointer.
+	IP  // 16-bit
+	EIP // 32-bit
+	RIP // 64-bit
+
+	// 387 floating point registers.
+	F0
+	F1
+	F2
+	F3
+	F4
+	F5
+	F6
+	F7
+
+	// MMX registers.
+	M0
+	M1
+	M2
+	M3
+	M4
+	M5
+	M6
+	M7
+
+	// XMM registers.
+	X0
+	X1
+	X2
+	X3
+	X4
+	X5
+	X6
+	X7
+	X8
+	X9
+	X10
+	X11
+	X12
+	X13
+	X14
+	X15
+
+	// Segment registers.
+	ES
+	CS
+	SS
+	DS
+	FS
+	GS
+
+	// System registers.
+	GDTR
+	IDTR
+	LDTR
+	MSW
+	TASK
+
+	// Control registers.
+	CR0
+	CR1
+	CR2
+	CR3
+	CR4
+	CR5
+	CR6
+	CR7
+	CR8
+	CR9
+	CR10
+	CR11
+	CR12
+	CR13
+	CR14
+	CR15
+
+	// Debug registers.
+	DR0
+	DR1
+	DR2
+	DR3
+	DR4
+	DR5
+	DR6
+	DR7
+	DR8
+	DR9
+	DR10
+	DR11
+	DR12
+	DR13
+	DR14
+	DR15
+
+	// Task registers.
+	TR0
+	TR1
+	TR2
+	TR3
+	TR4
+	TR5
+	TR6
+	TR7
+)
+
+const regMax = TR7
+
+func (Reg) isArg() {}
+
+func (r Reg) String() string {
+	i := int(r)
+	if i < 0 || i >= len(regNames) || regNames[i] == "" {
+		return fmt.Sprintf("Reg(%d)", i)
+	}
+	return regNames[i]
+}
+
+// A Mem is a memory reference.
+// The general form is Segment:[Base+Scale*Index+Disp].
+type Mem struct {
+	Segment Reg
+	Base    Reg
+	Scale   uint8
+	Index   Reg
+	Disp    int64
+}
+
+func (Mem) isArg() {}
+
+func (m Mem) String() string {
+	var base, plus, scale, index, disp string
+
+	if m.Base != 0 {
+		base = m.Base.String()
+	}
+	if m.Scale != 0 {
+		if m.Base != 0 {
+			plus = "+"
+		}
+		if m.Scale > 1 {
+			scale = fmt.Sprintf("%d*", m.Scale)
+		}
+		index = m.Index.String()
+	}
+	if m.Disp != 0 || m.Base == 0 && m.Scale == 0 {
+		disp = fmt.Sprintf("%+#x", m.Disp)
+	}
+	return "[" + base + plus + scale + index + disp + "]"
+}
+
+// A Rel is an offset relative to the current instruction pointer.
+type Rel int32
+
+func (Rel) isArg() {}
+
+func (r Rel) String() string {
+	return fmt.Sprintf(".%+d", r)
+}
+
+// An Imm is an integer constant.
+type Imm int64
+
+func (Imm) isArg() {}
+
+func (i Imm) String() string {
+	return fmt.Sprintf("%#x", int64(i))
+}
+
+func (i Inst) String() string {
+	var buf bytes.Buffer
+	for _, p := range i.Prefix {
+		if p == 0 {
+			break
+		}
+		if p&PrefixImplicit != 0 {
+			continue
+		}
+		fmt.Fprintf(&buf, "%v ", p)
+	}
+	fmt.Fprintf(&buf, "%v", i.Op)
+	sep := " "
+	for _, v := range i.Args {
+		if v == nil {
+			break
+		}
+		fmt.Fprintf(&buf, "%s%v", sep, v)
+		sep = ", "
+	}
+	return buf.String()
+}
+
+func isReg(a Arg) bool {
+	_, ok := a.(Reg)
+	return ok
+}
+
+func isSegReg(a Arg) bool {
+	r, ok := a.(Reg)
+	return ok && ES <= r && r <= GS
+}
+
+func isMem(a Arg) bool {
+	_, ok := a.(Mem)
+	return ok
+}
+
+func isImm(a Arg) bool {
+	_, ok := a.(Imm)
+	return ok
+}
+
+func regBytes(a Arg) int {
+	r, ok := a.(Reg)
+	if !ok {
+		return 0
+	}
+	if AL <= r && r <= R15B {
+		return 1
+	}
+	if AX <= r && r <= R15W {
+		return 2
+	}
+	if EAX <= r && r <= R15L {
+		return 4
+	}
+	if RAX <= r && r <= R15 {
+		return 8
+	}
+	return 0
+}
+
+func isSegment(p Prefix) bool {
+	switch p {
+	case PrefixCS, PrefixDS, PrefixES, PrefixFS, PrefixGS, PrefixSS:
+		return true
+	}
+	return false
+}
+
+// The Op definitions and string list are in tables.go.
+
+var prefixNames = map[Prefix]string{
+	PrefixCS:       "CS",
+	PrefixDS:       "DS",
+	PrefixES:       "ES",
+	PrefixFS:       "FS",
+	PrefixGS:       "GS",
+	PrefixSS:       "SS",
+	PrefixLOCK:     "LOCK",
+	PrefixREP:      "REP",
+	PrefixREPN:     "REPN",
+	PrefixAddrSize: "ADDRSIZE",
+	PrefixDataSize: "DATASIZE",
+	PrefixAddr16:   "ADDR16",
+	PrefixData16:   "DATA16",
+	PrefixAddr32:   "ADDR32",
+	PrefixData32:   "DATA32",
+	PrefixBND:      "BND",
+	PrefixXACQUIRE: "XACQUIRE",
+	PrefixXRELEASE: "XRELEASE",
+	PrefixREX:      "REX",
+	PrefixPT:       "PT",
+	PrefixPN:       "PN",
+}
+
+var regNames = [...]string{
+	AL:   "AL",
+	CL:   "CL",
+	BL:   "BL",
+	DL:   "DL",
+	AH:   "AH",
+	CH:   "CH",
+	BH:   "BH",
+	DH:   "DH",
+	SPB:  "SPB",
+	BPB:  "BPB",
+	SIB:  "SIB",
+	DIB:  "DIB",
+	R8B:  "R8B",
+	R9B:  "R9B",
+	R10B: "R10B",
+	R11B: "R11B",
+	R12B: "R12B",
+	R13B: "R13B",
+	R14B: "R14B",
+	R15B: "R15B",
+	AX:   "AX",
+	CX:   "CX",
+	BX:   "BX",
+	DX:   "DX",
+	SP:   "SP",
+	BP:   "BP",
+	SI:   "SI",
+	DI:   "DI",
+	R8W:  "R8W",
+	R9W:  "R9W",
+	R10W: "R10W",
+	R11W: "R11W",
+	R12W: "R12W",
+	R13W: "R13W",
+	R14W: "R14W",
+	R15W: "R15W",
+	EAX:  "EAX",
+	ECX:  "ECX",
+	EDX:  "EDX",
+	EBX:  "EBX",
+	ESP:  "ESP",
+	EBP:  "EBP",
+	ESI:  "ESI",
+	EDI:  "EDI",
+	R8L:  "R8L",
+	R9L:  "R9L",
+	R10L: "R10L",
+	R11L: "R11L",
+	R12L: "R12L",
+	R13L: "R13L",
+	R14L: "R14L",
+	R15L: "R15L",
+	RAX:  "RAX",
+	RCX:  "RCX",
+	RDX:  "RDX",
+	RBX:  "RBX",
+	RSP:  "RSP",
+	RBP:  "RBP",
+	RSI:  "RSI",
+	RDI:  "RDI",
+	R8:   "R8",
+	R9:   "R9",
+	R10:  "R10",
+	R11:  "R11",
+	R12:  "R12",
+	R13:  "R13",
+	R14:  "R14",
+	R15:  "R15",
+	IP:   "IP",
+	EIP:  "EIP",
+	RIP:  "RIP",
+	F0:   "F0",
+	F1:   "F1",
+	F2:   "F2",
+	F3:   "F3",
+	F4:   "F4",
+	F5:   "F5",
+	F6:   "F6",
+	F7:   "F7",
+	M0:   "M0",
+	M1:   "M1",
+	M2:   "M2",
+	M3:   "M3",
+	M4:   "M4",
+	M5:   "M5",
+	M6:   "M6",
+	M7:   "M7",
+	X0:   "X0",
+	X1:   "X1",
+	X2:   "X2",
+	X3:   "X3",
+	X4:   "X4",
+	X5:   "X5",
+	X6:   "X6",
+	X7:   "X7",
+	X8:   "X8",
+	X9:   "X9",
+	X10:  "X10",
+	X11:  "X11",
+	X12:  "X12",
+	X13:  "X13",
+	X14:  "X14",
+	X15:  "X15",
+	CS:   "CS",
+	SS:   "SS",
+	DS:   "DS",
+	ES:   "ES",
+	FS:   "FS",
+	GS:   "GS",
+	GDTR: "GDTR",
+	IDTR: "IDTR",
+	LDTR: "LDTR",
+	MSW:  "MSW",
+	TASK: "TASK",
+	CR0:  "CR0",
+	CR1:  "CR1",
+	CR2:  "CR2",
+	CR3:  "CR3",
+	CR4:  "CR4",
+	CR5:  "CR5",
+	CR6:  "CR6",
+	CR7:  "CR7",
+	CR8:  "CR8",
+	CR9:  "CR9",
+	CR10: "CR10",
+	CR11: "CR11",
+	CR12: "CR12",
+	CR13: "CR13",
+	CR14: "CR14",
+	CR15: "CR15",
+	DR0:  "DR0",
+	DR1:  "DR1",
+	DR2:  "DR2",
+	DR3:  "DR3",
+	DR4:  "DR4",
+	DR5:  "DR5",
+	DR6:  "DR6",
+	DR7:  "DR7",
+	DR8:  "DR8",
+	DR9:  "DR9",
+	DR10: "DR10",
+	DR11: "DR11",
+	DR12: "DR12",
+	DR13: "DR13",
+	DR14: "DR14",
+	DR15: "DR15",
+	TR0:  "TR0",
+	TR1:  "TR1",
+	TR2:  "TR2",
+	TR3:  "TR3",
+	TR4:  "TR4",
+	TR5:  "TR5",
+	TR6:  "TR6",
+	TR7:  "TR7",
+}
diff --git a/vendor/golang.org/x/arch/x86/x86asm/intel.go b/vendor/golang.org/x/arch/x86/x86asm/intel.go
new file mode 100644
index 000000000..472eabda8
--- /dev/null
+++ b/vendor/golang.org/x/arch/x86/x86asm/intel.go
@@ -0,0 +1,560 @@
+// Copyright 2014 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package x86asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// IntelSyntax returns the Intel assembler syntax for the instruction, as defined by Intel's XED tool.
+func IntelSyntax(inst Inst, pc uint64, symname SymLookup) string {
+	if symname == nil {
+		symname = func(uint64) (string, uint64) { return "", 0 }
+	}
+
+	var iargs []Arg
+	for _, a := range inst.Args {
+		if a == nil {
+			break
+		}
+		iargs = append(iargs, a)
+	}
+
+	switch inst.Op {
+	case INSB, INSD, INSW, OUTSB, OUTSD, OUTSW, LOOPNE, JCXZ, JECXZ, JRCXZ, LOOP, LOOPE, MOV, XLATB:
+		if inst.Op == MOV && (inst.Opcode>>16)&0xFFFC != 0x0F20 {
+			break
+		}
+		for i, p := range inst.Prefix {
+			if p&0xFF == PrefixAddrSize {
+				inst.Prefix[i] &^= PrefixImplicit
+			}
+		}
+	}
+
+	switch inst.Op {
+	case MOV:
+		dst, _ := inst.Args[0].(Reg)
+		src, _ := inst.Args[1].(Reg)
+		if ES <= dst && dst <= GS && EAX <= src && src <= R15L {
+			src -= EAX - AX
+			iargs[1] = src
+		}
+		if ES <= dst && dst <= GS && RAX <= src && src <= R15 {
+			src -= RAX - AX
+			iargs[1] = src
+		}
+
+		if inst.Opcode>>24&^3 == 0xA0 {
+			for i, p := range inst.Prefix {
+				if p&0xFF == PrefixAddrSize {
+					inst.Prefix[i] |= PrefixImplicit
+				}
+			}
+		}
+	}
+
+	switch inst.Op {
+	case AAM, AAD:
+		if imm, ok := iargs[0].(Imm); ok {
+			if inst.DataSize == 32 {
+				iargs[0] = Imm(uint32(int8(imm)))
+			} else if inst.DataSize == 16 {
+				iargs[0] = Imm(uint16(int8(imm)))
+			}
+		}
+
+	case PUSH:
+		if imm, ok := iargs[0].(Imm); ok {
+			iargs[0] = Imm(uint32(imm))
+		}
+	}
+
+	for _, p := range inst.Prefix {
+		if p&PrefixImplicit != 0 {
+			for j, pj := range inst.Prefix {
+				if pj&0xFF == p&0xFF {
+					inst.Prefix[j] |= PrefixImplicit
+				}
+			}
+		}
+	}
+
+	if inst.Op != 0 {
+		for i, p := range inst.Prefix {
+			switch p &^ PrefixIgnored {
+			case PrefixData16, PrefixData32, PrefixCS, PrefixDS, PrefixES, PrefixSS:
+				inst.Prefix[i] |= PrefixImplicit
+			}
+			if p.IsREX() {
+				inst.Prefix[i] |= PrefixImplicit
+			}
+			if p.IsVEX() {
+				if p == PrefixVEX3Bytes {
+					inst.Prefix[i+2] |= PrefixImplicit
+				}
+				inst.Prefix[i] |= PrefixImplicit
+				inst.Prefix[i+1] |= PrefixImplicit
+			}
+		}
+	}
+
+	if isLoop[inst.Op] || inst.Op == JCXZ || inst.Op == JECXZ || inst.Op == JRCXZ {
+		for i, p := range inst.Prefix {
+			if p == PrefixPT || p == PrefixPN {
+				inst.Prefix[i] |= PrefixImplicit
+			}
+		}
+	}
+
+	switch inst.Op {
+	case AAA, AAS, CBW, CDQE, CLC, CLD, CLI, CLTS, CMC, CPUID, CQO, CWD, DAA, DAS,
+		FDECSTP, FINCSTP, FNCLEX, FNINIT, FNOP, FWAIT, HLT,
+		ICEBP, INSB, INSD, INSW, INT, INTO, INVD, IRET, IRETQ,
+		LAHF, LEAVE, LRET, MONITOR, MWAIT, NOP, OUTSB, OUTSD, OUTSW,
+		PAUSE, POPA, POPF, POPFQ, PUSHA, PUSHF, PUSHFQ,
+		RDMSR, RDPMC, RDTSC, RDTSCP, RET, RSM,
+		SAHF, STC, STD, STI, SYSENTER, SYSEXIT, SYSRET,
+		UD2, WBINVD, WRMSR, XEND, XLATB, XTEST:
+
+		if inst.Op == NOP && inst.Opcode>>24 != 0x90 {
+			break
+		}
+		if inst.Op == RET && inst.Opcode>>24 != 0xC3 {
+			break
+		}
+		if inst.Op == INT && inst.Opcode>>24 != 0xCC {
+			break
+		}
+		if inst.Op == LRET && inst.Opcode>>24 != 0xcb {
+			break
+		}
+		for i, p := range inst.Prefix {
+			if p&0xFF == PrefixDataSize {
+				inst.Prefix[i] &^= PrefixImplicit | PrefixIgnored
+			}
+		}
+
+	case 0:
+		// ok
+	}
+
+	switch inst.Op {
+	case INSB, INSD, INSW, OUTSB, OUTSD, OUTSW, MONITOR, MWAIT, XLATB:
+		iargs = nil
+
+	case STOSB, STOSW, STOSD, STOSQ:
+		iargs = iargs[:1]
+
+	case LODSB, LODSW, LODSD, LODSQ, SCASB, SCASW, SCASD, SCASQ:
+		iargs = iargs[1:]
+	}
+
+	const (
+		haveData16 = 1 << iota
+		haveData32
+		haveAddr16
+		haveAddr32
+		haveXacquire
+		haveXrelease
+		haveLock
+		haveHintTaken
+		haveHintNotTaken
+		haveBnd
+	)
+	var prefixBits uint32
+	prefix := ""
+	for _, p := range inst.Prefix {
+		if p == 0 {
+			break
+		}
+		if p&0xFF == 0xF3 {
+			prefixBits &^= haveBnd
+		}
+		if p&(PrefixImplicit|PrefixIgnored) != 0 {
+			continue
+		}
+		switch p {
+		default:
+			prefix += strings.ToLower(p.String()) + " "
+		case PrefixCS, PrefixDS, PrefixES, PrefixFS, PrefixGS, PrefixSS:
+			if inst.Op == 0 {
+				prefix += strings.ToLower(p.String()) + " "
+			}
+		case PrefixREPN:
+			prefix += "repne "
+		case PrefixLOCK:
+			prefixBits |= haveLock
+		case PrefixData16, PrefixDataSize:
+			prefixBits |= haveData16
+		case PrefixData32:
+			prefixBits |= haveData32
+		case PrefixAddrSize, PrefixAddr16:
+			prefixBits |= haveAddr16
+		case PrefixAddr32:
+			prefixBits |= haveAddr32
+		case PrefixXACQUIRE:
+			prefixBits |= haveXacquire
+		case PrefixXRELEASE:
+			prefixBits |= haveXrelease
+		case PrefixPT:
+			prefixBits |= haveHintTaken
+		case PrefixPN:
+			prefixBits |= haveHintNotTaken
+		case PrefixBND:
+			prefixBits |= haveBnd
+		}
+	}
+	switch inst.Op {
+	case JMP:
+		if inst.Opcode>>24 == 0xEB {
+			prefixBits &^= haveBnd
+		}
+	case RET, LRET:
+		prefixBits &^= haveData16 | haveData32
+	}
+
+	if prefixBits&haveXacquire != 0 {
+		prefix += "xacquire "
+	}
+	if prefixBits&haveXrelease != 0 {
+		prefix += "xrelease "
+	}
+	if prefixBits&haveLock != 0 {
+		prefix += "lock "
+	}
+	if prefixBits&haveBnd != 0 {
+		prefix += "bnd "
+	}
+	if prefixBits&haveHintTaken != 0 {
+		prefix += "hint-taken "
+	}
+	if prefixBits&haveHintNotTaken != 0 {
+		prefix += "hint-not-taken "
+	}
+	if prefixBits&haveAddr16 != 0 {
+		prefix += "addr16 "
+	}
+	if prefixBits&haveAddr32 != 0 {
+		prefix += "addr32 "
+	}
+	if prefixBits&haveData16 != 0 {
+		prefix += "data16 "
+	}
+	if prefixBits&haveData32 != 0 {
+		prefix += "data32 "
+	}
+
+	if inst.Op == 0 {
+		if prefix == "" {
+			return "<no instruction>"
+		}
+		return prefix[:len(prefix)-1]
+	}
+
+	var args []string
+	for _, a := range iargs {
+		if a == nil {
+			break
+		}
+		args = append(args, intelArg(&inst, pc, symname, a))
+	}
+
+	var op string
+	switch inst.Op {
+	case NOP:
+		if inst.Opcode>>24 == 0x0F {
+			if inst.DataSize == 16 {
+				args = append(args, "ax")
+			} else {
+				args = append(args, "eax")
+			}
+		}
+
+	case BLENDVPD, BLENDVPS, PBLENDVB:
+		args = args[:2]
+
+	case INT:
+		if inst.Opcode>>24 == 0xCC {
+			args = nil
+			op = "int3"
+		}
+
+	case LCALL, LJMP:
+		if len(args) == 2 {
+			args[0], args[1] = args[1], args[0]
+		}
+
+	case FCHS, FABS, FTST, FLDPI, FLDL2E, FLDLG2, F2XM1, FXAM, FLD1, FLDL2T, FSQRT, FRNDINT, FCOS, FSIN:
+		if len(args) == 0 {
+			args = append(args, "st0")
+		}
+
+	case FPTAN, FSINCOS, FUCOMPP, FCOMPP, FYL2X, FPATAN, FXTRACT, FPREM1, FPREM, FYL2XP1, FSCALE:
+		if len(args) == 0 {
+			args = []string{"st0", "st1"}
+		}
+
+	case FST, FSTP, FISTTP, FIST, FISTP, FBSTP:
+		if len(args) == 1 {
+			args = append(args, "st0")
+		}
+
+	case FLD, FXCH, FCOM, FCOMP, FIADD, FIMUL, FICOM, FICOMP, FISUBR, FIDIV, FUCOM, FUCOMP, FILD, FBLD, FADD, FMUL, FSUB, FSUBR, FISUB, FDIV, FDIVR, FIDIVR:
+		if len(args) == 1 {
+			args = []string{"st0", args[0]}
+		}
+
+	case MASKMOVDQU, MASKMOVQ, XLATB, OUTSB, OUTSW, OUTSD:
+	FixSegment:
+		for i := len(inst.Prefix) - 1; i >= 0; i-- {
+			p := inst.Prefix[i] & 0xFF
+			switch p {
+			case PrefixCS, PrefixES, PrefixFS, PrefixGS, PrefixSS:
+				if inst.Mode != 64 || p == PrefixFS || p == PrefixGS {
+					args = append(args, strings.ToLower((inst.Prefix[i] & 0xFF).String()))
+					break FixSegment
+				}
+			case PrefixDS:
+				if inst.Mode != 64 {
+					break FixSegment
+				}
+			}
+		}
+	}
+
+	if op == "" {
+		op = intelOp[inst.Op]
+	}
+	if op == "" {
+		op = strings.ToLower(inst.Op.String())
+	}
+	if args != nil {
+		op += " " + strings.Join(args, ", ")
+	}
+	return prefix + op
+}
+
+func intelArg(inst *Inst, pc uint64, symname SymLookup, arg Arg) string {
+	switch a := arg.(type) {
+	case Imm:
+		if s, base := symname(uint64(a)); s != "" {
+			suffix := ""
+			if uint64(a) != base {
+				suffix = fmt.Sprintf("%+d", uint64(a)-base)
+			}
+			return fmt.Sprintf("$%s%s", s, suffix)
+		}
+		if inst.Mode == 32 {
+			return fmt.Sprintf("%#x", uint32(a))
+		}
+		if Imm(int32(a)) == a {
+			return fmt.Sprintf("%#x", int64(a))
+		}
+		return fmt.Sprintf("%#x", uint64(a))
+	case Mem:
+		if a.Base == EIP {
+			a.Base = RIP
+		}
+		prefix := ""
+		switch inst.MemBytes {
+		case 1:
+			prefix = "byte "
+		case 2:
+			prefix = "word "
+		case 4:
+			prefix = "dword "
+		case 8:
+			prefix = "qword "
+		case 16:
+			prefix = "xmmword "
+		case 32:
+			prefix = "ymmword "
+		}
+		switch inst.Op {
+		case INVLPG:
+			prefix = "byte "
+		case STOSB, MOVSB, CMPSB, LODSB, SCASB:
+			prefix = "byte "
+		case STOSW, MOVSW, CMPSW, LODSW, SCASW:
+			prefix = "word "
+		case STOSD, MOVSD, CMPSD, LODSD, SCASD:
+			prefix = "dword "
+		case STOSQ, MOVSQ, CMPSQ, LODSQ, SCASQ:
+			prefix = "qword "
+		case LAR:
+			prefix = "word "
+		case BOUND:
+			if inst.Mode == 32 {
+				prefix = "qword "
+			} else {
+				prefix = "dword "
+			}
+		case PREFETCHW, PREFETCHNTA, PREFETCHT0, PREFETCHT1, PREFETCHT2, CLFLUSH:
+			prefix = "zmmword "
+		}
+		switch inst.Op {
+		case MOVSB, MOVSW, MOVSD, MOVSQ, CMPSB, CMPSW, CMPSD, CMPSQ, STOSB, STOSW, STOSD, STOSQ, SCASB, SCASW, SCASD, SCASQ, LODSB, LODSW, LODSD, LODSQ:
+			switch a.Base {
+			case DI, EDI, RDI:
+				if a.Segment == ES {
+					a.Segment = 0
+				}
+			case SI, ESI, RSI:
+				if a.Segment == DS {
+					a.Segment = 0
+				}
+			}
+		case LEA:
+			a.Segment = 0
+		default:
+			switch a.Base {
+			case SP, ESP, RSP, BP, EBP, RBP:
+				if a.Segment == SS {
+					a.Segment = 0
+				}
+			default:
+				if a.Segment == DS {
+					a.Segment = 0
+				}
+			}
+		}
+
+		if inst.Mode == 64 && a.Segment != FS && a.Segment != GS {
+			a.Segment = 0
+		}
+
+		prefix += "ptr "
+		if s, disp := memArgToSymbol(a, pc, inst.Len, symname); s != "" {
+			suffix := ""
+			if disp != 0 {
+				suffix = fmt.Sprintf("%+d", disp)
+			}
+			return prefix + fmt.Sprintf("[%s%s]", s, suffix)
+		}
+		if a.Segment != 0 {
+			prefix += strings.ToLower(a.Segment.String()) + ":"
+		}
+		prefix += "["
+		if a.Base != 0 {
+			prefix += intelArg(inst, pc, symname, a.Base)
+		}
+		if a.Scale != 0 && a.Index != 0 {
+			if a.Base != 0 {
+				prefix += "+"
+			}
+			prefix += fmt.Sprintf("%s*%d", intelArg(inst, pc, symname, a.Index), a.Scale)
+		}
+		if a.Disp != 0 {
+			if prefix[len(prefix)-1] == '[' && (a.Disp >= 0 || int64(int32(a.Disp)) != a.Disp) {
+				prefix += fmt.Sprintf("%#x", uint64(a.Disp))
+			} else {
+				prefix += fmt.Sprintf("%+#x", a.Disp)
+			}
+		}
+		prefix += "]"
+		return prefix
+	case Rel:
+		if pc == 0 {
+			return fmt.Sprintf(".%+#x", int64(a))
+		} else {
+			addr := pc + uint64(inst.Len) + uint64(a)
+			if s, base := symname(addr); s != "" && addr == base {
+				return fmt.Sprintf("%s", s)
+			} else {
+				addr := pc + uint64(inst.Len) + uint64(a)
+				return fmt.Sprintf("%#x", addr)
+			}
+		}
+	case Reg:
+		if int(a) < len(intelReg) && intelReg[a] != "" {
+			switch inst.Op {
+			case VMOVDQA, VMOVDQU, VMOVNTDQA, VMOVNTDQ:
+				return strings.Replace(intelReg[a], "xmm", "ymm", -1)
+			default:
+				return intelReg[a]
+			}
+		}
+	}
+	return strings.ToLower(arg.String())
+}
+
+var intelOp = map[Op]string{
+	JAE:       "jnb",
+	JA:        "jnbe",
+	JGE:       "jnl",
+	JNE:       "jnz",
+	JG:        "jnle",
+	JE:        "jz",
+	SETAE:     "setnb",
+	SETA:      "setnbe",
+	SETGE:     "setnl",
+	SETNE:     "setnz",
+	SETG:      "setnle",
+	SETE:      "setz",
+	CMOVAE:    "cmovnb",
+	CMOVA:     "cmovnbe",
+	CMOVGE:    "cmovnl",
+	CMOVNE:    "cmovnz",
+	CMOVG:     "cmovnle",
+	CMOVE:     "cmovz",
+	LCALL:     "call far",
+	LJMP:      "jmp far",
+	LRET:      "ret far",
+	ICEBP:     "int1",
+	MOVSD_XMM: "movsd",
+	XLATB:     "xlat",
+}
+
+var intelReg = [...]string{
+	F0:  "st0",
+	F1:  "st1",
+	F2:  "st2",
+	F3:  "st3",
+	F4:  "st4",
+	F5:  "st5",
+	F6:  "st6",
+	F7:  "st7",
+	M0:  "mmx0",
+	M1:  "mmx1",
+	M2:  "mmx2",
+	M3:  "mmx3",
+	M4:  "mmx4",
+	M5:  "mmx5",
+	M6:  "mmx6",
+	M7:  "mmx7",
+	X0:  "xmm0",
+	X1:  "xmm1",
+	X2:  "xmm2",
+	X3:  "xmm3",
+	X4:  "xmm4",
+	X5:  "xmm5",
+	X6:  "xmm6",
+	X7:  "xmm7",
+	X8:  "xmm8",
+	X9:  "xmm9",
+	X10: "xmm10",
+	X11: "xmm11",
+	X12: "xmm12",
+	X13: "xmm13",
+	X14: "xmm14",
+	X15: "xmm15",
+
+	// TODO: Maybe the constants are named wrong.
+	SPB: "spl",
+	BPB: "bpl",
+	SIB: "sil",
+	DIB: "dil",
+
+	R8L:  "r8d",
+	R9L:  "r9d",
+	R10L: "r10d",
+	R11L: "r11d",
+	R12L: "r12d",
+	R13L: "r13d",
+	R14L: "r14d",
+	R15L: "r15d",
+}
diff --git a/vendor/golang.org/x/arch/x86/x86asm/plan9x.go b/vendor/golang.org/x/arch/x86/x86asm/plan9x.go
new file mode 100644
index 000000000..59d8f9775
--- /dev/null
+++ b/vendor/golang.org/x/arch/x86/x86asm/plan9x.go
@@ -0,0 +1,382 @@
+// Copyright 2014 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package x86asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type SymLookup func(uint64) (string, uint64)
+
+// GoSyntax returns the Go assembler syntax for the instruction.
+// The syntax was originally defined by Plan 9.
+// The pc is the program counter of the instruction, used for expanding
+// PC-relative addresses into absolute ones.
+// The symname function queries the symbol table for the program
+// being disassembled. Given a target address it returns the name and base
+// address of the symbol containing the target, if any; otherwise it returns "", 0.
+func GoSyntax(inst Inst, pc uint64, symname SymLookup) string {
+	if symname == nil {
+		symname = func(uint64) (string, uint64) { return "", 0 }
+	}
+	var args []string
+	for i := len(inst.Args) - 1; i >= 0; i-- {
+		a := inst.Args[i]
+		if a == nil {
+			continue
+		}
+		args = append(args, plan9Arg(&inst, pc, symname, a))
+	}
+
+	var rep string
+	var last Prefix
+	for _, p := range inst.Prefix {
+		if p == 0 || p.IsREX() || p.IsVEX() {
+			break
+		}
+
+		switch {
+		// Don't show prefixes implied by the instruction text.
+		case p&0xFF00 == PrefixImplicit:
+			continue
+		// Only REP and REPN are recognized repeaters. Plan 9 syntax
+		// treats them as separate opcodes.
+		case p&0xFF == PrefixREP:
+			rep = "REP; "
+		case p&0xFF == PrefixREPN:
+			rep = "REPNE; "
+		default:
+			last = p
+		}
+	}
+
+	prefix := ""
+	switch last & 0xFF {
+	case 0, 0x66, 0x67:
+		// ignore
+	default:
+		prefix += last.String() + " "
+	}
+
+	op := inst.Op.String()
+	if plan9Suffix[inst.Op] {
+		s := inst.DataSize
+		if inst.MemBytes != 0 {
+			s = inst.MemBytes * 8
+		}
+		switch s {
+		case 8:
+			op += "B"
+		case 16:
+			op += "W"
+		case 32:
+			op += "L"
+		case 64:
+			op += "Q"
+		}
+	}
+
+	if args != nil {
+		op += " " + strings.Join(args, ", ")
+	}
+
+	return rep + prefix + op
+}
+
+func plan9Arg(inst *Inst, pc uint64, symname func(uint64) (string, uint64), arg Arg) string {
+	switch a := arg.(type) {
+	case Reg:
+		return plan9Reg[a]
+	case Rel:
+		if pc == 0 {
+			break
+		}
+		// If the absolute address is the start of a symbol, use the name.
+		// Otherwise use the raw address, so that things like relative
+		// jumps show up as JMP 0x123 instead of JMP f+10(SB).
+		// It is usually easier to search for 0x123 than to do the mental
+		// arithmetic to find f+10.
+		addr := pc + uint64(inst.Len) + uint64(a)
+		if s, base := symname(addr); s != "" && addr == base {
+			return fmt.Sprintf("%s(SB)", s)
+		}
+		return fmt.Sprintf("%#x", addr)
+
+	case Imm:
+		if s, base := symname(uint64(a)); s != "" {
+			suffix := ""
+			if uint64(a) != base {
+				suffix = fmt.Sprintf("%+d", uint64(a)-base)
+			}
+			return fmt.Sprintf("$%s%s(SB)", s, suffix)
+		}
+		if inst.Mode == 32 {
+			return fmt.Sprintf("$%#x", uint32(a))
+		}
+		if Imm(int32(a)) == a {
+			return fmt.Sprintf("$%#x", int64(a))
+		}
+		return fmt.Sprintf("$%#x", uint64(a))
+	case Mem:
+		if s, disp := memArgToSymbol(a, pc, inst.Len, symname); s != "" {
+			suffix := ""
+			if disp != 0 {
+				suffix = fmt.Sprintf("%+d", disp)
+			}
+			return fmt.Sprintf("%s%s(SB)", s, suffix)
+		}
+		s := ""
+		if a.Segment != 0 {
+			s += fmt.Sprintf("%s:", plan9Reg[a.Segment])
+		}
+		if a.Disp != 0 {
+			s += fmt.Sprintf("%#x", a.Disp)
+		} else {
+			s += "0"
+		}
+		if a.Base != 0 {
+			s += fmt.Sprintf("(%s)", plan9Reg[a.Base])
+		}
+		if a.Index != 0 && a.Scale != 0 {
+			s += fmt.Sprintf("(%s*%d)", plan9Reg[a.Index], a.Scale)
+		}
+		return s
+	}
+	return arg.String()
+}
+
+func memArgToSymbol(a Mem, pc uint64, instrLen int, symname SymLookup) (string, int64) {
+	if a.Segment != 0 || a.Disp == 0 || a.Index != 0 || a.Scale != 0 {
+		return "", 0
+	}
+
+	var disp uint64
+	switch a.Base {
+	case IP, EIP, RIP:
+		disp = uint64(a.Disp + int64(pc) + int64(instrLen))
+	case 0:
+		disp = uint64(a.Disp)
+	default:
+		return "", 0
+	}
+
+	s, base := symname(disp)
+	return s, int64(disp) - int64(base)
+}
+
+var plan9Suffix = [maxOp + 1]bool{
+	ADC:       true,
+	ADD:       true,
+	AND:       true,
+	BSF:       true,
+	BSR:       true,
+	BT:        true,
+	BTC:       true,
+	BTR:       true,
+	BTS:       true,
+	CMP:       true,
+	CMPXCHG:   true,
+	CVTSI2SD:  true,
+	CVTSI2SS:  true,
+	CVTSD2SI:  true,
+	CVTSS2SI:  true,
+	CVTTSD2SI: true,
+	CVTTSS2SI: true,
+	DEC:       true,
+	DIV:       true,
+	FLDENV:    true,
+	FRSTOR:    true,
+	IDIV:      true,
+	IMUL:      true,
+	IN:        true,
+	INC:       true,
+	LEA:       true,
+	MOV:       true,
+	MOVNTI:    true,
+	MUL:       true,
+	NEG:       true,
+	NOP:       true,
+	NOT:       true,
+	OR:        true,
+	OUT:       true,
+	POP:       true,
+	POPA:      true,
+	POPCNT:    true,
+	PUSH:      true,
+	PUSHA:     true,
+	RCL:       true,
+	RCR:       true,
+	ROL:       true,
+	ROR:       true,
+	SAR:       true,
+	SBB:       true,
+	SHL:       true,
+	SHLD:      true,
+	SHR:       true,
+	SHRD:      true,
+	SUB:       true,
+	TEST:      true,
+	XADD:      true,
+	XCHG:      true,
+	XOR:       true,
+}
+
+var plan9Reg = [...]string{
+	AL:   "AL",
+	CL:   "CL",
+	BL:   "BL",
+	DL:   "DL",
+	AH:   "AH",
+	CH:   "CH",
+	BH:   "BH",
+	DH:   "DH",
+	SPB:  "SP",
+	BPB:  "BP",
+	SIB:  "SI",
+	DIB:  "DI",
+	R8B:  "R8",
+	R9B:  "R9",
+	R10B: "R10",
+	R11B: "R11",
+	R12B: "R12",
+	R13B: "R13",
+	R14B: "R14",
+	R15B: "R15",
+	AX:   "AX",
+	CX:   "CX",
+	BX:   "BX",
+	DX:   "DX",
+	SP:   "SP",
+	BP:   "BP",
+	SI:   "SI",
+	DI:   "DI",
+	R8W:  "R8",
+	R9W:  "R9",
+	R10W: "R10",
+	R11W: "R11",
+	R12W: "R12",
+	R13W: "R13",
+	R14W: "R14",
+	R15W: "R15",
+	EAX:  "AX",
+	ECX:  "CX",
+	EDX:  "DX",
+	EBX:  "BX",
+	ESP:  "SP",
+	EBP:  "BP",
+	ESI:  "SI",
+	EDI:  "DI",
+	R8L:  "R8",
+	R9L:  "R9",
+	R10L: "R10",
+	R11L: "R11",
+	R12L: "R12",
+	R13L: "R13",
+	R14L: "R14",
+	R15L: "R15",
+	RAX:  "AX",
+	RCX:  "CX",
+	RDX:  "DX",
+	RBX:  "BX",
+	RSP:  "SP",
+	RBP:  "BP",
+	RSI:  "SI",
+	RDI:  "DI",
+	R8:   "R8",
+	R9:   "R9",
+	R10:  "R10",
+	R11:  "R11",
+	R12:  "R12",
+	R13:  "R13",
+	R14:  "R14",
+	R15:  "R15",
+	IP:   "IP",
+	EIP:  "IP",
+	RIP:  "IP",
+	F0:   "F0",
+	F1:   "F1",
+	F2:   "F2",
+	F3:   "F3",
+	F4:   "F4",
+	F5:   "F5",
+	F6:   "F6",
+	F7:   "F7",
+	M0:   "M0",
+	M1:   "M1",
+	M2:   "M2",
+	M3:   "M3",
+	M4:   "M4",
+	M5:   "M5",
+	M6:   "M6",
+	M7:   "M7",
+	X0:   "X0",
+	X1:   "X1",
+	X2:   "X2",
+	X3:   "X3",
+	X4:   "X4",
+	X5:   "X5",
+	X6:   "X6",
+	X7:   "X7",
+	X8:   "X8",
+	X9:   "X9",
+	X10:  "X10",
+	X11:  "X11",
+	X12:  "X12",
+	X13:  "X13",
+	X14:  "X14",
+	X15:  "X15",
+	CS:   "CS",
+	SS:   "SS",
+	DS:   "DS",
+	ES:   "ES",
+	FS:   "FS",
+	GS:   "GS",
+	GDTR: "GDTR",
+	IDTR: "IDTR",
+	LDTR: "LDTR",
+	MSW:  "MSW",
+	TASK: "TASK",
+	CR0:  "CR0",
+	CR1:  "CR1",
+	CR2:  "CR2",
+	CR3:  "CR3",
+	CR4:  "CR4",
+	CR5:  "CR5",
+	CR6:  "CR6",
+	CR7:  "CR7",
+	CR8:  "CR8",
+	CR9:  "CR9",
+	CR10: "CR10",
+	CR11: "CR11",
+	CR12: "CR12",
+	CR13: "CR13",
+	CR14: "CR14",
+	CR15: "CR15",
+	DR0:  "DR0",
+	DR1:  "DR1",
+	DR2:  "DR2",
+	DR3:  "DR3",
+	DR4:  "DR4",
+	DR5:  "DR5",
+	DR6:  "DR6",
+	DR7:  "DR7",
+	DR8:  "DR8",
+	DR9:  "DR9",
+	DR10: "DR10",
+	DR11: "DR11",
+	DR12: "DR12",
+	DR13: "DR13",
+	DR14: "DR14",
+	DR15: "DR15",
+	TR0:  "TR0",
+	TR1:  "TR1",
+	TR2:  "TR2",
+	TR3:  "TR3",
+	TR4:  "TR4",
+	TR5:  "TR5",
+	TR6:  "TR6",
+	TR7:  "TR7",
+}
diff --git a/vendor/golang.org/x/arch/x86/x86asm/tables.go b/vendor/golang.org/x/arch/x86/x86asm/tables.go
new file mode 100644
index 000000000..af3fb73c5
--- /dev/null
+++ b/vendor/golang.org/x/arch/x86/x86asm/tables.go
@@ -0,0 +1,9925 @@
+// DO NOT EDIT
+// generated by: x86map -fmt=decoder ../x86.csv
+
+package x86asm
+
+var decoder = [...]uint16{
+	uint16(xFail),
+	/*1*/ uint16(xCondByte), 243,
+	0x00, 490,
+	0x01, 496,
+	0x02, 525,
+	0x03, 531,
+	0x04, 560,
+	0x05, 566,
+	0x06, 595,
+	0x07, 602,
+	0x08, 609,
+	0x09, 615,
+	0x0A, 644,
+	0x0B, 650,
+	0x0C, 679,
+	0x0D, 685,
+	0x0E, 714,
+	0x0F, 721,
+	0x10, 8045,
+	0x11, 8051,
+	0x12, 8080,
+	0x13, 8086,
+	0x14, 8115,
+	0x15, 8121,
+	0x16, 8150,
+	0x17, 8157,
+	0x18, 8164,
+	0x19, 8170,
+	0x1A, 8199,
+	0x1B, 8205,
+	0x1C, 8234,
+	0x1D, 8240,
+	0x1E, 8269,
+	0x1F, 8276,
+	0x20, 8283,
+	0x21, 8289,
+	0x22, 8318,
+	0x23, 8324,
+	0x24, 8353,
+	0x25, 8359,
+	0x27, 8388,
+	0x28, 8394,
+	0x29, 8400,
+	0x2A, 8429,
+	0x2B, 8471,
+	0x2C, 8500,
+	0x2D, 8506,
+	0x2F, 8535,
+	0x30, 8541,
+	0x31, 8547,
+	0x32, 8576,
+	0x33, 8582,
+	0x34, 8611,
+	0x35, 8617,
+	0x37, 8646,
+	0x38, 8652,
+	0x39, 8658,
+	0x3A, 8687,
+	0x3B, 8693,
+	0x3C, 8722,
+	0x3D, 8728,
+	0x3F, 8757,
+	0x40, 8763,
+	0x41, 8763,
+	0x42, 8763,
+	0x43, 8763,
+	0x44, 8763,
+	0x45, 8763,
+	0x46, 8763,
+	0x47, 8763,
+	0x48, 8778,
+	0x49, 8778,
+	0x4a, 8778,
+	0x4b, 8778,
+	0x4c, 8778,
+	0x4d, 8778,
+	0x4e, 8778,
+	0x4f, 8778,
+	0x50, 8793,
+	0x51, 8793,
+	0x52, 8793,
+	0x53, 8793,
+	0x54, 8793,
+	0x55, 8793,
+	0x56, 8793,
+	0x57, 8793,
+	0x58, 8820,
+	0x59, 8820,
+	0x5a, 8820,
+	0x5b, 8820,
+	0x5c, 8820,
+	0x5d, 8820,
+	0x5e, 8820,
+	0x5f, 8820,
+	0x60, 8847,
+	0x61, 8860,
+	0x62, 8873,
+	0x63, 8892,
+	0x68, 8923,
+	0x69, 8942,
+	0x6A, 8977,
+	0x6B, 8982,
+	0x6C, 9017,
+	0x6D, 9020,
+	0x6E, 9033,
+	0x6F, 9036,
+	0x70, 9109,
+	0x71, 9114,
+	0x72, 9119,
+	0x73, 9124,
+	0x74, 9129,
+	0x75, 9134,
+	0x76, 9139,
+	0x77, 9144,
+	0x78, 9171,
+	0x79, 9176,
+	0x7A, 9181,
+	0x7B, 9186,
+	0x7C, 9191,
+	0x7D, 9196,
+	0x7E, 9201,
+	0x7F, 9206,
+	0x80, 9271,
+	0x81, 9328,
+	0x83, 9569,
+	0x84, 9810,
+	0x85, 9816,
+	0x86, 9845,
+	0x87, 9851,
+	0x88, 9880,
+	0x89, 9886,
+	0x8A, 9908,
+	0x8B, 9914,
+	0x8C, 9936,
+	0x8D, 9965,
+	0x8E, 9994,
+	0x8F, 10023,
+	0x90, 10059,
+	0x91, 10059,
+	0x92, 10059,
+	0x93, 10059,
+	0x94, 10059,
+	0x95, 10059,
+	0x96, 10059,
+	0x97, 10059,
+	0x98, 10085,
+	0x99, 10105,
+	0x9A, 10125,
+	0x9B, 10142,
+	0x9C, 10145,
+	0x9D, 10168,
+	0x9E, 10191,
+	0x9F, 10194,
+	0xA0, 10197,
+	0xA1, 10216,
+	0xA2, 10238,
+	0xA3, 10257,
+	0xA4, 10279,
+	0xA5, 10282,
+	0xA6, 10302,
+	0xA7, 10305,
+	0xA8, 10325,
+	0xA9, 10331,
+	0xAA, 10360,
+	0xAB, 10363,
+	0xAC, 10383,
+	0xAD, 10386,
+	0xAE, 10406,
+	0xAF, 10409,
+	0xb0, 10429,
+	0xb1, 10429,
+	0xb2, 10429,
+	0xb3, 10429,
+	0xb4, 10429,
+	0xb5, 10429,
+	0xb6, 10429,
+	0xb7, 10429,
+	0xb8, 10435,
+	0xb9, 10435,
+	0xba, 10435,
+	0xbb, 10435,
+	0xbc, 10435,
+	0xbd, 10435,
+	0xbe, 10435,
+	0xbf, 10435,
+	0xC0, 10464,
+	0xC1, 10515,
+	0xC2, 10713,
+	0xC3, 10718,
+	0xC4, 10721,
+	0xC5, 10740,
+	0xC6, 10759,
+	0xC7, 10783,
+	0xC8, 10844,
+	0xC9, 10851,
+	0xCA, 10874,
+	0xCB, 10879,
+	0xCC, 10882,
+	0xCD, 10886,
+	0xCE, 10891,
+	0xCF, 10897,
+	0xD0, 10917,
+	0xD1, 10961,
+	0xD2, 11152,
+	0xD3, 11196,
+	0xD4, 11387,
+	0xD5, 11395,
+	0xD7, 11403,
+	0xD8, 11416,
+	0xD9, 11625,
+	0xDA, 11844,
+	0xDB, 11976,
+	0xDC, 12147,
+	0xDD, 12316,
+	0xDE, 12455,
+	0xDF, 12629,
+	0xE0, 12740,
+	0xE1, 12745,
+	0xE2, 12750,
+	0xE3, 12755,
+	0xE4, 12781,
+	0xE5, 12787,
+	0xE6, 12809,
+	0xE7, 12815,
+	0xE8, 12873,
+	0xE9, 12904,
+	0xEA, 12935,
+	0xEB, 12952,
+	0xEC, 12957,
+	0xED, 12962,
+	0xEE, 12981,
+	0xEF, 12986,
+	0xF1, 13005,
+	0xF4, 13008,
+	0xF5, 13011,
+	0xF6, 13014,
+	0xF7, 13053,
+	0xF8, 13229,
+	0xF9, 13232,
+	0xFA, 13235,
+	0xFB, 13238,
+	0xFC, 13241,
+	0xFD, 13244,
+	0xFE, 13247,
+	0xFF, 13264,
+	uint16(xFail),
+	/*490*/ uint16(xSetOp), uint16(ADD),
+	/*492*/ uint16(xReadSlashR),
+	/*493*/ uint16(xArgRM8),
+	/*494*/ uint16(xArgR8),
+	/*495*/ uint16(xMatch),
+	/*496*/ uint16(xCondIs64), 499, 515,
+	/*499*/ uint16(xCondDataSize), 503, 509, 0,
+	/*503*/ uint16(xSetOp), uint16(ADD),
+	/*505*/ uint16(xReadSlashR),
+	/*506*/ uint16(xArgRM16),
+	/*507*/ uint16(xArgR16),
+	/*508*/ uint16(xMatch),
+	/*509*/ uint16(xSetOp), uint16(ADD),
+	/*511*/ uint16(xReadSlashR),
+	/*512*/ uint16(xArgRM32),
+	/*513*/ uint16(xArgR32),
+	/*514*/ uint16(xMatch),
+	/*515*/ uint16(xCondDataSize), 503, 509, 519,
+	/*519*/ uint16(xSetOp), uint16(ADD),
+	/*521*/ uint16(xReadSlashR),
+	/*522*/ uint16(xArgRM64),
+	/*523*/ uint16(xArgR64),
+	/*524*/ uint16(xMatch),
+	/*525*/ uint16(xSetOp), uint16(ADD),
+	/*527*/ uint16(xReadSlashR),
+	/*528*/ uint16(xArgR8),
+	/*529*/ uint16(xArgRM8),
+	/*530*/ uint16(xMatch),
+	/*531*/ uint16(xCondIs64), 534, 550,
+	/*534*/ uint16(xCondDataSize), 538, 544, 0,
+	/*538*/ uint16(xSetOp), uint16(ADD),
+	/*540*/ uint16(xReadSlashR),
+	/*541*/ uint16(xArgR16),
+	/*542*/ uint16(xArgRM16),
+	/*543*/ uint16(xMatch),
+	/*544*/ uint16(xSetOp), uint16(ADD),
+	/*546*/ uint16(xReadSlashR),
+	/*547*/ uint16(xArgR32),
+	/*548*/ uint16(xArgRM32),
+	/*549*/ uint16(xMatch),
+	/*550*/ uint16(xCondDataSize), 538, 544, 554,
+	/*554*/ uint16(xSetOp), uint16(ADD),
+	/*556*/ uint16(xReadSlashR),
+	/*557*/ uint16(xArgR64),
+	/*558*/ uint16(xArgRM64),
+	/*559*/ uint16(xMatch),
+	/*560*/ uint16(xSetOp), uint16(ADD),
+	/*562*/ uint16(xReadIb),
+	/*563*/ uint16(xArgAL),
+	/*564*/ uint16(xArgImm8u),
+	/*565*/ uint16(xMatch),
+	/*566*/ uint16(xCondIs64), 569, 585,
+	/*569*/ uint16(xCondDataSize), 573, 579, 0,
+	/*573*/ uint16(xSetOp), uint16(ADD),
+	/*575*/ uint16(xReadIw),
+	/*576*/ uint16(xArgAX),
+	/*577*/ uint16(xArgImm16),
+	/*578*/ uint16(xMatch),
+	/*579*/ uint16(xSetOp), uint16(ADD),
+	/*581*/ uint16(xReadId),
+	/*582*/ uint16(xArgEAX),
+	/*583*/ uint16(xArgImm32),
+	/*584*/ uint16(xMatch),
+	/*585*/ uint16(xCondDataSize), 573, 579, 589,
+	/*589*/ uint16(xSetOp), uint16(ADD),
+	/*591*/ uint16(xReadId),
+	/*592*/ uint16(xArgRAX),
+	/*593*/ uint16(xArgImm32),
+	/*594*/ uint16(xMatch),
+	/*595*/ uint16(xCondIs64), 598, 0,
+	/*598*/ uint16(xSetOp), uint16(PUSH),
+	/*600*/ uint16(xArgES),
+	/*601*/ uint16(xMatch),
+	/*602*/ uint16(xCondIs64), 605, 0,
+	/*605*/ uint16(xSetOp), uint16(POP),
+	/*607*/ uint16(xArgES),
+	/*608*/ uint16(xMatch),
+	/*609*/ uint16(xSetOp), uint16(OR),
+	/*611*/ uint16(xReadSlashR),
+	/*612*/ uint16(xArgRM8),
+	/*613*/ uint16(xArgR8),
+	/*614*/ uint16(xMatch),
+	/*615*/ uint16(xCondIs64), 618, 634,
+	/*618*/ uint16(xCondDataSize), 622, 628, 0,
+	/*622*/ uint16(xSetOp), uint16(OR),
+	/*624*/ uint16(xReadSlashR),
+	/*625*/ uint16(xArgRM16),
+	/*626*/ uint16(xArgR16),
+	/*627*/ uint16(xMatch),
+	/*628*/ uint16(xSetOp), uint16(OR),
+	/*630*/ uint16(xReadSlashR),
+	/*631*/ uint16(xArgRM32),
+	/*632*/ uint16(xArgR32),
+	/*633*/ uint16(xMatch),
+	/*634*/ uint16(xCondDataSize), 622, 628, 638,
+	/*638*/ uint16(xSetOp), uint16(OR),
+	/*640*/ uint16(xReadSlashR),
+	/*641*/ uint16(xArgRM64),
+	/*642*/ uint16(xArgR64),
+	/*643*/ uint16(xMatch),
+	/*644*/ uint16(xSetOp), uint16(OR),
+	/*646*/ uint16(xReadSlashR),
+	/*647*/ uint16(xArgR8),
+	/*648*/ uint16(xArgRM8),
+	/*649*/ uint16(xMatch),
+	/*650*/ uint16(xCondIs64), 653, 669,
+	/*653*/ uint16(xCondDataSize), 657, 663, 0,
+	/*657*/ uint16(xSetOp), uint16(OR),
+	/*659*/ uint16(xReadSlashR),
+	/*660*/ uint16(xArgR16),
+	/*661*/ uint16(xArgRM16),
+	/*662*/ uint16(xMatch),
+	/*663*/ uint16(xSetOp), uint16(OR),
+	/*665*/ uint16(xReadSlashR),
+	/*666*/ uint16(xArgR32),
+	/*667*/ uint16(xArgRM32),
+	/*668*/ uint16(xMatch),
+	/*669*/ uint16(xCondDataSize), 657, 663, 673,
+	/*673*/ uint16(xSetOp), uint16(OR),
+	/*675*/ uint16(xReadSlashR),
+	/*676*/ uint16(xArgR64),
+	/*677*/ uint16(xArgRM64),
+	/*678*/ uint16(xMatch),
+	/*679*/ uint16(xSetOp), uint16(OR),
+	/*681*/ uint16(xReadIb),
+	/*682*/ uint16(xArgAL),
+	/*683*/ uint16(xArgImm8u),
+	/*684*/ uint16(xMatch),
+	/*685*/ uint16(xCondIs64), 688, 704,
+	/*688*/ uint16(xCondDataSize), 692, 698, 0,
+	/*692*/ uint16(xSetOp), uint16(OR),
+	/*694*/ uint16(xReadIw),
+	/*695*/ uint16(xArgAX),
+	/*696*/ uint16(xArgImm16),
+	/*697*/ uint16(xMatch),
+	/*698*/ uint16(xSetOp), uint16(OR),
+	/*700*/ uint16(xReadId),
+	/*701*/ uint16(xArgEAX),
+	/*702*/ uint16(xArgImm32),
+	/*703*/ uint16(xMatch),
+	/*704*/ uint16(xCondDataSize), 692, 698, 708,
+	/*708*/ uint16(xSetOp), uint16(OR),
+	/*710*/ uint16(xReadId),
+	/*711*/ uint16(xArgRAX),
+	/*712*/ uint16(xArgImm32),
+	/*713*/ uint16(xMatch),
+	/*714*/ uint16(xCondIs64), 717, 0,
+	/*717*/ uint16(xSetOp), uint16(PUSH),
+	/*719*/ uint16(xArgCS),
+	/*720*/ uint16(xMatch),
+	/*721*/ uint16(xCondByte), 229,
+	0x00, 1182,
+	0x01, 1239,
+	0x02, 1347,
+	0x03, 1369,
+	0x05, 1391,
+	0x06, 1397,
+	0x07, 1400,
+	0x08, 1406,
+	0x09, 1409,
+	0x0B, 1412,
+	0x0D, 1415,
+	0x10, 1428,
+	0x11, 1462,
+	0x12, 1496,
+	0x13, 1539,
+	0x14, 1557,
+	0x15, 1575,
+	0x16, 1593,
+	0x17, 1628,
+	0x18, 1646,
+	0x1F, 1671,
+	0x20, 1692,
+	0x21, 1707,
+	0x22, 1722,
+	0x23, 1737,
+	0x24, 1752,
+	0x26, 1767,
+	0x28, 1782,
+	0x29, 1800,
+	0x2A, 1818,
+	0x2B, 1905,
+	0x2C, 1939,
+	0x2D, 2026,
+	0x2E, 2113,
+	0x2F, 2131,
+	0x30, 2149,
+	0x31, 2152,
+	0x32, 2155,
+	0x33, 2158,
+	0x34, 2161,
+	0x35, 2164,
+	0x38, 2174,
+	0x3A, 3075,
+	0x40, 3486,
+	0x41, 3515,
+	0x42, 3544,
+	0x43, 3573,
+	0x44, 3602,
+	0x45, 3631,
+	0x46, 3660,
+	0x47, 3689,
+	0x48, 3718,
+	0x49, 3747,
+	0x4A, 3776,
+	0x4B, 3805,
+	0x4C, 3834,
+	0x4D, 3863,
+	0x4E, 3892,
+	0x4F, 3921,
+	0x50, 3950,
+	0x51, 3968,
+	0x52, 4002,
+	0x53, 4020,
+	0x54, 4038,
+	0x55, 4056,
+	0x56, 4074,
+	0x57, 4092,
+	0x58, 4110,
+	0x59, 4144,
+	0x5A, 4178,
+	0x5B, 4212,
+	0x5C, 4238,
+	0x5D, 4272,
+	0x5E, 4306,
+	0x5F, 4340,
+	0x60, 4374,
+	0x61, 4392,
+	0x62, 4410,
+	0x63, 4428,
+	0x64, 4446,
+	0x65, 4464,
+	0x66, 4482,
+	0x67, 4500,
+	0x68, 4518,
+	0x69, 4536,
+	0x6A, 4554,
+	0x6B, 4572,
+	0x6C, 4590,
+	0x6D, 4600,
+	0x6E, 4610,
+	0x6F, 4677,
+	0x70, 4703,
+	0x71, 4745,
+	0x72, 4808,
+	0x73, 4871,
+	0x74, 4936,
+	0x75, 4954,
+	0x76, 4972,
+	0x77, 4990,
+	0x7C, 4993,
+	0x7D, 5011,
+	0x7E, 5029,
+	0x7F, 5106,
+	0x80, 5132,
+	0x81, 5163,
+	0x82, 5194,
+	0x83, 5225,
+	0x84, 5256,
+	0x85, 5287,
+	0x86, 5318,
+	0x87, 5349,
+	0x88, 5380,
+	0x89, 5411,
+	0x8A, 5442,
+	0x8B, 5473,
+	0x8C, 5504,
+	0x8D, 5535,
+	0x8E, 5566,
+	0x8F, 5597,
+	0x90, 5628,
+	0x91, 5633,
+	0x92, 5638,
+	0x93, 5643,
+	0x94, 5648,
+	0x95, 5653,
+	0x96, 5658,
+	0x97, 5663,
+	0x98, 5668,
+	0x99, 5673,
+	0x9A, 5678,
+	0x9B, 5683,
+	0x9C, 5688,
+	0x9D, 5693,
+	0x9E, 5698,
+	0x9F, 5703,
+	0xA0, 5708,
+	0xA1, 5712,
+	0xA2, 5739,
+	0xA3, 5742,
+	0xA4, 5771,
+	0xA5, 5806,
+	0xA8, 5838,
+	0xA9, 5842,
+	0xAA, 5869,
+	0xAB, 5872,
+	0xAC, 5901,
+	0xAD, 5936,
+	0xAE, 5968,
+	0xAF, 6226,
+	0xB0, 6255,
+	0xB1, 6261,
+	0xB2, 6290,
+	0xB3, 6319,
+	0xB4, 6348,
+	0xB5, 6377,
+	0xB6, 6406,
+	0xB7, 6435,
+	0xB8, 6464,
+	0xB9, 6501,
+	0xBA, 6511,
+	0xBB, 6636,
+	0xBC, 6665,
+	0xBD, 6732,
+	0xBE, 6799,
+	0xBF, 6828,
+	0xC0, 6857,
+	0xC1, 6863,
+	0xC2, 6892,
+	0xC3, 6934,
+	0xC4, 6963,
+	0xC5, 6985,
+	0xC6, 7007,
+	0xC7, 7029,
+	0xc8, 7158,
+	0xc9, 7158,
+	0xca, 7158,
+	0xcb, 7158,
+	0xcc, 7158,
+	0xcd, 7158,
+	0xce, 7158,
+	0xcf, 7158,
+	0xD0, 7181,
+	0xD1, 7199,
+	0xD2, 7217,
+	0xD3, 7235,
+	0xD4, 7253,
+	0xD5, 7271,
+	0xD6, 7289,
+	0xD7, 7315,
+	0xD8, 7333,
+	0xD9, 7351,
+	0xDA, 7369,
+	0xDB, 7387,
+	0xDC, 7405,
+	0xDD, 7423,
+	0xDE, 7441,
+	0xDF, 7459,
+	0xE0, 7477,
+	0xE1, 7495,
+	0xE2, 7513,
+	0xE3, 7531,
+	0xE4, 7549,
+	0xE5, 7567,
+	0xE6, 7585,
+	0xE7, 7611,
+	0xE8, 7629,
+	0xE9, 7647,
+	0xEA, 7665,
+	0xEB, 7683,
+	0xEC, 7701,
+	0xED, 7719,
+	0xEE, 7737,
+	0xEF, 7755,
+	0xF0, 7773,
+	0xF1, 7783,
+	0xF2, 7801,
+	0xF3, 7819,
+	0xF4, 7837,
+	0xF5, 7855,
+	0xF6, 7873,
+	0xF7, 7891,
+	0xF8, 7909,
+	0xF9, 7927,
+	0xFA, 7945,
+	0xFB, 7963,
+	0xFC, 7981,
+	0xFD, 7999,
+	0xFE, 8017,
+	0xFF, 8035,
+	uint16(xFail),
+	/*1182*/ uint16(xCondSlashR),
+	1191, // 0
+	1207, // 1
+	1223, // 2
+	1227, // 3
+	1231, // 4
+	1235, // 5
+	0,    // 6
+	0,    // 7
+	/*1191*/ uint16(xCondDataSize), 1195, 1199, 1203,
+	/*1195*/ uint16(xSetOp), uint16(SLDT),
+	/*1197*/ uint16(xArgRM16),
+	/*1198*/ uint16(xMatch),
+	/*1199*/ uint16(xSetOp), uint16(SLDT),
+	/*1201*/ uint16(xArgR32M16),
+	/*1202*/ uint16(xMatch),
+	/*1203*/ uint16(xSetOp), uint16(SLDT),
+	/*1205*/ uint16(xArgR64M16),
+	/*1206*/ uint16(xMatch),
+	/*1207*/ uint16(xCondDataSize), 1211, 1215, 1219,
+	/*1211*/ uint16(xSetOp), uint16(STR),
+	/*1213*/ uint16(xArgRM16),
+	/*1214*/ uint16(xMatch),
+	/*1215*/ uint16(xSetOp), uint16(STR),
+	/*1217*/ uint16(xArgR32M16),
+	/*1218*/ uint16(xMatch),
+	/*1219*/ uint16(xSetOp), uint16(STR),
+	/*1221*/ uint16(xArgR64M16),
+	/*1222*/ uint16(xMatch),
+	/*1223*/ uint16(xSetOp), uint16(LLDT),
+	/*1225*/ uint16(xArgRM16),
+	/*1226*/ uint16(xMatch),
+	/*1227*/ uint16(xSetOp), uint16(LTR),
+	/*1229*/ uint16(xArgRM16),
+	/*1230*/ uint16(xMatch),
+	/*1231*/ uint16(xSetOp), uint16(VERR),
+	/*1233*/ uint16(xArgRM16),
+	/*1234*/ uint16(xMatch),
+	/*1235*/ uint16(xSetOp), uint16(VERW),
+	/*1237*/ uint16(xArgRM16),
+	/*1238*/ uint16(xMatch),
+	/*1239*/ uint16(xCondByte), 8,
+	0xC8, 1320,
+	0xC9, 1323,
+	0xD0, 1326,
+	0xD1, 1329,
+	0xD5, 1332,
+	0xD6, 1335,
+	0xF8, 1338,
+	0xF9, 1344,
+	/*1257*/ uint16(xCondSlashR),
+	1266, // 0
+	1270, // 1
+	1274, // 2
+	1285, // 3
+	1296, // 4
+	0,    // 5
+	1312, // 6
+	1316, // 7
+	/*1266*/ uint16(xSetOp), uint16(SGDT),
+	/*1268*/ uint16(xArgM),
+	/*1269*/ uint16(xMatch),
+	/*1270*/ uint16(xSetOp), uint16(SIDT),
+	/*1272*/ uint16(xArgM),
+	/*1273*/ uint16(xMatch),
+	/*1274*/ uint16(xCondIs64), 1277, 1281,
+	/*1277*/ uint16(xSetOp), uint16(LGDT),
+	/*1279*/ uint16(xArgM16and32),
+	/*1280*/ uint16(xMatch),
+	/*1281*/ uint16(xSetOp), uint16(LGDT),
+	/*1283*/ uint16(xArgM16and64),
+	/*1284*/ uint16(xMatch),
+	/*1285*/ uint16(xCondIs64), 1288, 1292,
+	/*1288*/ uint16(xSetOp), uint16(LIDT),
+	/*1290*/ uint16(xArgM16and32),
+	/*1291*/ uint16(xMatch),
+	/*1292*/ uint16(xSetOp), uint16(LIDT),
+	/*1294*/ uint16(xArgM16and64),
+	/*1295*/ uint16(xMatch),
+	/*1296*/ uint16(xCondDataSize), 1300, 1304, 1308,
+	/*1300*/ uint16(xSetOp), uint16(SMSW),
+	/*1302*/ uint16(xArgRM16),
+	/*1303*/ uint16(xMatch),
+	/*1304*/ uint16(xSetOp), uint16(SMSW),
+	/*1306*/ uint16(xArgR32M16),
+	/*1307*/ uint16(xMatch),
+	/*1308*/ uint16(xSetOp), uint16(SMSW),
+	/*1310*/ uint16(xArgR64M16),
+	/*1311*/ uint16(xMatch),
+	/*1312*/ uint16(xSetOp), uint16(LMSW),
+	/*1314*/ uint16(xArgRM16),
+	/*1315*/ uint16(xMatch),
+	/*1316*/ uint16(xSetOp), uint16(INVLPG),
+	/*1318*/ uint16(xArgM),
+	/*1319*/ uint16(xMatch),
+	/*1320*/ uint16(xSetOp), uint16(MONITOR),
+	/*1322*/ uint16(xMatch),
+	/*1323*/ uint16(xSetOp), uint16(MWAIT),
+	/*1325*/ uint16(xMatch),
+	/*1326*/ uint16(xSetOp), uint16(XGETBV),
+	/*1328*/ uint16(xMatch),
+	/*1329*/ uint16(xSetOp), uint16(XSETBV),
+	/*1331*/ uint16(xMatch),
+	/*1332*/ uint16(xSetOp), uint16(XEND),
+	/*1334*/ uint16(xMatch),
+	/*1335*/ uint16(xSetOp), uint16(XTEST),
+	/*1337*/ uint16(xMatch),
+	/*1338*/ uint16(xCondIs64), 0, 1341,
+	/*1341*/ uint16(xSetOp), uint16(SWAPGS),
+	/*1343*/ uint16(xMatch),
+	/*1344*/ uint16(xSetOp), uint16(RDTSCP),
+	/*1346*/ uint16(xMatch),
+	/*1347*/ uint16(xCondDataSize), 1351, 1357, 1363,
+	/*1351*/ uint16(xSetOp), uint16(LAR),
+	/*1353*/ uint16(xReadSlashR),
+	/*1354*/ uint16(xArgR16),
+	/*1355*/ uint16(xArgRM16),
+	/*1356*/ uint16(xMatch),
+	/*1357*/ uint16(xSetOp), uint16(LAR),
+	/*1359*/ uint16(xReadSlashR),
+	/*1360*/ uint16(xArgR32),
+	/*1361*/ uint16(xArgR32M16),
+	/*1362*/ uint16(xMatch),
+	/*1363*/ uint16(xSetOp), uint16(LAR),
+	/*1365*/ uint16(xReadSlashR),
+	/*1366*/ uint16(xArgR64),
+	/*1367*/ uint16(xArgR64M16),
+	/*1368*/ uint16(xMatch),
+	/*1369*/ uint16(xCondDataSize), 1373, 1379, 1385,
+	/*1373*/ uint16(xSetOp), uint16(LSL),
+	/*1375*/ uint16(xReadSlashR),
+	/*1376*/ uint16(xArgR16),
+	/*1377*/ uint16(xArgRM16),
+	/*1378*/ uint16(xMatch),
+	/*1379*/ uint16(xSetOp), uint16(LSL),
+	/*1381*/ uint16(xReadSlashR),
+	/*1382*/ uint16(xArgR32),
+	/*1383*/ uint16(xArgR32M16),
+	/*1384*/ uint16(xMatch),
+	/*1385*/ uint16(xSetOp), uint16(LSL),
+	/*1387*/ uint16(xReadSlashR),
+	/*1388*/ uint16(xArgR64),
+	/*1389*/ uint16(xArgR32M16),
+	/*1390*/ uint16(xMatch),
+	/*1391*/ uint16(xCondIs64), 0, 1394,
+	/*1394*/ uint16(xSetOp), uint16(SYSCALL),
+	/*1396*/ uint16(xMatch),
+	/*1397*/ uint16(xSetOp), uint16(CLTS),
+	/*1399*/ uint16(xMatch),
+	/*1400*/ uint16(xCondIs64), 0, 1403,
+	/*1403*/ uint16(xSetOp), uint16(SYSRET),
+	/*1405*/ uint16(xMatch),
+	/*1406*/ uint16(xSetOp), uint16(INVD),
+	/*1408*/ uint16(xMatch),
+	/*1409*/ uint16(xSetOp), uint16(WBINVD),
+	/*1411*/ uint16(xMatch),
+	/*1412*/ uint16(xSetOp), uint16(UD2),
+	/*1414*/ uint16(xMatch),
+	/*1415*/ uint16(xCondSlashR),
+	0,    // 0
+	1424, // 1
+	0,    // 2
+	0,    // 3
+	0,    // 4
+	0,    // 5
+	0,    // 6
+	0,    // 7
+	/*1424*/ uint16(xSetOp), uint16(PREFETCHW),
+	/*1426*/ uint16(xArgM8),
+	/*1427*/ uint16(xMatch),
+	/*1428*/ uint16(xCondPrefix), 4,
+	0xF3, 1456,
+	0xF2, 1450,
+	0x66, 1444,
+	0x0, 1438,
+	/*1438*/ uint16(xSetOp), uint16(MOVUPS),
+	/*1440*/ uint16(xReadSlashR),
+	/*1441*/ uint16(xArgXmm1),
+	/*1442*/ uint16(xArgXmm2M128),
+	/*1443*/ uint16(xMatch),
+	/*1444*/ uint16(xSetOp), uint16(MOVUPD),
+	/*1446*/ uint16(xReadSlashR),
+	/*1447*/ uint16(xArgXmm1),
+	/*1448*/ uint16(xArgXmm2M128),
+	/*1449*/ uint16(xMatch),
+	/*1450*/ uint16(xSetOp), uint16(MOVSD_XMM),
+	/*1452*/ uint16(xReadSlashR),
+	/*1453*/ uint16(xArgXmm1),
+	/*1454*/ uint16(xArgXmm2M64),
+	/*1455*/ uint16(xMatch),
+	/*1456*/ uint16(xSetOp), uint16(MOVSS),
+	/*1458*/ uint16(xReadSlashR),
+	/*1459*/ uint16(xArgXmm1),
+	/*1460*/ uint16(xArgXmm2M32),
+	/*1461*/ uint16(xMatch),
+	/*1462*/ uint16(xCondPrefix), 4,
+	0xF3, 1490,
+	0xF2, 1484,
+	0x66, 1478,
+	0x0, 1472,
+	/*1472*/ uint16(xSetOp), uint16(MOVUPS),
+	/*1474*/ uint16(xReadSlashR),
+	/*1475*/ uint16(xArgXmm2M128),
+	/*1476*/ uint16(xArgXmm1),
+	/*1477*/ uint16(xMatch),
+	/*1478*/ uint16(xSetOp), uint16(MOVUPD),
+	/*1480*/ uint16(xReadSlashR),
+	/*1481*/ uint16(xArgXmm2M128),
+	/*1482*/ uint16(xArgXmm),
+	/*1483*/ uint16(xMatch),
+	/*1484*/ uint16(xSetOp), uint16(MOVSD_XMM),
+	/*1486*/ uint16(xReadSlashR),
+	/*1487*/ uint16(xArgXmm2M64),
+	/*1488*/ uint16(xArgXmm1),
+	/*1489*/ uint16(xMatch),
+	/*1490*/ uint16(xSetOp), uint16(MOVSS),
+	/*1492*/ uint16(xReadSlashR),
+	/*1493*/ uint16(xArgXmm2M32),
+	/*1494*/ uint16(xArgXmm),
+	/*1495*/ uint16(xMatch),
+	/*1496*/ uint16(xCondPrefix), 4,
+	0xF3, 1533,
+	0xF2, 1527,
+	0x66, 1521,
+	0x0, 1506,
+	/*1506*/ uint16(xCondIsMem), 1509, 1515,
+	/*1509*/ uint16(xSetOp), uint16(MOVHLPS),
+	/*1511*/ uint16(xReadSlashR),
+	/*1512*/ uint16(xArgXmm1),
+	/*1513*/ uint16(xArgXmm2),
+	/*1514*/ uint16(xMatch),
+	/*1515*/ uint16(xSetOp), uint16(MOVLPS),
+	/*1517*/ uint16(xReadSlashR),
+	/*1518*/ uint16(xArgXmm),
+	/*1519*/ uint16(xArgM64),
+	/*1520*/ uint16(xMatch),
+	/*1521*/ uint16(xSetOp), uint16(MOVLPD),
+	/*1523*/ uint16(xReadSlashR),
+	/*1524*/ uint16(xArgXmm),
+	/*1525*/ uint16(xArgXmm2M64),
+	/*1526*/ uint16(xMatch),
+	/*1527*/ uint16(xSetOp), uint16(MOVDDUP),
+	/*1529*/ uint16(xReadSlashR),
+	/*1530*/ uint16(xArgXmm1),
+	/*1531*/ uint16(xArgXmm2M64),
+	/*1532*/ uint16(xMatch),
+	/*1533*/ uint16(xSetOp), uint16(MOVSLDUP),
+	/*1535*/ uint16(xReadSlashR),
+	/*1536*/ uint16(xArgXmm1),
+	/*1537*/ uint16(xArgXmm2M128),
+	/*1538*/ uint16(xMatch),
+	/*1539*/ uint16(xCondPrefix), 2,
+	0x66, 1551,
+	0x0, 1545,
+	/*1545*/ uint16(xSetOp), uint16(MOVLPS),
+	/*1547*/ uint16(xReadSlashR),
+	/*1548*/ uint16(xArgM64),
+	/*1549*/ uint16(xArgXmm),
+	/*1550*/ uint16(xMatch),
+	/*1551*/ uint16(xSetOp), uint16(MOVLPD),
+	/*1553*/ uint16(xReadSlashR),
+	/*1554*/ uint16(xArgXmm2M64),
+	/*1555*/ uint16(xArgXmm),
+	/*1556*/ uint16(xMatch),
+	/*1557*/ uint16(xCondPrefix), 2,
+	0x66, 1569,
+	0x0, 1563,
+	/*1563*/ uint16(xSetOp), uint16(UNPCKLPS),
+	/*1565*/ uint16(xReadSlashR),
+	/*1566*/ uint16(xArgXmm1),
+	/*1567*/ uint16(xArgXmm2M128),
+	/*1568*/ uint16(xMatch),
+	/*1569*/ uint16(xSetOp), uint16(UNPCKLPD),
+	/*1571*/ uint16(xReadSlashR),
+	/*1572*/ uint16(xArgXmm1),
+	/*1573*/ uint16(xArgXmm2M128),
+	/*1574*/ uint16(xMatch),
+	/*1575*/ uint16(xCondPrefix), 2,
+	0x66, 1587,
+	0x0, 1581,
+	/*1581*/ uint16(xSetOp), uint16(UNPCKHPS),
+	/*1583*/ uint16(xReadSlashR),
+	/*1584*/ uint16(xArgXmm1),
+	/*1585*/ uint16(xArgXmm2M128),
+	/*1586*/ uint16(xMatch),
+	/*1587*/ uint16(xSetOp), uint16(UNPCKHPD),
+	/*1589*/ uint16(xReadSlashR),
+	/*1590*/ uint16(xArgXmm1),
+	/*1591*/ uint16(xArgXmm2M128),
+	/*1592*/ uint16(xMatch),
+	/*1593*/ uint16(xCondPrefix), 3,
+	0xF3, 1622,
+	0x66, 1616,
+	0x0, 1601,
+	/*1601*/ uint16(xCondIsMem), 1604, 1610,
+	/*1604*/ uint16(xSetOp), uint16(MOVLHPS),
+	/*1606*/ uint16(xReadSlashR),
+	/*1607*/ uint16(xArgXmm1),
+	/*1608*/ uint16(xArgXmm2),
+	/*1609*/ uint16(xMatch),
+	/*1610*/ uint16(xSetOp), uint16(MOVHPS),
+	/*1612*/ uint16(xReadSlashR),
+	/*1613*/ uint16(xArgXmm),
+	/*1614*/ uint16(xArgM64),
+	/*1615*/ uint16(xMatch),
+	/*1616*/ uint16(xSetOp), uint16(MOVHPD),
+	/*1618*/ uint16(xReadSlashR),
+	/*1619*/ uint16(xArgXmm),
+	/*1620*/ uint16(xArgXmm2M64),
+	/*1621*/ uint16(xMatch),
+	/*1622*/ uint16(xSetOp), uint16(MOVSHDUP),
+	/*1624*/ uint16(xReadSlashR),
+	/*1625*/ uint16(xArgXmm1),
+	/*1626*/ uint16(xArgXmm2M128),
+	/*1627*/ uint16(xMatch),
+	/*1628*/ uint16(xCondPrefix), 2,
+	0x66, 1640,
+	0x0, 1634,
+	/*1634*/ uint16(xSetOp), uint16(MOVHPS),
+	/*1636*/ uint16(xReadSlashR),
+	/*1637*/ uint16(xArgM64),
+	/*1638*/ uint16(xArgXmm),
+	/*1639*/ uint16(xMatch),
+	/*1640*/ uint16(xSetOp), uint16(MOVHPD),
+	/*1642*/ uint16(xReadSlashR),
+	/*1643*/ uint16(xArgXmm2M64),
+	/*1644*/ uint16(xArgXmm),
+	/*1645*/ uint16(xMatch),
+	/*1646*/ uint16(xCondSlashR),
+	1655, // 0
+	1659, // 1
+	1663, // 2
+	1667, // 3
+	0,    // 4
+	0,    // 5
+	0,    // 6
+	0,    // 7
+	/*1655*/ uint16(xSetOp), uint16(PREFETCHNTA),
+	/*1657*/ uint16(xArgM8),
+	/*1658*/ uint16(xMatch),
+	/*1659*/ uint16(xSetOp), uint16(PREFETCHT0),
+	/*1661*/ uint16(xArgM8),
+	/*1662*/ uint16(xMatch),
+	/*1663*/ uint16(xSetOp), uint16(PREFETCHT1),
+	/*1665*/ uint16(xArgM8),
+	/*1666*/ uint16(xMatch),
+	/*1667*/ uint16(xSetOp), uint16(PREFETCHT2),
+	/*1669*/ uint16(xArgM8),
+	/*1670*/ uint16(xMatch),
+	/*1671*/ uint16(xCondSlashR),
+	1680, // 0
+	0,    // 1
+	0,    // 2
+	0,    // 3
+	0,    // 4
+	0,    // 5
+	0,    // 6
+	0,    // 7
+	/*1680*/ uint16(xCondDataSize), 1684, 1688, 0,
+	/*1684*/ uint16(xSetOp), uint16(NOP),
+	/*1686*/ uint16(xArgRM16),
+	/*1687*/ uint16(xMatch),
+	/*1688*/ uint16(xSetOp), uint16(NOP),
+	/*1690*/ uint16(xArgRM32),
+	/*1691*/ uint16(xMatch),
+	/*1692*/ uint16(xCondIs64), 1695, 1701,
+	/*1695*/ uint16(xSetOp), uint16(MOV),
+	/*1697*/ uint16(xReadSlashR),
+	/*1698*/ uint16(xArgRmf32),
+	/*1699*/ uint16(xArgCR0dashCR7),
+	/*1700*/ uint16(xMatch),
+	/*1701*/ uint16(xSetOp), uint16(MOV),
+	/*1703*/ uint16(xReadSlashR),
+	/*1704*/ uint16(xArgRmf64),
+	/*1705*/ uint16(xArgCR0dashCR7),
+	/*1706*/ uint16(xMatch),
+	/*1707*/ uint16(xCondIs64), 1710, 1716,
+	/*1710*/ uint16(xSetOp), uint16(MOV),
+	/*1712*/ uint16(xReadSlashR),
+	/*1713*/ uint16(xArgRmf32),
+	/*1714*/ uint16(xArgDR0dashDR7),
+	/*1715*/ uint16(xMatch),
+	/*1716*/ uint16(xSetOp), uint16(MOV),
+	/*1718*/ uint16(xReadSlashR),
+	/*1719*/ uint16(xArgRmf64),
+	/*1720*/ uint16(xArgDR0dashDR7),
+	/*1721*/ uint16(xMatch),
+	/*1722*/ uint16(xCondIs64), 1725, 1731,
+	/*1725*/ uint16(xSetOp), uint16(MOV),
+	/*1727*/ uint16(xReadSlashR),
+	/*1728*/ uint16(xArgCR0dashCR7),
+	/*1729*/ uint16(xArgRmf32),
+	/*1730*/ uint16(xMatch),
+	/*1731*/ uint16(xSetOp), uint16(MOV),
+	/*1733*/ uint16(xReadSlashR),
+	/*1734*/ uint16(xArgCR0dashCR7),
+	/*1735*/ uint16(xArgRmf64),
+	/*1736*/ uint16(xMatch),
+	/*1737*/ uint16(xCondIs64), 1740, 1746,
+	/*1740*/ uint16(xSetOp), uint16(MOV),
+	/*1742*/ uint16(xReadSlashR),
+	/*1743*/ uint16(xArgDR0dashDR7),
+	/*1744*/ uint16(xArgRmf32),
+	/*1745*/ uint16(xMatch),
+	/*1746*/ uint16(xSetOp), uint16(MOV),
+	/*1748*/ uint16(xReadSlashR),
+	/*1749*/ uint16(xArgDR0dashDR7),
+	/*1750*/ uint16(xArgRmf64),
+	/*1751*/ uint16(xMatch),
+	/*1752*/ uint16(xCondIs64), 1755, 1761,
+	/*1755*/ uint16(xSetOp), uint16(MOV),
+	/*1757*/ uint16(xReadSlashR),
+	/*1758*/ uint16(xArgRmf32),
+	/*1759*/ uint16(xArgTR0dashTR7),
+	/*1760*/ uint16(xMatch),
+	/*1761*/ uint16(xSetOp), uint16(MOV),
+	/*1763*/ uint16(xReadSlashR),
+	/*1764*/ uint16(xArgRmf64),
+	/*1765*/ uint16(xArgTR0dashTR7),
+	/*1766*/ uint16(xMatch),
+	/*1767*/ uint16(xCondIs64), 1770, 1776,
+	/*1770*/ uint16(xSetOp), uint16(MOV),
+	/*1772*/ uint16(xReadSlashR),
+	/*1773*/ uint16(xArgTR0dashTR7),
+	/*1774*/ uint16(xArgRmf32),
+	/*1775*/ uint16(xMatch),
+	/*1776*/ uint16(xSetOp), uint16(MOV),
+	/*1778*/ uint16(xReadSlashR),
+	/*1779*/ uint16(xArgTR0dashTR7),
+	/*1780*/ uint16(xArgRmf64),
+	/*1781*/ uint16(xMatch),
+	/*1782*/ uint16(xCondPrefix), 2,
+	0x66, 1794,
+	0x0, 1788,
+	/*1788*/ uint16(xSetOp), uint16(MOVAPS),
+	/*1790*/ uint16(xReadSlashR),
+	/*1791*/ uint16(xArgXmm1),
+	/*1792*/ uint16(xArgXmm2M128),
+	/*1793*/ uint16(xMatch),
+	/*1794*/ uint16(xSetOp), uint16(MOVAPD),
+	/*1796*/ uint16(xReadSlashR),
+	/*1797*/ uint16(xArgXmm1),
+	/*1798*/ uint16(xArgXmm2M128),
+	/*1799*/ uint16(xMatch),
+	/*1800*/ uint16(xCondPrefix), 2,
+	0x66, 1812,
+	0x0, 1806,
+	/*1806*/ uint16(xSetOp), uint16(MOVAPS),
+	/*1808*/ uint16(xReadSlashR),
+	/*1809*/ uint16(xArgXmm2M128),
+	/*1810*/ uint16(xArgXmm1),
+	/*1811*/ uint16(xMatch),
+	/*1812*/ uint16(xSetOp), uint16(MOVAPD),
+	/*1814*/ uint16(xReadSlashR),
+	/*1815*/ uint16(xArgXmm2M128),
+	/*1816*/ uint16(xArgXmm1),
+	/*1817*/ uint16(xMatch),
+	/*1818*/ uint16(xCondIs64), 1821, 1875,
+	/*1821*/ uint16(xCondPrefix), 4,
+	0xF3, 1859,
+	0xF2, 1843,
+	0x66, 1837,
+	0x0, 1831,
+	/*1831*/ uint16(xSetOp), uint16(CVTPI2PS),
+	/*1833*/ uint16(xReadSlashR),
+	/*1834*/ uint16(xArgXmm),
+	/*1835*/ uint16(xArgMmM64),
+	/*1836*/ uint16(xMatch),
+	/*1837*/ uint16(xSetOp), uint16(CVTPI2PD),
+	/*1839*/ uint16(xReadSlashR),
+	/*1840*/ uint16(xArgXmm),
+	/*1841*/ uint16(xArgMmM64),
+	/*1842*/ uint16(xMatch),
+	/*1843*/ uint16(xCondDataSize), 1847, 1853, 0,
+	/*1847*/ uint16(xSetOp), uint16(CVTSI2SD),
+	/*1849*/ uint16(xReadSlashR),
+	/*1850*/ uint16(xArgXmm),
+	/*1851*/ uint16(xArgRM32),
+	/*1852*/ uint16(xMatch),
+	/*1853*/ uint16(xSetOp), uint16(CVTSI2SD),
+	/*1855*/ uint16(xReadSlashR),
+	/*1856*/ uint16(xArgXmm),
+	/*1857*/ uint16(xArgRM32),
+	/*1858*/ uint16(xMatch),
+	/*1859*/ uint16(xCondDataSize), 1863, 1869, 0,
+	/*1863*/ uint16(xSetOp), uint16(CVTSI2SS),
+	/*1865*/ uint16(xReadSlashR),
+	/*1866*/ uint16(xArgXmm),
+	/*1867*/ uint16(xArgRM32),
+	/*1868*/ uint16(xMatch),
+	/*1869*/ uint16(xSetOp), uint16(CVTSI2SS),
+	/*1871*/ uint16(xReadSlashR),
+	/*1872*/ uint16(xArgXmm),
+	/*1873*/ uint16(xArgRM32),
+	/*1874*/ uint16(xMatch),
+	/*1875*/ uint16(xCondPrefix), 4,
+	0xF3, 1895,
+	0xF2, 1885,
+	0x66, 1837,
+	0x0, 1831,
+	/*1885*/ uint16(xCondDataSize), 1847, 1853, 1889,
+	/*1889*/ uint16(xSetOp), uint16(CVTSI2SD),
+	/*1891*/ uint16(xReadSlashR),
+	/*1892*/ uint16(xArgXmm),
+	/*1893*/ uint16(xArgRM64),
+	/*1894*/ uint16(xMatch),
+	/*1895*/ uint16(xCondDataSize), 1863, 1869, 1899,
+	/*1899*/ uint16(xSetOp), uint16(CVTSI2SS),
+	/*1901*/ uint16(xReadSlashR),
+	/*1902*/ uint16(xArgXmm),
+	/*1903*/ uint16(xArgRM64),
+	/*1904*/ uint16(xMatch),
+	/*1905*/ uint16(xCondPrefix), 4,
+	0xF3, 1933,
+	0xF2, 1927,
+	0x66, 1921,
+	0x0, 1915,
+	/*1915*/ uint16(xSetOp), uint16(MOVNTPS),
+	/*1917*/ uint16(xReadSlashR),
+	/*1918*/ uint16(xArgM128),
+	/*1919*/ uint16(xArgXmm),
+	/*1920*/ uint16(xMatch),
+	/*1921*/ uint16(xSetOp), uint16(MOVNTPD),
+	/*1923*/ uint16(xReadSlashR),
+	/*1924*/ uint16(xArgM128),
+	/*1925*/ uint16(xArgXmm),
+	/*1926*/ uint16(xMatch),
+	/*1927*/ uint16(xSetOp), uint16(MOVNTSD),
+	/*1929*/ uint16(xReadSlashR),
+	/*1930*/ uint16(xArgM64),
+	/*1931*/ uint16(xArgXmm),
+	/*1932*/ uint16(xMatch),
+	/*1933*/ uint16(xSetOp), uint16(MOVNTSS),
+	/*1935*/ uint16(xReadSlashR),
+	/*1936*/ uint16(xArgM32),
+	/*1937*/ uint16(xArgXmm),
+	/*1938*/ uint16(xMatch),
+	/*1939*/ uint16(xCondIs64), 1942, 1996,
+	/*1942*/ uint16(xCondPrefix), 4,
+	0xF3, 1980,
+	0xF2, 1964,
+	0x66, 1958,
+	0x0, 1952,
+	/*1952*/ uint16(xSetOp), uint16(CVTTPS2PI),
+	/*1954*/ uint16(xReadSlashR),
+	/*1955*/ uint16(xArgMm),
+	/*1956*/ uint16(xArgXmmM64),
+	/*1957*/ uint16(xMatch),
+	/*1958*/ uint16(xSetOp), uint16(CVTTPD2PI),
+	/*1960*/ uint16(xReadSlashR),
+	/*1961*/ uint16(xArgMm),
+	/*1962*/ uint16(xArgXmmM128),
+	/*1963*/ uint16(xMatch),
+	/*1964*/ uint16(xCondDataSize), 1968, 1974, 0,
+	/*1968*/ uint16(xSetOp), uint16(CVTTSD2SI),
+	/*1970*/ uint16(xReadSlashR),
+	/*1971*/ uint16(xArgR32),
+	/*1972*/ uint16(xArgXmmM64),
+	/*1973*/ uint16(xMatch),
+	/*1974*/ uint16(xSetOp), uint16(CVTTSD2SI),
+	/*1976*/ uint16(xReadSlashR),
+	/*1977*/ uint16(xArgR32),
+	/*1978*/ uint16(xArgXmmM64),
+	/*1979*/ uint16(xMatch),
+	/*1980*/ uint16(xCondDataSize), 1984, 1990, 0,
+	/*1984*/ uint16(xSetOp), uint16(CVTTSS2SI),
+	/*1986*/ uint16(xReadSlashR),
+	/*1987*/ uint16(xArgR32),
+	/*1988*/ uint16(xArgXmmM32),
+	/*1989*/ uint16(xMatch),
+	/*1990*/ uint16(xSetOp), uint16(CVTTSS2SI),
+	/*1992*/ uint16(xReadSlashR),
+	/*1993*/ uint16(xArgR32),
+	/*1994*/ uint16(xArgXmmM32),
+	/*1995*/ uint16(xMatch),
+	/*1996*/ uint16(xCondPrefix), 4,
+	0xF3, 2016,
+	0xF2, 2006,
+	0x66, 1958,
+	0x0, 1952,
+	/*2006*/ uint16(xCondDataSize), 1968, 1974, 2010,
+	/*2010*/ uint16(xSetOp), uint16(CVTTSD2SI),
+	/*2012*/ uint16(xReadSlashR),
+	/*2013*/ uint16(xArgR64),
+	/*2014*/ uint16(xArgXmmM64),
+	/*2015*/ uint16(xMatch),
+	/*2016*/ uint16(xCondDataSize), 1984, 1990, 2020,
+	/*2020*/ uint16(xSetOp), uint16(CVTTSS2SI),
+	/*2022*/ uint16(xReadSlashR),
+	/*2023*/ uint16(xArgR64),
+	/*2024*/ uint16(xArgXmmM32),
+	/*2025*/ uint16(xMatch),
+	/*2026*/ uint16(xCondIs64), 2029, 2083,
+	/*2029*/ uint16(xCondPrefix), 4,
+	0xF3, 2067,
+	0xF2, 2051,
+	0x66, 2045,
+	0x0, 2039,
+	/*2039*/ uint16(xSetOp), uint16(CVTPS2PI),
+	/*2041*/ uint16(xReadSlashR),
+	/*2042*/ uint16(xArgMm),
+	/*2043*/ uint16(xArgXmmM64),
+	/*2044*/ uint16(xMatch),
+	/*2045*/ uint16(xSetOp), uint16(CVTPD2PI),
+	/*2047*/ uint16(xReadSlashR),
+	/*2048*/ uint16(xArgMm),
+	/*2049*/ uint16(xArgXmmM128),
+	/*2050*/ uint16(xMatch),
+	/*2051*/ uint16(xCondDataSize), 2055, 2061, 0,
+	/*2055*/ uint16(xSetOp), uint16(CVTSD2SI),
+	/*2057*/ uint16(xReadSlashR),
+	/*2058*/ uint16(xArgR32),
+	/*2059*/ uint16(xArgXmmM64),
+	/*2060*/ uint16(xMatch),
+	/*2061*/ uint16(xSetOp), uint16(CVTSD2SI),
+	/*2063*/ uint16(xReadSlashR),
+	/*2064*/ uint16(xArgR32),
+	/*2065*/ uint16(xArgXmmM64),
+	/*2066*/ uint16(xMatch),
+	/*2067*/ uint16(xCondDataSize), 2071, 2077, 0,
+	/*2071*/ uint16(xSetOp), uint16(CVTSS2SI),
+	/*2073*/ uint16(xReadSlashR),
+	/*2074*/ uint16(xArgR32),
+	/*2075*/ uint16(xArgXmmM32),
+	/*2076*/ uint16(xMatch),
+	/*2077*/ uint16(xSetOp), uint16(CVTSS2SI),
+	/*2079*/ uint16(xReadSlashR),
+	/*2080*/ uint16(xArgR32),
+	/*2081*/ uint16(xArgXmmM32),
+	/*2082*/ uint16(xMatch),
+	/*2083*/ uint16(xCondPrefix), 4,
+	0xF3, 2103,
+	0xF2, 2093,
+	0x66, 2045,
+	0x0, 2039,
+	/*2093*/ uint16(xCondDataSize), 2055, 2061, 2097,
+	/*2097*/ uint16(xSetOp), uint16(CVTSD2SI),
+	/*2099*/ uint16(xReadSlashR),
+	/*2100*/ uint16(xArgR64),
+	/*2101*/ uint16(xArgXmmM64),
+	/*2102*/ uint16(xMatch),
+	/*2103*/ uint16(xCondDataSize), 2071, 2077, 2107,
+	/*2107*/ uint16(xSetOp), uint16(CVTSS2SI),
+	/*2109*/ uint16(xReadSlashR),
+	/*2110*/ uint16(xArgR64),
+	/*2111*/ uint16(xArgXmmM32),
+	/*2112*/ uint16(xMatch),
+	/*2113*/ uint16(xCondPrefix), 2,
+	0x66, 2125,
+	0x0, 2119,
+	/*2119*/ uint16(xSetOp), uint16(UCOMISS),
+	/*2121*/ uint16(xReadSlashR),
+	/*2122*/ uint16(xArgXmm1),
+	/*2123*/ uint16(xArgXmm2M32),
+	/*2124*/ uint16(xMatch),
+	/*2125*/ uint16(xSetOp), uint16(UCOMISD),
+	/*2127*/ uint16(xReadSlashR),
+	/*2128*/ uint16(xArgXmm1),
+	/*2129*/ uint16(xArgXmm2M64),
+	/*2130*/ uint16(xMatch),
+	/*2131*/ uint16(xCondPrefix), 2,
+	0x66, 2143,
+	0x0, 2137,
+	/*2137*/ uint16(xSetOp), uint16(COMISS),
+	/*2139*/ uint16(xReadSlashR),
+	/*2140*/ uint16(xArgXmm1),
+	/*2141*/ uint16(xArgXmm2M32),
+	/*2142*/ uint16(xMatch),
+	/*2143*/ uint16(xSetOp), uint16(COMISD),
+	/*2145*/ uint16(xReadSlashR),
+	/*2146*/ uint16(xArgXmm1),
+	/*2147*/ uint16(xArgXmm2M64),
+	/*2148*/ uint16(xMatch),
+	/*2149*/ uint16(xSetOp), uint16(WRMSR),
+	/*2151*/ uint16(xMatch),
+	/*2152*/ uint16(xSetOp), uint16(RDTSC),
+	/*2154*/ uint16(xMatch),
+	/*2155*/ uint16(xSetOp), uint16(RDMSR),
+	/*2157*/ uint16(xMatch),
+	/*2158*/ uint16(xSetOp), uint16(RDPMC),
+	/*2160*/ uint16(xMatch),
+	/*2161*/ uint16(xSetOp), uint16(SYSENTER),
+	/*2163*/ uint16(xMatch),
+	/*2164*/ uint16(xCondDataSize), 2168, 2168, 2171,
+	/*2168*/ uint16(xSetOp), uint16(SYSEXIT),
+	/*2170*/ uint16(xMatch),
+	/*2171*/ uint16(xSetOp), uint16(SYSEXIT),
+	/*2173*/ uint16(xMatch),
+	/*2174*/ uint16(xCondByte), 54,
+	0x00, 2285,
+	0x01, 2303,
+	0x02, 2321,
+	0x03, 2339,
+	0x04, 2357,
+	0x05, 2375,
+	0x06, 2393,
+	0x07, 2411,
+	0x08, 2429,
+	0x09, 2447,
+	0x0A, 2465,
+	0x0B, 2483,
+	0x10, 2501,
+	0x14, 2512,
+	0x15, 2523,
+	0x17, 2534,
+	0x1C, 2544,
+	0x1D, 2562,
+	0x1E, 2580,
+	0x20, 2598,
+	0x21, 2608,
+	0x22, 2618,
+	0x23, 2628,
+	0x24, 2638,
+	0x25, 2648,
+	0x28, 2658,
+	0x29, 2668,
+	0x2A, 2678,
+	0x2B, 2688,
+	0x30, 2698,
+	0x31, 2708,
+	0x32, 2718,
+	0x33, 2728,
+	0x34, 2738,
+	0x35, 2748,
+	0x37, 2758,
+	0x38, 2768,
+	0x39, 2778,
+	0x3A, 2788,
+	0x3B, 2798,
+	0x3C, 2808,
+	0x3D, 2818,
+	0x3E, 2828,
+	0x3F, 2838,
+	0x40, 2848,
+	0x41, 2858,
+	0x82, 2868,
+	0xDB, 2891,
+	0xDC, 2901,
+	0xDD, 2911,
+	0xDE, 2921,
+	0xDF, 2931,
+	0xF0, 2941,
+	0xF1, 3008,
+	uint16(xFail),
+	/*2285*/ uint16(xCondPrefix), 2,
+	0x66, 2297,
+	0x0, 2291,
+	/*2291*/ uint16(xSetOp), uint16(PSHUFB),
+	/*2293*/ uint16(xReadSlashR),
+	/*2294*/ uint16(xArgMm1),
+	/*2295*/ uint16(xArgMm2M64),
+	/*2296*/ uint16(xMatch),
+	/*2297*/ uint16(xSetOp), uint16(PSHUFB),
+	/*2299*/ uint16(xReadSlashR),
+	/*2300*/ uint16(xArgXmm1),
+	/*2301*/ uint16(xArgXmm2M128),
+	/*2302*/ uint16(xMatch),
+	/*2303*/ uint16(xCondPrefix), 2,
+	0x66, 2315,
+	0x0, 2309,
+	/*2309*/ uint16(xSetOp), uint16(PHADDW),
+	/*2311*/ uint16(xReadSlashR),
+	/*2312*/ uint16(xArgMm1),
+	/*2313*/ uint16(xArgMm2M64),
+	/*2314*/ uint16(xMatch),
+	/*2315*/ uint16(xSetOp), uint16(PHADDW),
+	/*2317*/ uint16(xReadSlashR),
+	/*2318*/ uint16(xArgXmm1),
+	/*2319*/ uint16(xArgXmm2M128),
+	/*2320*/ uint16(xMatch),
+	/*2321*/ uint16(xCondPrefix), 2,
+	0x66, 2333,
+	0x0, 2327,
+	/*2327*/ uint16(xSetOp), uint16(PHADDD),
+	/*2329*/ uint16(xReadSlashR),
+	/*2330*/ uint16(xArgMm1),
+	/*2331*/ uint16(xArgMm2M64),
+	/*2332*/ uint16(xMatch),
+	/*2333*/ uint16(xSetOp), uint16(PHADDD),
+	/*2335*/ uint16(xReadSlashR),
+	/*2336*/ uint16(xArgXmm1),
+	/*2337*/ uint16(xArgXmm2M128),
+	/*2338*/ uint16(xMatch),
+	/*2339*/ uint16(xCondPrefix), 2,
+	0x66, 2351,
+	0x0, 2345,
+	/*2345*/ uint16(xSetOp), uint16(PHADDSW),
+	/*2347*/ uint16(xReadSlashR),
+	/*2348*/ uint16(xArgMm1),
+	/*2349*/ uint16(xArgMm2M64),
+	/*2350*/ uint16(xMatch),
+	/*2351*/ uint16(xSetOp), uint16(PHADDSW),
+	/*2353*/ uint16(xReadSlashR),
+	/*2354*/ uint16(xArgXmm1),
+	/*2355*/ uint16(xArgXmm2M128),
+	/*2356*/ uint16(xMatch),
+	/*2357*/ uint16(xCondPrefix), 2,
+	0x66, 2369,
+	0x0, 2363,
+	/*2363*/ uint16(xSetOp), uint16(PMADDUBSW),
+	/*2365*/ uint16(xReadSlashR),
+	/*2366*/ uint16(xArgMm1),
+	/*2367*/ uint16(xArgMm2M64),
+	/*2368*/ uint16(xMatch),
+	/*2369*/ uint16(xSetOp), uint16(PMADDUBSW),
+	/*2371*/ uint16(xReadSlashR),
+	/*2372*/ uint16(xArgXmm1),
+	/*2373*/ uint16(xArgXmm2M128),
+	/*2374*/ uint16(xMatch),
+	/*2375*/ uint16(xCondPrefix), 2,
+	0x66, 2387,
+	0x0, 2381,
+	/*2381*/ uint16(xSetOp), uint16(PHSUBW),
+	/*2383*/ uint16(xReadSlashR),
+	/*2384*/ uint16(xArgMm1),
+	/*2385*/ uint16(xArgMm2M64),
+	/*2386*/ uint16(xMatch),
+	/*2387*/ uint16(xSetOp), uint16(PHSUBW),
+	/*2389*/ uint16(xReadSlashR),
+	/*2390*/ uint16(xArgXmm1),
+	/*2391*/ uint16(xArgXmm2M128),
+	/*2392*/ uint16(xMatch),
+	/*2393*/ uint16(xCondPrefix), 2,
+	0x66, 2405,
+	0x0, 2399,
+	/*2399*/ uint16(xSetOp), uint16(PHSUBD),
+	/*2401*/ uint16(xReadSlashR),
+	/*2402*/ uint16(xArgMm1),
+	/*2403*/ uint16(xArgMm2M64),
+	/*2404*/ uint16(xMatch),
+	/*2405*/ uint16(xSetOp), uint16(PHSUBD),
+	/*2407*/ uint16(xReadSlashR),
+	/*2408*/ uint16(xArgXmm1),
+	/*2409*/ uint16(xArgXmm2M128),
+	/*2410*/ uint16(xMatch),
+	/*2411*/ uint16(xCondPrefix), 2,
+	0x66, 2423,
+	0x0, 2417,
+	/*2417*/ uint16(xSetOp), uint16(PHSUBSW),
+	/*2419*/ uint16(xReadSlashR),
+	/*2420*/ uint16(xArgMm1),
+	/*2421*/ uint16(xArgMm2M64),
+	/*2422*/ uint16(xMatch),
+	/*2423*/ uint16(xSetOp), uint16(PHSUBSW),
+	/*2425*/ uint16(xReadSlashR),
+	/*2426*/ uint16(xArgXmm1),
+	/*2427*/ uint16(xArgXmm2M128),
+	/*2428*/ uint16(xMatch),
+	/*2429*/ uint16(xCondPrefix), 2,
+	0x66, 2441,
+	0x0, 2435,
+	/*2435*/ uint16(xSetOp), uint16(PSIGNB),
+	/*2437*/ uint16(xReadSlashR),
+	/*2438*/ uint16(xArgMm1),
+	/*2439*/ uint16(xArgMm2M64),
+	/*2440*/ uint16(xMatch),
+	/*2441*/ uint16(xSetOp), uint16(PSIGNB),
+	/*2443*/ uint16(xReadSlashR),
+	/*2444*/ uint16(xArgXmm1),
+	/*2445*/ uint16(xArgXmm2M128),
+	/*2446*/ uint16(xMatch),
+	/*2447*/ uint16(xCondPrefix), 2,
+	0x66, 2459,
+	0x0, 2453,
+	/*2453*/ uint16(xSetOp), uint16(PSIGNW),
+	/*2455*/ uint16(xReadSlashR),
+	/*2456*/ uint16(xArgMm1),
+	/*2457*/ uint16(xArgMm2M64),
+	/*2458*/ uint16(xMatch),
+	/*2459*/ uint16(xSetOp), uint16(PSIGNW),
+	/*2461*/ uint16(xReadSlashR),
+	/*2462*/ uint16(xArgXmm1),
+	/*2463*/ uint16(xArgXmm2M128),
+	/*2464*/ uint16(xMatch),
+	/*2465*/ uint16(xCondPrefix), 2,
+	0x66, 2477,
+	0x0, 2471,
+	/*2471*/ uint16(xSetOp), uint16(PSIGND),
+	/*2473*/ uint16(xReadSlashR),
+	/*2474*/ uint16(xArgMm1),
+	/*2475*/ uint16(xArgMm2M64),
+	/*2476*/ uint16(xMatch),
+	/*2477*/ uint16(xSetOp), uint16(PSIGND),
+	/*2479*/ uint16(xReadSlashR),
+	/*2480*/ uint16(xArgXmm1),
+	/*2481*/ uint16(xArgXmm2M128),
+	/*2482*/ uint16(xMatch),
+	/*2483*/ uint16(xCondPrefix), 2,
+	0x66, 2495,
+	0x0, 2489,
+	/*2489*/ uint16(xSetOp), uint16(PMULHRSW),
+	/*2491*/ uint16(xReadSlashR),
+	/*2492*/ uint16(xArgMm1),
+	/*2493*/ uint16(xArgMm2M64),
+	/*2494*/ uint16(xMatch),
+	/*2495*/ uint16(xSetOp), uint16(PMULHRSW),
+	/*2497*/ uint16(xReadSlashR),
+	/*2498*/ uint16(xArgXmm1),
+	/*2499*/ uint16(xArgXmm2M128),
+	/*2500*/ uint16(xMatch),
+	/*2501*/ uint16(xCondPrefix), 1,
+	0x66, 2505,
+	/*2505*/ uint16(xSetOp), uint16(PBLENDVB),
+	/*2507*/ uint16(xReadSlashR),
+	/*2508*/ uint16(xArgXmm1),
+	/*2509*/ uint16(xArgXmm2M128),
+	/*2510*/ uint16(xArgXMM0),
+	/*2511*/ uint16(xMatch),
+	/*2512*/ uint16(xCondPrefix), 1,
+	0x66, 2516,
+	/*2516*/ uint16(xSetOp), uint16(BLENDVPS),
+	/*2518*/ uint16(xReadSlashR),
+	/*2519*/ uint16(xArgXmm1),
+	/*2520*/ uint16(xArgXmm2M128),
+	/*2521*/ uint16(xArgXMM0),
+	/*2522*/ uint16(xMatch),
+	/*2523*/ uint16(xCondPrefix), 1,
+	0x66, 2527,
+	/*2527*/ uint16(xSetOp), uint16(BLENDVPD),
+	/*2529*/ uint16(xReadSlashR),
+	/*2530*/ uint16(xArgXmm1),
+	/*2531*/ uint16(xArgXmm2M128),
+	/*2532*/ uint16(xArgXMM0),
+	/*2533*/ uint16(xMatch),
+	/*2534*/ uint16(xCondPrefix), 1,
+	0x66, 2538,
+	/*2538*/ uint16(xSetOp), uint16(PTEST),
+	/*2540*/ uint16(xReadSlashR),
+	/*2541*/ uint16(xArgXmm1),
+	/*2542*/ uint16(xArgXmm2M128),
+	/*2543*/ uint16(xMatch),
+	/*2544*/ uint16(xCondPrefix), 2,
+	0x66, 2556,
+	0x0, 2550,
+	/*2550*/ uint16(xSetOp), uint16(PABSB),
+	/*2552*/ uint16(xReadSlashR),
+	/*2553*/ uint16(xArgMm1),
+	/*2554*/ uint16(xArgMm2M64),
+	/*2555*/ uint16(xMatch),
+	/*2556*/ uint16(xSetOp), uint16(PABSB),
+	/*2558*/ uint16(xReadSlashR),
+	/*2559*/ uint16(xArgXmm1),
+	/*2560*/ uint16(xArgXmm2M128),
+	/*2561*/ uint16(xMatch),
+	/*2562*/ uint16(xCondPrefix), 2,
+	0x66, 2574,
+	0x0, 2568,
+	/*2568*/ uint16(xSetOp), uint16(PABSW),
+	/*2570*/ uint16(xReadSlashR),
+	/*2571*/ uint16(xArgMm1),
+	/*2572*/ uint16(xArgMm2M64),
+	/*2573*/ uint16(xMatch),
+	/*2574*/ uint16(xSetOp), uint16(PABSW),
+	/*2576*/ uint16(xReadSlashR),
+	/*2577*/ uint16(xArgXmm1),
+	/*2578*/ uint16(xArgXmm2M128),
+	/*2579*/ uint16(xMatch),
+	/*2580*/ uint16(xCondPrefix), 2,
+	0x66, 2592,
+	0x0, 2586,
+	/*2586*/ uint16(xSetOp), uint16(PABSD),
+	/*2588*/ uint16(xReadSlashR),
+	/*2589*/ uint16(xArgMm1),
+	/*2590*/ uint16(xArgMm2M64),
+	/*2591*/ uint16(xMatch),
+	/*2592*/ uint16(xSetOp), uint16(PABSD),
+	/*2594*/ uint16(xReadSlashR),
+	/*2595*/ uint16(xArgXmm1),
+	/*2596*/ uint16(xArgXmm2M128),
+	/*2597*/ uint16(xMatch),
+	/*2598*/ uint16(xCondPrefix), 1,
+	0x66, 2602,
+	/*2602*/ uint16(xSetOp), uint16(PMOVSXBW),
+	/*2604*/ uint16(xReadSlashR),
+	/*2605*/ uint16(xArgXmm1),
+	/*2606*/ uint16(xArgXmm2M64),
+	/*2607*/ uint16(xMatch),
+	/*2608*/ uint16(xCondPrefix), 1,
+	0x66, 2612,
+	/*2612*/ uint16(xSetOp), uint16(PMOVSXBD),
+	/*2614*/ uint16(xReadSlashR),
+	/*2615*/ uint16(xArgXmm1),
+	/*2616*/ uint16(xArgXmm2M32),
+	/*2617*/ uint16(xMatch),
+	/*2618*/ uint16(xCondPrefix), 1,
+	0x66, 2622,
+	/*2622*/ uint16(xSetOp), uint16(PMOVSXBQ),
+	/*2624*/ uint16(xReadSlashR),
+	/*2625*/ uint16(xArgXmm1),
+	/*2626*/ uint16(xArgXmm2M16),
+	/*2627*/ uint16(xMatch),
+	/*2628*/ uint16(xCondPrefix), 1,
+	0x66, 2632,
+	/*2632*/ uint16(xSetOp), uint16(PMOVSXWD),
+	/*2634*/ uint16(xReadSlashR),
+	/*2635*/ uint16(xArgXmm1),
+	/*2636*/ uint16(xArgXmm2M64),
+	/*2637*/ uint16(xMatch),
+	/*2638*/ uint16(xCondPrefix), 1,
+	0x66, 2642,
+	/*2642*/ uint16(xSetOp), uint16(PMOVSXWQ),
+	/*2644*/ uint16(xReadSlashR),
+	/*2645*/ uint16(xArgXmm1),
+	/*2646*/ uint16(xArgXmm2M32),
+	/*2647*/ uint16(xMatch),
+	/*2648*/ uint16(xCondPrefix), 1,
+	0x66, 2652,
+	/*2652*/ uint16(xSetOp), uint16(PMOVSXDQ),
+	/*2654*/ uint16(xReadSlashR),
+	/*2655*/ uint16(xArgXmm1),
+	/*2656*/ uint16(xArgXmm2M64),
+	/*2657*/ uint16(xMatch),
+	/*2658*/ uint16(xCondPrefix), 1,
+	0x66, 2662,
+	/*2662*/ uint16(xSetOp), uint16(PMULDQ),
+	/*2664*/ uint16(xReadSlashR),
+	/*2665*/ uint16(xArgXmm1),
+	/*2666*/ uint16(xArgXmm2M128),
+	/*2667*/ uint16(xMatch),
+	/*2668*/ uint16(xCondPrefix), 1,
+	0x66, 2672,
+	/*2672*/ uint16(xSetOp), uint16(PCMPEQQ),
+	/*2674*/ uint16(xReadSlashR),
+	/*2675*/ uint16(xArgXmm1),
+	/*2676*/ uint16(xArgXmm2M128),
+	/*2677*/ uint16(xMatch),
+	/*2678*/ uint16(xCondPrefix), 1,
+	0x66, 2682,
+	/*2682*/ uint16(xSetOp), uint16(MOVNTDQA),
+	/*2684*/ uint16(xReadSlashR),
+	/*2685*/ uint16(xArgXmm1),
+	/*2686*/ uint16(xArgM128),
+	/*2687*/ uint16(xMatch),
+	/*2688*/ uint16(xCondPrefix), 1,
+	0x66, 2692,
+	/*2692*/ uint16(xSetOp), uint16(PACKUSDW),
+	/*2694*/ uint16(xReadSlashR),
+	/*2695*/ uint16(xArgXmm1),
+	/*2696*/ uint16(xArgXmm2M128),
+	/*2697*/ uint16(xMatch),
+	/*2698*/ uint16(xCondPrefix), 1,
+	0x66, 2702,
+	/*2702*/ uint16(xSetOp), uint16(PMOVZXBW),
+	/*2704*/ uint16(xReadSlashR),
+	/*2705*/ uint16(xArgXmm1),
+	/*2706*/ uint16(xArgXmm2M64),
+	/*2707*/ uint16(xMatch),
+	/*2708*/ uint16(xCondPrefix), 1,
+	0x66, 2712,
+	/*2712*/ uint16(xSetOp), uint16(PMOVZXBD),
+	/*2714*/ uint16(xReadSlashR),
+	/*2715*/ uint16(xArgXmm1),
+	/*2716*/ uint16(xArgXmm2M32),
+	/*2717*/ uint16(xMatch),
+	/*2718*/ uint16(xCondPrefix), 1,
+	0x66, 2722,
+	/*2722*/ uint16(xSetOp), uint16(PMOVZXBQ),
+	/*2724*/ uint16(xReadSlashR),
+	/*2725*/ uint16(xArgXmm1),
+	/*2726*/ uint16(xArgXmm2M16),
+	/*2727*/ uint16(xMatch),
+	/*2728*/ uint16(xCondPrefix), 1,
+	0x66, 2732,
+	/*2732*/ uint16(xSetOp), uint16(PMOVZXWD),
+	/*2734*/ uint16(xReadSlashR),
+	/*2735*/ uint16(xArgXmm1),
+	/*2736*/ uint16(xArgXmm2M64),
+	/*2737*/ uint16(xMatch),
+	/*2738*/ uint16(xCondPrefix), 1,
+	0x66, 2742,
+	/*2742*/ uint16(xSetOp), uint16(PMOVZXWQ),
+	/*2744*/ uint16(xReadSlashR),
+	/*2745*/ uint16(xArgXmm1),
+	/*2746*/ uint16(xArgXmm2M32),
+	/*2747*/ uint16(xMatch),
+	/*2748*/ uint16(xCondPrefix), 1,
+	0x66, 2752,
+	/*2752*/ uint16(xSetOp), uint16(PMOVZXDQ),
+	/*2754*/ uint16(xReadSlashR),
+	/*2755*/ uint16(xArgXmm1),
+	/*2756*/ uint16(xArgXmm2M64),
+	/*2757*/ uint16(xMatch),
+	/*2758*/ uint16(xCondPrefix), 1,
+	0x66, 2762,
+	/*2762*/ uint16(xSetOp), uint16(PCMPGTQ),
+	/*2764*/ uint16(xReadSlashR),
+	/*2765*/ uint16(xArgXmm1),
+	/*2766*/ uint16(xArgXmm2M128),
+	/*2767*/ uint16(xMatch),
+	/*2768*/ uint16(xCondPrefix), 1,
+	0x66, 2772,
+	/*2772*/ uint16(xSetOp), uint16(PMINSB),
+	/*2774*/ uint16(xReadSlashR),
+	/*2775*/ uint16(xArgXmm1),
+	/*2776*/ uint16(xArgXmm2M128),
+	/*2777*/ uint16(xMatch),
+	/*2778*/ uint16(xCondPrefix), 1,
+	0x66, 2782,
+	/*2782*/ uint16(xSetOp), uint16(PMINSD),
+	/*2784*/ uint16(xReadSlashR),
+	/*2785*/ uint16(xArgXmm1),
+	/*2786*/ uint16(xArgXmm2M128),
+	/*2787*/ uint16(xMatch),
+	/*2788*/ uint16(xCondPrefix), 1,
+	0x66, 2792,
+	/*2792*/ uint16(xSetOp), uint16(PMINUW),
+	/*2794*/ uint16(xReadSlashR),
+	/*2795*/ uint16(xArgXmm1),
+	/*2796*/ uint16(xArgXmm2M128),
+	/*2797*/ uint16(xMatch),
+	/*2798*/ uint16(xCondPrefix), 1,
+	0x66, 2802,
+	/*2802*/ uint16(xSetOp), uint16(PMINUD),
+	/*2804*/ uint16(xReadSlashR),
+	/*2805*/ uint16(xArgXmm1),
+	/*2806*/ uint16(xArgXmm2M128),
+	/*2807*/ uint16(xMatch),
+	/*2808*/ uint16(xCondPrefix), 1,
+	0x66, 2812,
+	/*2812*/ uint16(xSetOp), uint16(PMAXSB),
+	/*2814*/ uint16(xReadSlashR),
+	/*2815*/ uint16(xArgXmm1),
+	/*2816*/ uint16(xArgXmm2M128),
+	/*2817*/ uint16(xMatch),
+	/*2818*/ uint16(xCondPrefix), 1,
+	0x66, 2822,
+	/*2822*/ uint16(xSetOp), uint16(PMAXSD),
+	/*2824*/ uint16(xReadSlashR),
+	/*2825*/ uint16(xArgXmm1),
+	/*2826*/ uint16(xArgXmm2M128),
+	/*2827*/ uint16(xMatch),
+	/*2828*/ uint16(xCondPrefix), 1,
+	0x66, 2832,
+	/*2832*/ uint16(xSetOp), uint16(PMAXUW),
+	/*2834*/ uint16(xReadSlashR),
+	/*2835*/ uint16(xArgXmm1),
+	/*2836*/ uint16(xArgXmm2M128),
+	/*2837*/ uint16(xMatch),
+	/*2838*/ uint16(xCondPrefix), 1,
+	0x66, 2842,
+	/*2842*/ uint16(xSetOp), uint16(PMAXUD),
+	/*2844*/ uint16(xReadSlashR),
+	/*2845*/ uint16(xArgXmm1),
+	/*2846*/ uint16(xArgXmm2M128),
+	/*2847*/ uint16(xMatch),
+	/*2848*/ uint16(xCondPrefix), 1,
+	0x66, 2852,
+	/*2852*/ uint16(xSetOp), uint16(PMULLD),
+	/*2854*/ uint16(xReadSlashR),
+	/*2855*/ uint16(xArgXmm1),
+	/*2856*/ uint16(xArgXmm2M128),
+	/*2857*/ uint16(xMatch),
+	/*2858*/ uint16(xCondPrefix), 1,
+	0x66, 2862,
+	/*2862*/ uint16(xSetOp), uint16(PHMINPOSUW),
+	/*2864*/ uint16(xReadSlashR),
+	/*2865*/ uint16(xArgXmm1),
+	/*2866*/ uint16(xArgXmm2M128),
+	/*2867*/ uint16(xMatch),
+	/*2868*/ uint16(xCondIs64), 2871, 2881,
+	/*2871*/ uint16(xCondPrefix), 1,
+	0x66, 2875,
+	/*2875*/ uint16(xSetOp), uint16(INVPCID),
+	/*2877*/ uint16(xReadSlashR),
+	/*2878*/ uint16(xArgR32),
+	/*2879*/ uint16(xArgM128),
+	/*2880*/ uint16(xMatch),
+	/*2881*/ uint16(xCondPrefix), 1,
+	0x66, 2885,
+	/*2885*/ uint16(xSetOp), uint16(INVPCID),
+	/*2887*/ uint16(xReadSlashR),
+	/*2888*/ uint16(xArgR64),
+	/*2889*/ uint16(xArgM128),
+	/*2890*/ uint16(xMatch),
+	/*2891*/ uint16(xCondPrefix), 1,
+	0x66, 2895,
+	/*2895*/ uint16(xSetOp), uint16(AESIMC),
+	/*2897*/ uint16(xReadSlashR),
+	/*2898*/ uint16(xArgXmm1),
+	/*2899*/ uint16(xArgXmm2M128),
+	/*2900*/ uint16(xMatch),
+	/*2901*/ uint16(xCondPrefix), 1,
+	0x66, 2905,
+	/*2905*/ uint16(xSetOp), uint16(AESENC),
+	/*2907*/ uint16(xReadSlashR),
+	/*2908*/ uint16(xArgXmm1),
+	/*2909*/ uint16(xArgXmm2M128),
+	/*2910*/ uint16(xMatch),
+	/*2911*/ uint16(xCondPrefix), 1,
+	0x66, 2915,
+	/*2915*/ uint16(xSetOp), uint16(AESENCLAST),
+	/*2917*/ uint16(xReadSlashR),
+	/*2918*/ uint16(xArgXmm1),
+	/*2919*/ uint16(xArgXmm2M128),
+	/*2920*/ uint16(xMatch),
+	/*2921*/ uint16(xCondPrefix), 1,
+	0x66, 2925,
+	/*2925*/ uint16(xSetOp), uint16(AESDEC),
+	/*2927*/ uint16(xReadSlashR),
+	/*2928*/ uint16(xArgXmm1),
+	/*2929*/ uint16(xArgXmm2M128),
+	/*2930*/ uint16(xMatch),
+	/*2931*/ uint16(xCondPrefix), 1,
+	0x66, 2935,
+	/*2935*/ uint16(xSetOp), uint16(AESDECLAST),
+	/*2937*/ uint16(xReadSlashR),
+	/*2938*/ uint16(xArgXmm1),
+	/*2939*/ uint16(xArgXmm2M128),
+	/*2940*/ uint16(xMatch),
+	/*2941*/ uint16(xCondIs64), 2944, 2982,
+	/*2944*/ uint16(xCondPrefix), 2,
+	0xF2, 2966,
+	0x0, 2950,
+	/*2950*/ uint16(xCondDataSize), 2954, 2960, 0,
+	/*2954*/ uint16(xSetOp), uint16(MOVBE),
+	/*2956*/ uint16(xReadSlashR),
+	/*2957*/ uint16(xArgR16),
+	/*2958*/ uint16(xArgM16),
+	/*2959*/ uint16(xMatch),
+	/*2960*/ uint16(xSetOp), uint16(MOVBE),
+	/*2962*/ uint16(xReadSlashR),
+	/*2963*/ uint16(xArgR32),
+	/*2964*/ uint16(xArgM32),
+	/*2965*/ uint16(xMatch),
+	/*2966*/ uint16(xCondDataSize), 2970, 2976, 0,
+	/*2970*/ uint16(xSetOp), uint16(CRC32),
+	/*2972*/ uint16(xReadSlashR),
+	/*2973*/ uint16(xArgR32),
+	/*2974*/ uint16(xArgRM8),
+	/*2975*/ uint16(xMatch),
+	/*2976*/ uint16(xSetOp), uint16(CRC32),
+	/*2978*/ uint16(xReadSlashR),
+	/*2979*/ uint16(xArgR32),
+	/*2980*/ uint16(xArgRM8),
+	/*2981*/ uint16(xMatch),
+	/*2982*/ uint16(xCondPrefix), 2,
+	0xF2, 2998,
+	0x0, 2988,
+	/*2988*/ uint16(xCondDataSize), 2954, 2960, 2992,
+	/*2992*/ uint16(xSetOp), uint16(MOVBE),
+	/*2994*/ uint16(xReadSlashR),
+	/*2995*/ uint16(xArgR64),
+	/*2996*/ uint16(xArgM64),
+	/*2997*/ uint16(xMatch),
+	/*2998*/ uint16(xCondDataSize), 2970, 2976, 3002,
+	/*3002*/ uint16(xSetOp), uint16(CRC32),
+	/*3004*/ uint16(xReadSlashR),
+	/*3005*/ uint16(xArgR64),
+	/*3006*/ uint16(xArgRM8),
+	/*3007*/ uint16(xMatch),
+	/*3008*/ uint16(xCondIs64), 3011, 3049,
+	/*3011*/ uint16(xCondPrefix), 2,
+	0xF2, 3033,
+	0x0, 3017,
+	/*3017*/ uint16(xCondDataSize), 3021, 3027, 0,
+	/*3021*/ uint16(xSetOp), uint16(MOVBE),
+	/*3023*/ uint16(xReadSlashR),
+	/*3024*/ uint16(xArgM16),
+	/*3025*/ uint16(xArgR16),
+	/*3026*/ uint16(xMatch),
+	/*3027*/ uint16(xSetOp), uint16(MOVBE),
+	/*3029*/ uint16(xReadSlashR),
+	/*3030*/ uint16(xArgM32),
+	/*3031*/ uint16(xArgR32),
+	/*3032*/ uint16(xMatch),
+	/*3033*/ uint16(xCondDataSize), 3037, 3043, 0,
+	/*3037*/ uint16(xSetOp), uint16(CRC32),
+	/*3039*/ uint16(xReadSlashR),
+	/*3040*/ uint16(xArgR32),
+	/*3041*/ uint16(xArgRM16),
+	/*3042*/ uint16(xMatch),
+	/*3043*/ uint16(xSetOp), uint16(CRC32),
+	/*3045*/ uint16(xReadSlashR),
+	/*3046*/ uint16(xArgR32),
+	/*3047*/ uint16(xArgRM32),
+	/*3048*/ uint16(xMatch),
+	/*3049*/ uint16(xCondPrefix), 2,
+	0xF2, 3065,
+	0x0, 3055,
+	/*3055*/ uint16(xCondDataSize), 3021, 3027, 3059,
+	/*3059*/ uint16(xSetOp), uint16(MOVBE),
+	/*3061*/ uint16(xReadSlashR),
+	/*3062*/ uint16(xArgM64),
+	/*3063*/ uint16(xArgR64),
+	/*3064*/ uint16(xMatch),
+	/*3065*/ uint16(xCondDataSize), 3037, 3043, 3069,
+	/*3069*/ uint16(xSetOp), uint16(CRC32),
+	/*3071*/ uint16(xReadSlashR),
+	/*3072*/ uint16(xArgR64),
+	/*3073*/ uint16(xArgRM64),
+	/*3074*/ uint16(xMatch),
+	/*3075*/ uint16(xCondByte), 24,
+	0x08, 3126,
+	0x09, 3138,
+	0x0A, 3150,
+	0x0B, 3162,
+	0x0C, 3174,
+	0x0D, 3186,
+	0x0E, 3198,
+	0x0F, 3210,
+	0x14, 3232,
+	0x15, 3244,
+	0x16, 3256,
+	0x17, 3299,
+	0x20, 3311,
+	0x21, 3323,
+	0x22, 3335,
+	0x40, 3378,
+	0x41, 3390,
+	0x42, 3402,
+	0x44, 3414,
+	0x60, 3426,
+	0x61, 3438,
+	0x62, 3450,
+	0x63, 3462,
+	0xDF, 3474,
+	uint16(xFail),
+	/*3126*/ uint16(xCondPrefix), 1,
+	0x66, 3130,
+	/*3130*/ uint16(xSetOp), uint16(ROUNDPS),
+	/*3132*/ uint16(xReadSlashR),
+	/*3133*/ uint16(xReadIb),
+	/*3134*/ uint16(xArgXmm1),
+	/*3135*/ uint16(xArgXmm2M128),
+	/*3136*/ uint16(xArgImm8u),
+	/*3137*/ uint16(xMatch),
+	/*3138*/ uint16(xCondPrefix), 1,
+	0x66, 3142,
+	/*3142*/ uint16(xSetOp), uint16(ROUNDPD),
+	/*3144*/ uint16(xReadSlashR),
+	/*3145*/ uint16(xReadIb),
+	/*3146*/ uint16(xArgXmm1),
+	/*3147*/ uint16(xArgXmm2M128),
+	/*3148*/ uint16(xArgImm8u),
+	/*3149*/ uint16(xMatch),
+	/*3150*/ uint16(xCondPrefix), 1,
+	0x66, 3154,
+	/*3154*/ uint16(xSetOp), uint16(ROUNDSS),
+	/*3156*/ uint16(xReadSlashR),
+	/*3157*/ uint16(xReadIb),
+	/*3158*/ uint16(xArgXmm1),
+	/*3159*/ uint16(xArgXmm2M32),
+	/*3160*/ uint16(xArgImm8u),
+	/*3161*/ uint16(xMatch),
+	/*3162*/ uint16(xCondPrefix), 1,
+	0x66, 3166,
+	/*3166*/ uint16(xSetOp), uint16(ROUNDSD),
+	/*3168*/ uint16(xReadSlashR),
+	/*3169*/ uint16(xReadIb),
+	/*3170*/ uint16(xArgXmm1),
+	/*3171*/ uint16(xArgXmm2M64),
+	/*3172*/ uint16(xArgImm8u),
+	/*3173*/ uint16(xMatch),
+	/*3174*/ uint16(xCondPrefix), 1,
+	0x66, 3178,
+	/*3178*/ uint16(xSetOp), uint16(BLENDPS),
+	/*3180*/ uint16(xReadSlashR),
+	/*3181*/ uint16(xReadIb),
+	/*3182*/ uint16(xArgXmm1),
+	/*3183*/ uint16(xArgXmm2M128),
+	/*3184*/ uint16(xArgImm8u),
+	/*3185*/ uint16(xMatch),
+	/*3186*/ uint16(xCondPrefix), 1,
+	0x66, 3190,
+	/*3190*/ uint16(xSetOp), uint16(BLENDPD),
+	/*3192*/ uint16(xReadSlashR),
+	/*3193*/ uint16(xReadIb),
+	/*3194*/ uint16(xArgXmm1),
+	/*3195*/ uint16(xArgXmm2M128),
+	/*3196*/ uint16(xArgImm8u),
+	/*3197*/ uint16(xMatch),
+	/*3198*/ uint16(xCondPrefix), 1,
+	0x66, 3202,
+	/*3202*/ uint16(xSetOp), uint16(PBLENDW),
+	/*3204*/ uint16(xReadSlashR),
+	/*3205*/ uint16(xReadIb),
+	/*3206*/ uint16(xArgXmm1),
+	/*3207*/ uint16(xArgXmm2M128),
+	/*3208*/ uint16(xArgImm8u),
+	/*3209*/ uint16(xMatch),
+	/*3210*/ uint16(xCondPrefix), 2,
+	0x66, 3224,
+	0x0, 3216,
+	/*3216*/ uint16(xSetOp), uint16(PALIGNR),
+	/*3218*/ uint16(xReadSlashR),
+	/*3219*/ uint16(xReadIb),
+	/*3220*/ uint16(xArgMm1),
+	/*3221*/ uint16(xArgMm2M64),
+	/*3222*/ uint16(xArgImm8u),
+	/*3223*/ uint16(xMatch),
+	/*3224*/ uint16(xSetOp), uint16(PALIGNR),
+	/*3226*/ uint16(xReadSlashR),
+	/*3227*/ uint16(xReadIb),
+	/*3228*/ uint16(xArgXmm1),
+	/*3229*/ uint16(xArgXmm2M128),
+	/*3230*/ uint16(xArgImm8u),
+	/*3231*/ uint16(xMatch),
+	/*3232*/ uint16(xCondPrefix), 1,
+	0x66, 3236,
+	/*3236*/ uint16(xSetOp), uint16(PEXTRB),
+	/*3238*/ uint16(xReadSlashR),
+	/*3239*/ uint16(xReadIb),
+	/*3240*/ uint16(xArgR32M8),
+	/*3241*/ uint16(xArgXmm1),
+	/*3242*/ uint16(xArgImm8u),
+	/*3243*/ uint16(xMatch),
+	/*3244*/ uint16(xCondPrefix), 1,
+	0x66, 3248,
+	/*3248*/ uint16(xSetOp), uint16(PEXTRW),
+	/*3250*/ uint16(xReadSlashR),
+	/*3251*/ uint16(xReadIb),
+	/*3252*/ uint16(xArgR32M16),
+	/*3253*/ uint16(xArgXmm1),
+	/*3254*/ uint16(xArgImm8u),
+	/*3255*/ uint16(xMatch),
+	/*3256*/ uint16(xCondIs64), 3259, 3283,
+	/*3259*/ uint16(xCondPrefix), 1,
+	0x66, 3263,
+	/*3263*/ uint16(xCondDataSize), 3267, 3275, 0,
+	/*3267*/ uint16(xSetOp), uint16(PEXTRD),
+	/*3269*/ uint16(xReadSlashR),
+	/*3270*/ uint16(xReadIb),
+	/*3271*/ uint16(xArgRM32),
+	/*3272*/ uint16(xArgXmm1),
+	/*3273*/ uint16(xArgImm8u),
+	/*3274*/ uint16(xMatch),
+	/*3275*/ uint16(xSetOp), uint16(PEXTRD),
+	/*3277*/ uint16(xReadSlashR),
+	/*3278*/ uint16(xReadIb),
+	/*3279*/ uint16(xArgRM32),
+	/*3280*/ uint16(xArgXmm1),
+	/*3281*/ uint16(xArgImm8u),
+	/*3282*/ uint16(xMatch),
+	/*3283*/ uint16(xCondPrefix), 1,
+	0x66, 3287,
+	/*3287*/ uint16(xCondDataSize), 3267, 3275, 3291,
+	/*3291*/ uint16(xSetOp), uint16(PEXTRQ),
+	/*3293*/ uint16(xReadSlashR),
+	/*3294*/ uint16(xReadIb),
+	/*3295*/ uint16(xArgRM64),
+	/*3296*/ uint16(xArgXmm1),
+	/*3297*/ uint16(xArgImm8u),
+	/*3298*/ uint16(xMatch),
+	/*3299*/ uint16(xCondPrefix), 1,
+	0x66, 3303,
+	/*3303*/ uint16(xSetOp), uint16(EXTRACTPS),
+	/*3305*/ uint16(xReadSlashR),
+	/*3306*/ uint16(xReadIb),
+	/*3307*/ uint16(xArgRM32),
+	/*3308*/ uint16(xArgXmm1),
+	/*3309*/ uint16(xArgImm8u),
+	/*3310*/ uint16(xMatch),
+	/*3311*/ uint16(xCondPrefix), 1,
+	0x66, 3315,
+	/*3315*/ uint16(xSetOp), uint16(PINSRB),
+	/*3317*/ uint16(xReadSlashR),
+	/*3318*/ uint16(xReadIb),
+	/*3319*/ uint16(xArgXmm1),
+	/*3320*/ uint16(xArgR32M8),
+	/*3321*/ uint16(xArgImm8u),
+	/*3322*/ uint16(xMatch),
+	/*3323*/ uint16(xCondPrefix), 1,
+	0x66, 3327,
+	/*3327*/ uint16(xSetOp), uint16(INSERTPS),
+	/*3329*/ uint16(xReadSlashR),
+	/*3330*/ uint16(xReadIb),
+	/*3331*/ uint16(xArgXmm1),
+	/*3332*/ uint16(xArgXmm2M32),
+	/*3333*/ uint16(xArgImm8u),
+	/*3334*/ uint16(xMatch),
+	/*3335*/ uint16(xCondIs64), 3338, 3362,
+	/*3338*/ uint16(xCondPrefix), 1,
+	0x66, 3342,
+	/*3342*/ uint16(xCondDataSize), 3346, 3354, 0,
+	/*3346*/ uint16(xSetOp), uint16(PINSRD),
+	/*3348*/ uint16(xReadSlashR),
+	/*3349*/ uint16(xReadIb),
+	/*3350*/ uint16(xArgXmm1),
+	/*3351*/ uint16(xArgRM32),
+	/*3352*/ uint16(xArgImm8u),
+	/*3353*/ uint16(xMatch),
+	/*3354*/ uint16(xSetOp), uint16(PINSRD),
+	/*3356*/ uint16(xReadSlashR),
+	/*3357*/ uint16(xReadIb),
+	/*3358*/ uint16(xArgXmm1),
+	/*3359*/ uint16(xArgRM32),
+	/*3360*/ uint16(xArgImm8u),
+	/*3361*/ uint16(xMatch),
+	/*3362*/ uint16(xCondPrefix), 1,
+	0x66, 3366,
+	/*3366*/ uint16(xCondDataSize), 3346, 3354, 3370,
+	/*3370*/ uint16(xSetOp), uint16(PINSRQ),
+	/*3372*/ uint16(xReadSlashR),
+	/*3373*/ uint16(xReadIb),
+	/*3374*/ uint16(xArgXmm1),
+	/*3375*/ uint16(xArgRM64),
+	/*3376*/ uint16(xArgImm8u),
+	/*3377*/ uint16(xMatch),
+	/*3378*/ uint16(xCondPrefix), 1,
+	0x66, 3382,
+	/*3382*/ uint16(xSetOp), uint16(DPPS),
+	/*3384*/ uint16(xReadSlashR),
+	/*3385*/ uint16(xReadIb),
+	/*3386*/ uint16(xArgXmm1),
+	/*3387*/ uint16(xArgXmm2M128),
+	/*3388*/ uint16(xArgImm8u),
+	/*3389*/ uint16(xMatch),
+	/*3390*/ uint16(xCondPrefix), 1,
+	0x66, 3394,
+	/*3394*/ uint16(xSetOp), uint16(DPPD),
+	/*3396*/ uint16(xReadSlashR),
+	/*3397*/ uint16(xReadIb),
+	/*3398*/ uint16(xArgXmm1),
+	/*3399*/ uint16(xArgXmm2M128),
+	/*3400*/ uint16(xArgImm8u),
+	/*3401*/ uint16(xMatch),
+	/*3402*/ uint16(xCondPrefix), 1,
+	0x66, 3406,
+	/*3406*/ uint16(xSetOp), uint16(MPSADBW),
+	/*3408*/ uint16(xReadSlashR),
+	/*3409*/ uint16(xReadIb),
+	/*3410*/ uint16(xArgXmm1),
+	/*3411*/ uint16(xArgXmm2M128),
+	/*3412*/ uint16(xArgImm8u),
+	/*3413*/ uint16(xMatch),
+	/*3414*/ uint16(xCondPrefix), 1,
+	0x66, 3418,
+	/*3418*/ uint16(xSetOp), uint16(PCLMULQDQ),
+	/*3420*/ uint16(xReadSlashR),
+	/*3421*/ uint16(xReadIb),
+	/*3422*/ uint16(xArgXmm1),
+	/*3423*/ uint16(xArgXmm2M128),
+	/*3424*/ uint16(xArgImm8u),
+	/*3425*/ uint16(xMatch),
+	/*3426*/ uint16(xCondPrefix), 1,
+	0x66, 3430,
+	/*3430*/ uint16(xSetOp), uint16(PCMPESTRM),
+	/*3432*/ uint16(xReadSlashR),
+	/*3433*/ uint16(xReadIb),
+	/*3434*/ uint16(xArgXmm1),
+	/*3435*/ uint16(xArgXmm2M128),
+	/*3436*/ uint16(xArgImm8u),
+	/*3437*/ uint16(xMatch),
+	/*3438*/ uint16(xCondPrefix), 1,
+	0x66, 3442,
+	/*3442*/ uint16(xSetOp), uint16(PCMPESTRI),
+	/*3444*/ uint16(xReadSlashR),
+	/*3445*/ uint16(xReadIb),
+	/*3446*/ uint16(xArgXmm1),
+	/*3447*/ uint16(xArgXmm2M128),
+	/*3448*/ uint16(xArgImm8u),
+	/*3449*/ uint16(xMatch),
+	/*3450*/ uint16(xCondPrefix), 1,
+	0x66, 3454,
+	/*3454*/ uint16(xSetOp), uint16(PCMPISTRM),
+	/*3456*/ uint16(xReadSlashR),
+	/*3457*/ uint16(xReadIb),
+	/*3458*/ uint16(xArgXmm1),
+	/*3459*/ uint16(xArgXmm2M128),
+	/*3460*/ uint16(xArgImm8u),
+	/*3461*/ uint16(xMatch),
+	/*3462*/ uint16(xCondPrefix), 1,
+	0x66, 3466,
+	/*3466*/ uint16(xSetOp), uint16(PCMPISTRI),
+	/*3468*/ uint16(xReadSlashR),
+	/*3469*/ uint16(xReadIb),
+	/*3470*/ uint16(xArgXmm1),
+	/*3471*/ uint16(xArgXmm2M128),
+	/*3472*/ uint16(xArgImm8u),
+	/*3473*/ uint16(xMatch),
+	/*3474*/ uint16(xCondPrefix), 1,
+	0x66, 3478,
+	/*3478*/ uint16(xSetOp), uint16(AESKEYGENASSIST),
+	/*3480*/ uint16(xReadSlashR),
+	/*3481*/ uint16(xReadIb),
+	/*3482*/ uint16(xArgXmm1),
+	/*3483*/ uint16(xArgXmm2M128),
+	/*3484*/ uint16(xArgImm8u),
+	/*3485*/ uint16(xMatch),
+	/*3486*/ uint16(xCondIs64), 3489, 3505,
+	/*3489*/ uint16(xCondDataSize), 3493, 3499, 0,
+	/*3493*/ uint16(xSetOp), uint16(CMOVO),
+	/*3495*/ uint16(xReadSlashR),
+	/*3496*/ uint16(xArgR16),
+	/*3497*/ uint16(xArgRM16),
+	/*3498*/ uint16(xMatch),
+	/*3499*/ uint16(xSetOp), uint16(CMOVO),
+	/*3501*/ uint16(xReadSlashR),
+	/*3502*/ uint16(xArgR32),
+	/*3503*/ uint16(xArgRM32),
+	/*3504*/ uint16(xMatch),
+	/*3505*/ uint16(xCondDataSize), 3493, 3499, 3509,
+	/*3509*/ uint16(xSetOp), uint16(CMOVO),
+	/*3511*/ uint16(xReadSlashR),
+	/*3512*/ uint16(xArgR64),
+	/*3513*/ uint16(xArgRM64),
+	/*3514*/ uint16(xMatch),
+	/*3515*/ uint16(xCondIs64), 3518, 3534,
+	/*3518*/ uint16(xCondDataSize), 3522, 3528, 0,
+	/*3522*/ uint16(xSetOp), uint16(CMOVNO),
+	/*3524*/ uint16(xReadSlashR),
+	/*3525*/ uint16(xArgR16),
+	/*3526*/ uint16(xArgRM16),
+	/*3527*/ uint16(xMatch),
+	/*3528*/ uint16(xSetOp), uint16(CMOVNO),
+	/*3530*/ uint16(xReadSlashR),
+	/*3531*/ uint16(xArgR32),
+	/*3532*/ uint16(xArgRM32),
+	/*3533*/ uint16(xMatch),
+	/*3534*/ uint16(xCondDataSize), 3522, 3528, 3538,
+	/*3538*/ uint16(xSetOp), uint16(CMOVNO),
+	/*3540*/ uint16(xReadSlashR),
+	/*3541*/ uint16(xArgR64),
+	/*3542*/ uint16(xArgRM64),
+	/*3543*/ uint16(xMatch),
+	/*3544*/ uint16(xCondIs64), 3547, 3563,
+	/*3547*/ uint16(xCondDataSize), 3551, 3557, 0,
+	/*3551*/ uint16(xSetOp), uint16(CMOVB),
+	/*3553*/ uint16(xReadSlashR),
+	/*3554*/ uint16(xArgR16),
+	/*3555*/ uint16(xArgRM16),
+	/*3556*/ uint16(xMatch),
+	/*3557*/ uint16(xSetOp), uint16(CMOVB),
+	/*3559*/ uint16(xReadSlashR),
+	/*3560*/ uint16(xArgR32),
+	/*3561*/ uint16(xArgRM32),
+	/*3562*/ uint16(xMatch),
+	/*3563*/ uint16(xCondDataSize), 3551, 3557, 3567,
+	/*3567*/ uint16(xSetOp), uint16(CMOVB),
+	/*3569*/ uint16(xReadSlashR),
+	/*3570*/ uint16(xArgR64),
+	/*3571*/ uint16(xArgRM64),
+	/*3572*/ uint16(xMatch),
+	/*3573*/ uint16(xCondIs64), 3576, 3592,
+	/*3576*/ uint16(xCondDataSize), 3580, 3586, 0,
+	/*3580*/ uint16(xSetOp), uint16(CMOVAE),
+	/*3582*/ uint16(xReadSlashR),
+	/*3583*/ uint16(xArgR16),
+	/*3584*/ uint16(xArgRM16),
+	/*3585*/ uint16(xMatch),
+	/*3586*/ uint16(xSetOp), uint16(CMOVAE),
+	/*3588*/ uint16(xReadSlashR),
+	/*3589*/ uint16(xArgR32),
+	/*3590*/ uint16(xArgRM32),
+	/*3591*/ uint16(xMatch),
+	/*3592*/ uint16(xCondDataSize), 3580, 3586, 3596,
+	/*3596*/ uint16(xSetOp), uint16(CMOVAE),
+	/*3598*/ uint16(xReadSlashR),
+	/*3599*/ uint16(xArgR64),
+	/*3600*/ uint16(xArgRM64),
+	/*3601*/ uint16(xMatch),
+	/*3602*/ uint16(xCondIs64), 3605, 3621,
+	/*3605*/ uint16(xCondDataSize), 3609, 3615, 0,
+	/*3609*/ uint16(xSetOp), uint16(CMOVE),
+	/*3611*/ uint16(xReadSlashR),
+	/*3612*/ uint16(xArgR16),
+	/*3613*/ uint16(xArgRM16),
+	/*3614*/ uint16(xMatch),
+	/*3615*/ uint16(xSetOp), uint16(CMOVE),
+	/*3617*/ uint16(xReadSlashR),
+	/*3618*/ uint16(xArgR32),
+	/*3619*/ uint16(xArgRM32),
+	/*3620*/ uint16(xMatch),
+	/*3621*/ uint16(xCondDataSize), 3609, 3615, 3625,
+	/*3625*/ uint16(xSetOp), uint16(CMOVE),
+	/*3627*/ uint16(xReadSlashR),
+	/*3628*/ uint16(xArgR64),
+	/*3629*/ uint16(xArgRM64),
+	/*3630*/ uint16(xMatch),
+	/*3631*/ uint16(xCondIs64), 3634, 3650,
+	/*3634*/ uint16(xCondDataSize), 3638, 3644, 0,
+	/*3638*/ uint16(xSetOp), uint16(CMOVNE),
+	/*3640*/ uint16(xReadSlashR),
+	/*3641*/ uint16(xArgR16),
+	/*3642*/ uint16(xArgRM16),
+	/*3643*/ uint16(xMatch),
+	/*3644*/ uint16(xSetOp), uint16(CMOVNE),
+	/*3646*/ uint16(xReadSlashR),
+	/*3647*/ uint16(xArgR32),
+	/*3648*/ uint16(xArgRM32),
+	/*3649*/ uint16(xMatch),
+	/*3650*/ uint16(xCondDataSize), 3638, 3644, 3654,
+	/*3654*/ uint16(xSetOp), uint16(CMOVNE),
+	/*3656*/ uint16(xReadSlashR),
+	/*3657*/ uint16(xArgR64),
+	/*3658*/ uint16(xArgRM64),
+	/*3659*/ uint16(xMatch),
+	/*3660*/ uint16(xCondIs64), 3663, 3679,
+	/*3663*/ uint16(xCondDataSize), 3667, 3673, 0,
+	/*3667*/ uint16(xSetOp), uint16(CMOVBE),
+	/*3669*/ uint16(xReadSlashR),
+	/*3670*/ uint16(xArgR16),
+	/*3671*/ uint16(xArgRM16),
+	/*3672*/ uint16(xMatch),
+	/*3673*/ uint16(xSetOp), uint16(CMOVBE),
+	/*3675*/ uint16(xReadSlashR),
+	/*3676*/ uint16(xArgR32),
+	/*3677*/ uint16(xArgRM32),
+	/*3678*/ uint16(xMatch),
+	/*3679*/ uint16(xCondDataSize), 3667, 3673, 3683,
+	/*3683*/ uint16(xSetOp), uint16(CMOVBE),
+	/*3685*/ uint16(xReadSlashR),
+	/*3686*/ uint16(xArgR64),
+	/*3687*/ uint16(xArgRM64),
+	/*3688*/ uint16(xMatch),
+	/*3689*/ uint16(xCondIs64), 3692, 3708,
+	/*3692*/ uint16(xCondDataSize), 3696, 3702, 0,
+	/*3696*/ uint16(xSetOp), uint16(CMOVA),
+	/*3698*/ uint16(xReadSlashR),
+	/*3699*/ uint16(xArgR16),
+	/*3700*/ uint16(xArgRM16),
+	/*3701*/ uint16(xMatch),
+	/*3702*/ uint16(xSetOp), uint16(CMOVA),
+	/*3704*/ uint16(xReadSlashR),
+	/*3705*/ uint16(xArgR32),
+	/*3706*/ uint16(xArgRM32),
+	/*3707*/ uint16(xMatch),
+	/*3708*/ uint16(xCondDataSize), 3696, 3702, 3712,
+	/*3712*/ uint16(xSetOp), uint16(CMOVA),
+	/*3714*/ uint16(xReadSlashR),
+	/*3715*/ uint16(xArgR64),
+	/*3716*/ uint16(xArgRM64),
+	/*3717*/ uint16(xMatch),
+	/*3718*/ uint16(xCondIs64), 3721, 3737,
+	/*3721*/ uint16(xCondDataSize), 3725, 3731, 0,
+	/*3725*/ uint16(xSetOp), uint16(CMOVS),
+	/*3727*/ uint16(xReadSlashR),
+	/*3728*/ uint16(xArgR16),
+	/*3729*/ uint16(xArgRM16),
+	/*3730*/ uint16(xMatch),
+	/*3731*/ uint16(xSetOp), uint16(CMOVS),
+	/*3733*/ uint16(xReadSlashR),
+	/*3734*/ uint16(xArgR32),
+	/*3735*/ uint16(xArgRM32),
+	/*3736*/ uint16(xMatch),
+	/*3737*/ uint16(xCondDataSize), 3725, 3731, 3741,
+	/*3741*/ uint16(xSetOp), uint16(CMOVS),
+	/*3743*/ uint16(xReadSlashR),
+	/*3744*/ uint16(xArgR64),
+	/*3745*/ uint16(xArgRM64),
+	/*3746*/ uint16(xMatch),
+	/*3747*/ uint16(xCondIs64), 3750, 3766,
+	/*3750*/ uint16(xCondDataSize), 3754, 3760, 0,
+	/*3754*/ uint16(xSetOp), uint16(CMOVNS),
+	/*3756*/ uint16(xReadSlashR),
+	/*3757*/ uint16(xArgR16),
+	/*3758*/ uint16(xArgRM16),
+	/*3759*/ uint16(xMatch),
+	/*3760*/ uint16(xSetOp), uint16(CMOVNS),
+	/*3762*/ uint16(xReadSlashR),
+	/*3763*/ uint16(xArgR32),
+	/*3764*/ uint16(xArgRM32),
+	/*3765*/ uint16(xMatch),
+	/*3766*/ uint16(xCondDataSize), 3754, 3760, 3770,
+	/*3770*/ uint16(xSetOp), uint16(CMOVNS),
+	/*3772*/ uint16(xReadSlashR),
+	/*3773*/ uint16(xArgR64),
+	/*3774*/ uint16(xArgRM64),
+	/*3775*/ uint16(xMatch),
+	/*3776*/ uint16(xCondIs64), 3779, 3795,
+	/*3779*/ uint16(xCondDataSize), 3783, 3789, 0,
+	/*3783*/ uint16(xSetOp), uint16(CMOVP),
+	/*3785*/ uint16(xReadSlashR),
+	/*3786*/ uint16(xArgR16),
+	/*3787*/ uint16(xArgRM16),
+	/*3788*/ uint16(xMatch),
+	/*3789*/ uint16(xSetOp), uint16(CMOVP),
+	/*3791*/ uint16(xReadSlashR),
+	/*3792*/ uint16(xArgR32),
+	/*3793*/ uint16(xArgRM32),
+	/*3794*/ uint16(xMatch),
+	/*3795*/ uint16(xCondDataSize), 3783, 3789, 3799,
+	/*3799*/ uint16(xSetOp), uint16(CMOVP),
+	/*3801*/ uint16(xReadSlashR),
+	/*3802*/ uint16(xArgR64),
+	/*3803*/ uint16(xArgRM64),
+	/*3804*/ uint16(xMatch),
+	/*3805*/ uint16(xCondIs64), 3808, 3824,
+	/*3808*/ uint16(xCondDataSize), 3812, 3818, 0,
+	/*3812*/ uint16(xSetOp), uint16(CMOVNP),
+	/*3814*/ uint16(xReadSlashR),
+	/*3815*/ uint16(xArgR16),
+	/*3816*/ uint16(xArgRM16),
+	/*3817*/ uint16(xMatch),
+	/*3818*/ uint16(xSetOp), uint16(CMOVNP),
+	/*3820*/ uint16(xReadSlashR),
+	/*3821*/ uint16(xArgR32),
+	/*3822*/ uint16(xArgRM32),
+	/*3823*/ uint16(xMatch),
+	/*3824*/ uint16(xCondDataSize), 3812, 3818, 3828,
+	/*3828*/ uint16(xSetOp), uint16(CMOVNP),
+	/*3830*/ uint16(xReadSlashR),
+	/*3831*/ uint16(xArgR64),
+	/*3832*/ uint16(xArgRM64),
+	/*3833*/ uint16(xMatch),
+	/*3834*/ uint16(xCondIs64), 3837, 3853,
+	/*3837*/ uint16(xCondDataSize), 3841, 3847, 0,
+	/*3841*/ uint16(xSetOp), uint16(CMOVL),
+	/*3843*/ uint16(xReadSlashR),
+	/*3844*/ uint16(xArgR16),
+	/*3845*/ uint16(xArgRM16),
+	/*3846*/ uint16(xMatch),
+	/*3847*/ uint16(xSetOp), uint16(CMOVL),
+	/*3849*/ uint16(xReadSlashR),
+	/*3850*/ uint16(xArgR32),
+	/*3851*/ uint16(xArgRM32),
+	/*3852*/ uint16(xMatch),
+	/*3853*/ uint16(xCondDataSize), 3841, 3847, 3857,
+	/*3857*/ uint16(xSetOp), uint16(CMOVL),
+	/*3859*/ uint16(xReadSlashR),
+	/*3860*/ uint16(xArgR64),
+	/*3861*/ uint16(xArgRM64),
+	/*3862*/ uint16(xMatch),
+	/*3863*/ uint16(xCondIs64), 3866, 3882,
+	/*3866*/ uint16(xCondDataSize), 3870, 3876, 0,
+	/*3870*/ uint16(xSetOp), uint16(CMOVGE),
+	/*3872*/ uint16(xReadSlashR),
+	/*3873*/ uint16(xArgR16),
+	/*3874*/ uint16(xArgRM16),
+	/*3875*/ uint16(xMatch),
+	/*3876*/ uint16(xSetOp), uint16(CMOVGE),
+	/*3878*/ uint16(xReadSlashR),
+	/*3879*/ uint16(xArgR32),
+	/*3880*/ uint16(xArgRM32),
+	/*3881*/ uint16(xMatch),
+	/*3882*/ uint16(xCondDataSize), 3870, 3876, 3886,
+	/*3886*/ uint16(xSetOp), uint16(CMOVGE),
+	/*3888*/ uint16(xReadSlashR),
+	/*3889*/ uint16(xArgR64),
+	/*3890*/ uint16(xArgRM64),
+	/*3891*/ uint16(xMatch),
+	/*3892*/ uint16(xCondIs64), 3895, 3911,
+	/*3895*/ uint16(xCondDataSize), 3899, 3905, 0,
+	/*3899*/ uint16(xSetOp), uint16(CMOVLE),
+	/*3901*/ uint16(xReadSlashR),
+	/*3902*/ uint16(xArgR16),
+	/*3903*/ uint16(xArgRM16),
+	/*3904*/ uint16(xMatch),
+	/*3905*/ uint16(xSetOp), uint16(CMOVLE),
+	/*3907*/ uint16(xReadSlashR),
+	/*3908*/ uint16(xArgR32),
+	/*3909*/ uint16(xArgRM32),
+	/*3910*/ uint16(xMatch),
+	/*3911*/ uint16(xCondDataSize), 3899, 3905, 3915,
+	/*3915*/ uint16(xSetOp), uint16(CMOVLE),
+	/*3917*/ uint16(xReadSlashR),
+	/*3918*/ uint16(xArgR64),
+	/*3919*/ uint16(xArgRM64),
+	/*3920*/ uint16(xMatch),
+	/*3921*/ uint16(xCondIs64), 3924, 3940,
+	/*3924*/ uint16(xCondDataSize), 3928, 3934, 0,
+	/*3928*/ uint16(xSetOp), uint16(CMOVG),
+	/*3930*/ uint16(xReadSlashR),
+	/*3931*/ uint16(xArgR16),
+	/*3932*/ uint16(xArgRM16),
+	/*3933*/ uint16(xMatch),
+	/*3934*/ uint16(xSetOp), uint16(CMOVG),
+	/*3936*/ uint16(xReadSlashR),
+	/*3937*/ uint16(xArgR32),
+	/*3938*/ uint16(xArgRM32),
+	/*3939*/ uint16(xMatch),
+	/*3940*/ uint16(xCondDataSize), 3928, 3934, 3944,
+	/*3944*/ uint16(xSetOp), uint16(CMOVG),
+	/*3946*/ uint16(xReadSlashR),
+	/*3947*/ uint16(xArgR64),
+	/*3948*/ uint16(xArgRM64),
+	/*3949*/ uint16(xMatch),
+	/*3950*/ uint16(xCondPrefix), 2,
+	0x66, 3962,
+	0x0, 3956,
+	/*3956*/ uint16(xSetOp), uint16(MOVMSKPS),
+	/*3958*/ uint16(xReadSlashR),
+	/*3959*/ uint16(xArgR32),
+	/*3960*/ uint16(xArgXmm2),
+	/*3961*/ uint16(xMatch),
+	/*3962*/ uint16(xSetOp), uint16(MOVMSKPD),
+	/*3964*/ uint16(xReadSlashR),
+	/*3965*/ uint16(xArgR32),
+	/*3966*/ uint16(xArgXmm2),
+	/*3967*/ uint16(xMatch),
+	/*3968*/ uint16(xCondPrefix), 4,
+	0xF3, 3996,
+	0xF2, 3990,
+	0x66, 3984,
+	0x0, 3978,
+	/*3978*/ uint16(xSetOp), uint16(SQRTPS),
+	/*3980*/ uint16(xReadSlashR),
+	/*3981*/ uint16(xArgXmm1),
+	/*3982*/ uint16(xArgXmm2M128),
+	/*3983*/ uint16(xMatch),
+	/*3984*/ uint16(xSetOp), uint16(SQRTPD),
+	/*3986*/ uint16(xReadSlashR),
+	/*3987*/ uint16(xArgXmm1),
+	/*3988*/ uint16(xArgXmm2M128),
+	/*3989*/ uint16(xMatch),
+	/*3990*/ uint16(xSetOp), uint16(SQRTSD),
+	/*3992*/ uint16(xReadSlashR),
+	/*3993*/ uint16(xArgXmm1),
+	/*3994*/ uint16(xArgXmm2M64),
+	/*3995*/ uint16(xMatch),
+	/*3996*/ uint16(xSetOp), uint16(SQRTSS),
+	/*3998*/ uint16(xReadSlashR),
+	/*3999*/ uint16(xArgXmm1),
+	/*4000*/ uint16(xArgXmm2M32),
+	/*4001*/ uint16(xMatch),
+	/*4002*/ uint16(xCondPrefix), 2,
+	0xF3, 4014,
+	0x0, 4008,
+	/*4008*/ uint16(xSetOp), uint16(RSQRTPS),
+	/*4010*/ uint16(xReadSlashR),
+	/*4011*/ uint16(xArgXmm1),
+	/*4012*/ uint16(xArgXmm2M128),
+	/*4013*/ uint16(xMatch),
+	/*4014*/ uint16(xSetOp), uint16(RSQRTSS),
+	/*4016*/ uint16(xReadSlashR),
+	/*4017*/ uint16(xArgXmm1),
+	/*4018*/ uint16(xArgXmm2M32),
+	/*4019*/ uint16(xMatch),
+	/*4020*/ uint16(xCondPrefix), 2,
+	0xF3, 4032,
+	0x0, 4026,
+	/*4026*/ uint16(xSetOp), uint16(RCPPS),
+	/*4028*/ uint16(xReadSlashR),
+	/*4029*/ uint16(xArgXmm1),
+	/*4030*/ uint16(xArgXmm2M128),
+	/*4031*/ uint16(xMatch),
+	/*4032*/ uint16(xSetOp), uint16(RCPSS),
+	/*4034*/ uint16(xReadSlashR),
+	/*4035*/ uint16(xArgXmm1),
+	/*4036*/ uint16(xArgXmm2M32),
+	/*4037*/ uint16(xMatch),
+	/*4038*/ uint16(xCondPrefix), 2,
+	0x66, 4050,
+	0x0, 4044,
+	/*4044*/ uint16(xSetOp), uint16(ANDPS),
+	/*4046*/ uint16(xReadSlashR),
+	/*4047*/ uint16(xArgXmm1),
+	/*4048*/ uint16(xArgXmm2M128),
+	/*4049*/ uint16(xMatch),
+	/*4050*/ uint16(xSetOp), uint16(ANDPD),
+	/*4052*/ uint16(xReadSlashR),
+	/*4053*/ uint16(xArgXmm1),
+	/*4054*/ uint16(xArgXmm2M128),
+	/*4055*/ uint16(xMatch),
+	/*4056*/ uint16(xCondPrefix), 2,
+	0x66, 4068,
+	0x0, 4062,
+	/*4062*/ uint16(xSetOp), uint16(ANDNPS),
+	/*4064*/ uint16(xReadSlashR),
+	/*4065*/ uint16(xArgXmm1),
+	/*4066*/ uint16(xArgXmm2M128),
+	/*4067*/ uint16(xMatch),
+	/*4068*/ uint16(xSetOp), uint16(ANDNPD),
+	/*4070*/ uint16(xReadSlashR),
+	/*4071*/ uint16(xArgXmm1),
+	/*4072*/ uint16(xArgXmm2M128),
+	/*4073*/ uint16(xMatch),
+	/*4074*/ uint16(xCondPrefix), 2,
+	0x66, 4086,
+	0x0, 4080,
+	/*4080*/ uint16(xSetOp), uint16(ORPS),
+	/*4082*/ uint16(xReadSlashR),
+	/*4083*/ uint16(xArgXmm1),
+	/*4084*/ uint16(xArgXmm2M128),
+	/*4085*/ uint16(xMatch),
+	/*4086*/ uint16(xSetOp), uint16(ORPD),
+	/*4088*/ uint16(xReadSlashR),
+	/*4089*/ uint16(xArgXmm1),
+	/*4090*/ uint16(xArgXmm2M128),
+	/*4091*/ uint16(xMatch),
+	/*4092*/ uint16(xCondPrefix), 2,
+	0x66, 4104,
+	0x0, 4098,
+	/*4098*/ uint16(xSetOp), uint16(XORPS),
+	/*4100*/ uint16(xReadSlashR),
+	/*4101*/ uint16(xArgXmm1),
+	/*4102*/ uint16(xArgXmm2M128),
+	/*4103*/ uint16(xMatch),
+	/*4104*/ uint16(xSetOp), uint16(XORPD),
+	/*4106*/ uint16(xReadSlashR),
+	/*4107*/ uint16(xArgXmm1),
+	/*4108*/ uint16(xArgXmm2M128),
+	/*4109*/ uint16(xMatch),
+	/*4110*/ uint16(xCondPrefix), 4,
+	0xF3, 4138,
+	0xF2, 4132,
+	0x66, 4126,
+	0x0, 4120,
+	/*4120*/ uint16(xSetOp), uint16(ADDPS),
+	/*4122*/ uint16(xReadSlashR),
+	/*4123*/ uint16(xArgXmm1),
+	/*4124*/ uint16(xArgXmm2M128),
+	/*4125*/ uint16(xMatch),
+	/*4126*/ uint16(xSetOp), uint16(ADDPD),
+	/*4128*/ uint16(xReadSlashR),
+	/*4129*/ uint16(xArgXmm1),
+	/*4130*/ uint16(xArgXmm2M128),
+	/*4131*/ uint16(xMatch),
+	/*4132*/ uint16(xSetOp), uint16(ADDSD),
+	/*4134*/ uint16(xReadSlashR),
+	/*4135*/ uint16(xArgXmm1),
+	/*4136*/ uint16(xArgXmm2M64),
+	/*4137*/ uint16(xMatch),
+	/*4138*/ uint16(xSetOp), uint16(ADDSS),
+	/*4140*/ uint16(xReadSlashR),
+	/*4141*/ uint16(xArgXmm1),
+	/*4142*/ uint16(xArgXmm2M32),
+	/*4143*/ uint16(xMatch),
+	/*4144*/ uint16(xCondPrefix), 4,
+	0xF3, 4172,
+	0xF2, 4166,
+	0x66, 4160,
+	0x0, 4154,
+	/*4154*/ uint16(xSetOp), uint16(MULPS),
+	/*4156*/ uint16(xReadSlashR),
+	/*4157*/ uint16(xArgXmm1),
+	/*4158*/ uint16(xArgXmm2M128),
+	/*4159*/ uint16(xMatch),
+	/*4160*/ uint16(xSetOp), uint16(MULPD),
+	/*4162*/ uint16(xReadSlashR),
+	/*4163*/ uint16(xArgXmm1),
+	/*4164*/ uint16(xArgXmm2M128),
+	/*4165*/ uint16(xMatch),
+	/*4166*/ uint16(xSetOp), uint16(MULSD),
+	/*4168*/ uint16(xReadSlashR),
+	/*4169*/ uint16(xArgXmm1),
+	/*4170*/ uint16(xArgXmm2M64),
+	/*4171*/ uint16(xMatch),
+	/*4172*/ uint16(xSetOp), uint16(MULSS),
+	/*4174*/ uint16(xReadSlashR),
+	/*4175*/ uint16(xArgXmm1),
+	/*4176*/ uint16(xArgXmm2M32),
+	/*4177*/ uint16(xMatch),
+	/*4178*/ uint16(xCondPrefix), 4,
+	0xF3, 4206,
+	0xF2, 4200,
+	0x66, 4194,
+	0x0, 4188,
+	/*4188*/ uint16(xSetOp), uint16(CVTPS2PD),
+	/*4190*/ uint16(xReadSlashR),
+	/*4191*/ uint16(xArgXmm1),
+	/*4192*/ uint16(xArgXmm2M64),
+	/*4193*/ uint16(xMatch),
+	/*4194*/ uint16(xSetOp), uint16(CVTPD2PS),
+	/*4196*/ uint16(xReadSlashR),
+	/*4197*/ uint16(xArgXmm1),
+	/*4198*/ uint16(xArgXmm2M128),
+	/*4199*/ uint16(xMatch),
+	/*4200*/ uint16(xSetOp), uint16(CVTSD2SS),
+	/*4202*/ uint16(xReadSlashR),
+	/*4203*/ uint16(xArgXmm1),
+	/*4204*/ uint16(xArgXmm2M64),
+	/*4205*/ uint16(xMatch),
+	/*4206*/ uint16(xSetOp), uint16(CVTSS2SD),
+	/*4208*/ uint16(xReadSlashR),
+	/*4209*/ uint16(xArgXmm1),
+	/*4210*/ uint16(xArgXmm2M32),
+	/*4211*/ uint16(xMatch),
+	/*4212*/ uint16(xCondPrefix), 3,
+	0xF3, 4232,
+	0x66, 4226,
+	0x0, 4220,
+	/*4220*/ uint16(xSetOp), uint16(CVTDQ2PS),
+	/*4222*/ uint16(xReadSlashR),
+	/*4223*/ uint16(xArgXmm1),
+	/*4224*/ uint16(xArgXmm2M128),
+	/*4225*/ uint16(xMatch),
+	/*4226*/ uint16(xSetOp), uint16(CVTPS2DQ),
+	/*4228*/ uint16(xReadSlashR),
+	/*4229*/ uint16(xArgXmm1),
+	/*4230*/ uint16(xArgXmm2M128),
+	/*4231*/ uint16(xMatch),
+	/*4232*/ uint16(xSetOp), uint16(CVTTPS2DQ),
+	/*4234*/ uint16(xReadSlashR),
+	/*4235*/ uint16(xArgXmm1),
+	/*4236*/ uint16(xArgXmm2M128),
+	/*4237*/ uint16(xMatch),
+	/*4238*/ uint16(xCondPrefix), 4,
+	0xF3, 4266,
+	0xF2, 4260,
+	0x66, 4254,
+	0x0, 4248,
+	/*4248*/ uint16(xSetOp), uint16(SUBPS),
+	/*4250*/ uint16(xReadSlashR),
+	/*4251*/ uint16(xArgXmm1),
+	/*4252*/ uint16(xArgXmm2M128),
+	/*4253*/ uint16(xMatch),
+	/*4254*/ uint16(xSetOp), uint16(SUBPD),
+	/*4256*/ uint16(xReadSlashR),
+	/*4257*/ uint16(xArgXmm1),
+	/*4258*/ uint16(xArgXmm2M128),
+	/*4259*/ uint16(xMatch),
+	/*4260*/ uint16(xSetOp), uint16(SUBSD),
+	/*4262*/ uint16(xReadSlashR),
+	/*4263*/ uint16(xArgXmm1),
+	/*4264*/ uint16(xArgXmm2M64),
+	/*4265*/ uint16(xMatch),
+	/*4266*/ uint16(xSetOp), uint16(SUBSS),
+	/*4268*/ uint16(xReadSlashR),
+	/*4269*/ uint16(xArgXmm1),
+	/*4270*/ uint16(xArgXmm2M32),
+	/*4271*/ uint16(xMatch),
+	/*4272*/ uint16(xCondPrefix), 4,
+	0xF3, 4300,
+	0xF2, 4294,
+	0x66, 4288,
+	0x0, 4282,
+	/*4282*/ uint16(xSetOp), uint16(MINPS),
+	/*4284*/ uint16(xReadSlashR),
+	/*4285*/ uint16(xArgXmm1),
+	/*4286*/ uint16(xArgXmm2M128),
+	/*4287*/ uint16(xMatch),
+	/*4288*/ uint16(xSetOp), uint16(MINPD),
+	/*4290*/ uint16(xReadSlashR),
+	/*4291*/ uint16(xArgXmm1),
+	/*4292*/ uint16(xArgXmm2M128),
+	/*4293*/ uint16(xMatch),
+	/*4294*/ uint16(xSetOp), uint16(MINSD),
+	/*4296*/ uint16(xReadSlashR),
+	/*4297*/ uint16(xArgXmm1),
+	/*4298*/ uint16(xArgXmm2M64),
+	/*4299*/ uint16(xMatch),
+	/*4300*/ uint16(xSetOp), uint16(MINSS),
+	/*4302*/ uint16(xReadSlashR),
+	/*4303*/ uint16(xArgXmm1),
+	/*4304*/ uint16(xArgXmm2M32),
+	/*4305*/ uint16(xMatch),
+	/*4306*/ uint16(xCondPrefix), 4,
+	0xF3, 4334,
+	0xF2, 4328,
+	0x66, 4322,
+	0x0, 4316,
+	/*4316*/ uint16(xSetOp), uint16(DIVPS),
+	/*4318*/ uint16(xReadSlashR),
+	/*4319*/ uint16(xArgXmm1),
+	/*4320*/ uint16(xArgXmm2M128),
+	/*4321*/ uint16(xMatch),
+	/*4322*/ uint16(xSetOp), uint16(DIVPD),
+	/*4324*/ uint16(xReadSlashR),
+	/*4325*/ uint16(xArgXmm1),
+	/*4326*/ uint16(xArgXmm2M128),
+	/*4327*/ uint16(xMatch),
+	/*4328*/ uint16(xSetOp), uint16(DIVSD),
+	/*4330*/ uint16(xReadSlashR),
+	/*4331*/ uint16(xArgXmm1),
+	/*4332*/ uint16(xArgXmm2M64),
+	/*4333*/ uint16(xMatch),
+	/*4334*/ uint16(xSetOp), uint16(DIVSS),
+	/*4336*/ uint16(xReadSlashR),
+	/*4337*/ uint16(xArgXmm1),
+	/*4338*/ uint16(xArgXmm2M32),
+	/*4339*/ uint16(xMatch),
+	/*4340*/ uint16(xCondPrefix), 4,
+	0xF3, 4368,
+	0xF2, 4362,
+	0x66, 4356,
+	0x0, 4350,
+	/*4350*/ uint16(xSetOp), uint16(MAXPS),
+	/*4352*/ uint16(xReadSlashR),
+	/*4353*/ uint16(xArgXmm1),
+	/*4354*/ uint16(xArgXmm2M128),
+	/*4355*/ uint16(xMatch),
+	/*4356*/ uint16(xSetOp), uint16(MAXPD),
+	/*4358*/ uint16(xReadSlashR),
+	/*4359*/ uint16(xArgXmm1),
+	/*4360*/ uint16(xArgXmm2M128),
+	/*4361*/ uint16(xMatch),
+	/*4362*/ uint16(xSetOp), uint16(MAXSD),
+	/*4364*/ uint16(xReadSlashR),
+	/*4365*/ uint16(xArgXmm1),
+	/*4366*/ uint16(xArgXmm2M64),
+	/*4367*/ uint16(xMatch),
+	/*4368*/ uint16(xSetOp), uint16(MAXSS),
+	/*4370*/ uint16(xReadSlashR),
+	/*4371*/ uint16(xArgXmm1),
+	/*4372*/ uint16(xArgXmm2M32),
+	/*4373*/ uint16(xMatch),
+	/*4374*/ uint16(xCondPrefix), 2,
+	0x66, 4386,
+	0x0, 4380,
+	/*4380*/ uint16(xSetOp), uint16(PUNPCKLBW),
+	/*4382*/ uint16(xReadSlashR),
+	/*4383*/ uint16(xArgMm),
+	/*4384*/ uint16(xArgMmM32),
+	/*4385*/ uint16(xMatch),
+	/*4386*/ uint16(xSetOp), uint16(PUNPCKLBW),
+	/*4388*/ uint16(xReadSlashR),
+	/*4389*/ uint16(xArgXmm1),
+	/*4390*/ uint16(xArgXmm2M128),
+	/*4391*/ uint16(xMatch),
+	/*4392*/ uint16(xCondPrefix), 2,
+	0x66, 4404,
+	0x0, 4398,
+	/*4398*/ uint16(xSetOp), uint16(PUNPCKLWD),
+	/*4400*/ uint16(xReadSlashR),
+	/*4401*/ uint16(xArgMm),
+	/*4402*/ uint16(xArgMmM32),
+	/*4403*/ uint16(xMatch),
+	/*4404*/ uint16(xSetOp), uint16(PUNPCKLWD),
+	/*4406*/ uint16(xReadSlashR),
+	/*4407*/ uint16(xArgXmm1),
+	/*4408*/ uint16(xArgXmm2M128),
+	/*4409*/ uint16(xMatch),
+	/*4410*/ uint16(xCondPrefix), 2,
+	0x66, 4422,
+	0x0, 4416,
+	/*4416*/ uint16(xSetOp), uint16(PUNPCKLDQ),
+	/*4418*/ uint16(xReadSlashR),
+	/*4419*/ uint16(xArgMm),
+	/*4420*/ uint16(xArgMmM32),
+	/*4421*/ uint16(xMatch),
+	/*4422*/ uint16(xSetOp), uint16(PUNPCKLDQ),
+	/*4424*/ uint16(xReadSlashR),
+	/*4425*/ uint16(xArgXmm1),
+	/*4426*/ uint16(xArgXmm2M128),
+	/*4427*/ uint16(xMatch),
+	/*4428*/ uint16(xCondPrefix), 2,
+	0x66, 4440,
+	0x0, 4434,
+	/*4434*/ uint16(xSetOp), uint16(PACKSSWB),
+	/*4436*/ uint16(xReadSlashR),
+	/*4437*/ uint16(xArgMm1),
+	/*4438*/ uint16(xArgMm2M64),
+	/*4439*/ uint16(xMatch),
+	/*4440*/ uint16(xSetOp), uint16(PACKSSWB),
+	/*4442*/ uint16(xReadSlashR),
+	/*4443*/ uint16(xArgXmm1),
+	/*4444*/ uint16(xArgXmm2M128),
+	/*4445*/ uint16(xMatch),
+	/*4446*/ uint16(xCondPrefix), 2,
+	0x66, 4458,
+	0x0, 4452,
+	/*4452*/ uint16(xSetOp), uint16(PCMPGTB),
+	/*4454*/ uint16(xReadSlashR),
+	/*4455*/ uint16(xArgMm),
+	/*4456*/ uint16(xArgMmM64),
+	/*4457*/ uint16(xMatch),
+	/*4458*/ uint16(xSetOp), uint16(PCMPGTB),
+	/*4460*/ uint16(xReadSlashR),
+	/*4461*/ uint16(xArgXmm1),
+	/*4462*/ uint16(xArgXmm2M128),
+	/*4463*/ uint16(xMatch),
+	/*4464*/ uint16(xCondPrefix), 2,
+	0x66, 4476,
+	0x0, 4470,
+	/*4470*/ uint16(xSetOp), uint16(PCMPGTW),
+	/*4472*/ uint16(xReadSlashR),
+	/*4473*/ uint16(xArgMm),
+	/*4474*/ uint16(xArgMmM64),
+	/*4475*/ uint16(xMatch),
+	/*4476*/ uint16(xSetOp), uint16(PCMPGTW),
+	/*4478*/ uint16(xReadSlashR),
+	/*4479*/ uint16(xArgXmm1),
+	/*4480*/ uint16(xArgXmm2M128),
+	/*4481*/ uint16(xMatch),
+	/*4482*/ uint16(xCondPrefix), 2,
+	0x66, 4494,
+	0x0, 4488,
+	/*4488*/ uint16(xSetOp), uint16(PCMPGTD),
+	/*4490*/ uint16(xReadSlashR),
+	/*4491*/ uint16(xArgMm),
+	/*4492*/ uint16(xArgMmM64),
+	/*4493*/ uint16(xMatch),
+	/*4494*/ uint16(xSetOp), uint16(PCMPGTD),
+	/*4496*/ uint16(xReadSlashR),
+	/*4497*/ uint16(xArgXmm1),
+	/*4498*/ uint16(xArgXmm2M128),
+	/*4499*/ uint16(xMatch),
+	/*4500*/ uint16(xCondPrefix), 2,
+	0x66, 4512,
+	0x0, 4506,
+	/*4506*/ uint16(xSetOp), uint16(PACKUSWB),
+	/*4508*/ uint16(xReadSlashR),
+	/*4509*/ uint16(xArgMm),
+	/*4510*/ uint16(xArgMmM64),
+	/*4511*/ uint16(xMatch),
+	/*4512*/ uint16(xSetOp), uint16(PACKUSWB),
+	/*4514*/ uint16(xReadSlashR),
+	/*4515*/ uint16(xArgXmm1),
+	/*4516*/ uint16(xArgXmm2M128),
+	/*4517*/ uint16(xMatch),
+	/*4518*/ uint16(xCondPrefix), 2,
+	0x66, 4530,
+	0x0, 4524,
+	/*4524*/ uint16(xSetOp), uint16(PUNPCKHBW),
+	/*4526*/ uint16(xReadSlashR),
+	/*4527*/ uint16(xArgMm),
+	/*4528*/ uint16(xArgMmM64),
+	/*4529*/ uint16(xMatch),
+	/*4530*/ uint16(xSetOp), uint16(PUNPCKHBW),
+	/*4532*/ uint16(xReadSlashR),
+	/*4533*/ uint16(xArgXmm1),
+	/*4534*/ uint16(xArgXmm2M128),
+	/*4535*/ uint16(xMatch),
+	/*4536*/ uint16(xCondPrefix), 2,
+	0x66, 4548,
+	0x0, 4542,
+	/*4542*/ uint16(xSetOp), uint16(PUNPCKHWD),
+	/*4544*/ uint16(xReadSlashR),
+	/*4545*/ uint16(xArgMm),
+	/*4546*/ uint16(xArgMmM64),
+	/*4547*/ uint16(xMatch),
+	/*4548*/ uint16(xSetOp), uint16(PUNPCKHWD),
+	/*4550*/ uint16(xReadSlashR),
+	/*4551*/ uint16(xArgXmm1),
+	/*4552*/ uint16(xArgXmm2M128),
+	/*4553*/ uint16(xMatch),
+	/*4554*/ uint16(xCondPrefix), 2,
+	0x66, 4566,
+	0x0, 4560,
+	/*4560*/ uint16(xSetOp), uint16(PUNPCKHDQ),
+	/*4562*/ uint16(xReadSlashR),
+	/*4563*/ uint16(xArgMm),
+	/*4564*/ uint16(xArgMmM64),
+	/*4565*/ uint16(xMatch),
+	/*4566*/ uint16(xSetOp), uint16(PUNPCKHDQ),
+	/*4568*/ uint16(xReadSlashR),
+	/*4569*/ uint16(xArgXmm1),
+	/*4570*/ uint16(xArgXmm2M128),
+	/*4571*/ uint16(xMatch),
+	/*4572*/ uint16(xCondPrefix), 2,
+	0x66, 4584,
+	0x0, 4578,
+	/*4578*/ uint16(xSetOp), uint16(PACKSSDW),
+	/*4580*/ uint16(xReadSlashR),
+	/*4581*/ uint16(xArgMm1),
+	/*4582*/ uint16(xArgMm2M64),
+	/*4583*/ uint16(xMatch),
+	/*4584*/ uint16(xSetOp), uint16(PACKSSDW),
+	/*4586*/ uint16(xReadSlashR),
+	/*4587*/ uint16(xArgXmm1),
+	/*4588*/ uint16(xArgXmm2M128),
+	/*4589*/ uint16(xMatch),
+	/*4590*/ uint16(xCondPrefix), 1,
+	0x66, 4594,
+	/*4594*/ uint16(xSetOp), uint16(PUNPCKLQDQ),
+	/*4596*/ uint16(xReadSlashR),
+	/*4597*/ uint16(xArgXmm1),
+	/*4598*/ uint16(xArgXmm2M128),
+	/*4599*/ uint16(xMatch),
+	/*4600*/ uint16(xCondPrefix), 1,
+	0x66, 4604,
+	/*4604*/ uint16(xSetOp), uint16(PUNPCKHQDQ),
+	/*4606*/ uint16(xReadSlashR),
+	/*4607*/ uint16(xArgXmm1),
+	/*4608*/ uint16(xArgXmm2M128),
+	/*4609*/ uint16(xMatch),
+	/*4610*/ uint16(xCondIs64), 4613, 4651,
+	/*4613*/ uint16(xCondPrefix), 2,
+	0x66, 4635,
+	0x0, 4619,
+	/*4619*/ uint16(xCondDataSize), 4623, 4629, 0,
+	/*4623*/ uint16(xSetOp), uint16(MOVD),
+	/*4625*/ uint16(xReadSlashR),
+	/*4626*/ uint16(xArgMm),
+	/*4627*/ uint16(xArgRM32),
+	/*4628*/ uint16(xMatch),
+	/*4629*/ uint16(xSetOp), uint16(MOVD),
+	/*4631*/ uint16(xReadSlashR),
+	/*4632*/ uint16(xArgMm),
+	/*4633*/ uint16(xArgRM32),
+	/*4634*/ uint16(xMatch),
+	/*4635*/ uint16(xCondDataSize), 4639, 4645, 0,
+	/*4639*/ uint16(xSetOp), uint16(MOVD),
+	/*4641*/ uint16(xReadSlashR),
+	/*4642*/ uint16(xArgXmm),
+	/*4643*/ uint16(xArgRM32),
+	/*4644*/ uint16(xMatch),
+	/*4645*/ uint16(xSetOp), uint16(MOVD),
+	/*4647*/ uint16(xReadSlashR),
+	/*4648*/ uint16(xArgXmm),
+	/*4649*/ uint16(xArgRM32),
+	/*4650*/ uint16(xMatch),
+	/*4651*/ uint16(xCondPrefix), 2,
+	0x66, 4667,
+	0x0, 4657,
+	/*4657*/ uint16(xCondDataSize), 4623, 4629, 4661,
+	/*4661*/ uint16(xSetOp), uint16(MOVQ),
+	/*4663*/ uint16(xReadSlashR),
+	/*4664*/ uint16(xArgMm),
+	/*4665*/ uint16(xArgRM64),
+	/*4666*/ uint16(xMatch),
+	/*4667*/ uint16(xCondDataSize), 4639, 4645, 4671,
+	/*4671*/ uint16(xSetOp), uint16(MOVQ),
+	/*4673*/ uint16(xReadSlashR),
+	/*4674*/ uint16(xArgXmm),
+	/*4675*/ uint16(xArgRM64),
+	/*4676*/ uint16(xMatch),
+	/*4677*/ uint16(xCondPrefix), 3,
+	0xF3, 4697,
+	0x66, 4691,
+	0x0, 4685,
+	/*4685*/ uint16(xSetOp), uint16(MOVQ),
+	/*4687*/ uint16(xReadSlashR),
+	/*4688*/ uint16(xArgMm),
+	/*4689*/ uint16(xArgMmM64),
+	/*4690*/ uint16(xMatch),
+	/*4691*/ uint16(xSetOp), uint16(MOVDQA),
+	/*4693*/ uint16(xReadSlashR),
+	/*4694*/ uint16(xArgXmm1),
+	/*4695*/ uint16(xArgXmm2M128),
+	/*4696*/ uint16(xMatch),
+	/*4697*/ uint16(xSetOp), uint16(MOVDQU),
+	/*4699*/ uint16(xReadSlashR),
+	/*4700*/ uint16(xArgXmm1),
+	/*4701*/ uint16(xArgXmm2M128),
+	/*4702*/ uint16(xMatch),
+	/*4703*/ uint16(xCondPrefix), 4,
+	0xF3, 4737,
+	0xF2, 4729,
+	0x66, 4721,
+	0x0, 4713,
+	/*4713*/ uint16(xSetOp), uint16(PSHUFW),
+	/*4715*/ uint16(xReadSlashR),
+	/*4716*/ uint16(xReadIb),
+	/*4717*/ uint16(xArgMm1),
+	/*4718*/ uint16(xArgMm2M64),
+	/*4719*/ uint16(xArgImm8u),
+	/*4720*/ uint16(xMatch),
+	/*4721*/ uint16(xSetOp), uint16(PSHUFD),
+	/*4723*/ uint16(xReadSlashR),
+	/*4724*/ uint16(xReadIb),
+	/*4725*/ uint16(xArgXmm1),
+	/*4726*/ uint16(xArgXmm2M128),
+	/*4727*/ uint16(xArgImm8u),
+	/*4728*/ uint16(xMatch),
+	/*4729*/ uint16(xSetOp), uint16(PSHUFLW),
+	/*4731*/ uint16(xReadSlashR),
+	/*4732*/ uint16(xReadIb),
+	/*4733*/ uint16(xArgXmm1),
+	/*4734*/ uint16(xArgXmm2M128),
+	/*4735*/ uint16(xArgImm8u),
+	/*4736*/ uint16(xMatch),
+	/*4737*/ uint16(xSetOp), uint16(PSHUFHW),
+	/*4739*/ uint16(xReadSlashR),
+	/*4740*/ uint16(xReadIb),
+	/*4741*/ uint16(xArgXmm1),
+	/*4742*/ uint16(xArgXmm2M128),
+	/*4743*/ uint16(xArgImm8u),
+	/*4744*/ uint16(xMatch),
+	/*4745*/ uint16(xCondSlashR),
+	0,    // 0
+	0,    // 1
+	4754, // 2
+	0,    // 3
+	4772, // 4
+	0,    // 5
+	4790, // 6
+	0,    // 7
+	/*4754*/ uint16(xCondPrefix), 2,
+	0x66, 4766,
+	0x0, 4760,
+	/*4760*/ uint16(xSetOp), uint16(PSRLW),
+	/*4762*/ uint16(xReadIb),
+	/*4763*/ uint16(xArgMm2),
+	/*4764*/ uint16(xArgImm8u),
+	/*4765*/ uint16(xMatch),
+	/*4766*/ uint16(xSetOp), uint16(PSRLW),
+	/*4768*/ uint16(xReadIb),
+	/*4769*/ uint16(xArgXmm2),
+	/*4770*/ uint16(xArgImm8u),
+	/*4771*/ uint16(xMatch),
+	/*4772*/ uint16(xCondPrefix), 2,
+	0x66, 4784,
+	0x0, 4778,
+	/*4778*/ uint16(xSetOp), uint16(PSRAW),
+	/*4780*/ uint16(xReadIb),
+	/*4781*/ uint16(xArgMm2),
+	/*4782*/ uint16(xArgImm8u),
+	/*4783*/ uint16(xMatch),
+	/*4784*/ uint16(xSetOp), uint16(PSRAW),
+	/*4786*/ uint16(xReadIb),
+	/*4787*/ uint16(xArgXmm2),
+	/*4788*/ uint16(xArgImm8u),
+	/*4789*/ uint16(xMatch),
+	/*4790*/ uint16(xCondPrefix), 2,
+	0x66, 4802,
+	0x0, 4796,
+	/*4796*/ uint16(xSetOp), uint16(PSLLW),
+	/*4798*/ uint16(xReadIb),
+	/*4799*/ uint16(xArgMm2),
+	/*4800*/ uint16(xArgImm8u),
+	/*4801*/ uint16(xMatch),
+	/*4802*/ uint16(xSetOp), uint16(PSLLW),
+	/*4804*/ uint16(xReadIb),
+	/*4805*/ uint16(xArgXmm2),
+	/*4806*/ uint16(xArgImm8u),
+	/*4807*/ uint16(xMatch),
+	/*4808*/ uint16(xCondSlashR),
+	0,    // 0
+	0,    // 1
+	4817, // 2
+	0,    // 3
+	4835, // 4
+	0,    // 5
+	4853, // 6
+	0,    // 7
+	/*4817*/ uint16(xCondPrefix), 2,
+	0x66, 4829,
+	0x0, 4823,
+	/*4823*/ uint16(xSetOp), uint16(PSRLD),
+	/*4825*/ uint16(xReadIb),
+	/*4826*/ uint16(xArgMm2),
+	/*4827*/ uint16(xArgImm8u),
+	/*4828*/ uint16(xMatch),
+	/*4829*/ uint16(xSetOp), uint16(PSRLD),
+	/*4831*/ uint16(xReadIb),
+	/*4832*/ uint16(xArgXmm2),
+	/*4833*/ uint16(xArgImm8u),
+	/*4834*/ uint16(xMatch),
+	/*4835*/ uint16(xCondPrefix), 2,
+	0x66, 4847,
+	0x0, 4841,
+	/*4841*/ uint16(xSetOp), uint16(PSRAD),
+	/*4843*/ uint16(xReadIb),
+	/*4844*/ uint16(xArgMm2),
+	/*4845*/ uint16(xArgImm8u),
+	/*4846*/ uint16(xMatch),
+	/*4847*/ uint16(xSetOp), uint16(PSRAD),
+	/*4849*/ uint16(xReadIb),
+	/*4850*/ uint16(xArgXmm2),
+	/*4851*/ uint16(xArgImm8u),
+	/*4852*/ uint16(xMatch),
+	/*4853*/ uint16(xCondPrefix), 2,
+	0x66, 4865,
+	0x0, 4859,
+	/*4859*/ uint16(xSetOp), uint16(PSLLD),
+	/*4861*/ uint16(xReadIb),
+	/*4862*/ uint16(xArgMm2),
+	/*4863*/ uint16(xArgImm8u),
+	/*4864*/ uint16(xMatch),
+	/*4865*/ uint16(xSetOp), uint16(PSLLD),
+	/*4867*/ uint16(xReadIb),
+	/*4868*/ uint16(xArgXmm2),
+	/*4869*/ uint16(xArgImm8u),
+	/*4870*/ uint16(xMatch),
+	/*4871*/ uint16(xCondSlashR),
+	0,    // 0
+	0,    // 1
+	4880, // 2
+	4898, // 3
+	0,    // 4
+	0,    // 5
+	4908, // 6
+	4926, // 7
+	/*4880*/ uint16(xCondPrefix), 2,
+	0x66, 4892,
+	0x0, 4886,
+	/*4886*/ uint16(xSetOp), uint16(PSRLQ),
+	/*4888*/ uint16(xReadIb),
+	/*4889*/ uint16(xArgMm2),
+	/*4890*/ uint16(xArgImm8u),
+	/*4891*/ uint16(xMatch),
+	/*4892*/ uint16(xSetOp), uint16(PSRLQ),
+	/*4894*/ uint16(xReadIb),
+	/*4895*/ uint16(xArgXmm2),
+	/*4896*/ uint16(xArgImm8u),
+	/*4897*/ uint16(xMatch),
+	/*4898*/ uint16(xCondPrefix), 1,
+	0x66, 4902,
+	/*4902*/ uint16(xSetOp), uint16(PSRLDQ),
+	/*4904*/ uint16(xReadIb),
+	/*4905*/ uint16(xArgXmm2),
+	/*4906*/ uint16(xArgImm8u),
+	/*4907*/ uint16(xMatch),
+	/*4908*/ uint16(xCondPrefix), 2,
+	0x66, 4920,
+	0x0, 4914,
+	/*4914*/ uint16(xSetOp), uint16(PSLLQ),
+	/*4916*/ uint16(xReadIb),
+	/*4917*/ uint16(xArgMm2),
+	/*4918*/ uint16(xArgImm8u),
+	/*4919*/ uint16(xMatch),
+	/*4920*/ uint16(xSetOp), uint16(PSLLQ),
+	/*4922*/ uint16(xReadIb),
+	/*4923*/ uint16(xArgXmm2),
+	/*4924*/ uint16(xArgImm8u),
+	/*4925*/ uint16(xMatch),
+	/*4926*/ uint16(xCondPrefix), 1,
+	0x66, 4930,
+	/*4930*/ uint16(xSetOp), uint16(PSLLDQ),
+	/*4932*/ uint16(xReadIb),
+	/*4933*/ uint16(xArgXmm2),
+	/*4934*/ uint16(xArgImm8u),
+	/*4935*/ uint16(xMatch),
+	/*4936*/ uint16(xCondPrefix), 2,
+	0x66, 4948,
+	0x0, 4942,
+	/*4942*/ uint16(xSetOp), uint16(PCMPEQB),
+	/*4944*/ uint16(xReadSlashR),
+	/*4945*/ uint16(xArgMm),
+	/*4946*/ uint16(xArgMmM64),
+	/*4947*/ uint16(xMatch),
+	/*4948*/ uint16(xSetOp), uint16(PCMPEQB),
+	/*4950*/ uint16(xReadSlashR),
+	/*4951*/ uint16(xArgXmm1),
+	/*4952*/ uint16(xArgXmm2M128),
+	/*4953*/ uint16(xMatch),
+	/*4954*/ uint16(xCondPrefix), 2,
+	0x66, 4966,
+	0x0, 4960,
+	/*4960*/ uint16(xSetOp), uint16(PCMPEQW),
+	/*4962*/ uint16(xReadSlashR),
+	/*4963*/ uint16(xArgMm),
+	/*4964*/ uint16(xArgMmM64),
+	/*4965*/ uint16(xMatch),
+	/*4966*/ uint16(xSetOp), uint16(PCMPEQW),
+	/*4968*/ uint16(xReadSlashR),
+	/*4969*/ uint16(xArgXmm1),
+	/*4970*/ uint16(xArgXmm2M128),
+	/*4971*/ uint16(xMatch),
+	/*4972*/ uint16(xCondPrefix), 2,
+	0x66, 4984,
+	0x0, 4978,
+	/*4978*/ uint16(xSetOp), uint16(PCMPEQD),
+	/*4980*/ uint16(xReadSlashR),
+	/*4981*/ uint16(xArgMm),
+	/*4982*/ uint16(xArgMmM64),
+	/*4983*/ uint16(xMatch),
+	/*4984*/ uint16(xSetOp), uint16(PCMPEQD),
+	/*4986*/ uint16(xReadSlashR),
+	/*4987*/ uint16(xArgXmm1),
+	/*4988*/ uint16(xArgXmm2M128),
+	/*4989*/ uint16(xMatch),
+	/*4990*/ uint16(xSetOp), uint16(EMMS),
+	/*4992*/ uint16(xMatch),
+	/*4993*/ uint16(xCondPrefix), 2,
+	0xF2, 5005,
+	0x66, 4999,
+	/*4999*/ uint16(xSetOp), uint16(HADDPD),
+	/*5001*/ uint16(xReadSlashR),
+	/*5002*/ uint16(xArgXmm1),
+	/*5003*/ uint16(xArgXmm2M128),
+	/*5004*/ uint16(xMatch),
+	/*5005*/ uint16(xSetOp), uint16(HADDPS),
+	/*5007*/ uint16(xReadSlashR),
+	/*5008*/ uint16(xArgXmm1),
+	/*5009*/ uint16(xArgXmm2M128),
+	/*5010*/ uint16(xMatch),
+	/*5011*/ uint16(xCondPrefix), 2,
+	0xF2, 5023,
+	0x66, 5017,
+	/*5017*/ uint16(xSetOp), uint16(HSUBPD),
+	/*5019*/ uint16(xReadSlashR),
+	/*5020*/ uint16(xArgXmm1),
+	/*5021*/ uint16(xArgXmm2M128),
+	/*5022*/ uint16(xMatch),
+	/*5023*/ uint16(xSetOp), uint16(HSUBPS),
+	/*5025*/ uint16(xReadSlashR),
+	/*5026*/ uint16(xArgXmm1),
+	/*5027*/ uint16(xArgXmm2M128),
+	/*5028*/ uint16(xMatch),
+	/*5029*/ uint16(xCondIs64), 5032, 5078,
+	/*5032*/ uint16(xCondPrefix), 3,
+	0xF3, 5072,
+	0x66, 5056,
+	0x0, 5040,
+	/*5040*/ uint16(xCondDataSize), 5044, 5050, 0,
+	/*5044*/ uint16(xSetOp), uint16(MOVD),
+	/*5046*/ uint16(xReadSlashR),
+	/*5047*/ uint16(xArgRM32),
+	/*5048*/ uint16(xArgMm),
+	/*5049*/ uint16(xMatch),
+	/*5050*/ uint16(xSetOp), uint16(MOVD),
+	/*5052*/ uint16(xReadSlashR),
+	/*5053*/ uint16(xArgRM32),
+	/*5054*/ uint16(xArgMm),
+	/*5055*/ uint16(xMatch),
+	/*5056*/ uint16(xCondDataSize), 5060, 5066, 0,
+	/*5060*/ uint16(xSetOp), uint16(MOVD),
+	/*5062*/ uint16(xReadSlashR),
+	/*5063*/ uint16(xArgRM32),
+	/*5064*/ uint16(xArgXmm),
+	/*5065*/ uint16(xMatch),
+	/*5066*/ uint16(xSetOp), uint16(MOVD),
+	/*5068*/ uint16(xReadSlashR),
+	/*5069*/ uint16(xArgRM32),
+	/*5070*/ uint16(xArgXmm),
+	/*5071*/ uint16(xMatch),
+	/*5072*/ uint16(xSetOp), uint16(MOVQ),
+	/*5074*/ uint16(xReadSlashR),
+	/*5075*/ uint16(xArgXmm1),
+	/*5076*/ uint16(xArgXmm2M64),
+	/*5077*/ uint16(xMatch),
+	/*5078*/ uint16(xCondPrefix), 3,
+	0xF3, 5072,
+	0x66, 5096,
+	0x0, 5086,
+	/*5086*/ uint16(xCondDataSize), 5044, 5050, 5090,
+	/*5090*/ uint16(xSetOp), uint16(MOVQ),
+	/*5092*/ uint16(xReadSlashR),
+	/*5093*/ uint16(xArgRM64),
+	/*5094*/ uint16(xArgMm),
+	/*5095*/ uint16(xMatch),
+	/*5096*/ uint16(xCondDataSize), 5060, 5066, 5100,
+	/*5100*/ uint16(xSetOp), uint16(MOVQ),
+	/*5102*/ uint16(xReadSlashR),
+	/*5103*/ uint16(xArgRM64),
+	/*5104*/ uint16(xArgXmm),
+	/*5105*/ uint16(xMatch),
+	/*5106*/ uint16(xCondPrefix), 3,
+	0xF3, 5126,
+	0x66, 5120,
+	0x0, 5114,
+	/*5114*/ uint16(xSetOp), uint16(MOVQ),
+	/*5116*/ uint16(xReadSlashR),
+	/*5117*/ uint16(xArgMmM64),
+	/*5118*/ uint16(xArgMm),
+	/*5119*/ uint16(xMatch),
+	/*5120*/ uint16(xSetOp), uint16(MOVDQA),
+	/*5122*/ uint16(xReadSlashR),
+	/*5123*/ uint16(xArgXmm2M128),
+	/*5124*/ uint16(xArgXmm1),
+	/*5125*/ uint16(xMatch),
+	/*5126*/ uint16(xSetOp), uint16(MOVDQU),
+	/*5128*/ uint16(xReadSlashR),
+	/*5129*/ uint16(xArgXmm2M128),
+	/*5130*/ uint16(xArgXmm1),
+	/*5131*/ uint16(xMatch),
+	/*5132*/ uint16(xCondIs64), 5135, 5149,
+	/*5135*/ uint16(xCondDataSize), 5139, 5144, 0,
+	/*5139*/ uint16(xSetOp), uint16(JO),
+	/*5141*/ uint16(xReadCw),
+	/*5142*/ uint16(xArgRel16),
+	/*5143*/ uint16(xMatch),
+	/*5144*/ uint16(xSetOp), uint16(JO),
+	/*5146*/ uint16(xReadCd),
+	/*5147*/ uint16(xArgRel32),
+	/*5148*/ uint16(xMatch),
+	/*5149*/ uint16(xCondDataSize), 5153, 5144, 5158,
+	/*5153*/ uint16(xSetOp), uint16(JO),
+	/*5155*/ uint16(xReadCd),
+	/*5156*/ uint16(xArgRel32),
+	/*5157*/ uint16(xMatch),
+	/*5158*/ uint16(xSetOp), uint16(JO),
+	/*5160*/ uint16(xReadCd),
+	/*5161*/ uint16(xArgRel32),
+	/*5162*/ uint16(xMatch),
+	/*5163*/ uint16(xCondIs64), 5166, 5180,
+	/*5166*/ uint16(xCondDataSize), 5170, 5175, 0,
+	/*5170*/ uint16(xSetOp), uint16(JNO),
+	/*5172*/ uint16(xReadCw),
+	/*5173*/ uint16(xArgRel16),
+	/*5174*/ uint16(xMatch),
+	/*5175*/ uint16(xSetOp), uint16(JNO),
+	/*5177*/ uint16(xReadCd),
+	/*5178*/ uint16(xArgRel32),
+	/*5179*/ uint16(xMatch),
+	/*5180*/ uint16(xCondDataSize), 5184, 5175, 5189,
+	/*5184*/ uint16(xSetOp), uint16(JNO),
+	/*5186*/ uint16(xReadCd),
+	/*5187*/ uint16(xArgRel32),
+	/*5188*/ uint16(xMatch),
+	/*5189*/ uint16(xSetOp), uint16(JNO),
+	/*5191*/ uint16(xReadCd),
+	/*5192*/ uint16(xArgRel32),
+	/*5193*/ uint16(xMatch),
+	/*5194*/ uint16(xCondIs64), 5197, 5211,
+	/*5197*/ uint16(xCondDataSize), 5201, 5206, 0,
+	/*5201*/ uint16(xSetOp), uint16(JB),
+	/*5203*/ uint16(xReadCw),
+	/*5204*/ uint16(xArgRel16),
+	/*5205*/ uint16(xMatch),
+	/*5206*/ uint16(xSetOp), uint16(JB),
+	/*5208*/ uint16(xReadCd),
+	/*5209*/ uint16(xArgRel32),
+	/*5210*/ uint16(xMatch),
+	/*5211*/ uint16(xCondDataSize), 5215, 5206, 5220,
+	/*5215*/ uint16(xSetOp), uint16(JB),
+	/*5217*/ uint16(xReadCd),
+	/*5218*/ uint16(xArgRel32),
+	/*5219*/ uint16(xMatch),
+	/*5220*/ uint16(xSetOp), uint16(JB),
+	/*5222*/ uint16(xReadCd),
+	/*5223*/ uint16(xArgRel32),
+	/*5224*/ uint16(xMatch),
+	/*5225*/ uint16(xCondIs64), 5228, 5242,
+	/*5228*/ uint16(xCondDataSize), 5232, 5237, 0,
+	/*5232*/ uint16(xSetOp), uint16(JAE),
+	/*5234*/ uint16(xReadCw),
+	/*5235*/ uint16(xArgRel16),
+	/*5236*/ uint16(xMatch),
+	/*5237*/ uint16(xSetOp), uint16(JAE),
+	/*5239*/ uint16(xReadCd),
+	/*5240*/ uint16(xArgRel32),
+	/*5241*/ uint16(xMatch),
+	/*5242*/ uint16(xCondDataSize), 5246, 5237, 5251,
+	/*5246*/ uint16(xSetOp), uint16(JAE),
+	/*5248*/ uint16(xReadCd),
+	/*5249*/ uint16(xArgRel32),
+	/*5250*/ uint16(xMatch),
+	/*5251*/ uint16(xSetOp), uint16(JAE),
+	/*5253*/ uint16(xReadCd),
+	/*5254*/ uint16(xArgRel32),
+	/*5255*/ uint16(xMatch),
+	/*5256*/ uint16(xCondIs64), 5259, 5273,
+	/*5259*/ uint16(xCondDataSize), 5263, 5268, 0,
+	/*5263*/ uint16(xSetOp), uint16(JE),
+	/*5265*/ uint16(xReadCw),
+	/*5266*/ uint16(xArgRel16),
+	/*5267*/ uint16(xMatch),
+	/*5268*/ uint16(xSetOp), uint16(JE),
+	/*5270*/ uint16(xReadCd),
+	/*5271*/ uint16(xArgRel32),
+	/*5272*/ uint16(xMatch),
+	/*5273*/ uint16(xCondDataSize), 5277, 5268, 5282,
+	/*5277*/ uint16(xSetOp), uint16(JE),
+	/*5279*/ uint16(xReadCd),
+	/*5280*/ uint16(xArgRel32),
+	/*5281*/ uint16(xMatch),
+	/*5282*/ uint16(xSetOp), uint16(JE),
+	/*5284*/ uint16(xReadCd),
+	/*5285*/ uint16(xArgRel32),
+	/*5286*/ uint16(xMatch),
+	/*5287*/ uint16(xCondIs64), 5290, 5304,
+	/*5290*/ uint16(xCondDataSize), 5294, 5299, 0,
+	/*5294*/ uint16(xSetOp), uint16(JNE),
+	/*5296*/ uint16(xReadCw),
+	/*5297*/ uint16(xArgRel16),
+	/*5298*/ uint16(xMatch),
+	/*5299*/ uint16(xSetOp), uint16(JNE),
+	/*5301*/ uint16(xReadCd),
+	/*5302*/ uint16(xArgRel32),
+	/*5303*/ uint16(xMatch),
+	/*5304*/ uint16(xCondDataSize), 5308, 5299, 5313,
+	/*5308*/ uint16(xSetOp), uint16(JNE),
+	/*5310*/ uint16(xReadCd),
+	/*5311*/ uint16(xArgRel32),
+	/*5312*/ uint16(xMatch),
+	/*5313*/ uint16(xSetOp), uint16(JNE),
+	/*5315*/ uint16(xReadCd),
+	/*5316*/ uint16(xArgRel32),
+	/*5317*/ uint16(xMatch),
+	/*5318*/ uint16(xCondIs64), 5321, 5335,
+	/*5321*/ uint16(xCondDataSize), 5325, 5330, 0,
+	/*5325*/ uint16(xSetOp), uint16(JBE),
+	/*5327*/ uint16(xReadCw),
+	/*5328*/ uint16(xArgRel16),
+	/*5329*/ uint16(xMatch),
+	/*5330*/ uint16(xSetOp), uint16(JBE),
+	/*5332*/ uint16(xReadCd),
+	/*5333*/ uint16(xArgRel32),
+	/*5334*/ uint16(xMatch),
+	/*5335*/ uint16(xCondDataSize), 5339, 5330, 5344,
+	/*5339*/ uint16(xSetOp), uint16(JBE),
+	/*5341*/ uint16(xReadCd),
+	/*5342*/ uint16(xArgRel32),
+	/*5343*/ uint16(xMatch),
+	/*5344*/ uint16(xSetOp), uint16(JBE),
+	/*5346*/ uint16(xReadCd),
+	/*5347*/ uint16(xArgRel32),
+	/*5348*/ uint16(xMatch),
+	/*5349*/ uint16(xCondIs64), 5352, 5366,
+	/*5352*/ uint16(xCondDataSize), 5356, 5361, 0,
+	/*5356*/ uint16(xSetOp), uint16(JA),
+	/*5358*/ uint16(xReadCw),
+	/*5359*/ uint16(xArgRel16),
+	/*5360*/ uint16(xMatch),
+	/*5361*/ uint16(xSetOp), uint16(JA),
+	/*5363*/ uint16(xReadCd),
+	/*5364*/ uint16(xArgRel32),
+	/*5365*/ uint16(xMatch),
+	/*5366*/ uint16(xCondDataSize), 5370, 5361, 5375,
+	/*5370*/ uint16(xSetOp), uint16(JA),
+	/*5372*/ uint16(xReadCd),
+	/*5373*/ uint16(xArgRel32),
+	/*5374*/ uint16(xMatch),
+	/*5375*/ uint16(xSetOp), uint16(JA),
+	/*5377*/ uint16(xReadCd),
+	/*5378*/ uint16(xArgRel32),
+	/*5379*/ uint16(xMatch),
+	/*5380*/ uint16(xCondIs64), 5383, 5397,
+	/*5383*/ uint16(xCondDataSize), 5387, 5392, 0,
+	/*5387*/ uint16(xSetOp), uint16(JS),
+	/*5389*/ uint16(xReadCw),
+	/*5390*/ uint16(xArgRel16),
+	/*5391*/ uint16(xMatch),
+	/*5392*/ uint16(xSetOp), uint16(JS),
+	/*5394*/ uint16(xReadCd),
+	/*5395*/ uint16(xArgRel32),
+	/*5396*/ uint16(xMatch),
+	/*5397*/ uint16(xCondDataSize), 5401, 5392, 5406,
+	/*5401*/ uint16(xSetOp), uint16(JS),
+	/*5403*/ uint16(xReadCd),
+	/*5404*/ uint16(xArgRel32),
+	/*5405*/ uint16(xMatch),
+	/*5406*/ uint16(xSetOp), uint16(JS),
+	/*5408*/ uint16(xReadCd),
+	/*5409*/ uint16(xArgRel32),
+	/*5410*/ uint16(xMatch),
+	/*5411*/ uint16(xCondIs64), 5414, 5428,
+	/*5414*/ uint16(xCondDataSize), 5418, 5423, 0,
+	/*5418*/ uint16(xSetOp), uint16(JNS),
+	/*5420*/ uint16(xReadCw),
+	/*5421*/ uint16(xArgRel16),
+	/*5422*/ uint16(xMatch),
+	/*5423*/ uint16(xSetOp), uint16(JNS),
+	/*5425*/ uint16(xReadCd),
+	/*5426*/ uint16(xArgRel32),
+	/*5427*/ uint16(xMatch),
+	/*5428*/ uint16(xCondDataSize), 5432, 5423, 5437,
+	/*5432*/ uint16(xSetOp), uint16(JNS),
+	/*5434*/ uint16(xReadCd),
+	/*5435*/ uint16(xArgRel32),
+	/*5436*/ uint16(xMatch),
+	/*5437*/ uint16(xSetOp), uint16(JNS),
+	/*5439*/ uint16(xReadCd),
+	/*5440*/ uint16(xArgRel32),
+	/*5441*/ uint16(xMatch),
+	/*5442*/ uint16(xCondIs64), 5445, 5459,
+	/*5445*/ uint16(xCondDataSize), 5449, 5454, 0,
+	/*5449*/ uint16(xSetOp), uint16(JP),
+	/*5451*/ uint16(xReadCw),
+	/*5452*/ uint16(xArgRel16),
+	/*5453*/ uint16(xMatch),
+	/*5454*/ uint16(xSetOp), uint16(JP),
+	/*5456*/ uint16(xReadCd),
+	/*5457*/ uint16(xArgRel32),
+	/*5458*/ uint16(xMatch),
+	/*5459*/ uint16(xCondDataSize), 5463, 5454, 5468,
+	/*5463*/ uint16(xSetOp), uint16(JP),
+	/*5465*/ uint16(xReadCd),
+	/*5466*/ uint16(xArgRel32),
+	/*5467*/ uint16(xMatch),
+	/*5468*/ uint16(xSetOp), uint16(JP),
+	/*5470*/ uint16(xReadCd),
+	/*5471*/ uint16(xArgRel32),
+	/*5472*/ uint16(xMatch),
+	/*5473*/ uint16(xCondIs64), 5476, 5490,
+	/*5476*/ uint16(xCondDataSize), 5480, 5485, 0,
+	/*5480*/ uint16(xSetOp), uint16(JNP),
+	/*5482*/ uint16(xReadCw),
+	/*5483*/ uint16(xArgRel16),
+	/*5484*/ uint16(xMatch),
+	/*5485*/ uint16(xSetOp), uint16(JNP),
+	/*5487*/ uint16(xReadCd),
+	/*5488*/ uint16(xArgRel32),
+	/*5489*/ uint16(xMatch),
+	/*5490*/ uint16(xCondDataSize), 5494, 5485, 5499,
+	/*5494*/ uint16(xSetOp), uint16(JNP),
+	/*5496*/ uint16(xReadCd),
+	/*5497*/ uint16(xArgRel32),
+	/*5498*/ uint16(xMatch),
+	/*5499*/ uint16(xSetOp), uint16(JNP),
+	/*5501*/ uint16(xReadCd),
+	/*5502*/ uint16(xArgRel32),
+	/*5503*/ uint16(xMatch),
+	/*5504*/ uint16(xCondIs64), 5507, 5521,
+	/*5507*/ uint16(xCondDataSize), 5511, 5516, 0,
+	/*5511*/ uint16(xSetOp), uint16(JL),
+	/*5513*/ uint16(xReadCw),
+	/*5514*/ uint16(xArgRel16),
+	/*5515*/ uint16(xMatch),
+	/*5516*/ uint16(xSetOp), uint16(JL),
+	/*5518*/ uint16(xReadCd),
+	/*5519*/ uint16(xArgRel32),
+	/*5520*/ uint16(xMatch),
+	/*5521*/ uint16(xCondDataSize), 5525, 5516, 5530,
+	/*5525*/ uint16(xSetOp), uint16(JL),
+	/*5527*/ uint16(xReadCd),
+	/*5528*/ uint16(xArgRel32),
+	/*5529*/ uint16(xMatch),
+	/*5530*/ uint16(xSetOp), uint16(JL),
+	/*5532*/ uint16(xReadCd),
+	/*5533*/ uint16(xArgRel32),
+	/*5534*/ uint16(xMatch),
+	/*5535*/ uint16(xCondIs64), 5538, 5552,
+	/*5538*/ uint16(xCondDataSize), 5542, 5547, 0,
+	/*5542*/ uint16(xSetOp), uint16(JGE),
+	/*5544*/ uint16(xReadCw),
+	/*5545*/ uint16(xArgRel16),
+	/*5546*/ uint16(xMatch),
+	/*5547*/ uint16(xSetOp), uint16(JGE),
+	/*5549*/ uint16(xReadCd),
+	/*5550*/ uint16(xArgRel32),
+	/*5551*/ uint16(xMatch),
+	/*5552*/ uint16(xCondDataSize), 5556, 5547, 5561,
+	/*5556*/ uint16(xSetOp), uint16(JGE),
+	/*5558*/ uint16(xReadCd),
+	/*5559*/ uint16(xArgRel32),
+	/*5560*/ uint16(xMatch),
+	/*5561*/ uint16(xSetOp), uint16(JGE),
+	/*5563*/ uint16(xReadCd),
+	/*5564*/ uint16(xArgRel32),
+	/*5565*/ uint16(xMatch),
+	/*5566*/ uint16(xCondIs64), 5569, 5583,
+	/*5569*/ uint16(xCondDataSize), 5573, 5578, 0,
+	/*5573*/ uint16(xSetOp), uint16(JLE),
+	/*5575*/ uint16(xReadCw),
+	/*5576*/ uint16(xArgRel16),
+	/*5577*/ uint16(xMatch),
+	/*5578*/ uint16(xSetOp), uint16(JLE),
+	/*5580*/ uint16(xReadCd),
+	/*5581*/ uint16(xArgRel32),
+	/*5582*/ uint16(xMatch),
+	/*5583*/ uint16(xCondDataSize), 5587, 5578, 5592,
+	/*5587*/ uint16(xSetOp), uint16(JLE),
+	/*5589*/ uint16(xReadCd),
+	/*5590*/ uint16(xArgRel32),
+	/*5591*/ uint16(xMatch),
+	/*5592*/ uint16(xSetOp), uint16(JLE),
+	/*5594*/ uint16(xReadCd),
+	/*5595*/ uint16(xArgRel32),
+	/*5596*/ uint16(xMatch),
+	/*5597*/ uint16(xCondIs64), 5600, 5614,
+	/*5600*/ uint16(xCondDataSize), 5604, 5609, 0,
+	/*5604*/ uint16(xSetOp), uint16(JG),
+	/*5606*/ uint16(xReadCw),
+	/*5607*/ uint16(xArgRel16),
+	/*5608*/ uint16(xMatch),
+	/*5609*/ uint16(xSetOp), uint16(JG),
+	/*5611*/ uint16(xReadCd),
+	/*5612*/ uint16(xArgRel32),
+	/*5613*/ uint16(xMatch),
+	/*5614*/ uint16(xCondDataSize), 5618, 5609, 5623,
+	/*5618*/ uint16(xSetOp), uint16(JG),
+	/*5620*/ uint16(xReadCd),
+	/*5621*/ uint16(xArgRel32),
+	/*5622*/ uint16(xMatch),
+	/*5623*/ uint16(xSetOp), uint16(JG),
+	/*5625*/ uint16(xReadCd),
+	/*5626*/ uint16(xArgRel32),
+	/*5627*/ uint16(xMatch),
+	/*5628*/ uint16(xSetOp), uint16(SETO),
+	/*5630*/ uint16(xReadSlashR),
+	/*5631*/ uint16(xArgRM8),
+	/*5632*/ uint16(xMatch),
+	/*5633*/ uint16(xSetOp), uint16(SETNO),
+	/*5635*/ uint16(xReadSlashR),
+	/*5636*/ uint16(xArgRM8),
+	/*5637*/ uint16(xMatch),
+	/*5638*/ uint16(xSetOp), uint16(SETB),
+	/*5640*/ uint16(xReadSlashR),
+	/*5641*/ uint16(xArgRM8),
+	/*5642*/ uint16(xMatch),
+	/*5643*/ uint16(xSetOp), uint16(SETAE),
+	/*5645*/ uint16(xReadSlashR),
+	/*5646*/ uint16(xArgRM8),
+	/*5647*/ uint16(xMatch),
+	/*5648*/ uint16(xSetOp), uint16(SETE),
+	/*5650*/ uint16(xReadSlashR),
+	/*5651*/ uint16(xArgRM8),
+	/*5652*/ uint16(xMatch),
+	/*5653*/ uint16(xSetOp), uint16(SETNE),
+	/*5655*/ uint16(xReadSlashR),
+	/*5656*/ uint16(xArgRM8),
+	/*5657*/ uint16(xMatch),
+	/*5658*/ uint16(xSetOp), uint16(SETBE),
+	/*5660*/ uint16(xReadSlashR),
+	/*5661*/ uint16(xArgRM8),
+	/*5662*/ uint16(xMatch),
+	/*5663*/ uint16(xSetOp), uint16(SETA),
+	/*5665*/ uint16(xReadSlashR),
+	/*5666*/ uint16(xArgRM8),
+	/*5667*/ uint16(xMatch),
+	/*5668*/ uint16(xSetOp), uint16(SETS),
+	/*5670*/ uint16(xReadSlashR),
+	/*5671*/ uint16(xArgRM8),
+	/*5672*/ uint16(xMatch),
+	/*5673*/ uint16(xSetOp), uint16(SETNS),
+	/*5675*/ uint16(xReadSlashR),
+	/*5676*/ uint16(xArgRM8),
+	/*5677*/ uint16(xMatch),
+	/*5678*/ uint16(xSetOp), uint16(SETP),
+	/*5680*/ uint16(xReadSlashR),
+	/*5681*/ uint16(xArgRM8),
+	/*5682*/ uint16(xMatch),
+	/*5683*/ uint16(xSetOp), uint16(SETNP),
+	/*5685*/ uint16(xReadSlashR),
+	/*5686*/ uint16(xArgRM8),
+	/*5687*/ uint16(xMatch),
+	/*5688*/ uint16(xSetOp), uint16(SETL),
+	/*5690*/ uint16(xReadSlashR),
+	/*5691*/ uint16(xArgRM8),
+	/*5692*/ uint16(xMatch),
+	/*5693*/ uint16(xSetOp), uint16(SETGE),
+	/*5695*/ uint16(xReadSlashR),
+	/*5696*/ uint16(xArgRM8),
+	/*5697*/ uint16(xMatch),
+	/*5698*/ uint16(xSetOp), uint16(SETLE),
+	/*5700*/ uint16(xReadSlashR),
+	/*5701*/ uint16(xArgRM8),
+	/*5702*/ uint16(xMatch),
+	/*5703*/ uint16(xSetOp), uint16(SETG),
+	/*5705*/ uint16(xReadSlashR),
+	/*5706*/ uint16(xArgRM8),
+	/*5707*/ uint16(xMatch),
+	/*5708*/ uint16(xSetOp), uint16(PUSH),
+	/*5710*/ uint16(xArgFS),
+	/*5711*/ uint16(xMatch),
+	/*5712*/ uint16(xCondIs64), 5715, 5727,
+	/*5715*/ uint16(xCondDataSize), 5719, 5723, 0,
+	/*5719*/ uint16(xSetOp), uint16(POP),
+	/*5721*/ uint16(xArgFS),
+	/*5722*/ uint16(xMatch),
+	/*5723*/ uint16(xSetOp), uint16(POP),
+	/*5725*/ uint16(xArgFS),
+	/*5726*/ uint16(xMatch),
+	/*5727*/ uint16(xCondDataSize), 5719, 5731, 5735,
+	/*5731*/ uint16(xSetOp), uint16(POP),
+	/*5733*/ uint16(xArgFS),
+	/*5734*/ uint16(xMatch),
+	/*5735*/ uint16(xSetOp), uint16(POP),
+	/*5737*/ uint16(xArgFS),
+	/*5738*/ uint16(xMatch),
+	/*5739*/ uint16(xSetOp), uint16(CPUID),
+	/*5741*/ uint16(xMatch),
+	/*5742*/ uint16(xCondIs64), 5745, 5761,
+	/*5745*/ uint16(xCondDataSize), 5749, 5755, 0,
+	/*5749*/ uint16(xSetOp), uint16(BT),
+	/*5751*/ uint16(xReadSlashR),
+	/*5752*/ uint16(xArgRM16),
+	/*5753*/ uint16(xArgR16),
+	/*5754*/ uint16(xMatch),
+	/*5755*/ uint16(xSetOp), uint16(BT),
+	/*5757*/ uint16(xReadSlashR),
+	/*5758*/ uint16(xArgRM32),
+	/*5759*/ uint16(xArgR32),
+	/*5760*/ uint16(xMatch),
+	/*5761*/ uint16(xCondDataSize), 5749, 5755, 5765,
+	/*5765*/ uint16(xSetOp), uint16(BT),
+	/*5767*/ uint16(xReadSlashR),
+	/*5768*/ uint16(xArgRM64),
+	/*5769*/ uint16(xArgR64),
+	/*5770*/ uint16(xMatch),
+	/*5771*/ uint16(xCondIs64), 5774, 5794,
+	/*5774*/ uint16(xCondDataSize), 5778, 5786, 0,
+	/*5778*/ uint16(xSetOp), uint16(SHLD),
+	/*5780*/ uint16(xReadSlashR),
+	/*5781*/ uint16(xReadIb),
+	/*5782*/ uint16(xArgRM16),
+	/*5783*/ uint16(xArgR16),
+	/*5784*/ uint16(xArgImm8u),
+	/*5785*/ uint16(xMatch),
+	/*5786*/ uint16(xSetOp), uint16(SHLD),
+	/*5788*/ uint16(xReadSlashR),
+	/*5789*/ uint16(xReadIb),
+	/*5790*/ uint16(xArgRM32),
+	/*5791*/ uint16(xArgR32),
+	/*5792*/ uint16(xArgImm8u),
+	/*5793*/ uint16(xMatch),
+	/*5794*/ uint16(xCondDataSize), 5778, 5786, 5798,
+	/*5798*/ uint16(xSetOp), uint16(SHLD),
+	/*5800*/ uint16(xReadSlashR),
+	/*5801*/ uint16(xReadIb),
+	/*5802*/ uint16(xArgRM64),
+	/*5803*/ uint16(xArgR64),
+	/*5804*/ uint16(xArgImm8u),
+	/*5805*/ uint16(xMatch),
+	/*5806*/ uint16(xCondIs64), 5809, 5827,
+	/*5809*/ uint16(xCondDataSize), 5813, 5820, 0,
+	/*5813*/ uint16(xSetOp), uint16(SHLD),
+	/*5815*/ uint16(xReadSlashR),
+	/*5816*/ uint16(xArgRM16),
+	/*5817*/ uint16(xArgR16),
+	/*5818*/ uint16(xArgCL),
+	/*5819*/ uint16(xMatch),
+	/*5820*/ uint16(xSetOp), uint16(SHLD),
+	/*5822*/ uint16(xReadSlashR),
+	/*5823*/ uint16(xArgRM32),
+	/*5824*/ uint16(xArgR32),
+	/*5825*/ uint16(xArgCL),
+	/*5826*/ uint16(xMatch),
+	/*5827*/ uint16(xCondDataSize), 5813, 5820, 5831,
+	/*5831*/ uint16(xSetOp), uint16(SHLD),
+	/*5833*/ uint16(xReadSlashR),
+	/*5834*/ uint16(xArgRM64),
+	/*5835*/ uint16(xArgR64),
+	/*5836*/ uint16(xArgCL),
+	/*5837*/ uint16(xMatch),
+	/*5838*/ uint16(xSetOp), uint16(PUSH),
+	/*5840*/ uint16(xArgGS),
+	/*5841*/ uint16(xMatch),
+	/*5842*/ uint16(xCondIs64), 5845, 5857,
+	/*5845*/ uint16(xCondDataSize), 5849, 5853, 0,
+	/*5849*/ uint16(xSetOp), uint16(POP),
+	/*5851*/ uint16(xArgGS),
+	/*5852*/ uint16(xMatch),
+	/*5853*/ uint16(xSetOp), uint16(POP),
+	/*5855*/ uint16(xArgGS),
+	/*5856*/ uint16(xMatch),
+	/*5857*/ uint16(xCondDataSize), 5849, 5861, 5865,
+	/*5861*/ uint16(xSetOp), uint16(POP),
+	/*5863*/ uint16(xArgGS),
+	/*5864*/ uint16(xMatch),
+	/*5865*/ uint16(xSetOp), uint16(POP),
+	/*5867*/ uint16(xArgGS),
+	/*5868*/ uint16(xMatch),
+	/*5869*/ uint16(xSetOp), uint16(RSM),
+	/*5871*/ uint16(xMatch),
+	/*5872*/ uint16(xCondIs64), 5875, 5891,
+	/*5875*/ uint16(xCondDataSize), 5879, 5885, 0,
+	/*5879*/ uint16(xSetOp), uint16(BTS),
+	/*5881*/ uint16(xReadSlashR),
+	/*5882*/ uint16(xArgRM16),
+	/*5883*/ uint16(xArgR16),
+	/*5884*/ uint16(xMatch),
+	/*5885*/ uint16(xSetOp), uint16(BTS),
+	/*5887*/ uint16(xReadSlashR),
+	/*5888*/ uint16(xArgRM32),
+	/*5889*/ uint16(xArgR32),
+	/*5890*/ uint16(xMatch),
+	/*5891*/ uint16(xCondDataSize), 5879, 5885, 5895,
+	/*5895*/ uint16(xSetOp), uint16(BTS),
+	/*5897*/ uint16(xReadSlashR),
+	/*5898*/ uint16(xArgRM64),
+	/*5899*/ uint16(xArgR64),
+	/*5900*/ uint16(xMatch),
+	/*5901*/ uint16(xCondIs64), 5904, 5924,
+	/*5904*/ uint16(xCondDataSize), 5908, 5916, 0,
+	/*5908*/ uint16(xSetOp), uint16(SHRD),
+	/*5910*/ uint16(xReadSlashR),
+	/*5911*/ uint16(xReadIb),
+	/*5912*/ uint16(xArgRM16),
+	/*5913*/ uint16(xArgR16),
+	/*5914*/ uint16(xArgImm8u),
+	/*5915*/ uint16(xMatch),
+	/*5916*/ uint16(xSetOp), uint16(SHRD),
+	/*5918*/ uint16(xReadSlashR),
+	/*5919*/ uint16(xReadIb),
+	/*5920*/ uint16(xArgRM32),
+	/*5921*/ uint16(xArgR32),
+	/*5922*/ uint16(xArgImm8u),
+	/*5923*/ uint16(xMatch),
+	/*5924*/ uint16(xCondDataSize), 5908, 5916, 5928,
+	/*5928*/ uint16(xSetOp), uint16(SHRD),
+	/*5930*/ uint16(xReadSlashR),
+	/*5931*/ uint16(xReadIb),
+	/*5932*/ uint16(xArgRM64),
+	/*5933*/ uint16(xArgR64),
+	/*5934*/ uint16(xArgImm8u),
+	/*5935*/ uint16(xMatch),
+	/*5936*/ uint16(xCondIs64), 5939, 5957,
+	/*5939*/ uint16(xCondDataSize), 5943, 5950, 0,
+	/*5943*/ uint16(xSetOp), uint16(SHRD),
+	/*5945*/ uint16(xReadSlashR),
+	/*5946*/ uint16(xArgRM16),
+	/*5947*/ uint16(xArgR16),
+	/*5948*/ uint16(xArgCL),
+	/*5949*/ uint16(xMatch),
+	/*5950*/ uint16(xSetOp), uint16(SHRD),
+	/*5952*/ uint16(xReadSlashR),
+	/*5953*/ uint16(xArgRM32),
+	/*5954*/ uint16(xArgR32),
+	/*5955*/ uint16(xArgCL),
+	/*5956*/ uint16(xMatch),
+	/*5957*/ uint16(xCondDataSize), 5943, 5950, 5961,
+	/*5961*/ uint16(xSetOp), uint16(SHRD),
+	/*5963*/ uint16(xReadSlashR),
+	/*5964*/ uint16(xArgRM64),
+	/*5965*/ uint16(xArgR64),
+	/*5966*/ uint16(xArgCL),
+	/*5967*/ uint16(xMatch),
+	/*5968*/ uint16(xCondByte), 3,
+	0xE8, 6217,
+	0xF0, 6220,
+	0xF8, 6223,
+	/*5976*/ uint16(xCondSlashR),
+	5985, // 0
+	6039, // 1
+	6093, // 2
+	6122, // 3
+	6151, // 4
+	6174, // 5
+	6197, // 6
+	6213, // 7
+	/*5985*/ uint16(xCondIs64), 5988, 6000,
+	/*5988*/ uint16(xCondDataSize), 5992, 5996, 0,
+	/*5992*/ uint16(xSetOp), uint16(FXSAVE),
+	/*5994*/ uint16(xArgM512byte),
+	/*5995*/ uint16(xMatch),
+	/*5996*/ uint16(xSetOp), uint16(FXSAVE),
+	/*5998*/ uint16(xArgM512byte),
+	/*5999*/ uint16(xMatch),
+	/*6000*/ uint16(xCondPrefix), 2,
+	0xF3, 6014,
+	0x0, 6006,
+	/*6006*/ uint16(xCondDataSize), 5992, 5996, 6010,
+	/*6010*/ uint16(xSetOp), uint16(FXSAVE64),
+	/*6012*/ uint16(xArgM512byte),
+	/*6013*/ uint16(xMatch),
+	/*6014*/ uint16(xCondDataSize), 6018, 6025, 6032,
+	/*6018*/ uint16(xCondIsMem), 6021, 0,
+	/*6021*/ uint16(xSetOp), uint16(RDFSBASE),
+	/*6023*/ uint16(xArgRM32),
+	/*6024*/ uint16(xMatch),
+	/*6025*/ uint16(xCondIsMem), 6028, 0,
+	/*6028*/ uint16(xSetOp), uint16(RDFSBASE),
+	/*6030*/ uint16(xArgRM32),
+	/*6031*/ uint16(xMatch),
+	/*6032*/ uint16(xCondIsMem), 6035, 0,
+	/*6035*/ uint16(xSetOp), uint16(RDFSBASE),
+	/*6037*/ uint16(xArgRM64),
+	/*6038*/ uint16(xMatch),
+	/*6039*/ uint16(xCondIs64), 6042, 6054,
+	/*6042*/ uint16(xCondDataSize), 6046, 6050, 0,
+	/*6046*/ uint16(xSetOp), uint16(FXRSTOR),
+	/*6048*/ uint16(xArgM512byte),
+	/*6049*/ uint16(xMatch),
+	/*6050*/ uint16(xSetOp), uint16(FXRSTOR),
+	/*6052*/ uint16(xArgM512byte),
+	/*6053*/ uint16(xMatch),
+	/*6054*/ uint16(xCondPrefix), 2,
+	0xF3, 6068,
+	0x0, 6060,
+	/*6060*/ uint16(xCondDataSize), 6046, 6050, 6064,
+	/*6064*/ uint16(xSetOp), uint16(FXRSTOR64),
+	/*6066*/ uint16(xArgM512byte),
+	/*6067*/ uint16(xMatch),
+	/*6068*/ uint16(xCondDataSize), 6072, 6079, 6086,
+	/*6072*/ uint16(xCondIsMem), 6075, 0,
+	/*6075*/ uint16(xSetOp), uint16(RDGSBASE),
+	/*6077*/ uint16(xArgRM32),
+	/*6078*/ uint16(xMatch),
+	/*6079*/ uint16(xCondIsMem), 6082, 0,
+	/*6082*/ uint16(xSetOp), uint16(RDGSBASE),
+	/*6084*/ uint16(xArgRM32),
+	/*6085*/ uint16(xMatch),
+	/*6086*/ uint16(xCondIsMem), 6089, 0,
+	/*6089*/ uint16(xSetOp), uint16(RDGSBASE),
+	/*6091*/ uint16(xArgRM64),
+	/*6092*/ uint16(xMatch),
+	/*6093*/ uint16(xCondIs64), 6096, 6100,
+	/*6096*/ uint16(xSetOp), uint16(LDMXCSR),
+	/*6098*/ uint16(xArgM32),
+	/*6099*/ uint16(xMatch),
+	/*6100*/ uint16(xCondPrefix), 2,
+	0xF3, 6106,
+	0x0, 6096,
+	/*6106*/ uint16(xCondDataSize), 6110, 6114, 6118,
+	/*6110*/ uint16(xSetOp), uint16(WRFSBASE),
+	/*6112*/ uint16(xArgRM32),
+	/*6113*/ uint16(xMatch),
+	/*6114*/ uint16(xSetOp), uint16(WRFSBASE),
+	/*6116*/ uint16(xArgRM32),
+	/*6117*/ uint16(xMatch),
+	/*6118*/ uint16(xSetOp), uint16(WRFSBASE),
+	/*6120*/ uint16(xArgRM64),
+	/*6121*/ uint16(xMatch),
+	/*6122*/ uint16(xCondIs64), 6125, 6129,
+	/*6125*/ uint16(xSetOp), uint16(STMXCSR),
+	/*6127*/ uint16(xArgM32),
+	/*6128*/ uint16(xMatch),
+	/*6129*/ uint16(xCondPrefix), 2,
+	0xF3, 6135,
+	0x0, 6125,
+	/*6135*/ uint16(xCondDataSize), 6139, 6143, 6147,
+	/*6139*/ uint16(xSetOp), uint16(WRGSBASE),
+	/*6141*/ uint16(xArgRM32),
+	/*6142*/ uint16(xMatch),
+	/*6143*/ uint16(xSetOp), uint16(WRGSBASE),
+	/*6145*/ uint16(xArgRM32),
+	/*6146*/ uint16(xMatch),
+	/*6147*/ uint16(xSetOp), uint16(WRGSBASE),
+	/*6149*/ uint16(xArgRM64),
+	/*6150*/ uint16(xMatch),
+	/*6151*/ uint16(xCondIs64), 6154, 6166,
+	/*6154*/ uint16(xCondDataSize), 6158, 6162, 0,
+	/*6158*/ uint16(xSetOp), uint16(XSAVE),
+	/*6160*/ uint16(xArgMem),
+	/*6161*/ uint16(xMatch),
+	/*6162*/ uint16(xSetOp), uint16(XSAVE),
+	/*6164*/ uint16(xArgMem),
+	/*6165*/ uint16(xMatch),
+	/*6166*/ uint16(xCondDataSize), 6158, 6162, 6170,
+	/*6170*/ uint16(xSetOp), uint16(XSAVE64),
+	/*6172*/ uint16(xArgMem),
+	/*6173*/ uint16(xMatch),
+	/*6174*/ uint16(xCondIs64), 6177, 6189,
+	/*6177*/ uint16(xCondDataSize), 6181, 6185, 0,
+	/*6181*/ uint16(xSetOp), uint16(XRSTOR),
+	/*6183*/ uint16(xArgMem),
+	/*6184*/ uint16(xMatch),
+	/*6185*/ uint16(xSetOp), uint16(XRSTOR),
+	/*6187*/ uint16(xArgMem),
+	/*6188*/ uint16(xMatch),
+	/*6189*/ uint16(xCondDataSize), 6181, 6185, 6193,
+	/*6193*/ uint16(xSetOp), uint16(XRSTOR64),
+	/*6195*/ uint16(xArgMem),
+	/*6196*/ uint16(xMatch),
+	/*6197*/ uint16(xCondDataSize), 6201, 6205, 6209,
+	/*6201*/ uint16(xSetOp), uint16(XSAVEOPT),
+	/*6203*/ uint16(xArgMem),
+	/*6204*/ uint16(xMatch),
+	/*6205*/ uint16(xSetOp), uint16(XSAVEOPT),
+	/*6207*/ uint16(xArgMem),
+	/*6208*/ uint16(xMatch),
+	/*6209*/ uint16(xSetOp), uint16(XSAVEOPT64),
+	/*6211*/ uint16(xArgMem),
+	/*6212*/ uint16(xMatch),
+	/*6213*/ uint16(xSetOp), uint16(CLFLUSH),
+	/*6215*/ uint16(xArgM8),
+	/*6216*/ uint16(xMatch),
+	/*6217*/ uint16(xSetOp), uint16(LFENCE),
+	/*6219*/ uint16(xMatch),
+	/*6220*/ uint16(xSetOp), uint16(MFENCE),
+	/*6222*/ uint16(xMatch),
+	/*6223*/ uint16(xSetOp), uint16(SFENCE),
+	/*6225*/ uint16(xMatch),
+	/*6226*/ uint16(xCondIs64), 6229, 6245,
+	/*6229*/ uint16(xCondDataSize), 6233, 6239, 0,
+	/*6233*/ uint16(xSetOp), uint16(IMUL),
+	/*6235*/ uint16(xReadSlashR),
+	/*6236*/ uint16(xArgR16),
+	/*6237*/ uint16(xArgRM16),
+	/*6238*/ uint16(xMatch),
+	/*6239*/ uint16(xSetOp), uint16(IMUL),
+	/*6241*/ uint16(xReadSlashR),
+	/*6242*/ uint16(xArgR32),
+	/*6243*/ uint16(xArgRM32),
+	/*6244*/ uint16(xMatch),
+	/*6245*/ uint16(xCondDataSize), 6233, 6239, 6249,
+	/*6249*/ uint16(xSetOp), uint16(IMUL),
+	/*6251*/ uint16(xReadSlashR),
+	/*6252*/ uint16(xArgR64),
+	/*6253*/ uint16(xArgRM64),
+	/*6254*/ uint16(xMatch),
+	/*6255*/ uint16(xSetOp), uint16(CMPXCHG),
+	/*6257*/ uint16(xReadSlashR),
+	/*6258*/ uint16(xArgRM8),
+	/*6259*/ uint16(xArgR8),
+	/*6260*/ uint16(xMatch),
+	/*6261*/ uint16(xCondIs64), 6264, 6280,
+	/*6264*/ uint16(xCondDataSize), 6268, 6274, 0,
+	/*6268*/ uint16(xSetOp), uint16(CMPXCHG),
+	/*6270*/ uint16(xReadSlashR),
+	/*6271*/ uint16(xArgRM16),
+	/*6272*/ uint16(xArgR16),
+	/*6273*/ uint16(xMatch),
+	/*6274*/ uint16(xSetOp), uint16(CMPXCHG),
+	/*6276*/ uint16(xReadSlashR),
+	/*6277*/ uint16(xArgRM32),
+	/*6278*/ uint16(xArgR32),
+	/*6279*/ uint16(xMatch),
+	/*6280*/ uint16(xCondDataSize), 6268, 6274, 6284,
+	/*6284*/ uint16(xSetOp), uint16(CMPXCHG),
+	/*6286*/ uint16(xReadSlashR),
+	/*6287*/ uint16(xArgRM64),
+	/*6288*/ uint16(xArgR64),
+	/*6289*/ uint16(xMatch),
+	/*6290*/ uint16(xCondIs64), 6293, 6309,
+	/*6293*/ uint16(xCondDataSize), 6297, 6303, 0,
+	/*6297*/ uint16(xSetOp), uint16(LSS),
+	/*6299*/ uint16(xReadSlashR),
+	/*6300*/ uint16(xArgR16),
+	/*6301*/ uint16(xArgM16colon16),
+	/*6302*/ uint16(xMatch),
+	/*6303*/ uint16(xSetOp), uint16(LSS),
+	/*6305*/ uint16(xReadSlashR),
+	/*6306*/ uint16(xArgR32),
+	/*6307*/ uint16(xArgM16colon32),
+	/*6308*/ uint16(xMatch),
+	/*6309*/ uint16(xCondDataSize), 6297, 6303, 6313,
+	/*6313*/ uint16(xSetOp), uint16(LSS),
+	/*6315*/ uint16(xReadSlashR),
+	/*6316*/ uint16(xArgR64),
+	/*6317*/ uint16(xArgM16colon64),
+	/*6318*/ uint16(xMatch),
+	/*6319*/ uint16(xCondIs64), 6322, 6338,
+	/*6322*/ uint16(xCondDataSize), 6326, 6332, 0,
+	/*6326*/ uint16(xSetOp), uint16(BTR),
+	/*6328*/ uint16(xReadSlashR),
+	/*6329*/ uint16(xArgRM16),
+	/*6330*/ uint16(xArgR16),
+	/*6331*/ uint16(xMatch),
+	/*6332*/ uint16(xSetOp), uint16(BTR),
+	/*6334*/ uint16(xReadSlashR),
+	/*6335*/ uint16(xArgRM32),
+	/*6336*/ uint16(xArgR32),
+	/*6337*/ uint16(xMatch),
+	/*6338*/ uint16(xCondDataSize), 6326, 6332, 6342,
+	/*6342*/ uint16(xSetOp), uint16(BTR),
+	/*6344*/ uint16(xReadSlashR),
+	/*6345*/ uint16(xArgRM64),
+	/*6346*/ uint16(xArgR64),
+	/*6347*/ uint16(xMatch),
+	/*6348*/ uint16(xCondIs64), 6351, 6367,
+	/*6351*/ uint16(xCondDataSize), 6355, 6361, 0,
+	/*6355*/ uint16(xSetOp), uint16(LFS),
+	/*6357*/ uint16(xReadSlashR),
+	/*6358*/ uint16(xArgR16),
+	/*6359*/ uint16(xArgM16colon16),
+	/*6360*/ uint16(xMatch),
+	/*6361*/ uint16(xSetOp), uint16(LFS),
+	/*6363*/ uint16(xReadSlashR),
+	/*6364*/ uint16(xArgR32),
+	/*6365*/ uint16(xArgM16colon32),
+	/*6366*/ uint16(xMatch),
+	/*6367*/ uint16(xCondDataSize), 6355, 6361, 6371,
+	/*6371*/ uint16(xSetOp), uint16(LFS),
+	/*6373*/ uint16(xReadSlashR),
+	/*6374*/ uint16(xArgR64),
+	/*6375*/ uint16(xArgM16colon64),
+	/*6376*/ uint16(xMatch),
+	/*6377*/ uint16(xCondIs64), 6380, 6396,
+	/*6380*/ uint16(xCondDataSize), 6384, 6390, 0,
+	/*6384*/ uint16(xSetOp), uint16(LGS),
+	/*6386*/ uint16(xReadSlashR),
+	/*6387*/ uint16(xArgR16),
+	/*6388*/ uint16(xArgM16colon16),
+	/*6389*/ uint16(xMatch),
+	/*6390*/ uint16(xSetOp), uint16(LGS),
+	/*6392*/ uint16(xReadSlashR),
+	/*6393*/ uint16(xArgR32),
+	/*6394*/ uint16(xArgM16colon32),
+	/*6395*/ uint16(xMatch),
+	/*6396*/ uint16(xCondDataSize), 6384, 6390, 6400,
+	/*6400*/ uint16(xSetOp), uint16(LGS),
+	/*6402*/ uint16(xReadSlashR),
+	/*6403*/ uint16(xArgR64),
+	/*6404*/ uint16(xArgM16colon64),
+	/*6405*/ uint16(xMatch),
+	/*6406*/ uint16(xCondIs64), 6409, 6425,
+	/*6409*/ uint16(xCondDataSize), 6413, 6419, 0,
+	/*6413*/ uint16(xSetOp), uint16(MOVZX),
+	/*6415*/ uint16(xReadSlashR),
+	/*6416*/ uint16(xArgR16),
+	/*6417*/ uint16(xArgRM8),
+	/*6418*/ uint16(xMatch),
+	/*6419*/ uint16(xSetOp), uint16(MOVZX),
+	/*6421*/ uint16(xReadSlashR),
+	/*6422*/ uint16(xArgR32),
+	/*6423*/ uint16(xArgRM8),
+	/*6424*/ uint16(xMatch),
+	/*6425*/ uint16(xCondDataSize), 6413, 6419, 6429,
+	/*6429*/ uint16(xSetOp), uint16(MOVZX),
+	/*6431*/ uint16(xReadSlashR),
+	/*6432*/ uint16(xArgR64),
+	/*6433*/ uint16(xArgRM8),
+	/*6434*/ uint16(xMatch),
+	/*6435*/ uint16(xCondIs64), 6438, 6454,
+	/*6438*/ uint16(xCondDataSize), 6442, 6448, 0,
+	/*6442*/ uint16(xSetOp), uint16(MOVZX),
+	/*6444*/ uint16(xReadSlashR),
+	/*6445*/ uint16(xArgR16),
+	/*6446*/ uint16(xArgRM16),
+	/*6447*/ uint16(xMatch),
+	/*6448*/ uint16(xSetOp), uint16(MOVZX),
+	/*6450*/ uint16(xReadSlashR),
+	/*6451*/ uint16(xArgR32),
+	/*6452*/ uint16(xArgRM16),
+	/*6453*/ uint16(xMatch),
+	/*6454*/ uint16(xCondDataSize), 6442, 6448, 6458,
+	/*6458*/ uint16(xSetOp), uint16(MOVZX),
+	/*6460*/ uint16(xReadSlashR),
+	/*6461*/ uint16(xArgR64),
+	/*6462*/ uint16(xArgRM16),
+	/*6463*/ uint16(xMatch),
+	/*6464*/ uint16(xCondIs64), 6467, 6487,
+	/*6467*/ uint16(xCondPrefix), 1,
+	0xF3, 6471,
+	/*6471*/ uint16(xCondDataSize), 6475, 6481, 0,
+	/*6475*/ uint16(xSetOp), uint16(POPCNT),
+	/*6477*/ uint16(xReadSlashR),
+	/*6478*/ uint16(xArgR16),
+	/*6479*/ uint16(xArgRM16),
+	/*6480*/ uint16(xMatch),
+	/*6481*/ uint16(xSetOp), uint16(POPCNT),
+	/*6483*/ uint16(xReadSlashR),
+	/*6484*/ uint16(xArgR32),
+	/*6485*/ uint16(xArgRM32),
+	/*6486*/ uint16(xMatch),
+	/*6487*/ uint16(xCondPrefix), 1,
+	0xF3, 6491,
+	/*6491*/ uint16(xCondDataSize), 6475, 6481, 6495,
+	/*6495*/ uint16(xSetOp), uint16(POPCNT),
+	/*6497*/ uint16(xReadSlashR),
+	/*6498*/ uint16(xArgR64),
+	/*6499*/ uint16(xArgRM64),
+	/*6500*/ uint16(xMatch),
+	/*6501*/ uint16(xCondDataSize), 0, 6505, 0,
+	/*6505*/ uint16(xSetOp), uint16(UD1),
+	/*6507*/ uint16(xReadSlashR),
+	/*6508*/ uint16(xArgR32),
+	/*6509*/ uint16(xArgRM32),
+	/*6510*/ uint16(xMatch),
+	/*6511*/ uint16(xCondSlashR),
+	0,    // 0
+	0,    // 1
+	0,    // 2
+	0,    // 3
+	6520, // 4
+	6549, // 5
+	6578, // 6
+	6607, // 7
+	/*6520*/ uint16(xCondIs64), 6523, 6539,
+	/*6523*/ uint16(xCondDataSize), 6527, 6533, 0,
+	/*6527*/ uint16(xSetOp), uint16(BT),
+	/*6529*/ uint16(xReadIb),
+	/*6530*/ uint16(xArgRM16),
+	/*6531*/ uint16(xArgImm8u),
+	/*6532*/ uint16(xMatch),
+	/*6533*/ uint16(xSetOp), uint16(BT),
+	/*6535*/ uint16(xReadIb),
+	/*6536*/ uint16(xArgRM32),
+	/*6537*/ uint16(xArgImm8u),
+	/*6538*/ uint16(xMatch),
+	/*6539*/ uint16(xCondDataSize), 6527, 6533, 6543,
+	/*6543*/ uint16(xSetOp), uint16(BT),
+	/*6545*/ uint16(xReadIb),
+	/*6546*/ uint16(xArgRM64),
+	/*6547*/ uint16(xArgImm8u),
+	/*6548*/ uint16(xMatch),
+	/*6549*/ uint16(xCondIs64), 6552, 6568,
+	/*6552*/ uint16(xCondDataSize), 6556, 6562, 0,
+	/*6556*/ uint16(xSetOp), uint16(BTS),
+	/*6558*/ uint16(xReadIb),
+	/*6559*/ uint16(xArgRM16),
+	/*6560*/ uint16(xArgImm8u),
+	/*6561*/ uint16(xMatch),
+	/*6562*/ uint16(xSetOp), uint16(BTS),
+	/*6564*/ uint16(xReadIb),
+	/*6565*/ uint16(xArgRM32),
+	/*6566*/ uint16(xArgImm8u),
+	/*6567*/ uint16(xMatch),
+	/*6568*/ uint16(xCondDataSize), 6556, 6562, 6572,
+	/*6572*/ uint16(xSetOp), uint16(BTS),
+	/*6574*/ uint16(xReadIb),
+	/*6575*/ uint16(xArgRM64),
+	/*6576*/ uint16(xArgImm8u),
+	/*6577*/ uint16(xMatch),
+	/*6578*/ uint16(xCondIs64), 6581, 6597,
+	/*6581*/ uint16(xCondDataSize), 6585, 6591, 0,
+	/*6585*/ uint16(xSetOp), uint16(BTR),
+	/*6587*/ uint16(xReadIb),
+	/*6588*/ uint16(xArgRM16),
+	/*6589*/ uint16(xArgImm8u),
+	/*6590*/ uint16(xMatch),
+	/*6591*/ uint16(xSetOp), uint16(BTR),
+	/*6593*/ uint16(xReadIb),
+	/*6594*/ uint16(xArgRM32),
+	/*6595*/ uint16(xArgImm8u),
+	/*6596*/ uint16(xMatch),
+	/*6597*/ uint16(xCondDataSize), 6585, 6591, 6601,
+	/*6601*/ uint16(xSetOp), uint16(BTR),
+	/*6603*/ uint16(xReadIb),
+	/*6604*/ uint16(xArgRM64),
+	/*6605*/ uint16(xArgImm8u),
+	/*6606*/ uint16(xMatch),
+	/*6607*/ uint16(xCondIs64), 6610, 6626,
+	/*6610*/ uint16(xCondDataSize), 6614, 6620, 0,
+	/*6614*/ uint16(xSetOp), uint16(BTC),
+	/*6616*/ uint16(xReadIb),
+	/*6617*/ uint16(xArgRM16),
+	/*6618*/ uint16(xArgImm8u),
+	/*6619*/ uint16(xMatch),
+	/*6620*/ uint16(xSetOp), uint16(BTC),
+	/*6622*/ uint16(xReadIb),
+	/*6623*/ uint16(xArgRM32),
+	/*6624*/ uint16(xArgImm8u),
+	/*6625*/ uint16(xMatch),
+	/*6626*/ uint16(xCondDataSize), 6614, 6620, 6630,
+	/*6630*/ uint16(xSetOp), uint16(BTC),
+	/*6632*/ uint16(xReadIb),
+	/*6633*/ uint16(xArgRM64),
+	/*6634*/ uint16(xArgImm8u),
+	/*6635*/ uint16(xMatch),
+	/*6636*/ uint16(xCondIs64), 6639, 6655,
+	/*6639*/ uint16(xCondDataSize), 6643, 6649, 0,
+	/*6643*/ uint16(xSetOp), uint16(BTC),
+	/*6645*/ uint16(xReadSlashR),
+	/*6646*/ uint16(xArgRM16),
+	/*6647*/ uint16(xArgR16),
+	/*6648*/ uint16(xMatch),
+	/*6649*/ uint16(xSetOp), uint16(BTC),
+	/*6651*/ uint16(xReadSlashR),
+	/*6652*/ uint16(xArgRM32),
+	/*6653*/ uint16(xArgR32),
+	/*6654*/ uint16(xMatch),
+	/*6655*/ uint16(xCondDataSize), 6643, 6649, 6659,
+	/*6659*/ uint16(xSetOp), uint16(BTC),
+	/*6661*/ uint16(xReadSlashR),
+	/*6662*/ uint16(xArgRM64),
+	/*6663*/ uint16(xArgR64),
+	/*6664*/ uint16(xMatch),
+	/*6665*/ uint16(xCondIs64), 6668, 6706,
+	/*6668*/ uint16(xCondPrefix), 2,
+	0xF3, 6690,
+	0x0, 6674,
+	/*6674*/ uint16(xCondDataSize), 6678, 6684, 0,
+	/*6678*/ uint16(xSetOp), uint16(BSF),
+	/*6680*/ uint16(xReadSlashR),
+	/*6681*/ uint16(xArgR16),
+	/*6682*/ uint16(xArgRM16),
+	/*6683*/ uint16(xMatch),
+	/*6684*/ uint16(xSetOp), uint16(BSF),
+	/*6686*/ uint16(xReadSlashR),
+	/*6687*/ uint16(xArgR32),
+	/*6688*/ uint16(xArgRM32),
+	/*6689*/ uint16(xMatch),
+	/*6690*/ uint16(xCondDataSize), 6694, 6700, 0,
+	/*6694*/ uint16(xSetOp), uint16(TZCNT),
+	/*6696*/ uint16(xReadSlashR),
+	/*6697*/ uint16(xArgR16),
+	/*6698*/ uint16(xArgRM16),
+	/*6699*/ uint16(xMatch),
+	/*6700*/ uint16(xSetOp), uint16(TZCNT),
+	/*6702*/ uint16(xReadSlashR),
+	/*6703*/ uint16(xArgR32),
+	/*6704*/ uint16(xArgRM32),
+	/*6705*/ uint16(xMatch),
+	/*6706*/ uint16(xCondPrefix), 2,
+	0xF3, 6722,
+	0x0, 6712,
+	/*6712*/ uint16(xCondDataSize), 6678, 6684, 6716,
+	/*6716*/ uint16(xSetOp), uint16(BSF),
+	/*6718*/ uint16(xReadSlashR),
+	/*6719*/ uint16(xArgR64),
+	/*6720*/ uint16(xArgRM64),
+	/*6721*/ uint16(xMatch),
+	/*6722*/ uint16(xCondDataSize), 6694, 6700, 6726,
+	/*6726*/ uint16(xSetOp), uint16(TZCNT),
+	/*6728*/ uint16(xReadSlashR),
+	/*6729*/ uint16(xArgR64),
+	/*6730*/ uint16(xArgRM64),
+	/*6731*/ uint16(xMatch),
+	/*6732*/ uint16(xCondIs64), 6735, 6773,
+	/*6735*/ uint16(xCondPrefix), 2,
+	0xF3, 6757,
+	0x0, 6741,
+	/*6741*/ uint16(xCondDataSize), 6745, 6751, 0,
+	/*6745*/ uint16(xSetOp), uint16(BSR),
+	/*6747*/ uint16(xReadSlashR),
+	/*6748*/ uint16(xArgR16),
+	/*6749*/ uint16(xArgRM16),
+	/*6750*/ uint16(xMatch),
+	/*6751*/ uint16(xSetOp), uint16(BSR),
+	/*6753*/ uint16(xReadSlashR),
+	/*6754*/ uint16(xArgR32),
+	/*6755*/ uint16(xArgRM32),
+	/*6756*/ uint16(xMatch),
+	/*6757*/ uint16(xCondDataSize), 6761, 6767, 0,
+	/*6761*/ uint16(xSetOp), uint16(LZCNT),
+	/*6763*/ uint16(xReadSlashR),
+	/*6764*/ uint16(xArgR16),
+	/*6765*/ uint16(xArgRM16),
+	/*6766*/ uint16(xMatch),
+	/*6767*/ uint16(xSetOp), uint16(LZCNT),
+	/*6769*/ uint16(xReadSlashR),
+	/*6770*/ uint16(xArgR32),
+	/*6771*/ uint16(xArgRM32),
+	/*6772*/ uint16(xMatch),
+	/*6773*/ uint16(xCondPrefix), 2,
+	0xF3, 6789,
+	0x0, 6779,
+	/*6779*/ uint16(xCondDataSize), 6745, 6751, 6783,
+	/*6783*/ uint16(xSetOp), uint16(BSR),
+	/*6785*/ uint16(xReadSlashR),
+	/*6786*/ uint16(xArgR64),
+	/*6787*/ uint16(xArgRM64),
+	/*6788*/ uint16(xMatch),
+	/*6789*/ uint16(xCondDataSize), 6761, 6767, 6793,
+	/*6793*/ uint16(xSetOp), uint16(LZCNT),
+	/*6795*/ uint16(xReadSlashR),
+	/*6796*/ uint16(xArgR64),
+	/*6797*/ uint16(xArgRM64),
+	/*6798*/ uint16(xMatch),
+	/*6799*/ uint16(xCondIs64), 6802, 6818,
+	/*6802*/ uint16(xCondDataSize), 6806, 6812, 0,
+	/*6806*/ uint16(xSetOp), uint16(MOVSX),
+	/*6808*/ uint16(xReadSlashR),
+	/*6809*/ uint16(xArgR16),
+	/*6810*/ uint16(xArgRM8),
+	/*6811*/ uint16(xMatch),
+	/*6812*/ uint16(xSetOp), uint16(MOVSX),
+	/*6814*/ uint16(xReadSlashR),
+	/*6815*/ uint16(xArgR32),
+	/*6816*/ uint16(xArgRM8),
+	/*6817*/ uint16(xMatch),
+	/*6818*/ uint16(xCondDataSize), 6806, 6812, 6822,
+	/*6822*/ uint16(xSetOp), uint16(MOVSX),
+	/*6824*/ uint16(xReadSlashR),
+	/*6825*/ uint16(xArgR64),
+	/*6826*/ uint16(xArgRM8),
+	/*6827*/ uint16(xMatch),
+	/*6828*/ uint16(xCondIs64), 6831, 6847,
+	/*6831*/ uint16(xCondDataSize), 6835, 6841, 0,
+	/*6835*/ uint16(xSetOp), uint16(MOVSX),
+	/*6837*/ uint16(xReadSlashR),
+	/*6838*/ uint16(xArgR16),
+	/*6839*/ uint16(xArgRM16),
+	/*6840*/ uint16(xMatch),
+	/*6841*/ uint16(xSetOp), uint16(MOVSX),
+	/*6843*/ uint16(xReadSlashR),
+	/*6844*/ uint16(xArgR32),
+	/*6845*/ uint16(xArgRM16),
+	/*6846*/ uint16(xMatch),
+	/*6847*/ uint16(xCondDataSize), 6835, 6841, 6851,
+	/*6851*/ uint16(xSetOp), uint16(MOVSX),
+	/*6853*/ uint16(xReadSlashR),
+	/*6854*/ uint16(xArgR64),
+	/*6855*/ uint16(xArgRM16),
+	/*6856*/ uint16(xMatch),
+	/*6857*/ uint16(xSetOp), uint16(XADD),
+	/*6859*/ uint16(xReadSlashR),
+	/*6860*/ uint16(xArgRM8),
+	/*6861*/ uint16(xArgR8),
+	/*6862*/ uint16(xMatch),
+	/*6863*/ uint16(xCondIs64), 6866, 6882,
+	/*6866*/ uint16(xCondDataSize), 6870, 6876, 0,
+	/*6870*/ uint16(xSetOp), uint16(XADD),
+	/*6872*/ uint16(xReadSlashR),
+	/*6873*/ uint16(xArgRM16),
+	/*6874*/ uint16(xArgR16),
+	/*6875*/ uint16(xMatch),
+	/*6876*/ uint16(xSetOp), uint16(XADD),
+	/*6878*/ uint16(xReadSlashR),
+	/*6879*/ uint16(xArgRM32),
+	/*6880*/ uint16(xArgR32),
+	/*6881*/ uint16(xMatch),
+	/*6882*/ uint16(xCondDataSize), 6870, 6876, 6886,
+	/*6886*/ uint16(xSetOp), uint16(XADD),
+	/*6888*/ uint16(xReadSlashR),
+	/*6889*/ uint16(xArgRM64),
+	/*6890*/ uint16(xArgR64),
+	/*6891*/ uint16(xMatch),
+	/*6892*/ uint16(xCondPrefix), 4,
+	0xF3, 6926,
+	0xF2, 6918,
+	0x66, 6910,
+	0x0, 6902,
+	/*6902*/ uint16(xSetOp), uint16(CMPPS),
+	/*6904*/ uint16(xReadSlashR),
+	/*6905*/ uint16(xReadIb),
+	/*6906*/ uint16(xArgXmm1),
+	/*6907*/ uint16(xArgXmm2M128),
+	/*6908*/ uint16(xArgImm8u),
+	/*6909*/ uint16(xMatch),
+	/*6910*/ uint16(xSetOp), uint16(CMPPD),
+	/*6912*/ uint16(xReadSlashR),
+	/*6913*/ uint16(xReadIb),
+	/*6914*/ uint16(xArgXmm1),
+	/*6915*/ uint16(xArgXmm2M128),
+	/*6916*/ uint16(xArgImm8u),
+	/*6917*/ uint16(xMatch),
+	/*6918*/ uint16(xSetOp), uint16(CMPSD_XMM),
+	/*6920*/ uint16(xReadSlashR),
+	/*6921*/ uint16(xReadIb),
+	/*6922*/ uint16(xArgXmm1),
+	/*6923*/ uint16(xArgXmm2M64),
+	/*6924*/ uint16(xArgImm8u),
+	/*6925*/ uint16(xMatch),
+	/*6926*/ uint16(xSetOp), uint16(CMPSS),
+	/*6928*/ uint16(xReadSlashR),
+	/*6929*/ uint16(xReadIb),
+	/*6930*/ uint16(xArgXmm1),
+	/*6931*/ uint16(xArgXmm2M32),
+	/*6932*/ uint16(xArgImm8u),
+	/*6933*/ uint16(xMatch),
+	/*6934*/ uint16(xCondIs64), 6937, 6953,
+	/*6937*/ uint16(xCondDataSize), 6941, 6947, 0,
+	/*6941*/ uint16(xSetOp), uint16(MOVNTI),
+	/*6943*/ uint16(xReadSlashR),
+	/*6944*/ uint16(xArgM32),
+	/*6945*/ uint16(xArgR32),
+	/*6946*/ uint16(xMatch),
+	/*6947*/ uint16(xSetOp), uint16(MOVNTI),
+	/*6949*/ uint16(xReadSlashR),
+	/*6950*/ uint16(xArgM32),
+	/*6951*/ uint16(xArgR32),
+	/*6952*/ uint16(xMatch),
+	/*6953*/ uint16(xCondDataSize), 6941, 6947, 6957,
+	/*6957*/ uint16(xSetOp), uint16(MOVNTI),
+	/*6959*/ uint16(xReadSlashR),
+	/*6960*/ uint16(xArgM64),
+	/*6961*/ uint16(xArgR64),
+	/*6962*/ uint16(xMatch),
+	/*6963*/ uint16(xCondPrefix), 2,
+	0x66, 6977,
+	0x0, 6969,
+	/*6969*/ uint16(xSetOp), uint16(PINSRW),
+	/*6971*/ uint16(xReadSlashR),
+	/*6972*/ uint16(xReadIb),
+	/*6973*/ uint16(xArgMm),
+	/*6974*/ uint16(xArgR32M16),
+	/*6975*/ uint16(xArgImm8u),
+	/*6976*/ uint16(xMatch),
+	/*6977*/ uint16(xSetOp), uint16(PINSRW),
+	/*6979*/ uint16(xReadSlashR),
+	/*6980*/ uint16(xReadIb),
+	/*6981*/ uint16(xArgXmm),
+	/*6982*/ uint16(xArgR32M16),
+	/*6983*/ uint16(xArgImm8u),
+	/*6984*/ uint16(xMatch),
+	/*6985*/ uint16(xCondPrefix), 2,
+	0x66, 6999,
+	0x0, 6991,
+	/*6991*/ uint16(xSetOp), uint16(PEXTRW),
+	/*6993*/ uint16(xReadSlashR),
+	/*6994*/ uint16(xReadIb),
+	/*6995*/ uint16(xArgR32),
+	/*6996*/ uint16(xArgMm2),
+	/*6997*/ uint16(xArgImm8u),
+	/*6998*/ uint16(xMatch),
+	/*6999*/ uint16(xSetOp), uint16(PEXTRW),
+	/*7001*/ uint16(xReadSlashR),
+	/*7002*/ uint16(xReadIb),
+	/*7003*/ uint16(xArgR32),
+	/*7004*/ uint16(xArgXmm2),
+	/*7005*/ uint16(xArgImm8u),
+	/*7006*/ uint16(xMatch),
+	/*7007*/ uint16(xCondPrefix), 2,
+	0x66, 7021,
+	0x0, 7013,
+	/*7013*/ uint16(xSetOp), uint16(SHUFPS),
+	/*7015*/ uint16(xReadSlashR),
+	/*7016*/ uint16(xReadIb),
+	/*7017*/ uint16(xArgXmm1),
+	/*7018*/ uint16(xArgXmm2M128),
+	/*7019*/ uint16(xArgImm8u),
+	/*7020*/ uint16(xMatch),
+	/*7021*/ uint16(xSetOp), uint16(SHUFPD),
+	/*7023*/ uint16(xReadSlashR),
+	/*7024*/ uint16(xReadIb),
+	/*7025*/ uint16(xArgXmm1),
+	/*7026*/ uint16(xArgXmm2M128),
+	/*7027*/ uint16(xArgImm8u),
+	/*7028*/ uint16(xMatch),
+	/*7029*/ uint16(xCondSlashR),
+	0,    // 0
+	7038, // 1
+	0,    // 2
+	7061, // 3
+	7084, // 4
+	7107, // 5
+	7130, // 6
+	0,    // 7
+	/*7038*/ uint16(xCondIs64), 7041, 7053,
+	/*7041*/ uint16(xCondDataSize), 7045, 7049, 0,
+	/*7045*/ uint16(xSetOp), uint16(CMPXCHG8B),
+	/*7047*/ uint16(xArgM64),
+	/*7048*/ uint16(xMatch),
+	/*7049*/ uint16(xSetOp), uint16(CMPXCHG8B),
+	/*7051*/ uint16(xArgM64),
+	/*7052*/ uint16(xMatch),
+	/*7053*/ uint16(xCondDataSize), 7045, 7049, 7057,
+	/*7057*/ uint16(xSetOp), uint16(CMPXCHG16B),
+	/*7059*/ uint16(xArgM128),
+	/*7060*/ uint16(xMatch),
+	/*7061*/ uint16(xCondIs64), 7064, 7076,
+	/*7064*/ uint16(xCondDataSize), 7068, 7072, 0,
+	/*7068*/ uint16(xSetOp), uint16(XRSTORS),
+	/*7070*/ uint16(xArgMem),
+	/*7071*/ uint16(xMatch),
+	/*7072*/ uint16(xSetOp), uint16(XRSTORS),
+	/*7074*/ uint16(xArgMem),
+	/*7075*/ uint16(xMatch),
+	/*7076*/ uint16(xCondDataSize), 7068, 7072, 7080,
+	/*7080*/ uint16(xSetOp), uint16(XRSTORS64),
+	/*7082*/ uint16(xArgMem),
+	/*7083*/ uint16(xMatch),
+	/*7084*/ uint16(xCondIs64), 7087, 7099,
+	/*7087*/ uint16(xCondDataSize), 7091, 7095, 0,
+	/*7091*/ uint16(xSetOp), uint16(XSAVEC),
+	/*7093*/ uint16(xArgMem),
+	/*7094*/ uint16(xMatch),
+	/*7095*/ uint16(xSetOp), uint16(XSAVEC),
+	/*7097*/ uint16(xArgMem),
+	/*7098*/ uint16(xMatch),
+	/*7099*/ uint16(xCondDataSize), 7091, 7095, 7103,
+	/*7103*/ uint16(xSetOp), uint16(XSAVEC64),
+	/*7105*/ uint16(xArgMem),
+	/*7106*/ uint16(xMatch),
+	/*7107*/ uint16(xCondIs64), 7110, 7122,
+	/*7110*/ uint16(xCondDataSize), 7114, 7118, 0,
+	/*7114*/ uint16(xSetOp), uint16(XSAVES),
+	/*7116*/ uint16(xArgMem),
+	/*7117*/ uint16(xMatch),
+	/*7118*/ uint16(xSetOp), uint16(XSAVES),
+	/*7120*/ uint16(xArgMem),
+	/*7121*/ uint16(xMatch),
+	/*7122*/ uint16(xCondDataSize), 7114, 7118, 7126,
+	/*7126*/ uint16(xSetOp), uint16(XSAVES64),
+	/*7128*/ uint16(xArgMem),
+	/*7129*/ uint16(xMatch),
+	/*7130*/ uint16(xCondIs64), 7133, 7151,
+	/*7133*/ uint16(xCondDataSize), 7137, 7144, 0,
+	/*7137*/ uint16(xCondIsMem), 7140, 0,
+	/*7140*/ uint16(xSetOp), uint16(RDRAND),
+	/*7142*/ uint16(xArgRmf16),
+	/*7143*/ uint16(xMatch),
+	/*7144*/ uint16(xCondIsMem), 7147, 0,
+	/*7147*/ uint16(xSetOp), uint16(RDRAND),
+	/*7149*/ uint16(xArgRmf32),
+	/*7150*/ uint16(xMatch),
+	/*7151*/ uint16(xCondDataSize), 7137, 7144, 7155,
+	/*7155*/ uint16(xSetOp), uint16(RDRAND),
+	/*7157*/ uint16(xMatch),
+	/*7158*/ uint16(xCondIs64), 7161, 7173,
+	/*7161*/ uint16(xCondDataSize), 7165, 7169, 0,
+	/*7165*/ uint16(xSetOp), uint16(BSWAP),
+	/*7167*/ uint16(xArgR16op),
+	/*7168*/ uint16(xMatch),
+	/*7169*/ uint16(xSetOp), uint16(BSWAP),
+	/*7171*/ uint16(xArgR32op),
+	/*7172*/ uint16(xMatch),
+	/*7173*/ uint16(xCondDataSize), 7165, 7169, 7177,
+	/*7177*/ uint16(xSetOp), uint16(BSWAP),
+	/*7179*/ uint16(xArgR64op),
+	/*7180*/ uint16(xMatch),
+	/*7181*/ uint16(xCondPrefix), 2,
+	0xF2, 7193,
+	0x66, 7187,
+	/*7187*/ uint16(xSetOp), uint16(ADDSUBPD),
+	/*7189*/ uint16(xReadSlashR),
+	/*7190*/ uint16(xArgXmm1),
+	/*7191*/ uint16(xArgXmm2M128),
+	/*7192*/ uint16(xMatch),
+	/*7193*/ uint16(xSetOp), uint16(ADDSUBPS),
+	/*7195*/ uint16(xReadSlashR),
+	/*7196*/ uint16(xArgXmm1),
+	/*7197*/ uint16(xArgXmm2M128),
+	/*7198*/ uint16(xMatch),
+	/*7199*/ uint16(xCondPrefix), 2,
+	0x66, 7211,
+	0x0, 7205,
+	/*7205*/ uint16(xSetOp), uint16(PSRLW),
+	/*7207*/ uint16(xReadSlashR),
+	/*7208*/ uint16(xArgMm),
+	/*7209*/ uint16(xArgMmM64),
+	/*7210*/ uint16(xMatch),
+	/*7211*/ uint16(xSetOp), uint16(PSRLW),
+	/*7213*/ uint16(xReadSlashR),
+	/*7214*/ uint16(xArgXmm1),
+	/*7215*/ uint16(xArgXmm2M128),
+	/*7216*/ uint16(xMatch),
+	/*7217*/ uint16(xCondPrefix), 2,
+	0x66, 7229,
+	0x0, 7223,
+	/*7223*/ uint16(xSetOp), uint16(PSRLD),
+	/*7225*/ uint16(xReadSlashR),
+	/*7226*/ uint16(xArgMm),
+	/*7227*/ uint16(xArgMmM64),
+	/*7228*/ uint16(xMatch),
+	/*7229*/ uint16(xSetOp), uint16(PSRLD),
+	/*7231*/ uint16(xReadSlashR),
+	/*7232*/ uint16(xArgXmm1),
+	/*7233*/ uint16(xArgXmm2M128),
+	/*7234*/ uint16(xMatch),
+	/*7235*/ uint16(xCondPrefix), 2,
+	0x66, 7247,
+	0x0, 7241,
+	/*7241*/ uint16(xSetOp), uint16(PSRLQ),
+	/*7243*/ uint16(xReadSlashR),
+	/*7244*/ uint16(xArgMm),
+	/*7245*/ uint16(xArgMmM64),
+	/*7246*/ uint16(xMatch),
+	/*7247*/ uint16(xSetOp), uint16(PSRLQ),
+	/*7249*/ uint16(xReadSlashR),
+	/*7250*/ uint16(xArgXmm1),
+	/*7251*/ uint16(xArgXmm2M128),
+	/*7252*/ uint16(xMatch),
+	/*7253*/ uint16(xCondPrefix), 2,
+	0x66, 7265,
+	0x0, 7259,
+	/*7259*/ uint16(xSetOp), uint16(PADDQ),
+	/*7261*/ uint16(xReadSlashR),
+	/*7262*/ uint16(xArgMm1),
+	/*7263*/ uint16(xArgMm2M64),
+	/*7264*/ uint16(xMatch),
+	/*7265*/ uint16(xSetOp), uint16(PADDQ),
+	/*7267*/ uint16(xReadSlashR),
+	/*7268*/ uint16(xArgXmm1),
+	/*7269*/ uint16(xArgXmm2M128),
+	/*7270*/ uint16(xMatch),
+	/*7271*/ uint16(xCondPrefix), 2,
+	0x66, 7283,
+	0x0, 7277,
+	/*7277*/ uint16(xSetOp), uint16(PMULLW),
+	/*7279*/ uint16(xReadSlashR),
+	/*7280*/ uint16(xArgMm),
+	/*7281*/ uint16(xArgMmM64),
+	/*7282*/ uint16(xMatch),
+	/*7283*/ uint16(xSetOp), uint16(PMULLW),
+	/*7285*/ uint16(xReadSlashR),
+	/*7286*/ uint16(xArgXmm1),
+	/*7287*/ uint16(xArgXmm2M128),
+	/*7288*/ uint16(xMatch),
+	/*7289*/ uint16(xCondPrefix), 3,
+	0xF3, 7309,
+	0xF2, 7303,
+	0x66, 7297,
+	/*7297*/ uint16(xSetOp), uint16(MOVQ),
+	/*7299*/ uint16(xReadSlashR),
+	/*7300*/ uint16(xArgXmm2M64),
+	/*7301*/ uint16(xArgXmm1),
+	/*7302*/ uint16(xMatch),
+	/*7303*/ uint16(xSetOp), uint16(MOVDQ2Q),
+	/*7305*/ uint16(xReadSlashR),
+	/*7306*/ uint16(xArgMm),
+	/*7307*/ uint16(xArgXmm2),
+	/*7308*/ uint16(xMatch),
+	/*7309*/ uint16(xSetOp), uint16(MOVQ2DQ),
+	/*7311*/ uint16(xReadSlashR),
+	/*7312*/ uint16(xArgXmm1),
+	/*7313*/ uint16(xArgMm2),
+	/*7314*/ uint16(xMatch),
+	/*7315*/ uint16(xCondPrefix), 2,
+	0x66, 7327,
+	0x0, 7321,
+	/*7321*/ uint16(xSetOp), uint16(PMOVMSKB),
+	/*7323*/ uint16(xReadSlashR),
+	/*7324*/ uint16(xArgR32),
+	/*7325*/ uint16(xArgMm2),
+	/*7326*/ uint16(xMatch),
+	/*7327*/ uint16(xSetOp), uint16(PMOVMSKB),
+	/*7329*/ uint16(xReadSlashR),
+	/*7330*/ uint16(xArgR32),
+	/*7331*/ uint16(xArgXmm2),
+	/*7332*/ uint16(xMatch),
+	/*7333*/ uint16(xCondPrefix), 2,
+	0x66, 7345,
+	0x0, 7339,
+	/*7339*/ uint16(xSetOp), uint16(PSUBUSB),
+	/*7341*/ uint16(xReadSlashR),
+	/*7342*/ uint16(xArgMm),
+	/*7343*/ uint16(xArgMmM64),
+	/*7344*/ uint16(xMatch),
+	/*7345*/ uint16(xSetOp), uint16(PSUBUSB),
+	/*7347*/ uint16(xReadSlashR),
+	/*7348*/ uint16(xArgXmm1),
+	/*7349*/ uint16(xArgXmm2M128),
+	/*7350*/ uint16(xMatch),
+	/*7351*/ uint16(xCondPrefix), 2,
+	0x66, 7363,
+	0x0, 7357,
+	/*7357*/ uint16(xSetOp), uint16(PSUBUSW),
+	/*7359*/ uint16(xReadSlashR),
+	/*7360*/ uint16(xArgMm),
+	/*7361*/ uint16(xArgMmM64),
+	/*7362*/ uint16(xMatch),
+	/*7363*/ uint16(xSetOp), uint16(PSUBUSW),
+	/*7365*/ uint16(xReadSlashR),
+	/*7366*/ uint16(xArgXmm1),
+	/*7367*/ uint16(xArgXmm2M128),
+	/*7368*/ uint16(xMatch),
+	/*7369*/ uint16(xCondPrefix), 2,
+	0x66, 7381,
+	0x0, 7375,
+	/*7375*/ uint16(xSetOp), uint16(PMINUB),
+	/*7377*/ uint16(xReadSlashR),
+	/*7378*/ uint16(xArgMm1),
+	/*7379*/ uint16(xArgMm2M64),
+	/*7380*/ uint16(xMatch),
+	/*7381*/ uint16(xSetOp), uint16(PMINUB),
+	/*7383*/ uint16(xReadSlashR),
+	/*7384*/ uint16(xArgXmm1),
+	/*7385*/ uint16(xArgXmm2M128),
+	/*7386*/ uint16(xMatch),
+	/*7387*/ uint16(xCondPrefix), 2,
+	0x66, 7399,
+	0x0, 7393,
+	/*7393*/ uint16(xSetOp), uint16(PAND),
+	/*7395*/ uint16(xReadSlashR),
+	/*7396*/ uint16(xArgMm),
+	/*7397*/ uint16(xArgMmM64),
+	/*7398*/ uint16(xMatch),
+	/*7399*/ uint16(xSetOp), uint16(PAND),
+	/*7401*/ uint16(xReadSlashR),
+	/*7402*/ uint16(xArgXmm1),
+	/*7403*/ uint16(xArgXmm2M128),
+	/*7404*/ uint16(xMatch),
+	/*7405*/ uint16(xCondPrefix), 2,
+	0x66, 7417,
+	0x0, 7411,
+	/*7411*/ uint16(xSetOp), uint16(PADDUSB),
+	/*7413*/ uint16(xReadSlashR),
+	/*7414*/ uint16(xArgMm),
+	/*7415*/ uint16(xArgMmM64),
+	/*7416*/ uint16(xMatch),
+	/*7417*/ uint16(xSetOp), uint16(PADDUSB),
+	/*7419*/ uint16(xReadSlashR),
+	/*7420*/ uint16(xArgXmm1),
+	/*7421*/ uint16(xArgXmm2M128),
+	/*7422*/ uint16(xMatch),
+	/*7423*/ uint16(xCondPrefix), 2,
+	0x66, 7435,
+	0x0, 7429,
+	/*7429*/ uint16(xSetOp), uint16(PADDUSW),
+	/*7431*/ uint16(xReadSlashR),
+	/*7432*/ uint16(xArgMm),
+	/*7433*/ uint16(xArgMmM64),
+	/*7434*/ uint16(xMatch),
+	/*7435*/ uint16(xSetOp), uint16(PADDUSW),
+	/*7437*/ uint16(xReadSlashR),
+	/*7438*/ uint16(xArgXmm1),
+	/*7439*/ uint16(xArgXmm2M128),
+	/*7440*/ uint16(xMatch),
+	/*7441*/ uint16(xCondPrefix), 2,
+	0x66, 7453,
+	0x0, 7447,
+	/*7447*/ uint16(xSetOp), uint16(PMAXUB),
+	/*7449*/ uint16(xReadSlashR),
+	/*7450*/ uint16(xArgMm1),
+	/*7451*/ uint16(xArgMm2M64),
+	/*7452*/ uint16(xMatch),
+	/*7453*/ uint16(xSetOp), uint16(PMAXUB),
+	/*7455*/ uint16(xReadSlashR),
+	/*7456*/ uint16(xArgXmm1),
+	/*7457*/ uint16(xArgXmm2M128),
+	/*7458*/ uint16(xMatch),
+	/*7459*/ uint16(xCondPrefix), 2,
+	0x66, 7471,
+	0x0, 7465,
+	/*7465*/ uint16(xSetOp), uint16(PANDN),
+	/*7467*/ uint16(xReadSlashR),
+	/*7468*/ uint16(xArgMm),
+	/*7469*/ uint16(xArgMmM64),
+	/*7470*/ uint16(xMatch),
+	/*7471*/ uint16(xSetOp), uint16(PANDN),
+	/*7473*/ uint16(xReadSlashR),
+	/*7474*/ uint16(xArgXmm1),
+	/*7475*/ uint16(xArgXmm2M128),
+	/*7476*/ uint16(xMatch),
+	/*7477*/ uint16(xCondPrefix), 2,
+	0x66, 7489,
+	0x0, 7483,
+	/*7483*/ uint16(xSetOp), uint16(PAVGB),
+	/*7485*/ uint16(xReadSlashR),
+	/*7486*/ uint16(xArgMm1),
+	/*7487*/ uint16(xArgMm2M64),
+	/*7488*/ uint16(xMatch),
+	/*7489*/ uint16(xSetOp), uint16(PAVGB),
+	/*7491*/ uint16(xReadSlashR),
+	/*7492*/ uint16(xArgXmm1),
+	/*7493*/ uint16(xArgXmm2M128),
+	/*7494*/ uint16(xMatch),
+	/*7495*/ uint16(xCondPrefix), 2,
+	0x66, 7507,
+	0x0, 7501,
+	/*7501*/ uint16(xSetOp), uint16(PSRAW),
+	/*7503*/ uint16(xReadSlashR),
+	/*7504*/ uint16(xArgMm),
+	/*7505*/ uint16(xArgMmM64),
+	/*7506*/ uint16(xMatch),
+	/*7507*/ uint16(xSetOp), uint16(PSRAW),
+	/*7509*/ uint16(xReadSlashR),
+	/*7510*/ uint16(xArgXmm1),
+	/*7511*/ uint16(xArgXmm2M128),
+	/*7512*/ uint16(xMatch),
+	/*7513*/ uint16(xCondPrefix), 2,
+	0x66, 7525,
+	0x0, 7519,
+	/*7519*/ uint16(xSetOp), uint16(PSRAD),
+	/*7521*/ uint16(xReadSlashR),
+	/*7522*/ uint16(xArgMm),
+	/*7523*/ uint16(xArgMmM64),
+	/*7524*/ uint16(xMatch),
+	/*7525*/ uint16(xSetOp), uint16(PSRAD),
+	/*7527*/ uint16(xReadSlashR),
+	/*7528*/ uint16(xArgXmm1),
+	/*7529*/ uint16(xArgXmm2M128),
+	/*7530*/ uint16(xMatch),
+	/*7531*/ uint16(xCondPrefix), 2,
+	0x66, 7543,
+	0x0, 7537,
+	/*7537*/ uint16(xSetOp), uint16(PAVGW),
+	/*7539*/ uint16(xReadSlashR),
+	/*7540*/ uint16(xArgMm1),
+	/*7541*/ uint16(xArgMm2M64),
+	/*7542*/ uint16(xMatch),
+	/*7543*/ uint16(xSetOp), uint16(PAVGW),
+	/*7545*/ uint16(xReadSlashR),
+	/*7546*/ uint16(xArgXmm1),
+	/*7547*/ uint16(xArgXmm2M128),
+	/*7548*/ uint16(xMatch),
+	/*7549*/ uint16(xCondPrefix), 2,
+	0x66, 7561,
+	0x0, 7555,
+	/*7555*/ uint16(xSetOp), uint16(PMULHUW),
+	/*7557*/ uint16(xReadSlashR),
+	/*7558*/ uint16(xArgMm1),
+	/*7559*/ uint16(xArgMm2M64),
+	/*7560*/ uint16(xMatch),
+	/*7561*/ uint16(xSetOp), uint16(PMULHUW),
+	/*7563*/ uint16(xReadSlashR),
+	/*7564*/ uint16(xArgXmm1),
+	/*7565*/ uint16(xArgXmm2M128),
+	/*7566*/ uint16(xMatch),
+	/*7567*/ uint16(xCondPrefix), 2,
+	0x66, 7579,
+	0x0, 7573,
+	/*7573*/ uint16(xSetOp), uint16(PMULHW),
+	/*7575*/ uint16(xReadSlashR),
+	/*7576*/ uint16(xArgMm),
+	/*7577*/ uint16(xArgMmM64),
+	/*7578*/ uint16(xMatch),
+	/*7579*/ uint16(xSetOp), uint16(PMULHW),
+	/*7581*/ uint16(xReadSlashR),
+	/*7582*/ uint16(xArgXmm1),
+	/*7583*/ uint16(xArgXmm2M128),
+	/*7584*/ uint16(xMatch),
+	/*7585*/ uint16(xCondPrefix), 3,
+	0xF3, 7605,
+	0xF2, 7599,
+	0x66, 7593,
+	/*7593*/ uint16(xSetOp), uint16(CVTTPD2DQ),
+	/*7595*/ uint16(xReadSlashR),
+	/*7596*/ uint16(xArgXmm1),
+	/*7597*/ uint16(xArgXmm2M128),
+	/*7598*/ uint16(xMatch),
+	/*7599*/ uint16(xSetOp), uint16(CVTPD2DQ),
+	/*7601*/ uint16(xReadSlashR),
+	/*7602*/ uint16(xArgXmm1),
+	/*7603*/ uint16(xArgXmm2M128),
+	/*7604*/ uint16(xMatch),
+	/*7605*/ uint16(xSetOp), uint16(CVTDQ2PD),
+	/*7607*/ uint16(xReadSlashR),
+	/*7608*/ uint16(xArgXmm1),
+	/*7609*/ uint16(xArgXmm2M64),
+	/*7610*/ uint16(xMatch),
+	/*7611*/ uint16(xCondPrefix), 2,
+	0x66, 7623,
+	0x0, 7617,
+	/*7617*/ uint16(xSetOp), uint16(MOVNTQ),
+	/*7619*/ uint16(xReadSlashR),
+	/*7620*/ uint16(xArgM64),
+	/*7621*/ uint16(xArgMm),
+	/*7622*/ uint16(xMatch),
+	/*7623*/ uint16(xSetOp), uint16(MOVNTDQ),
+	/*7625*/ uint16(xReadSlashR),
+	/*7626*/ uint16(xArgM128),
+	/*7627*/ uint16(xArgXmm),
+	/*7628*/ uint16(xMatch),
+	/*7629*/ uint16(xCondPrefix), 2,
+	0x66, 7641,
+	0x0, 7635,
+	/*7635*/ uint16(xSetOp), uint16(PSUBSB),
+	/*7637*/ uint16(xReadSlashR),
+	/*7638*/ uint16(xArgMm),
+	/*7639*/ uint16(xArgMmM64),
+	/*7640*/ uint16(xMatch),
+	/*7641*/ uint16(xSetOp), uint16(PSUBSB),
+	/*7643*/ uint16(xReadSlashR),
+	/*7644*/ uint16(xArgXmm1),
+	/*7645*/ uint16(xArgXmm2M128),
+	/*7646*/ uint16(xMatch),
+	/*7647*/ uint16(xCondPrefix), 2,
+	0x66, 7659,
+	0x0, 7653,
+	/*7653*/ uint16(xSetOp), uint16(PSUBSW),
+	/*7655*/ uint16(xReadSlashR),
+	/*7656*/ uint16(xArgMm),
+	/*7657*/ uint16(xArgMmM64),
+	/*7658*/ uint16(xMatch),
+	/*7659*/ uint16(xSetOp), uint16(PSUBSW),
+	/*7661*/ uint16(xReadSlashR),
+	/*7662*/ uint16(xArgXmm1),
+	/*7663*/ uint16(xArgXmm2M128),
+	/*7664*/ uint16(xMatch),
+	/*7665*/ uint16(xCondPrefix), 2,
+	0x66, 7677,
+	0x0, 7671,
+	/*7671*/ uint16(xSetOp), uint16(PMINSW),
+	/*7673*/ uint16(xReadSlashR),
+	/*7674*/ uint16(xArgMm1),
+	/*7675*/ uint16(xArgMm2M64),
+	/*7676*/ uint16(xMatch),
+	/*7677*/ uint16(xSetOp), uint16(PMINSW),
+	/*7679*/ uint16(xReadSlashR),
+	/*7680*/ uint16(xArgXmm1),
+	/*7681*/ uint16(xArgXmm2M128),
+	/*7682*/ uint16(xMatch),
+	/*7683*/ uint16(xCondPrefix), 2,
+	0x66, 7695,
+	0x0, 7689,
+	/*7689*/ uint16(xSetOp), uint16(POR),
+	/*7691*/ uint16(xReadSlashR),
+	/*7692*/ uint16(xArgMm),
+	/*7693*/ uint16(xArgMmM64),
+	/*7694*/ uint16(xMatch),
+	/*7695*/ uint16(xSetOp), uint16(POR),
+	/*7697*/ uint16(xReadSlashR),
+	/*7698*/ uint16(xArgXmm1),
+	/*7699*/ uint16(xArgXmm2M128),
+	/*7700*/ uint16(xMatch),
+	/*7701*/ uint16(xCondPrefix), 2,
+	0x66, 7713,
+	0x0, 7707,
+	/*7707*/ uint16(xSetOp), uint16(PADDSB),
+	/*7709*/ uint16(xReadSlashR),
+	/*7710*/ uint16(xArgMm),
+	/*7711*/ uint16(xArgMmM64),
+	/*7712*/ uint16(xMatch),
+	/*7713*/ uint16(xSetOp), uint16(PADDSB),
+	/*7715*/ uint16(xReadSlashR),
+	/*7716*/ uint16(xArgXmm1),
+	/*7717*/ uint16(xArgXmm2M128),
+	/*7718*/ uint16(xMatch),
+	/*7719*/ uint16(xCondPrefix), 2,
+	0x66, 7731,
+	0x0, 7725,
+	/*7725*/ uint16(xSetOp), uint16(PADDSW),
+	/*7727*/ uint16(xReadSlashR),
+	/*7728*/ uint16(xArgMm),
+	/*7729*/ uint16(xArgMmM64),
+	/*7730*/ uint16(xMatch),
+	/*7731*/ uint16(xSetOp), uint16(PADDSW),
+	/*7733*/ uint16(xReadSlashR),
+	/*7734*/ uint16(xArgXmm1),
+	/*7735*/ uint16(xArgXmm2M128),
+	/*7736*/ uint16(xMatch),
+	/*7737*/ uint16(xCondPrefix), 2,
+	0x66, 7749,
+	0x0, 7743,
+	/*7743*/ uint16(xSetOp), uint16(PMAXSW),
+	/*7745*/ uint16(xReadSlashR),
+	/*7746*/ uint16(xArgMm1),
+	/*7747*/ uint16(xArgMm2M64),
+	/*7748*/ uint16(xMatch),
+	/*7749*/ uint16(xSetOp), uint16(PMAXSW),
+	/*7751*/ uint16(xReadSlashR),
+	/*7752*/ uint16(xArgXmm1),
+	/*7753*/ uint16(xArgXmm2M128),
+	/*7754*/ uint16(xMatch),
+	/*7755*/ uint16(xCondPrefix), 2,
+	0x66, 7767,
+	0x0, 7761,
+	/*7761*/ uint16(xSetOp), uint16(PXOR),
+	/*7763*/ uint16(xReadSlashR),
+	/*7764*/ uint16(xArgMm),
+	/*7765*/ uint16(xArgMmM64),
+	/*7766*/ uint16(xMatch),
+	/*7767*/ uint16(xSetOp), uint16(PXOR),
+	/*7769*/ uint16(xReadSlashR),
+	/*7770*/ uint16(xArgXmm1),
+	/*7771*/ uint16(xArgXmm2M128),
+	/*7772*/ uint16(xMatch),
+	/*7773*/ uint16(xCondPrefix), 1,
+	0xF2, 7777,
+	/*7777*/ uint16(xSetOp), uint16(LDDQU),
+	/*7779*/ uint16(xReadSlashR),
+	/*7780*/ uint16(xArgXmm1),
+	/*7781*/ uint16(xArgM128),
+	/*7782*/ uint16(xMatch),
+	/*7783*/ uint16(xCondPrefix), 2,
+	0x66, 7795,
+	0x0, 7789,
+	/*7789*/ uint16(xSetOp), uint16(PSLLW),
+	/*7791*/ uint16(xReadSlashR),
+	/*7792*/ uint16(xArgMm),
+	/*7793*/ uint16(xArgMmM64),
+	/*7794*/ uint16(xMatch),
+	/*7795*/ uint16(xSetOp), uint16(PSLLW),
+	/*7797*/ uint16(xReadSlashR),
+	/*7798*/ uint16(xArgXmm1),
+	/*7799*/ uint16(xArgXmm2M128),
+	/*7800*/ uint16(xMatch),
+	/*7801*/ uint16(xCondPrefix), 2,
+	0x66, 7813,
+	0x0, 7807,
+	/*7807*/ uint16(xSetOp), uint16(PSLLD),
+	/*7809*/ uint16(xReadSlashR),
+	/*7810*/ uint16(xArgMm),
+	/*7811*/ uint16(xArgMmM64),
+	/*7812*/ uint16(xMatch),
+	/*7813*/ uint16(xSetOp), uint16(PSLLD),
+	/*7815*/ uint16(xReadSlashR),
+	/*7816*/ uint16(xArgXmm1),
+	/*7817*/ uint16(xArgXmm2M128),
+	/*7818*/ uint16(xMatch),
+	/*7819*/ uint16(xCondPrefix), 2,
+	0x66, 7831,
+	0x0, 7825,
+	/*7825*/ uint16(xSetOp), uint16(PSLLQ),
+	/*7827*/ uint16(xReadSlashR),
+	/*7828*/ uint16(xArgMm),
+	/*7829*/ uint16(xArgMmM64),
+	/*7830*/ uint16(xMatch),
+	/*7831*/ uint16(xSetOp), uint16(PSLLQ),
+	/*7833*/ uint16(xReadSlashR),
+	/*7834*/ uint16(xArgXmm1),
+	/*7835*/ uint16(xArgXmm2M128),
+	/*7836*/ uint16(xMatch),
+	/*7837*/ uint16(xCondPrefix), 2,
+	0x66, 7849,
+	0x0, 7843,
+	/*7843*/ uint16(xSetOp), uint16(PMULUDQ),
+	/*7845*/ uint16(xReadSlashR),
+	/*7846*/ uint16(xArgMm1),
+	/*7847*/ uint16(xArgMm2M64),
+	/*7848*/ uint16(xMatch),
+	/*7849*/ uint16(xSetOp), uint16(PMULUDQ),
+	/*7851*/ uint16(xReadSlashR),
+	/*7852*/ uint16(xArgXmm1),
+	/*7853*/ uint16(xArgXmm2M128),
+	/*7854*/ uint16(xMatch),
+	/*7855*/ uint16(xCondPrefix), 2,
+	0x66, 7867,
+	0x0, 7861,
+	/*7861*/ uint16(xSetOp), uint16(PMADDWD),
+	/*7863*/ uint16(xReadSlashR),
+	/*7864*/ uint16(xArgMm),
+	/*7865*/ uint16(xArgMmM64),
+	/*7866*/ uint16(xMatch),
+	/*7867*/ uint16(xSetOp), uint16(PMADDWD),
+	/*7869*/ uint16(xReadSlashR),
+	/*7870*/ uint16(xArgXmm1),
+	/*7871*/ uint16(xArgXmm2M128),
+	/*7872*/ uint16(xMatch),
+	/*7873*/ uint16(xCondPrefix), 2,
+	0x66, 7885,
+	0x0, 7879,
+	/*7879*/ uint16(xSetOp), uint16(PSADBW),
+	/*7881*/ uint16(xReadSlashR),
+	/*7882*/ uint16(xArgMm1),
+	/*7883*/ uint16(xArgMm2M64),
+	/*7884*/ uint16(xMatch),
+	/*7885*/ uint16(xSetOp), uint16(PSADBW),
+	/*7887*/ uint16(xReadSlashR),
+	/*7888*/ uint16(xArgXmm1),
+	/*7889*/ uint16(xArgXmm2M128),
+	/*7890*/ uint16(xMatch),
+	/*7891*/ uint16(xCondPrefix), 2,
+	0x66, 7903,
+	0x0, 7897,
+	/*7897*/ uint16(xSetOp), uint16(MASKMOVQ),
+	/*7899*/ uint16(xReadSlashR),
+	/*7900*/ uint16(xArgMm1),
+	/*7901*/ uint16(xArgMm2),
+	/*7902*/ uint16(xMatch),
+	/*7903*/ uint16(xSetOp), uint16(MASKMOVDQU),
+	/*7905*/ uint16(xReadSlashR),
+	/*7906*/ uint16(xArgXmm1),
+	/*7907*/ uint16(xArgXmm2),
+	/*7908*/ uint16(xMatch),
+	/*7909*/ uint16(xCondPrefix), 2,
+	0x66, 7921,
+	0x0, 7915,
+	/*7915*/ uint16(xSetOp), uint16(PSUBB),
+	/*7917*/ uint16(xReadSlashR),
+	/*7918*/ uint16(xArgMm),
+	/*7919*/ uint16(xArgMmM64),
+	/*7920*/ uint16(xMatch),
+	/*7921*/ uint16(xSetOp), uint16(PSUBB),
+	/*7923*/ uint16(xReadSlashR),
+	/*7924*/ uint16(xArgXmm1),
+	/*7925*/ uint16(xArgXmm2M128),
+	/*7926*/ uint16(xMatch),
+	/*7927*/ uint16(xCondPrefix), 2,
+	0x66, 7939,
+	0x0, 7933,
+	/*7933*/ uint16(xSetOp), uint16(PSUBW),
+	/*7935*/ uint16(xReadSlashR),
+	/*7936*/ uint16(xArgMm),
+	/*7937*/ uint16(xArgMmM64),
+	/*7938*/ uint16(xMatch),
+	/*7939*/ uint16(xSetOp), uint16(PSUBW),
+	/*7941*/ uint16(xReadSlashR),
+	/*7942*/ uint16(xArgXmm1),
+	/*7943*/ uint16(xArgXmm2M128),
+	/*7944*/ uint16(xMatch),
+	/*7945*/ uint16(xCondPrefix), 2,
+	0x66, 7957,
+	0x0, 7951,
+	/*7951*/ uint16(xSetOp), uint16(PSUBD),
+	/*7953*/ uint16(xReadSlashR),
+	/*7954*/ uint16(xArgMm),
+	/*7955*/ uint16(xArgMmM64),
+	/*7956*/ uint16(xMatch),
+	/*7957*/ uint16(xSetOp), uint16(PSUBD),
+	/*7959*/ uint16(xReadSlashR),
+	/*7960*/ uint16(xArgXmm1),
+	/*7961*/ uint16(xArgXmm2M128),
+	/*7962*/ uint16(xMatch),
+	/*7963*/ uint16(xCondPrefix), 2,
+	0x66, 7975,
+	0x0, 7969,
+	/*7969*/ uint16(xSetOp), uint16(PSUBQ),
+	/*7971*/ uint16(xReadSlashR),
+	/*7972*/ uint16(xArgMm1),
+	/*7973*/ uint16(xArgMm2M64),
+	/*7974*/ uint16(xMatch),
+	/*7975*/ uint16(xSetOp), uint16(PSUBQ),
+	/*7977*/ uint16(xReadSlashR),
+	/*7978*/ uint16(xArgXmm1),
+	/*7979*/ uint16(xArgXmm2M128),
+	/*7980*/ uint16(xMatch),
+	/*7981*/ uint16(xCondPrefix), 2,
+	0x66, 7993,
+	0x0, 7987,
+	/*7987*/ uint16(xSetOp), uint16(PADDB),
+	/*7989*/ uint16(xReadSlashR),
+	/*7990*/ uint16(xArgMm),
+	/*7991*/ uint16(xArgMmM64),
+	/*7992*/ uint16(xMatch),
+	/*7993*/ uint16(xSetOp), uint16(PADDB),
+	/*7995*/ uint16(xReadSlashR),
+	/*7996*/ uint16(xArgXmm1),
+	/*7997*/ uint16(xArgXmm2M128),
+	/*7998*/ uint16(xMatch),
+	/*7999*/ uint16(xCondPrefix), 2,
+	0x66, 8011,
+	0x0, 8005,
+	/*8005*/ uint16(xSetOp), uint16(PADDW),
+	/*8007*/ uint16(xReadSlashR),
+	/*8008*/ uint16(xArgMm),
+	/*8009*/ uint16(xArgMmM64),
+	/*8010*/ uint16(xMatch),
+	/*8011*/ uint16(xSetOp), uint16(PADDW),
+	/*8013*/ uint16(xReadSlashR),
+	/*8014*/ uint16(xArgXmm1),
+	/*8015*/ uint16(xArgXmm2M128),
+	/*8016*/ uint16(xMatch),
+	/*8017*/ uint16(xCondPrefix), 2,
+	0x66, 8029,
+	0x0, 8023,
+	/*8023*/ uint16(xSetOp), uint16(PADDD),
+	/*8025*/ uint16(xReadSlashR),
+	/*8026*/ uint16(xArgMm),
+	/*8027*/ uint16(xArgMmM64),
+	/*8028*/ uint16(xMatch),
+	/*8029*/ uint16(xSetOp), uint16(PADDD),
+	/*8031*/ uint16(xReadSlashR),
+	/*8032*/ uint16(xArgXmm1),
+	/*8033*/ uint16(xArgXmm2M128),
+	/*8034*/ uint16(xMatch),
+	/*8035*/ uint16(xCondDataSize), 0, 8039, 0,
+	/*8039*/ uint16(xSetOp), uint16(UD0),
+	/*8041*/ uint16(xReadSlashR),
+	/*8042*/ uint16(xArgR32),
+	/*8043*/ uint16(xArgRM32),
+	/*8044*/ uint16(xMatch),
+	/*8045*/ uint16(xSetOp), uint16(ADC),
+	/*8047*/ uint16(xReadSlashR),
+	/*8048*/ uint16(xArgRM8),
+	/*8049*/ uint16(xArgR8),
+	/*8050*/ uint16(xMatch),
+	/*8051*/ uint16(xCondIs64), 8054, 8070,
+	/*8054*/ uint16(xCondDataSize), 8058, 8064, 0,
+	/*8058*/ uint16(xSetOp), uint16(ADC),
+	/*8060*/ uint16(xReadSlashR),
+	/*8061*/ uint16(xArgRM16),
+	/*8062*/ uint16(xArgR16),
+	/*8063*/ uint16(xMatch),
+	/*8064*/ uint16(xSetOp), uint16(ADC),
+	/*8066*/ uint16(xReadSlashR),
+	/*8067*/ uint16(xArgRM32),
+	/*8068*/ uint16(xArgR32),
+	/*8069*/ uint16(xMatch),
+	/*8070*/ uint16(xCondDataSize), 8058, 8064, 8074,
+	/*8074*/ uint16(xSetOp), uint16(ADC),
+	/*8076*/ uint16(xReadSlashR),
+	/*8077*/ uint16(xArgRM64),
+	/*8078*/ uint16(xArgR64),
+	/*8079*/ uint16(xMatch),
+	/*8080*/ uint16(xSetOp), uint16(ADC),
+	/*8082*/ uint16(xReadSlashR),
+	/*8083*/ uint16(xArgR8),
+	/*8084*/ uint16(xArgRM8),
+	/*8085*/ uint16(xMatch),
+	/*8086*/ uint16(xCondIs64), 8089, 8105,
+	/*8089*/ uint16(xCondDataSize), 8093, 8099, 0,
+	/*8093*/ uint16(xSetOp), uint16(ADC),
+	/*8095*/ uint16(xReadSlashR),
+	/*8096*/ uint16(xArgR16),
+	/*8097*/ uint16(xArgRM16),
+	/*8098*/ uint16(xMatch),
+	/*8099*/ uint16(xSetOp), uint16(ADC),
+	/*8101*/ uint16(xReadSlashR),
+	/*8102*/ uint16(xArgR32),
+	/*8103*/ uint16(xArgRM32),
+	/*8104*/ uint16(xMatch),
+	/*8105*/ uint16(xCondDataSize), 8093, 8099, 8109,
+	/*8109*/ uint16(xSetOp), uint16(ADC),
+	/*8111*/ uint16(xReadSlashR),
+	/*8112*/ uint16(xArgR64),
+	/*8113*/ uint16(xArgRM64),
+	/*8114*/ uint16(xMatch),
+	/*8115*/ uint16(xSetOp), uint16(ADC),
+	/*8117*/ uint16(xReadIb),
+	/*8118*/ uint16(xArgAL),
+	/*8119*/ uint16(xArgImm8u),
+	/*8120*/ uint16(xMatch),
+	/*8121*/ uint16(xCondIs64), 8124, 8140,
+	/*8124*/ uint16(xCondDataSize), 8128, 8134, 0,
+	/*8128*/ uint16(xSetOp), uint16(ADC),
+	/*8130*/ uint16(xReadIw),
+	/*8131*/ uint16(xArgAX),
+	/*8132*/ uint16(xArgImm16),
+	/*8133*/ uint16(xMatch),
+	/*8134*/ uint16(xSetOp), uint16(ADC),
+	/*8136*/ uint16(xReadId),
+	/*8137*/ uint16(xArgEAX),
+	/*8138*/ uint16(xArgImm32),
+	/*8139*/ uint16(xMatch),
+	/*8140*/ uint16(xCondDataSize), 8128, 8134, 8144,
+	/*8144*/ uint16(xSetOp), uint16(ADC),
+	/*8146*/ uint16(xReadId),
+	/*8147*/ uint16(xArgRAX),
+	/*8148*/ uint16(xArgImm32),
+	/*8149*/ uint16(xMatch),
+	/*8150*/ uint16(xCondIs64), 8153, 0,
+	/*8153*/ uint16(xSetOp), uint16(PUSH),
+	/*8155*/ uint16(xArgSS),
+	/*8156*/ uint16(xMatch),
+	/*8157*/ uint16(xCondIs64), 8160, 0,
+	/*8160*/ uint16(xSetOp), uint16(POP),
+	/*8162*/ uint16(xArgSS),
+	/*8163*/ uint16(xMatch),
+	/*8164*/ uint16(xSetOp), uint16(SBB),
+	/*8166*/ uint16(xReadSlashR),
+	/*8167*/ uint16(xArgRM8),
+	/*8168*/ uint16(xArgR8),
+	/*8169*/ uint16(xMatch),
+	/*8170*/ uint16(xCondIs64), 8173, 8189,
+	/*8173*/ uint16(xCondDataSize), 8177, 8183, 0,
+	/*8177*/ uint16(xSetOp), uint16(SBB),
+	/*8179*/ uint16(xReadSlashR),
+	/*8180*/ uint16(xArgRM16),
+	/*8181*/ uint16(xArgR16),
+	/*8182*/ uint16(xMatch),
+	/*8183*/ uint16(xSetOp), uint16(SBB),
+	/*8185*/ uint16(xReadSlashR),
+	/*8186*/ uint16(xArgRM32),
+	/*8187*/ uint16(xArgR32),
+	/*8188*/ uint16(xMatch),
+	/*8189*/ uint16(xCondDataSize), 8177, 8183, 8193,
+	/*8193*/ uint16(xSetOp), uint16(SBB),
+	/*8195*/ uint16(xReadSlashR),
+	/*8196*/ uint16(xArgRM64),
+	/*8197*/ uint16(xArgR64),
+	/*8198*/ uint16(xMatch),
+	/*8199*/ uint16(xSetOp), uint16(SBB),
+	/*8201*/ uint16(xReadSlashR),
+	/*8202*/ uint16(xArgR8),
+	/*8203*/ uint16(xArgRM8),
+	/*8204*/ uint16(xMatch),
+	/*8205*/ uint16(xCondIs64), 8208, 8224,
+	/*8208*/ uint16(xCondDataSize), 8212, 8218, 0,
+	/*8212*/ uint16(xSetOp), uint16(SBB),
+	/*8214*/ uint16(xReadSlashR),
+	/*8215*/ uint16(xArgR16),
+	/*8216*/ uint16(xArgRM16),
+	/*8217*/ uint16(xMatch),
+	/*8218*/ uint16(xSetOp), uint16(SBB),
+	/*8220*/ uint16(xReadSlashR),
+	/*8221*/ uint16(xArgR32),
+	/*8222*/ uint16(xArgRM32),
+	/*8223*/ uint16(xMatch),
+	/*8224*/ uint16(xCondDataSize), 8212, 8218, 8228,
+	/*8228*/ uint16(xSetOp), uint16(SBB),
+	/*8230*/ uint16(xReadSlashR),
+	/*8231*/ uint16(xArgR64),
+	/*8232*/ uint16(xArgRM64),
+	/*8233*/ uint16(xMatch),
+	/*8234*/ uint16(xSetOp), uint16(SBB),
+	/*8236*/ uint16(xReadIb),
+	/*8237*/ uint16(xArgAL),
+	/*8238*/ uint16(xArgImm8u),
+	/*8239*/ uint16(xMatch),
+	/*8240*/ uint16(xCondIs64), 8243, 8259,
+	/*8243*/ uint16(xCondDataSize), 8247, 8253, 0,
+	/*8247*/ uint16(xSetOp), uint16(SBB),
+	/*8249*/ uint16(xReadIw),
+	/*8250*/ uint16(xArgAX),
+	/*8251*/ uint16(xArgImm16),
+	/*8252*/ uint16(xMatch),
+	/*8253*/ uint16(xSetOp), uint16(SBB),
+	/*8255*/ uint16(xReadId),
+	/*8256*/ uint16(xArgEAX),
+	/*8257*/ uint16(xArgImm32),
+	/*8258*/ uint16(xMatch),
+	/*8259*/ uint16(xCondDataSize), 8247, 8253, 8263,
+	/*8263*/ uint16(xSetOp), uint16(SBB),
+	/*8265*/ uint16(xReadId),
+	/*8266*/ uint16(xArgRAX),
+	/*8267*/ uint16(xArgImm32),
+	/*8268*/ uint16(xMatch),
+	/*8269*/ uint16(xCondIs64), 8272, 0,
+	/*8272*/ uint16(xSetOp), uint16(PUSH),
+	/*8274*/ uint16(xArgDS),
+	/*8275*/ uint16(xMatch),
+	/*8276*/ uint16(xCondIs64), 8279, 0,
+	/*8279*/ uint16(xSetOp), uint16(POP),
+	/*8281*/ uint16(xArgDS),
+	/*8282*/ uint16(xMatch),
+	/*8283*/ uint16(xSetOp), uint16(AND),
+	/*8285*/ uint16(xReadSlashR),
+	/*8286*/ uint16(xArgRM8),
+	/*8287*/ uint16(xArgR8),
+	/*8288*/ uint16(xMatch),
+	/*8289*/ uint16(xCondIs64), 8292, 8308,
+	/*8292*/ uint16(xCondDataSize), 8296, 8302, 0,
+	/*8296*/ uint16(xSetOp), uint16(AND),
+	/*8298*/ uint16(xReadSlashR),
+	/*8299*/ uint16(xArgRM16),
+	/*8300*/ uint16(xArgR16),
+	/*8301*/ uint16(xMatch),
+	/*8302*/ uint16(xSetOp), uint16(AND),
+	/*8304*/ uint16(xReadSlashR),
+	/*8305*/ uint16(xArgRM32),
+	/*8306*/ uint16(xArgR32),
+	/*8307*/ uint16(xMatch),
+	/*8308*/ uint16(xCondDataSize), 8296, 8302, 8312,
+	/*8312*/ uint16(xSetOp), uint16(AND),
+	/*8314*/ uint16(xReadSlashR),
+	/*8315*/ uint16(xArgRM64),
+	/*8316*/ uint16(xArgR64),
+	/*8317*/ uint16(xMatch),
+	/*8318*/ uint16(xSetOp), uint16(AND),
+	/*8320*/ uint16(xReadSlashR),
+	/*8321*/ uint16(xArgR8),
+	/*8322*/ uint16(xArgRM8),
+	/*8323*/ uint16(xMatch),
+	/*8324*/ uint16(xCondIs64), 8327, 8343,
+	/*8327*/ uint16(xCondDataSize), 8331, 8337, 0,
+	/*8331*/ uint16(xSetOp), uint16(AND),
+	/*8333*/ uint16(xReadSlashR),
+	/*8334*/ uint16(xArgR16),
+	/*8335*/ uint16(xArgRM16),
+	/*8336*/ uint16(xMatch),
+	/*8337*/ uint16(xSetOp), uint16(AND),
+	/*8339*/ uint16(xReadSlashR),
+	/*8340*/ uint16(xArgR32),
+	/*8341*/ uint16(xArgRM32),
+	/*8342*/ uint16(xMatch),
+	/*8343*/ uint16(xCondDataSize), 8331, 8337, 8347,
+	/*8347*/ uint16(xSetOp), uint16(AND),
+	/*8349*/ uint16(xReadSlashR),
+	/*8350*/ uint16(xArgR64),
+	/*8351*/ uint16(xArgRM64),
+	/*8352*/ uint16(xMatch),
+	/*8353*/ uint16(xSetOp), uint16(AND),
+	/*8355*/ uint16(xReadIb),
+	/*8356*/ uint16(xArgAL),
+	/*8357*/ uint16(xArgImm8u),
+	/*8358*/ uint16(xMatch),
+	/*8359*/ uint16(xCondIs64), 8362, 8378,
+	/*8362*/ uint16(xCondDataSize), 8366, 8372, 0,
+	/*8366*/ uint16(xSetOp), uint16(AND),
+	/*8368*/ uint16(xReadIw),
+	/*8369*/ uint16(xArgAX),
+	/*8370*/ uint16(xArgImm16),
+	/*8371*/ uint16(xMatch),
+	/*8372*/ uint16(xSetOp), uint16(AND),
+	/*8374*/ uint16(xReadId),
+	/*8375*/ uint16(xArgEAX),
+	/*8376*/ uint16(xArgImm32),
+	/*8377*/ uint16(xMatch),
+	/*8378*/ uint16(xCondDataSize), 8366, 8372, 8382,
+	/*8382*/ uint16(xSetOp), uint16(AND),
+	/*8384*/ uint16(xReadId),
+	/*8385*/ uint16(xArgRAX),
+	/*8386*/ uint16(xArgImm32),
+	/*8387*/ uint16(xMatch),
+	/*8388*/ uint16(xCondIs64), 8391, 0,
+	/*8391*/ uint16(xSetOp), uint16(DAA),
+	/*8393*/ uint16(xMatch),
+	/*8394*/ uint16(xSetOp), uint16(SUB),
+	/*8396*/ uint16(xReadSlashR),
+	/*8397*/ uint16(xArgRM8),
+	/*8398*/ uint16(xArgR8),
+	/*8399*/ uint16(xMatch),
+	/*8400*/ uint16(xCondIs64), 8403, 8419,
+	/*8403*/ uint16(xCondDataSize), 8407, 8413, 0,
+	/*8407*/ uint16(xSetOp), uint16(SUB),
+	/*8409*/ uint16(xReadSlashR),
+	/*8410*/ uint16(xArgRM16),
+	/*8411*/ uint16(xArgR16),
+	/*8412*/ uint16(xMatch),
+	/*8413*/ uint16(xSetOp), uint16(SUB),
+	/*8415*/ uint16(xReadSlashR),
+	/*8416*/ uint16(xArgRM32),
+	/*8417*/ uint16(xArgR32),
+	/*8418*/ uint16(xMatch),
+	/*8419*/ uint16(xCondDataSize), 8407, 8413, 8423,
+	/*8423*/ uint16(xSetOp), uint16(SUB),
+	/*8425*/ uint16(xReadSlashR),
+	/*8426*/ uint16(xArgRM64),
+	/*8427*/ uint16(xArgR64),
+	/*8428*/ uint16(xMatch),
+	/*8429*/ uint16(xCondPrefix), 3,
+	0xC5, 8457,
+	0xC4, 8443,
+	0x0, 8437,
+	/*8437*/ uint16(xSetOp), uint16(SUB),
+	/*8439*/ uint16(xReadSlashR),
+	/*8440*/ uint16(xArgR8),
+	/*8441*/ uint16(xArgRM8),
+	/*8442*/ uint16(xMatch),
+	/*8443*/ uint16(xCondPrefix), 1,
+	0x66, 8447,
+	/*8447*/ uint16(xCondPrefix), 1,
+	0x0F38, 8451,
+	/*8451*/ uint16(xSetOp), uint16(VMOVNTDQA),
+	/*8453*/ uint16(xReadSlashR),
+	/*8454*/ uint16(xArgYmm1),
+	/*8455*/ uint16(xArgM256),
+	/*8456*/ uint16(xMatch),
+	/*8457*/ uint16(xCondPrefix), 1,
+	0x66, 8461,
+	/*8461*/ uint16(xCondPrefix), 1,
+	0x0F38, 8465,
+	/*8465*/ uint16(xSetOp), uint16(VMOVNTDQA),
+	/*8467*/ uint16(xReadSlashR),
+	/*8468*/ uint16(xArgYmm1),
+	/*8469*/ uint16(xArgM256),
+	/*8470*/ uint16(xMatch),
+	/*8471*/ uint16(xCondIs64), 8474, 8490,
+	/*8474*/ uint16(xCondDataSize), 8478, 8484, 0,
+	/*8478*/ uint16(xSetOp), uint16(SUB),
+	/*8480*/ uint16(xReadSlashR),
+	/*8481*/ uint16(xArgR16),
+	/*8482*/ uint16(xArgRM16),
+	/*8483*/ uint16(xMatch),
+	/*8484*/ uint16(xSetOp), uint16(SUB),
+	/*8486*/ uint16(xReadSlashR),
+	/*8487*/ uint16(xArgR32),
+	/*8488*/ uint16(xArgRM32),
+	/*8489*/ uint16(xMatch),
+	/*8490*/ uint16(xCondDataSize), 8478, 8484, 8494,
+	/*8494*/ uint16(xSetOp), uint16(SUB),
+	/*8496*/ uint16(xReadSlashR),
+	/*8497*/ uint16(xArgR64),
+	/*8498*/ uint16(xArgRM64),
+	/*8499*/ uint16(xMatch),
+	/*8500*/ uint16(xSetOp), uint16(SUB),
+	/*8502*/ uint16(xReadIb),
+	/*8503*/ uint16(xArgAL),
+	/*8504*/ uint16(xArgImm8u),
+	/*8505*/ uint16(xMatch),
+	/*8506*/ uint16(xCondIs64), 8509, 8525,
+	/*8509*/ uint16(xCondDataSize), 8513, 8519, 0,
+	/*8513*/ uint16(xSetOp), uint16(SUB),
+	/*8515*/ uint16(xReadIw),
+	/*8516*/ uint16(xArgAX),
+	/*8517*/ uint16(xArgImm16),
+	/*8518*/ uint16(xMatch),
+	/*8519*/ uint16(xSetOp), uint16(SUB),
+	/*8521*/ uint16(xReadId),
+	/*8522*/ uint16(xArgEAX),
+	/*8523*/ uint16(xArgImm32),
+	/*8524*/ uint16(xMatch),
+	/*8525*/ uint16(xCondDataSize), 8513, 8519, 8529,
+	/*8529*/ uint16(xSetOp), uint16(SUB),
+	/*8531*/ uint16(xReadId),
+	/*8532*/ uint16(xArgRAX),
+	/*8533*/ uint16(xArgImm32),
+	/*8534*/ uint16(xMatch),
+	/*8535*/ uint16(xCondIs64), 8538, 0,
+	/*8538*/ uint16(xSetOp), uint16(DAS),
+	/*8540*/ uint16(xMatch),
+	/*8541*/ uint16(xSetOp), uint16(XOR),
+	/*8543*/ uint16(xReadSlashR),
+	/*8544*/ uint16(xArgRM8),
+	/*8545*/ uint16(xArgR8),
+	/*8546*/ uint16(xMatch),
+	/*8547*/ uint16(xCondIs64), 8550, 8566,
+	/*8550*/ uint16(xCondDataSize), 8554, 8560, 0,
+	/*8554*/ uint16(xSetOp), uint16(XOR),
+	/*8556*/ uint16(xReadSlashR),
+	/*8557*/ uint16(xArgRM16),
+	/*8558*/ uint16(xArgR16),
+	/*8559*/ uint16(xMatch),
+	/*8560*/ uint16(xSetOp), uint16(XOR),
+	/*8562*/ uint16(xReadSlashR),
+	/*8563*/ uint16(xArgRM32),
+	/*8564*/ uint16(xArgR32),
+	/*8565*/ uint16(xMatch),
+	/*8566*/ uint16(xCondDataSize), 8554, 8560, 8570,
+	/*8570*/ uint16(xSetOp), uint16(XOR),
+	/*8572*/ uint16(xReadSlashR),
+	/*8573*/ uint16(xArgRM64),
+	/*8574*/ uint16(xArgR64),
+	/*8575*/ uint16(xMatch),
+	/*8576*/ uint16(xSetOp), uint16(XOR),
+	/*8578*/ uint16(xReadSlashR),
+	/*8579*/ uint16(xArgR8),
+	/*8580*/ uint16(xArgRM8),
+	/*8581*/ uint16(xMatch),
+	/*8582*/ uint16(xCondIs64), 8585, 8601,
+	/*8585*/ uint16(xCondDataSize), 8589, 8595, 0,
+	/*8589*/ uint16(xSetOp), uint16(XOR),
+	/*8591*/ uint16(xReadSlashR),
+	/*8592*/ uint16(xArgR16),
+	/*8593*/ uint16(xArgRM16),
+	/*8594*/ uint16(xMatch),
+	/*8595*/ uint16(xSetOp), uint16(XOR),
+	/*8597*/ uint16(xReadSlashR),
+	/*8598*/ uint16(xArgR32),
+	/*8599*/ uint16(xArgRM32),
+	/*8600*/ uint16(xMatch),
+	/*8601*/ uint16(xCondDataSize), 8589, 8595, 8605,
+	/*8605*/ uint16(xSetOp), uint16(XOR),
+	/*8607*/ uint16(xReadSlashR),
+	/*8608*/ uint16(xArgR64),
+	/*8609*/ uint16(xArgRM64),
+	/*8610*/ uint16(xMatch),
+	/*8611*/ uint16(xSetOp), uint16(XOR),
+	/*8613*/ uint16(xReadIb),
+	/*8614*/ uint16(xArgAL),
+	/*8615*/ uint16(xArgImm8u),
+	/*8616*/ uint16(xMatch),
+	/*8617*/ uint16(xCondIs64), 8620, 8636,
+	/*8620*/ uint16(xCondDataSize), 8624, 8630, 0,
+	/*8624*/ uint16(xSetOp), uint16(XOR),
+	/*8626*/ uint16(xReadIw),
+	/*8627*/ uint16(xArgAX),
+	/*8628*/ uint16(xArgImm16),
+	/*8629*/ uint16(xMatch),
+	/*8630*/ uint16(xSetOp), uint16(XOR),
+	/*8632*/ uint16(xReadId),
+	/*8633*/ uint16(xArgEAX),
+	/*8634*/ uint16(xArgImm32),
+	/*8635*/ uint16(xMatch),
+	/*8636*/ uint16(xCondDataSize), 8624, 8630, 8640,
+	/*8640*/ uint16(xSetOp), uint16(XOR),
+	/*8642*/ uint16(xReadId),
+	/*8643*/ uint16(xArgRAX),
+	/*8644*/ uint16(xArgImm32),
+	/*8645*/ uint16(xMatch),
+	/*8646*/ uint16(xCondIs64), 8649, 0,
+	/*8649*/ uint16(xSetOp), uint16(AAA),
+	/*8651*/ uint16(xMatch),
+	/*8652*/ uint16(xSetOp), uint16(CMP),
+	/*8654*/ uint16(xReadSlashR),
+	/*8655*/ uint16(xArgRM8),
+	/*8656*/ uint16(xArgR8),
+	/*8657*/ uint16(xMatch),
+	/*8658*/ uint16(xCondIs64), 8661, 8677,
+	/*8661*/ uint16(xCondDataSize), 8665, 8671, 0,
+	/*8665*/ uint16(xSetOp), uint16(CMP),
+	/*8667*/ uint16(xReadSlashR),
+	/*8668*/ uint16(xArgRM16),
+	/*8669*/ uint16(xArgR16),
+	/*8670*/ uint16(xMatch),
+	/*8671*/ uint16(xSetOp), uint16(CMP),
+	/*8673*/ uint16(xReadSlashR),
+	/*8674*/ uint16(xArgRM32),
+	/*8675*/ uint16(xArgR32),
+	/*8676*/ uint16(xMatch),
+	/*8677*/ uint16(xCondDataSize), 8665, 8671, 8681,
+	/*8681*/ uint16(xSetOp), uint16(CMP),
+	/*8683*/ uint16(xReadSlashR),
+	/*8684*/ uint16(xArgRM64),
+	/*8685*/ uint16(xArgR64),
+	/*8686*/ uint16(xMatch),
+	/*8687*/ uint16(xSetOp), uint16(CMP),
+	/*8689*/ uint16(xReadSlashR),
+	/*8690*/ uint16(xArgR8),
+	/*8691*/ uint16(xArgRM8),
+	/*8692*/ uint16(xMatch),
+	/*8693*/ uint16(xCondIs64), 8696, 8712,
+	/*8696*/ uint16(xCondDataSize), 8700, 8706, 0,
+	/*8700*/ uint16(xSetOp), uint16(CMP),
+	/*8702*/ uint16(xReadSlashR),
+	/*8703*/ uint16(xArgR16),
+	/*8704*/ uint16(xArgRM16),
+	/*8705*/ uint16(xMatch),
+	/*8706*/ uint16(xSetOp), uint16(CMP),
+	/*8708*/ uint16(xReadSlashR),
+	/*8709*/ uint16(xArgR32),
+	/*8710*/ uint16(xArgRM32),
+	/*8711*/ uint16(xMatch),
+	/*8712*/ uint16(xCondDataSize), 8700, 8706, 8716,
+	/*8716*/ uint16(xSetOp), uint16(CMP),
+	/*8718*/ uint16(xReadSlashR),
+	/*8719*/ uint16(xArgR64),
+	/*8720*/ uint16(xArgRM64),
+	/*8721*/ uint16(xMatch),
+	/*8722*/ uint16(xSetOp), uint16(CMP),
+	/*8724*/ uint16(xReadIb),
+	/*8725*/ uint16(xArgAL),
+	/*8726*/ uint16(xArgImm8u),
+	/*8727*/ uint16(xMatch),
+	/*8728*/ uint16(xCondIs64), 8731, 8747,
+	/*8731*/ uint16(xCondDataSize), 8735, 8741, 0,
+	/*8735*/ uint16(xSetOp), uint16(CMP),
+	/*8737*/ uint16(xReadIw),
+	/*8738*/ uint16(xArgAX),
+	/*8739*/ uint16(xArgImm16),
+	/*8740*/ uint16(xMatch),
+	/*8741*/ uint16(xSetOp), uint16(CMP),
+	/*8743*/ uint16(xReadId),
+	/*8744*/ uint16(xArgEAX),
+	/*8745*/ uint16(xArgImm32),
+	/*8746*/ uint16(xMatch),
+	/*8747*/ uint16(xCondDataSize), 8735, 8741, 8751,
+	/*8751*/ uint16(xSetOp), uint16(CMP),
+	/*8753*/ uint16(xReadId),
+	/*8754*/ uint16(xArgRAX),
+	/*8755*/ uint16(xArgImm32),
+	/*8756*/ uint16(xMatch),
+	/*8757*/ uint16(xCondIs64), 8760, 0,
+	/*8760*/ uint16(xSetOp), uint16(AAS),
+	/*8762*/ uint16(xMatch),
+	/*8763*/ uint16(xCondIs64), 8766, 0,
+	/*8766*/ uint16(xCondDataSize), 8770, 8774, 0,
+	/*8770*/ uint16(xSetOp), uint16(INC),
+	/*8772*/ uint16(xArgR16op),
+	/*8773*/ uint16(xMatch),
+	/*8774*/ uint16(xSetOp), uint16(INC),
+	/*8776*/ uint16(xArgR32op),
+	/*8777*/ uint16(xMatch),
+	/*8778*/ uint16(xCondIs64), 8781, 0,
+	/*8781*/ uint16(xCondDataSize), 8785, 8789, 0,
+	/*8785*/ uint16(xSetOp), uint16(DEC),
+	/*8787*/ uint16(xArgR16op),
+	/*8788*/ uint16(xMatch),
+	/*8789*/ uint16(xSetOp), uint16(DEC),
+	/*8791*/ uint16(xArgR32op),
+	/*8792*/ uint16(xMatch),
+	/*8793*/ uint16(xCondIs64), 8796, 8808,
+	/*8796*/ uint16(xCondDataSize), 8800, 8804, 0,
+	/*8800*/ uint16(xSetOp), uint16(PUSH),
+	/*8802*/ uint16(xArgR16op),
+	/*8803*/ uint16(xMatch),
+	/*8804*/ uint16(xSetOp), uint16(PUSH),
+	/*8806*/ uint16(xArgR32op),
+	/*8807*/ uint16(xMatch),
+	/*8808*/ uint16(xCondDataSize), 8800, 8812, 8816,
+	/*8812*/ uint16(xSetOp), uint16(PUSH),
+	/*8814*/ uint16(xArgR64op),
+	/*8815*/ uint16(xMatch),
+	/*8816*/ uint16(xSetOp), uint16(PUSH),
+	/*8818*/ uint16(xArgR64op),
+	/*8819*/ uint16(xMatch),
+	/*8820*/ uint16(xCondIs64), 8823, 8835,
+	/*8823*/ uint16(xCondDataSize), 8827, 8831, 0,
+	/*8827*/ uint16(xSetOp), uint16(POP),
+	/*8829*/ uint16(xArgR16op),
+	/*8830*/ uint16(xMatch),
+	/*8831*/ uint16(xSetOp), uint16(POP),
+	/*8833*/ uint16(xArgR32op),
+	/*8834*/ uint16(xMatch),
+	/*8835*/ uint16(xCondDataSize), 8827, 8839, 8843,
+	/*8839*/ uint16(xSetOp), uint16(POP),
+	/*8841*/ uint16(xArgR64op),
+	/*8842*/ uint16(xMatch),
+	/*8843*/ uint16(xSetOp), uint16(POP),
+	/*8845*/ uint16(xArgR64op),
+	/*8846*/ uint16(xMatch),
+	/*8847*/ uint16(xCondIs64), 8850, 0,
+	/*8850*/ uint16(xCondDataSize), 8854, 8857, 0,
+	/*8854*/ uint16(xSetOp), uint16(PUSHA),
+	/*8856*/ uint16(xMatch),
+	/*8857*/ uint16(xSetOp), uint16(PUSHAD),
+	/*8859*/ uint16(xMatch),
+	/*8860*/ uint16(xCondIs64), 8863, 0,
+	/*8863*/ uint16(xCondDataSize), 8867, 8870, 0,
+	/*8867*/ uint16(xSetOp), uint16(POPA),
+	/*8869*/ uint16(xMatch),
+	/*8870*/ uint16(xSetOp), uint16(POPAD),
+	/*8872*/ uint16(xMatch),
+	/*8873*/ uint16(xCondIs64), 8876, 0,
+	/*8876*/ uint16(xCondDataSize), 8880, 8886, 0,
+	/*8880*/ uint16(xSetOp), uint16(BOUND),
+	/*8882*/ uint16(xReadSlashR),
+	/*8883*/ uint16(xArgR16),
+	/*8884*/ uint16(xArgM16and16),
+	/*8885*/ uint16(xMatch),
+	/*8886*/ uint16(xSetOp), uint16(BOUND),
+	/*8888*/ uint16(xReadSlashR),
+	/*8889*/ uint16(xArgR32),
+	/*8890*/ uint16(xArgM32and32),
+	/*8891*/ uint16(xMatch),
+	/*8892*/ uint16(xCondIs64), 8895, 8901,
+	/*8895*/ uint16(xSetOp), uint16(ARPL),
+	/*8897*/ uint16(xReadSlashR),
+	/*8898*/ uint16(xArgRM16),
+	/*8899*/ uint16(xArgR16),
+	/*8900*/ uint16(xMatch),
+	/*8901*/ uint16(xCondDataSize), 8905, 8911, 8917,
+	/*8905*/ uint16(xSetOp), uint16(MOVSXD),
+	/*8907*/ uint16(xReadSlashR),
+	/*8908*/ uint16(xArgR16),
+	/*8909*/ uint16(xArgRM32),
+	/*8910*/ uint16(xMatch),
+	/*8911*/ uint16(xSetOp), uint16(MOVSXD),
+	/*8913*/ uint16(xReadSlashR),
+	/*8914*/ uint16(xArgR32),
+	/*8915*/ uint16(xArgRM32),
+	/*8916*/ uint16(xMatch),
+	/*8917*/ uint16(xSetOp), uint16(MOVSXD),
+	/*8919*/ uint16(xReadSlashR),
+	/*8920*/ uint16(xArgR64),
+	/*8921*/ uint16(xArgRM32),
+	/*8922*/ uint16(xMatch),
+	/*8923*/ uint16(xCondDataSize), 8927, 8932, 8937,
+	/*8927*/ uint16(xSetOp), uint16(PUSH),
+	/*8929*/ uint16(xReadIw),
+	/*8930*/ uint16(xArgImm16),
+	/*8931*/ uint16(xMatch),
+	/*8932*/ uint16(xSetOp), uint16(PUSH),
+	/*8934*/ uint16(xReadId),
+	/*8935*/ uint16(xArgImm32),
+	/*8936*/ uint16(xMatch),
+	/*8937*/ uint16(xSetOp), uint16(PUSH),
+	/*8939*/ uint16(xReadId),
+	/*8940*/ uint16(xArgImm32),
+	/*8941*/ uint16(xMatch),
+	/*8942*/ uint16(xCondIs64), 8945, 8965,
+	/*8945*/ uint16(xCondDataSize), 8949, 8957, 0,
+	/*8949*/ uint16(xSetOp), uint16(IMUL),
+	/*8951*/ uint16(xReadSlashR),
+	/*8952*/ uint16(xReadIw),
+	/*8953*/ uint16(xArgR16),
+	/*8954*/ uint16(xArgRM16),
+	/*8955*/ uint16(xArgImm16),
+	/*8956*/ uint16(xMatch),
+	/*8957*/ uint16(xSetOp), uint16(IMUL),
+	/*8959*/ uint16(xReadSlashR),
+	/*8960*/ uint16(xReadId),
+	/*8961*/ uint16(xArgR32),
+	/*8962*/ uint16(xArgRM32),
+	/*8963*/ uint16(xArgImm32),
+	/*8964*/ uint16(xMatch),
+	/*8965*/ uint16(xCondDataSize), 8949, 8957, 8969,
+	/*8969*/ uint16(xSetOp), uint16(IMUL),
+	/*8971*/ uint16(xReadSlashR),
+	/*8972*/ uint16(xReadId),
+	/*8973*/ uint16(xArgR64),
+	/*8974*/ uint16(xArgRM64),
+	/*8975*/ uint16(xArgImm32),
+	/*8976*/ uint16(xMatch),
+	/*8977*/ uint16(xSetOp), uint16(PUSH),
+	/*8979*/ uint16(xReadIb),
+	/*8980*/ uint16(xArgImm8),
+	/*8981*/ uint16(xMatch),
+	/*8982*/ uint16(xCondIs64), 8985, 9005,
+	/*8985*/ uint16(xCondDataSize), 8989, 8997, 0,
+	/*8989*/ uint16(xSetOp), uint16(IMUL),
+	/*8991*/ uint16(xReadSlashR),
+	/*8992*/ uint16(xReadIb),
+	/*8993*/ uint16(xArgR16),
+	/*8994*/ uint16(xArgRM16),
+	/*8995*/ uint16(xArgImm8),
+	/*8996*/ uint16(xMatch),
+	/*8997*/ uint16(xSetOp), uint16(IMUL),
+	/*8999*/ uint16(xReadSlashR),
+	/*9000*/ uint16(xReadIb),
+	/*9001*/ uint16(xArgR32),
+	/*9002*/ uint16(xArgRM32),
+	/*9003*/ uint16(xArgImm8),
+	/*9004*/ uint16(xMatch),
+	/*9005*/ uint16(xCondDataSize), 8989, 8997, 9009,
+	/*9009*/ uint16(xSetOp), uint16(IMUL),
+	/*9011*/ uint16(xReadSlashR),
+	/*9012*/ uint16(xReadIb),
+	/*9013*/ uint16(xArgR64),
+	/*9014*/ uint16(xArgRM64),
+	/*9015*/ uint16(xArgImm8),
+	/*9016*/ uint16(xMatch),
+	/*9017*/ uint16(xSetOp), uint16(INSB),
+	/*9019*/ uint16(xMatch),
+	/*9020*/ uint16(xCondDataSize), 9024, 9027, 9030,
+	/*9024*/ uint16(xSetOp), uint16(INSW),
+	/*9026*/ uint16(xMatch),
+	/*9027*/ uint16(xSetOp), uint16(INSD),
+	/*9029*/ uint16(xMatch),
+	/*9030*/ uint16(xSetOp), uint16(INSD),
+	/*9032*/ uint16(xMatch),
+	/*9033*/ uint16(xSetOp), uint16(OUTSB),
+	/*9035*/ uint16(xMatch),
+	/*9036*/ uint16(xCondPrefix), 3,
+	0xC5, 9083,
+	0xC4, 9057,
+	0x0, 9044,
+	/*9044*/ uint16(xCondDataSize), 9048, 9051, 9054,
+	/*9048*/ uint16(xSetOp), uint16(OUTSW),
+	/*9050*/ uint16(xMatch),
+	/*9051*/ uint16(xSetOp), uint16(OUTSD),
+	/*9053*/ uint16(xMatch),
+	/*9054*/ uint16(xSetOp), uint16(OUTSD),
+	/*9056*/ uint16(xMatch),
+	/*9057*/ uint16(xCondPrefix), 2,
+	0xF3, 9073,
+	0x66, 9063,
+	/*9063*/ uint16(xCondPrefix), 1,
+	0x0F, 9067,
+	/*9067*/ uint16(xSetOp), uint16(VMOVDQA),
+	/*9069*/ uint16(xReadSlashR),
+	/*9070*/ uint16(xArgYmm1),
+	/*9071*/ uint16(xArgYmm2M256),
+	/*9072*/ uint16(xMatch),
+	/*9073*/ uint16(xCondPrefix), 1,
+	0x0F, 9077,
+	/*9077*/ uint16(xSetOp), uint16(VMOVDQU),
+	/*9079*/ uint16(xReadSlashR),
+	/*9080*/ uint16(xArgYmm1),
+	/*9081*/ uint16(xArgYmm2M256),
+	/*9082*/ uint16(xMatch),
+	/*9083*/ uint16(xCondPrefix), 2,
+	0xF3, 9099,
+	0x66, 9089,
+	/*9089*/ uint16(xCondPrefix), 1,
+	0x0F, 9093,
+	/*9093*/ uint16(xSetOp), uint16(VMOVDQA),
+	/*9095*/ uint16(xReadSlashR),
+	/*9096*/ uint16(xArgYmm1),
+	/*9097*/ uint16(xArgYmm2M256),
+	/*9098*/ uint16(xMatch),
+	/*9099*/ uint16(xCondPrefix), 1,
+	0x0F, 9103,
+	/*9103*/ uint16(xSetOp), uint16(VMOVDQU),
+	/*9105*/ uint16(xReadSlashR),
+	/*9106*/ uint16(xArgYmm1),
+	/*9107*/ uint16(xArgYmm2M256),
+	/*9108*/ uint16(xMatch),
+	/*9109*/ uint16(xSetOp), uint16(JO),
+	/*9111*/ uint16(xReadCb),
+	/*9112*/ uint16(xArgRel8),
+	/*9113*/ uint16(xMatch),
+	/*9114*/ uint16(xSetOp), uint16(JNO),
+	/*9116*/ uint16(xReadCb),
+	/*9117*/ uint16(xArgRel8),
+	/*9118*/ uint16(xMatch),
+	/*9119*/ uint16(xSetOp), uint16(JB),
+	/*9121*/ uint16(xReadCb),
+	/*9122*/ uint16(xArgRel8),
+	/*9123*/ uint16(xMatch),
+	/*9124*/ uint16(xSetOp), uint16(JAE),
+	/*9126*/ uint16(xReadCb),
+	/*9127*/ uint16(xArgRel8),
+	/*9128*/ uint16(xMatch),
+	/*9129*/ uint16(xSetOp), uint16(JE),
+	/*9131*/ uint16(xReadCb),
+	/*9132*/ uint16(xArgRel8),
+	/*9133*/ uint16(xMatch),
+	/*9134*/ uint16(xSetOp), uint16(JNE),
+	/*9136*/ uint16(xReadCb),
+	/*9137*/ uint16(xArgRel8),
+	/*9138*/ uint16(xMatch),
+	/*9139*/ uint16(xSetOp), uint16(JBE),
+	/*9141*/ uint16(xReadCb),
+	/*9142*/ uint16(xArgRel8),
+	/*9143*/ uint16(xMatch),
+	/*9144*/ uint16(xCondPrefix), 3,
+	0xC5, 9164,
+	0xC4, 9157,
+	0x0, 9152,
+	/*9152*/ uint16(xSetOp), uint16(JA),
+	/*9154*/ uint16(xReadCb),
+	/*9155*/ uint16(xArgRel8),
+	/*9156*/ uint16(xMatch),
+	/*9157*/ uint16(xCondPrefix), 1,
+	0x0F, 9161,
+	/*9161*/ uint16(xSetOp), uint16(VZEROUPPER),
+	/*9163*/ uint16(xMatch),
+	/*9164*/ uint16(xCondPrefix), 1,
+	0x0F, 9168,
+	/*9168*/ uint16(xSetOp), uint16(VZEROUPPER),
+	/*9170*/ uint16(xMatch),
+	/*9171*/ uint16(xSetOp), uint16(JS),
+	/*9173*/ uint16(xReadCb),
+	/*9174*/ uint16(xArgRel8),
+	/*9175*/ uint16(xMatch),
+	/*9176*/ uint16(xSetOp), uint16(JNS),
+	/*9178*/ uint16(xReadCb),
+	/*9179*/ uint16(xArgRel8),
+	/*9180*/ uint16(xMatch),
+	/*9181*/ uint16(xSetOp), uint16(JP),
+	/*9183*/ uint16(xReadCb),
+	/*9184*/ uint16(xArgRel8),
+	/*9185*/ uint16(xMatch),
+	/*9186*/ uint16(xSetOp), uint16(JNP),
+	/*9188*/ uint16(xReadCb),
+	/*9189*/ uint16(xArgRel8),
+	/*9190*/ uint16(xMatch),
+	/*9191*/ uint16(xSetOp), uint16(JL),
+	/*9193*/ uint16(xReadCb),
+	/*9194*/ uint16(xArgRel8),
+	/*9195*/ uint16(xMatch),
+	/*9196*/ uint16(xSetOp), uint16(JGE),
+	/*9198*/ uint16(xReadCb),
+	/*9199*/ uint16(xArgRel8),
+	/*9200*/ uint16(xMatch),
+	/*9201*/ uint16(xSetOp), uint16(JLE),
+	/*9203*/ uint16(xReadCb),
+	/*9204*/ uint16(xArgRel8),
+	/*9205*/ uint16(xMatch),
+	/*9206*/ uint16(xCondPrefix), 3,
+	0xC5, 9245,
+	0xC4, 9219,
+	0x0, 9214,
+	/*9214*/ uint16(xSetOp), uint16(JG),
+	/*9216*/ uint16(xReadCb),
+	/*9217*/ uint16(xArgRel8),
+	/*9218*/ uint16(xMatch),
+	/*9219*/ uint16(xCondPrefix), 2,
+	0xF3, 9235,
+	0x66, 9225,
+	/*9225*/ uint16(xCondPrefix), 1,
+	0x0F, 9229,
+	/*9229*/ uint16(xSetOp), uint16(VMOVDQA),
+	/*9231*/ uint16(xReadSlashR),
+	/*9232*/ uint16(xArgYmm2M256),
+	/*9233*/ uint16(xArgYmm1),
+	/*9234*/ uint16(xMatch),
+	/*9235*/ uint16(xCondPrefix), 1,
+	0x0F, 9239,
+	/*9239*/ uint16(xSetOp), uint16(VMOVDQU),
+	/*9241*/ uint16(xReadSlashR),
+	/*9242*/ uint16(xArgYmm2M256),
+	/*9243*/ uint16(xArgYmm1),
+	/*9244*/ uint16(xMatch),
+	/*9245*/ uint16(xCondPrefix), 2,
+	0xF3, 9261,
+	0x66, 9251,
+	/*9251*/ uint16(xCondPrefix), 1,
+	0x0F, 9255,
+	/*9255*/ uint16(xSetOp), uint16(VMOVDQA),
+	/*9257*/ uint16(xReadSlashR),
+	/*9258*/ uint16(xArgYmm2M256),
+	/*9259*/ uint16(xArgYmm1),
+	/*9260*/ uint16(xMatch),
+	/*9261*/ uint16(xCondPrefix), 1,
+	0x0F, 9265,
+	/*9265*/ uint16(xSetOp), uint16(VMOVDQU),
+	/*9267*/ uint16(xReadSlashR),
+	/*9268*/ uint16(xArgYmm2M256),
+	/*9269*/ uint16(xArgYmm1),
+	/*9270*/ uint16(xMatch),
+	/*9271*/ uint16(xCondSlashR),
+	9280, // 0
+	9286, // 1
+	9292, // 2
+	9298, // 3
+	9304, // 4
+	9310, // 5
+	9316, // 6
+	9322, // 7
+	/*9280*/ uint16(xSetOp), uint16(ADD),
+	/*9282*/ uint16(xReadIb),
+	/*9283*/ uint16(xArgRM8),
+	/*9284*/ uint16(xArgImm8u),
+	/*9285*/ uint16(xMatch),
+	/*9286*/ uint16(xSetOp), uint16(OR),
+	/*9288*/ uint16(xReadIb),
+	/*9289*/ uint16(xArgRM8),
+	/*9290*/ uint16(xArgImm8u),
+	/*9291*/ uint16(xMatch),
+	/*9292*/ uint16(xSetOp), uint16(ADC),
+	/*9294*/ uint16(xReadIb),
+	/*9295*/ uint16(xArgRM8),
+	/*9296*/ uint16(xArgImm8u),
+	/*9297*/ uint16(xMatch),
+	/*9298*/ uint16(xSetOp), uint16(SBB),
+	/*9300*/ uint16(xReadIb),
+	/*9301*/ uint16(xArgRM8),
+	/*9302*/ uint16(xArgImm8u),
+	/*9303*/ uint16(xMatch),
+	/*9304*/ uint16(xSetOp), uint16(AND),
+	/*9306*/ uint16(xReadIb),
+	/*9307*/ uint16(xArgRM8),
+	/*9308*/ uint16(xArgImm8u),
+	/*9309*/ uint16(xMatch),
+	/*9310*/ uint16(xSetOp), uint16(SUB),
+	/*9312*/ uint16(xReadIb),
+	/*9313*/ uint16(xArgRM8),
+	/*9314*/ uint16(xArgImm8u),
+	/*9315*/ uint16(xMatch),
+	/*9316*/ uint16(xSetOp), uint16(XOR),
+	/*9318*/ uint16(xReadIb),
+	/*9319*/ uint16(xArgRM8),
+	/*9320*/ uint16(xArgImm8u),
+	/*9321*/ uint16(xMatch),
+	/*9322*/ uint16(xSetOp), uint16(CMP),
+	/*9324*/ uint16(xReadIb),
+	/*9325*/ uint16(xArgRM8),
+	/*9326*/ uint16(xArgImm8u),
+	/*9327*/ uint16(xMatch),
+	/*9328*/ uint16(xCondSlashR),
+	9337, // 0
+	9366, // 1
+	9395, // 2
+	9424, // 3
+	9453, // 4
+	9482, // 5
+	9511, // 6
+	9540, // 7
+	/*9337*/ uint16(xCondIs64), 9340, 9356,
+	/*9340*/ uint16(xCondDataSize), 9344, 9350, 0,
+	/*9344*/ uint16(xSetOp), uint16(ADD),
+	/*9346*/ uint16(xReadIw),
+	/*9347*/ uint16(xArgRM16),
+	/*9348*/ uint16(xArgImm16),
+	/*9349*/ uint16(xMatch),
+	/*9350*/ uint16(xSetOp), uint16(ADD),
+	/*9352*/ uint16(xReadId),
+	/*9353*/ uint16(xArgRM32),
+	/*9354*/ uint16(xArgImm32),
+	/*9355*/ uint16(xMatch),
+	/*9356*/ uint16(xCondDataSize), 9344, 9350, 9360,
+	/*9360*/ uint16(xSetOp), uint16(ADD),
+	/*9362*/ uint16(xReadId),
+	/*9363*/ uint16(xArgRM64),
+	/*9364*/ uint16(xArgImm32),
+	/*9365*/ uint16(xMatch),
+	/*9366*/ uint16(xCondIs64), 9369, 9385,
+	/*9369*/ uint16(xCondDataSize), 9373, 9379, 0,
+	/*9373*/ uint16(xSetOp), uint16(OR),
+	/*9375*/ uint16(xReadIw),
+	/*9376*/ uint16(xArgRM16),
+	/*9377*/ uint16(xArgImm16),
+	/*9378*/ uint16(xMatch),
+	/*9379*/ uint16(xSetOp), uint16(OR),
+	/*9381*/ uint16(xReadId),
+	/*9382*/ uint16(xArgRM32),
+	/*9383*/ uint16(xArgImm32),
+	/*9384*/ uint16(xMatch),
+	/*9385*/ uint16(xCondDataSize), 9373, 9379, 9389,
+	/*9389*/ uint16(xSetOp), uint16(OR),
+	/*9391*/ uint16(xReadId),
+	/*9392*/ uint16(xArgRM64),
+	/*9393*/ uint16(xArgImm32),
+	/*9394*/ uint16(xMatch),
+	/*9395*/ uint16(xCondIs64), 9398, 9414,
+	/*9398*/ uint16(xCondDataSize), 9402, 9408, 0,
+	/*9402*/ uint16(xSetOp), uint16(ADC),
+	/*9404*/ uint16(xReadIw),
+	/*9405*/ uint16(xArgRM16),
+	/*9406*/ uint16(xArgImm16),
+	/*9407*/ uint16(xMatch),
+	/*9408*/ uint16(xSetOp), uint16(ADC),
+	/*9410*/ uint16(xReadId),
+	/*9411*/ uint16(xArgRM32),
+	/*9412*/ uint16(xArgImm32),
+	/*9413*/ uint16(xMatch),
+	/*9414*/ uint16(xCondDataSize), 9402, 9408, 9418,
+	/*9418*/ uint16(xSetOp), uint16(ADC),
+	/*9420*/ uint16(xReadId),
+	/*9421*/ uint16(xArgRM64),
+	/*9422*/ uint16(xArgImm32),
+	/*9423*/ uint16(xMatch),
+	/*9424*/ uint16(xCondIs64), 9427, 9443,
+	/*9427*/ uint16(xCondDataSize), 9431, 9437, 0,
+	/*9431*/ uint16(xSetOp), uint16(SBB),
+	/*9433*/ uint16(xReadIw),
+	/*9434*/ uint16(xArgRM16),
+	/*9435*/ uint16(xArgImm16),
+	/*9436*/ uint16(xMatch),
+	/*9437*/ uint16(xSetOp), uint16(SBB),
+	/*9439*/ uint16(xReadId),
+	/*9440*/ uint16(xArgRM32),
+	/*9441*/ uint16(xArgImm32),
+	/*9442*/ uint16(xMatch),
+	/*9443*/ uint16(xCondDataSize), 9431, 9437, 9447,
+	/*9447*/ uint16(xSetOp), uint16(SBB),
+	/*9449*/ uint16(xReadId),
+	/*9450*/ uint16(xArgRM64),
+	/*9451*/ uint16(xArgImm32),
+	/*9452*/ uint16(xMatch),
+	/*9453*/ uint16(xCondIs64), 9456, 9472,
+	/*9456*/ uint16(xCondDataSize), 9460, 9466, 0,
+	/*9460*/ uint16(xSetOp), uint16(AND),
+	/*9462*/ uint16(xReadIw),
+	/*9463*/ uint16(xArgRM16),
+	/*9464*/ uint16(xArgImm16),
+	/*9465*/ uint16(xMatch),
+	/*9466*/ uint16(xSetOp), uint16(AND),
+	/*9468*/ uint16(xReadId),
+	/*9469*/ uint16(xArgRM32),
+	/*9470*/ uint16(xArgImm32),
+	/*9471*/ uint16(xMatch),
+	/*9472*/ uint16(xCondDataSize), 9460, 9466, 9476,
+	/*9476*/ uint16(xSetOp), uint16(AND),
+	/*9478*/ uint16(xReadId),
+	/*9479*/ uint16(xArgRM64),
+	/*9480*/ uint16(xArgImm32),
+	/*9481*/ uint16(xMatch),
+	/*9482*/ uint16(xCondIs64), 9485, 9501,
+	/*9485*/ uint16(xCondDataSize), 9489, 9495, 0,
+	/*9489*/ uint16(xSetOp), uint16(SUB),
+	/*9491*/ uint16(xReadIw),
+	/*9492*/ uint16(xArgRM16),
+	/*9493*/ uint16(xArgImm16),
+	/*9494*/ uint16(xMatch),
+	/*9495*/ uint16(xSetOp), uint16(SUB),
+	/*9497*/ uint16(xReadId),
+	/*9498*/ uint16(xArgRM32),
+	/*9499*/ uint16(xArgImm32),
+	/*9500*/ uint16(xMatch),
+	/*9501*/ uint16(xCondDataSize), 9489, 9495, 9505,
+	/*9505*/ uint16(xSetOp), uint16(SUB),
+	/*9507*/ uint16(xReadId),
+	/*9508*/ uint16(xArgRM64),
+	/*9509*/ uint16(xArgImm32),
+	/*9510*/ uint16(xMatch),
+	/*9511*/ uint16(xCondIs64), 9514, 9530,
+	/*9514*/ uint16(xCondDataSize), 9518, 9524, 0,
+	/*9518*/ uint16(xSetOp), uint16(XOR),
+	/*9520*/ uint16(xReadIw),
+	/*9521*/ uint16(xArgRM16),
+	/*9522*/ uint16(xArgImm16),
+	/*9523*/ uint16(xMatch),
+	/*9524*/ uint16(xSetOp), uint16(XOR),
+	/*9526*/ uint16(xReadId),
+	/*9527*/ uint16(xArgRM32),
+	/*9528*/ uint16(xArgImm32),
+	/*9529*/ uint16(xMatch),
+	/*9530*/ uint16(xCondDataSize), 9518, 9524, 9534,
+	/*9534*/ uint16(xSetOp), uint16(XOR),
+	/*9536*/ uint16(xReadId),
+	/*9537*/ uint16(xArgRM64),
+	/*9538*/ uint16(xArgImm32),
+	/*9539*/ uint16(xMatch),
+	/*9540*/ uint16(xCondIs64), 9543, 9559,
+	/*9543*/ uint16(xCondDataSize), 9547, 9553, 0,
+	/*9547*/ uint16(xSetOp), uint16(CMP),
+	/*9549*/ uint16(xReadIw),
+	/*9550*/ uint16(xArgRM16),
+	/*9551*/ uint16(xArgImm16),
+	/*9552*/ uint16(xMatch),
+	/*9553*/ uint16(xSetOp), uint16(CMP),
+	/*9555*/ uint16(xReadId),
+	/*9556*/ uint16(xArgRM32),
+	/*9557*/ uint16(xArgImm32),
+	/*9558*/ uint16(xMatch),
+	/*9559*/ uint16(xCondDataSize), 9547, 9553, 9563,
+	/*9563*/ uint16(xSetOp), uint16(CMP),
+	/*9565*/ uint16(xReadId),
+	/*9566*/ uint16(xArgRM64),
+	/*9567*/ uint16(xArgImm32),
+	/*9568*/ uint16(xMatch),
+	/*9569*/ uint16(xCondSlashR),
+	9578, // 0
+	9607, // 1
+	9636, // 2
+	9665, // 3
+	9694, // 4
+	9723, // 5
+	9752, // 6
+	9781, // 7
+	/*9578*/ uint16(xCondIs64), 9581, 9597,
+	/*9581*/ uint16(xCondDataSize), 9585, 9591, 0,
+	/*9585*/ uint16(xSetOp), uint16(ADD),
+	/*9587*/ uint16(xReadIb),
+	/*9588*/ uint16(xArgRM16),
+	/*9589*/ uint16(xArgImm8),
+	/*9590*/ uint16(xMatch),
+	/*9591*/ uint16(xSetOp), uint16(ADD),
+	/*9593*/ uint16(xReadIb),
+	/*9594*/ uint16(xArgRM32),
+	/*9595*/ uint16(xArgImm8),
+	/*9596*/ uint16(xMatch),
+	/*9597*/ uint16(xCondDataSize), 9585, 9591, 9601,
+	/*9601*/ uint16(xSetOp), uint16(ADD),
+	/*9603*/ uint16(xReadIb),
+	/*9604*/ uint16(xArgRM64),
+	/*9605*/ uint16(xArgImm8),
+	/*9606*/ uint16(xMatch),
+	/*9607*/ uint16(xCondIs64), 9610, 9626,
+	/*9610*/ uint16(xCondDataSize), 9614, 9620, 0,
+	/*9614*/ uint16(xSetOp), uint16(OR),
+	/*9616*/ uint16(xReadIb),
+	/*9617*/ uint16(xArgRM16),
+	/*9618*/ uint16(xArgImm8),
+	/*9619*/ uint16(xMatch),
+	/*9620*/ uint16(xSetOp), uint16(OR),
+	/*9622*/ uint16(xReadIb),
+	/*9623*/ uint16(xArgRM32),
+	/*9624*/ uint16(xArgImm8),
+	/*9625*/ uint16(xMatch),
+	/*9626*/ uint16(xCondDataSize), 9614, 9620, 9630,
+	/*9630*/ uint16(xSetOp), uint16(OR),
+	/*9632*/ uint16(xReadIb),
+	/*9633*/ uint16(xArgRM64),
+	/*9634*/ uint16(xArgImm8),
+	/*9635*/ uint16(xMatch),
+	/*9636*/ uint16(xCondIs64), 9639, 9655,
+	/*9639*/ uint16(xCondDataSize), 9643, 9649, 0,
+	/*9643*/ uint16(xSetOp), uint16(ADC),
+	/*9645*/ uint16(xReadIb),
+	/*9646*/ uint16(xArgRM16),
+	/*9647*/ uint16(xArgImm8),
+	/*9648*/ uint16(xMatch),
+	/*9649*/ uint16(xSetOp), uint16(ADC),
+	/*9651*/ uint16(xReadIb),
+	/*9652*/ uint16(xArgRM32),
+	/*9653*/ uint16(xArgImm8),
+	/*9654*/ uint16(xMatch),
+	/*9655*/ uint16(xCondDataSize), 9643, 9649, 9659,
+	/*9659*/ uint16(xSetOp), uint16(ADC),
+	/*9661*/ uint16(xReadIb),
+	/*9662*/ uint16(xArgRM64),
+	/*9663*/ uint16(xArgImm8),
+	/*9664*/ uint16(xMatch),
+	/*9665*/ uint16(xCondIs64), 9668, 9684,
+	/*9668*/ uint16(xCondDataSize), 9672, 9678, 0,
+	/*9672*/ uint16(xSetOp), uint16(SBB),
+	/*9674*/ uint16(xReadIb),
+	/*9675*/ uint16(xArgRM16),
+	/*9676*/ uint16(xArgImm8),
+	/*9677*/ uint16(xMatch),
+	/*9678*/ uint16(xSetOp), uint16(SBB),
+	/*9680*/ uint16(xReadIb),
+	/*9681*/ uint16(xArgRM32),
+	/*9682*/ uint16(xArgImm8),
+	/*9683*/ uint16(xMatch),
+	/*9684*/ uint16(xCondDataSize), 9672, 9678, 9688,
+	/*9688*/ uint16(xSetOp), uint16(SBB),
+	/*9690*/ uint16(xReadIb),
+	/*9691*/ uint16(xArgRM64),
+	/*9692*/ uint16(xArgImm8),
+	/*9693*/ uint16(xMatch),
+	/*9694*/ uint16(xCondIs64), 9697, 9713,
+	/*9697*/ uint16(xCondDataSize), 9701, 9707, 0,
+	/*9701*/ uint16(xSetOp), uint16(AND),
+	/*9703*/ uint16(xReadIb),
+	/*9704*/ uint16(xArgRM16),
+	/*9705*/ uint16(xArgImm8),
+	/*9706*/ uint16(xMatch),
+	/*9707*/ uint16(xSetOp), uint16(AND),
+	/*9709*/ uint16(xReadIb),
+	/*9710*/ uint16(xArgRM32),
+	/*9711*/ uint16(xArgImm8),
+	/*9712*/ uint16(xMatch),
+	/*9713*/ uint16(xCondDataSize), 9701, 9707, 9717,
+	/*9717*/ uint16(xSetOp), uint16(AND),
+	/*9719*/ uint16(xReadIb),
+	/*9720*/ uint16(xArgRM64),
+	/*9721*/ uint16(xArgImm8),
+	/*9722*/ uint16(xMatch),
+	/*9723*/ uint16(xCondIs64), 9726, 9742,
+	/*9726*/ uint16(xCondDataSize), 9730, 9736, 0,
+	/*9730*/ uint16(xSetOp), uint16(SUB),
+	/*9732*/ uint16(xReadIb),
+	/*9733*/ uint16(xArgRM16),
+	/*9734*/ uint16(xArgImm8),
+	/*9735*/ uint16(xMatch),
+	/*9736*/ uint16(xSetOp), uint16(SUB),
+	/*9738*/ uint16(xReadIb),
+	/*9739*/ uint16(xArgRM32),
+	/*9740*/ uint16(xArgImm8),
+	/*9741*/ uint16(xMatch),
+	/*9742*/ uint16(xCondDataSize), 9730, 9736, 9746,
+	/*9746*/ uint16(xSetOp), uint16(SUB),
+	/*9748*/ uint16(xReadIb),
+	/*9749*/ uint16(xArgRM64),
+	/*9750*/ uint16(xArgImm8),
+	/*9751*/ uint16(xMatch),
+	/*9752*/ uint16(xCondIs64), 9755, 9771,
+	/*9755*/ uint16(xCondDataSize), 9759, 9765, 0,
+	/*9759*/ uint16(xSetOp), uint16(XOR),
+	/*9761*/ uint16(xReadIb),
+	/*9762*/ uint16(xArgRM16),
+	/*9763*/ uint16(xArgImm8),
+	/*9764*/ uint16(xMatch),
+	/*9765*/ uint16(xSetOp), uint16(XOR),
+	/*9767*/ uint16(xReadIb),
+	/*9768*/ uint16(xArgRM32),
+	/*9769*/ uint16(xArgImm8),
+	/*9770*/ uint16(xMatch),
+	/*9771*/ uint16(xCondDataSize), 9759, 9765, 9775,
+	/*9775*/ uint16(xSetOp), uint16(XOR),
+	/*9777*/ uint16(xReadIb),
+	/*9778*/ uint16(xArgRM64),
+	/*9779*/ uint16(xArgImm8),
+	/*9780*/ uint16(xMatch),
+	/*9781*/ uint16(xCondIs64), 9784, 9800,
+	/*9784*/ uint16(xCondDataSize), 9788, 9794, 0,
+	/*9788*/ uint16(xSetOp), uint16(CMP),
+	/*9790*/ uint16(xReadIb),
+	/*9791*/ uint16(xArgRM16),
+	/*9792*/ uint16(xArgImm8),
+	/*9793*/ uint16(xMatch),
+	/*9794*/ uint16(xSetOp), uint16(CMP),
+	/*9796*/ uint16(xReadIb),
+	/*9797*/ uint16(xArgRM32),
+	/*9798*/ uint16(xArgImm8),
+	/*9799*/ uint16(xMatch),
+	/*9800*/ uint16(xCondDataSize), 9788, 9794, 9804,
+	/*9804*/ uint16(xSetOp), uint16(CMP),
+	/*9806*/ uint16(xReadIb),
+	/*9807*/ uint16(xArgRM64),
+	/*9808*/ uint16(xArgImm8),
+	/*9809*/ uint16(xMatch),
+	/*9810*/ uint16(xSetOp), uint16(TEST),
+	/*9812*/ uint16(xReadSlashR),
+	/*9813*/ uint16(xArgRM8),
+	/*9814*/ uint16(xArgR8),
+	/*9815*/ uint16(xMatch),
+	/*9816*/ uint16(xCondIs64), 9819, 9835,
+	/*9819*/ uint16(xCondDataSize), 9823, 9829, 0,
+	/*9823*/ uint16(xSetOp), uint16(TEST),
+	/*9825*/ uint16(xReadSlashR),
+	/*9826*/ uint16(xArgRM16),
+	/*9827*/ uint16(xArgR16),
+	/*9828*/ uint16(xMatch),
+	/*9829*/ uint16(xSetOp), uint16(TEST),
+	/*9831*/ uint16(xReadSlashR),
+	/*9832*/ uint16(xArgRM32),
+	/*9833*/ uint16(xArgR32),
+	/*9834*/ uint16(xMatch),
+	/*9835*/ uint16(xCondDataSize), 9823, 9829, 9839,
+	/*9839*/ uint16(xSetOp), uint16(TEST),
+	/*9841*/ uint16(xReadSlashR),
+	/*9842*/ uint16(xArgRM64),
+	/*9843*/ uint16(xArgR64),
+	/*9844*/ uint16(xMatch),
+	/*9845*/ uint16(xSetOp), uint16(XCHG),
+	/*9847*/ uint16(xReadSlashR),
+	/*9848*/ uint16(xArgRM8),
+	/*9849*/ uint16(xArgR8),
+	/*9850*/ uint16(xMatch),
+	/*9851*/ uint16(xCondIs64), 9854, 9870,
+	/*9854*/ uint16(xCondDataSize), 9858, 9864, 0,
+	/*9858*/ uint16(xSetOp), uint16(XCHG),
+	/*9860*/ uint16(xReadSlashR),
+	/*9861*/ uint16(xArgRM16),
+	/*9862*/ uint16(xArgR16),
+	/*9863*/ uint16(xMatch),
+	/*9864*/ uint16(xSetOp), uint16(XCHG),
+	/*9866*/ uint16(xReadSlashR),
+	/*9867*/ uint16(xArgRM32),
+	/*9868*/ uint16(xArgR32),
+	/*9869*/ uint16(xMatch),
+	/*9870*/ uint16(xCondDataSize), 9858, 9864, 9874,
+	/*9874*/ uint16(xSetOp), uint16(XCHG),
+	/*9876*/ uint16(xReadSlashR),
+	/*9877*/ uint16(xArgRM64),
+	/*9878*/ uint16(xArgR64),
+	/*9879*/ uint16(xMatch),
+	/*9880*/ uint16(xSetOp), uint16(MOV),
+	/*9882*/ uint16(xReadSlashR),
+	/*9883*/ uint16(xArgRM8),
+	/*9884*/ uint16(xArgR8),
+	/*9885*/ uint16(xMatch),
+	/*9886*/ uint16(xCondDataSize), 9890, 9896, 9902,
+	/*9890*/ uint16(xSetOp), uint16(MOV),
+	/*9892*/ uint16(xReadSlashR),
+	/*9893*/ uint16(xArgRM16),
+	/*9894*/ uint16(xArgR16),
+	/*9895*/ uint16(xMatch),
+	/*9896*/ uint16(xSetOp), uint16(MOV),
+	/*9898*/ uint16(xReadSlashR),
+	/*9899*/ uint16(xArgRM32),
+	/*9900*/ uint16(xArgR32),
+	/*9901*/ uint16(xMatch),
+	/*9902*/ uint16(xSetOp), uint16(MOV),
+	/*9904*/ uint16(xReadSlashR),
+	/*9905*/ uint16(xArgRM64),
+	/*9906*/ uint16(xArgR64),
+	/*9907*/ uint16(xMatch),
+	/*9908*/ uint16(xSetOp), uint16(MOV),
+	/*9910*/ uint16(xReadSlashR),
+	/*9911*/ uint16(xArgR8),
+	/*9912*/ uint16(xArgRM8),
+	/*9913*/ uint16(xMatch),
+	/*9914*/ uint16(xCondDataSize), 9918, 9924, 9930,
+	/*9918*/ uint16(xSetOp), uint16(MOV),
+	/*9920*/ uint16(xReadSlashR),
+	/*9921*/ uint16(xArgR16),
+	/*9922*/ uint16(xArgRM16),
+	/*9923*/ uint16(xMatch),
+	/*9924*/ uint16(xSetOp), uint16(MOV),
+	/*9926*/ uint16(xReadSlashR),
+	/*9927*/ uint16(xArgR32),
+	/*9928*/ uint16(xArgRM32),
+	/*9929*/ uint16(xMatch),
+	/*9930*/ uint16(xSetOp), uint16(MOV),
+	/*9932*/ uint16(xReadSlashR),
+	/*9933*/ uint16(xArgR64),
+	/*9934*/ uint16(xArgRM64),
+	/*9935*/ uint16(xMatch),
+	/*9936*/ uint16(xCondIs64), 9939, 9955,
+	/*9939*/ uint16(xCondDataSize), 9943, 9949, 0,
+	/*9943*/ uint16(xSetOp), uint16(MOV),
+	/*9945*/ uint16(xReadSlashR),
+	/*9946*/ uint16(xArgRM16),
+	/*9947*/ uint16(xArgSreg),
+	/*9948*/ uint16(xMatch),
+	/*9949*/ uint16(xSetOp), uint16(MOV),
+	/*9951*/ uint16(xReadSlashR),
+	/*9952*/ uint16(xArgR32M16),
+	/*9953*/ uint16(xArgSreg),
+	/*9954*/ uint16(xMatch),
+	/*9955*/ uint16(xCondDataSize), 9943, 9949, 9959,
+	/*9959*/ uint16(xSetOp), uint16(MOV),
+	/*9961*/ uint16(xReadSlashR),
+	/*9962*/ uint16(xArgR64M16),
+	/*9963*/ uint16(xArgSreg),
+	/*9964*/ uint16(xMatch),
+	/*9965*/ uint16(xCondIs64), 9968, 9984,
+	/*9968*/ uint16(xCondDataSize), 9972, 9978, 0,
+	/*9972*/ uint16(xSetOp), uint16(LEA),
+	/*9974*/ uint16(xReadSlashR),
+	/*9975*/ uint16(xArgR16),
+	/*9976*/ uint16(xArgM),
+	/*9977*/ uint16(xMatch),
+	/*9978*/ uint16(xSetOp), uint16(LEA),
+	/*9980*/ uint16(xReadSlashR),
+	/*9981*/ uint16(xArgR32),
+	/*9982*/ uint16(xArgM),
+	/*9983*/ uint16(xMatch),
+	/*9984*/ uint16(xCondDataSize), 9972, 9978, 9988,
+	/*9988*/ uint16(xSetOp), uint16(LEA),
+	/*9990*/ uint16(xReadSlashR),
+	/*9991*/ uint16(xArgR64),
+	/*9992*/ uint16(xArgM),
+	/*9993*/ uint16(xMatch),
+	/*9994*/ uint16(xCondIs64), 9997, 10013,
+	/*9997*/ uint16(xCondDataSize), 10001, 10007, 0,
+	/*10001*/ uint16(xSetOp), uint16(MOV),
+	/*10003*/ uint16(xReadSlashR),
+	/*10004*/ uint16(xArgSreg),
+	/*10005*/ uint16(xArgRM16),
+	/*10006*/ uint16(xMatch),
+	/*10007*/ uint16(xSetOp), uint16(MOV),
+	/*10009*/ uint16(xReadSlashR),
+	/*10010*/ uint16(xArgSreg),
+	/*10011*/ uint16(xArgR32M16),
+	/*10012*/ uint16(xMatch),
+	/*10013*/ uint16(xCondDataSize), 10001, 10007, 10017,
+	/*10017*/ uint16(xSetOp), uint16(MOV),
+	/*10019*/ uint16(xReadSlashR),
+	/*10020*/ uint16(xArgSreg),
+	/*10021*/ uint16(xArgR64M16),
+	/*10022*/ uint16(xMatch),
+	/*10023*/ uint16(xCondSlashR),
+	10032, // 0
+	0,     // 1
+	0,     // 2
+	0,     // 3
+	0,     // 4
+	0,     // 5
+	0,     // 6
+	0,     // 7
+	/*10032*/ uint16(xCondIs64), 10035, 10047,
+	/*10035*/ uint16(xCondDataSize), 10039, 10043, 0,
+	/*10039*/ uint16(xSetOp), uint16(POP),
+	/*10041*/ uint16(xArgRM16),
+	/*10042*/ uint16(xMatch),
+	/*10043*/ uint16(xSetOp), uint16(POP),
+	/*10045*/ uint16(xArgRM32),
+	/*10046*/ uint16(xMatch),
+	/*10047*/ uint16(xCondDataSize), 10039, 10051, 10055,
+	/*10051*/ uint16(xSetOp), uint16(POP),
+	/*10053*/ uint16(xArgRM64),
+	/*10054*/ uint16(xMatch),
+	/*10055*/ uint16(xSetOp), uint16(POP),
+	/*10057*/ uint16(xArgRM64),
+	/*10058*/ uint16(xMatch),
+	/*10059*/ uint16(xCondIs64), 10062, 10076,
+	/*10062*/ uint16(xCondDataSize), 10066, 10071, 0,
+	/*10066*/ uint16(xSetOp), uint16(XCHG),
+	/*10068*/ uint16(xArgR16op),
+	/*10069*/ uint16(xArgAX),
+	/*10070*/ uint16(xMatch),
+	/*10071*/ uint16(xSetOp), uint16(XCHG),
+	/*10073*/ uint16(xArgR32op),
+	/*10074*/ uint16(xArgEAX),
+	/*10075*/ uint16(xMatch),
+	/*10076*/ uint16(xCondDataSize), 10066, 10071, 10080,
+	/*10080*/ uint16(xSetOp), uint16(XCHG),
+	/*10082*/ uint16(xArgR64op),
+	/*10083*/ uint16(xArgRAX),
+	/*10084*/ uint16(xMatch),
+	/*10085*/ uint16(xCondIs64), 10088, 10098,
+	/*10088*/ uint16(xCondDataSize), 10092, 10095, 0,
+	/*10092*/ uint16(xSetOp), uint16(CBW),
+	/*10094*/ uint16(xMatch),
+	/*10095*/ uint16(xSetOp), uint16(CWDE),
+	/*10097*/ uint16(xMatch),
+	/*10098*/ uint16(xCondDataSize), 10092, 10095, 10102,
+	/*10102*/ uint16(xSetOp), uint16(CDQE),
+	/*10104*/ uint16(xMatch),
+	/*10105*/ uint16(xCondIs64), 10108, 10118,
+	/*10108*/ uint16(xCondDataSize), 10112, 10115, 0,
+	/*10112*/ uint16(xSetOp), uint16(CWD),
+	/*10114*/ uint16(xMatch),
+	/*10115*/ uint16(xSetOp), uint16(CDQ),
+	/*10117*/ uint16(xMatch),
+	/*10118*/ uint16(xCondDataSize), 10112, 10115, 10122,
+	/*10122*/ uint16(xSetOp), uint16(CQO),
+	/*10124*/ uint16(xMatch),
+	/*10125*/ uint16(xCondIs64), 10128, 0,
+	/*10128*/ uint16(xCondDataSize), 10132, 10137, 0,
+	/*10132*/ uint16(xSetOp), uint16(LCALL),
+	/*10134*/ uint16(xReadCd),
+	/*10135*/ uint16(xArgPtr16colon16),
+	/*10136*/ uint16(xMatch),
+	/*10137*/ uint16(xSetOp), uint16(LCALL),
+	/*10139*/ uint16(xReadCp),
+	/*10140*/ uint16(xArgPtr16colon32),
+	/*10141*/ uint16(xMatch),
+	/*10142*/ uint16(xSetOp), uint16(FWAIT),
+	/*10144*/ uint16(xMatch),
+	/*10145*/ uint16(xCondIs64), 10148, 10158,
+	/*10148*/ uint16(xCondDataSize), 10152, 10155, 0,
+	/*10152*/ uint16(xSetOp), uint16(PUSHF),
+	/*10154*/ uint16(xMatch),
+	/*10155*/ uint16(xSetOp), uint16(PUSHFD),
+	/*10157*/ uint16(xMatch),
+	/*10158*/ uint16(xCondDataSize), 10152, 10162, 10165,
+	/*10162*/ uint16(xSetOp), uint16(PUSHFQ),
+	/*10164*/ uint16(xMatch),
+	/*10165*/ uint16(xSetOp), uint16(PUSHFQ),
+	/*10167*/ uint16(xMatch),
+	/*10168*/ uint16(xCondIs64), 10171, 10181,
+	/*10171*/ uint16(xCondDataSize), 10175, 10178, 0,
+	/*10175*/ uint16(xSetOp), uint16(POPF),
+	/*10177*/ uint16(xMatch),
+	/*10178*/ uint16(xSetOp), uint16(POPFD),
+	/*10180*/ uint16(xMatch),
+	/*10181*/ uint16(xCondDataSize), 10175, 10185, 10188,
+	/*10185*/ uint16(xSetOp), uint16(POPFQ),
+	/*10187*/ uint16(xMatch),
+	/*10188*/ uint16(xSetOp), uint16(POPFQ),
+	/*10190*/ uint16(xMatch),
+	/*10191*/ uint16(xSetOp), uint16(SAHF),
+	/*10193*/ uint16(xMatch),
+	/*10194*/ uint16(xSetOp), uint16(LAHF),
+	/*10196*/ uint16(xMatch),
+	/*10197*/ uint16(xCondIs64), 10200, 10206,
+	/*10200*/ uint16(xSetOp), uint16(MOV),
+	/*10202*/ uint16(xReadCm),
+	/*10203*/ uint16(xArgAL),
+	/*10204*/ uint16(xArgMoffs8),
+	/*10205*/ uint16(xMatch),
+	/*10206*/ uint16(xCondDataSize), 10200, 10200, 10210,
+	/*10210*/ uint16(xSetOp), uint16(MOV),
+	/*10212*/ uint16(xReadCm),
+	/*10213*/ uint16(xArgAL),
+	/*10214*/ uint16(xArgMoffs8),
+	/*10215*/ uint16(xMatch),
+	/*10216*/ uint16(xCondDataSize), 10220, 10226, 10232,
+	/*10220*/ uint16(xSetOp), uint16(MOV),
+	/*10222*/ uint16(xReadCm),
+	/*10223*/ uint16(xArgAX),
+	/*10224*/ uint16(xArgMoffs16),
+	/*10225*/ uint16(xMatch),
+	/*10226*/ uint16(xSetOp), uint16(MOV),
+	/*10228*/ uint16(xReadCm),
+	/*10229*/ uint16(xArgEAX),
+	/*10230*/ uint16(xArgMoffs32),
+	/*10231*/ uint16(xMatch),
+	/*10232*/ uint16(xSetOp), uint16(MOV),
+	/*10234*/ uint16(xReadCm),
+	/*10235*/ uint16(xArgRAX),
+	/*10236*/ uint16(xArgMoffs64),
+	/*10237*/ uint16(xMatch),
+	/*10238*/ uint16(xCondIs64), 10241, 10247,
+	/*10241*/ uint16(xSetOp), uint16(MOV),
+	/*10243*/ uint16(xReadCm),
+	/*10244*/ uint16(xArgMoffs8),
+	/*10245*/ uint16(xArgAL),
+	/*10246*/ uint16(xMatch),
+	/*10247*/ uint16(xCondDataSize), 10241, 10241, 10251,
+	/*10251*/ uint16(xSetOp), uint16(MOV),
+	/*10253*/ uint16(xReadCm),
+	/*10254*/ uint16(xArgMoffs8),
+	/*10255*/ uint16(xArgAL),
+	/*10256*/ uint16(xMatch),
+	/*10257*/ uint16(xCondDataSize), 10261, 10267, 10273,
+	/*10261*/ uint16(xSetOp), uint16(MOV),
+	/*10263*/ uint16(xReadCm),
+	/*10264*/ uint16(xArgMoffs16),
+	/*10265*/ uint16(xArgAX),
+	/*10266*/ uint16(xMatch),
+	/*10267*/ uint16(xSetOp), uint16(MOV),
+	/*10269*/ uint16(xReadCm),
+	/*10270*/ uint16(xArgMoffs32),
+	/*10271*/ uint16(xArgEAX),
+	/*10272*/ uint16(xMatch),
+	/*10273*/ uint16(xSetOp), uint16(MOV),
+	/*10275*/ uint16(xReadCm),
+	/*10276*/ uint16(xArgMoffs64),
+	/*10277*/ uint16(xArgRAX),
+	/*10278*/ uint16(xMatch),
+	/*10279*/ uint16(xSetOp), uint16(MOVSB),
+	/*10281*/ uint16(xMatch),
+	/*10282*/ uint16(xCondIs64), 10285, 10295,
+	/*10285*/ uint16(xCondDataSize), 10289, 10292, 0,
+	/*10289*/ uint16(xSetOp), uint16(MOVSW),
+	/*10291*/ uint16(xMatch),
+	/*10292*/ uint16(xSetOp), uint16(MOVSD),
+	/*10294*/ uint16(xMatch),
+	/*10295*/ uint16(xCondDataSize), 10289, 10292, 10299,
+	/*10299*/ uint16(xSetOp), uint16(MOVSQ),
+	/*10301*/ uint16(xMatch),
+	/*10302*/ uint16(xSetOp), uint16(CMPSB),
+	/*10304*/ uint16(xMatch),
+	/*10305*/ uint16(xCondIs64), 10308, 10318,
+	/*10308*/ uint16(xCondDataSize), 10312, 10315, 0,
+	/*10312*/ uint16(xSetOp), uint16(CMPSW),
+	/*10314*/ uint16(xMatch),
+	/*10315*/ uint16(xSetOp), uint16(CMPSD),
+	/*10317*/ uint16(xMatch),
+	/*10318*/ uint16(xCondDataSize), 10312, 10315, 10322,
+	/*10322*/ uint16(xSetOp), uint16(CMPSQ),
+	/*10324*/ uint16(xMatch),
+	/*10325*/ uint16(xSetOp), uint16(TEST),
+	/*10327*/ uint16(xReadIb),
+	/*10328*/ uint16(xArgAL),
+	/*10329*/ uint16(xArgImm8u),
+	/*10330*/ uint16(xMatch),
+	/*10331*/ uint16(xCondIs64), 10334, 10350,
+	/*10334*/ uint16(xCondDataSize), 10338, 10344, 0,
+	/*10338*/ uint16(xSetOp), uint16(TEST),
+	/*10340*/ uint16(xReadIw),
+	/*10341*/ uint16(xArgAX),
+	/*10342*/ uint16(xArgImm16),
+	/*10343*/ uint16(xMatch),
+	/*10344*/ uint16(xSetOp), uint16(TEST),
+	/*10346*/ uint16(xReadId),
+	/*10347*/ uint16(xArgEAX),
+	/*10348*/ uint16(xArgImm32),
+	/*10349*/ uint16(xMatch),
+	/*10350*/ uint16(xCondDataSize), 10338, 10344, 10354,
+	/*10354*/ uint16(xSetOp), uint16(TEST),
+	/*10356*/ uint16(xReadId),
+	/*10357*/ uint16(xArgRAX),
+	/*10358*/ uint16(xArgImm32),
+	/*10359*/ uint16(xMatch),
+	/*10360*/ uint16(xSetOp), uint16(STOSB),
+	/*10362*/ uint16(xMatch),
+	/*10363*/ uint16(xCondIs64), 10366, 10376,
+	/*10366*/ uint16(xCondDataSize), 10370, 10373, 0,
+	/*10370*/ uint16(xSetOp), uint16(STOSW),
+	/*10372*/ uint16(xMatch),
+	/*10373*/ uint16(xSetOp), uint16(STOSD),
+	/*10375*/ uint16(xMatch),
+	/*10376*/ uint16(xCondDataSize), 10370, 10373, 10380,
+	/*10380*/ uint16(xSetOp), uint16(STOSQ),
+	/*10382*/ uint16(xMatch),
+	/*10383*/ uint16(xSetOp), uint16(LODSB),
+	/*10385*/ uint16(xMatch),
+	/*10386*/ uint16(xCondIs64), 10389, 10399,
+	/*10389*/ uint16(xCondDataSize), 10393, 10396, 0,
+	/*10393*/ uint16(xSetOp), uint16(LODSW),
+	/*10395*/ uint16(xMatch),
+	/*10396*/ uint16(xSetOp), uint16(LODSD),
+	/*10398*/ uint16(xMatch),
+	/*10399*/ uint16(xCondDataSize), 10393, 10396, 10403,
+	/*10403*/ uint16(xSetOp), uint16(LODSQ),
+	/*10405*/ uint16(xMatch),
+	/*10406*/ uint16(xSetOp), uint16(SCASB),
+	/*10408*/ uint16(xMatch),
+	/*10409*/ uint16(xCondIs64), 10412, 10422,
+	/*10412*/ uint16(xCondDataSize), 10416, 10419, 0,
+	/*10416*/ uint16(xSetOp), uint16(SCASW),
+	/*10418*/ uint16(xMatch),
+	/*10419*/ uint16(xSetOp), uint16(SCASD),
+	/*10421*/ uint16(xMatch),
+	/*10422*/ uint16(xCondDataSize), 10416, 10419, 10426,
+	/*10426*/ uint16(xSetOp), uint16(SCASQ),
+	/*10428*/ uint16(xMatch),
+	/*10429*/ uint16(xSetOp), uint16(MOV),
+	/*10431*/ uint16(xReadIb),
+	/*10432*/ uint16(xArgR8op),
+	/*10433*/ uint16(xArgImm8u),
+	/*10434*/ uint16(xMatch),
+	/*10435*/ uint16(xCondIs64), 10438, 10454,
+	/*10438*/ uint16(xCondDataSize), 10442, 10448, 0,
+	/*10442*/ uint16(xSetOp), uint16(MOV),
+	/*10444*/ uint16(xReadIw),
+	/*10445*/ uint16(xArgR16op),
+	/*10446*/ uint16(xArgImm16),
+	/*10447*/ uint16(xMatch),
+	/*10448*/ uint16(xSetOp), uint16(MOV),
+	/*10450*/ uint16(xReadId),
+	/*10451*/ uint16(xArgR32op),
+	/*10452*/ uint16(xArgImm32),
+	/*10453*/ uint16(xMatch),
+	/*10454*/ uint16(xCondDataSize), 10442, 10448, 10458,
+	/*10458*/ uint16(xSetOp), uint16(MOV),
+	/*10460*/ uint16(xReadIo),
+	/*10461*/ uint16(xArgR64op),
+	/*10462*/ uint16(xArgImm64),
+	/*10463*/ uint16(xMatch),
+	/*10464*/ uint16(xCondSlashR),
+	10473, // 0
+	10479, // 1
+	10485, // 2
+	10491, // 3
+	10497, // 4
+	10503, // 5
+	0,     // 6
+	10509, // 7
+	/*10473*/ uint16(xSetOp), uint16(ROL),
+	/*10475*/ uint16(xReadIb),
+	/*10476*/ uint16(xArgRM8),
+	/*10477*/ uint16(xArgImm8u),
+	/*10478*/ uint16(xMatch),
+	/*10479*/ uint16(xSetOp), uint16(ROR),
+	/*10481*/ uint16(xReadIb),
+	/*10482*/ uint16(xArgRM8),
+	/*10483*/ uint16(xArgImm8u),
+	/*10484*/ uint16(xMatch),
+	/*10485*/ uint16(xSetOp), uint16(RCL),
+	/*10487*/ uint16(xReadIb),
+	/*10488*/ uint16(xArgRM8),
+	/*10489*/ uint16(xArgImm8u),
+	/*10490*/ uint16(xMatch),
+	/*10491*/ uint16(xSetOp), uint16(RCR),
+	/*10493*/ uint16(xReadIb),
+	/*10494*/ uint16(xArgRM8),
+	/*10495*/ uint16(xArgImm8u),
+	/*10496*/ uint16(xMatch),
+	/*10497*/ uint16(xSetOp), uint16(SHL),
+	/*10499*/ uint16(xReadIb),
+	/*10500*/ uint16(xArgRM8),
+	/*10501*/ uint16(xArgImm8u),
+	/*10502*/ uint16(xMatch),
+	/*10503*/ uint16(xSetOp), uint16(SHR),
+	/*10505*/ uint16(xReadIb),
+	/*10506*/ uint16(xArgRM8),
+	/*10507*/ uint16(xArgImm8u),
+	/*10508*/ uint16(xMatch),
+	/*10509*/ uint16(xSetOp), uint16(SAR),
+	/*10511*/ uint16(xReadIb),
+	/*10512*/ uint16(xArgRM8),
+	/*10513*/ uint16(xArgImm8u),
+	/*10514*/ uint16(xMatch),
+	/*10515*/ uint16(xCondSlashR),
+	10524, // 0
+	10546, // 1
+	10568, // 2
+	10597, // 3
+	10626, // 4
+	10655, // 5
+	0,     // 6
+	10684, // 7
+	/*10524*/ uint16(xCondDataSize), 10528, 10534, 10540,
+	/*10528*/ uint16(xSetOp), uint16(ROL),
+	/*10530*/ uint16(xReadIb),
+	/*10531*/ uint16(xArgRM16),
+	/*10532*/ uint16(xArgImm8u),
+	/*10533*/ uint16(xMatch),
+	/*10534*/ uint16(xSetOp), uint16(ROL),
+	/*10536*/ uint16(xReadIb),
+	/*10537*/ uint16(xArgRM32),
+	/*10538*/ uint16(xArgImm8u),
+	/*10539*/ uint16(xMatch),
+	/*10540*/ uint16(xSetOp), uint16(ROL),
+	/*10542*/ uint16(xReadIb),
+	/*10543*/ uint16(xArgRM64),
+	/*10544*/ uint16(xArgImm8u),
+	/*10545*/ uint16(xMatch),
+	/*10546*/ uint16(xCondDataSize), 10550, 10556, 10562,
+	/*10550*/ uint16(xSetOp), uint16(ROR),
+	/*10552*/ uint16(xReadIb),
+	/*10553*/ uint16(xArgRM16),
+	/*10554*/ uint16(xArgImm8u),
+	/*10555*/ uint16(xMatch),
+	/*10556*/ uint16(xSetOp), uint16(ROR),
+	/*10558*/ uint16(xReadIb),
+	/*10559*/ uint16(xArgRM32),
+	/*10560*/ uint16(xArgImm8u),
+	/*10561*/ uint16(xMatch),
+	/*10562*/ uint16(xSetOp), uint16(ROR),
+	/*10564*/ uint16(xReadIb),
+	/*10565*/ uint16(xArgRM64),
+	/*10566*/ uint16(xArgImm8u),
+	/*10567*/ uint16(xMatch),
+	/*10568*/ uint16(xCondIs64), 10571, 10587,
+	/*10571*/ uint16(xCondDataSize), 10575, 10581, 0,
+	/*10575*/ uint16(xSetOp), uint16(RCL),
+	/*10577*/ uint16(xReadIb),
+	/*10578*/ uint16(xArgRM16),
+	/*10579*/ uint16(xArgImm8u),
+	/*10580*/ uint16(xMatch),
+	/*10581*/ uint16(xSetOp), uint16(RCL),
+	/*10583*/ uint16(xReadIb),
+	/*10584*/ uint16(xArgRM32),
+	/*10585*/ uint16(xArgImm8u),
+	/*10586*/ uint16(xMatch),
+	/*10587*/ uint16(xCondDataSize), 10575, 10581, 10591,
+	/*10591*/ uint16(xSetOp), uint16(RCL),
+	/*10593*/ uint16(xReadIb),
+	/*10594*/ uint16(xArgRM64),
+	/*10595*/ uint16(xArgImm8u),
+	/*10596*/ uint16(xMatch),
+	/*10597*/ uint16(xCondIs64), 10600, 10616,
+	/*10600*/ uint16(xCondDataSize), 10604, 10610, 0,
+	/*10604*/ uint16(xSetOp), uint16(RCR),
+	/*10606*/ uint16(xReadIb),
+	/*10607*/ uint16(xArgRM16),
+	/*10608*/ uint16(xArgImm8u),
+	/*10609*/ uint16(xMatch),
+	/*10610*/ uint16(xSetOp), uint16(RCR),
+	/*10612*/ uint16(xReadIb),
+	/*10613*/ uint16(xArgRM32),
+	/*10614*/ uint16(xArgImm8u),
+	/*10615*/ uint16(xMatch),
+	/*10616*/ uint16(xCondDataSize), 10604, 10610, 10620,
+	/*10620*/ uint16(xSetOp), uint16(RCR),
+	/*10622*/ uint16(xReadIb),
+	/*10623*/ uint16(xArgRM64),
+	/*10624*/ uint16(xArgImm8u),
+	/*10625*/ uint16(xMatch),
+	/*10626*/ uint16(xCondIs64), 10629, 10645,
+	/*10629*/ uint16(xCondDataSize), 10633, 10639, 0,
+	/*10633*/ uint16(xSetOp), uint16(SHL),
+	/*10635*/ uint16(xReadIb),
+	/*10636*/ uint16(xArgRM16),
+	/*10637*/ uint16(xArgImm8u),
+	/*10638*/ uint16(xMatch),
+	/*10639*/ uint16(xSetOp), uint16(SHL),
+	/*10641*/ uint16(xReadIb),
+	/*10642*/ uint16(xArgRM32),
+	/*10643*/ uint16(xArgImm8u),
+	/*10644*/ uint16(xMatch),
+	/*10645*/ uint16(xCondDataSize), 10633, 10639, 10649,
+	/*10649*/ uint16(xSetOp), uint16(SHL),
+	/*10651*/ uint16(xReadIb),
+	/*10652*/ uint16(xArgRM64),
+	/*10653*/ uint16(xArgImm8u),
+	/*10654*/ uint16(xMatch),
+	/*10655*/ uint16(xCondIs64), 10658, 10674,
+	/*10658*/ uint16(xCondDataSize), 10662, 10668, 0,
+	/*10662*/ uint16(xSetOp), uint16(SHR),
+	/*10664*/ uint16(xReadIb),
+	/*10665*/ uint16(xArgRM16),
+	/*10666*/ uint16(xArgImm8u),
+	/*10667*/ uint16(xMatch),
+	/*10668*/ uint16(xSetOp), uint16(SHR),
+	/*10670*/ uint16(xReadIb),
+	/*10671*/ uint16(xArgRM32),
+	/*10672*/ uint16(xArgImm8u),
+	/*10673*/ uint16(xMatch),
+	/*10674*/ uint16(xCondDataSize), 10662, 10668, 10678,
+	/*10678*/ uint16(xSetOp), uint16(SHR),
+	/*10680*/ uint16(xReadIb),
+	/*10681*/ uint16(xArgRM64),
+	/*10682*/ uint16(xArgImm8u),
+	/*10683*/ uint16(xMatch),
+	/*10684*/ uint16(xCondIs64), 10687, 10703,
+	/*10687*/ uint16(xCondDataSize), 10691, 10697, 0,
+	/*10691*/ uint16(xSetOp), uint16(SAR),
+	/*10693*/ uint16(xReadIb),
+	/*10694*/ uint16(xArgRM16),
+	/*10695*/ uint16(xArgImm8u),
+	/*10696*/ uint16(xMatch),
+	/*10697*/ uint16(xSetOp), uint16(SAR),
+	/*10699*/ uint16(xReadIb),
+	/*10700*/ uint16(xArgRM32),
+	/*10701*/ uint16(xArgImm8u),
+	/*10702*/ uint16(xMatch),
+	/*10703*/ uint16(xCondDataSize), 10691, 10697, 10707,
+	/*10707*/ uint16(xSetOp), uint16(SAR),
+	/*10709*/ uint16(xReadIb),
+	/*10710*/ uint16(xArgRM64),
+	/*10711*/ uint16(xArgImm8u),
+	/*10712*/ uint16(xMatch),
+	/*10713*/ uint16(xSetOp), uint16(RET),
+	/*10715*/ uint16(xReadIw),
+	/*10716*/ uint16(xArgImm16u),
+	/*10717*/ uint16(xMatch),
+	/*10718*/ uint16(xSetOp), uint16(RET),
+	/*10720*/ uint16(xMatch),
+	/*10721*/ uint16(xCondIs64), 10724, 0,
+	/*10724*/ uint16(xCondDataSize), 10728, 10734, 0,
+	/*10728*/ uint16(xSetOp), uint16(LES),
+	/*10730*/ uint16(xReadSlashR),
+	/*10731*/ uint16(xArgR16),
+	/*10732*/ uint16(xArgM16colon16),
+	/*10733*/ uint16(xMatch),
+	/*10734*/ uint16(xSetOp), uint16(LES),
+	/*10736*/ uint16(xReadSlashR),
+	/*10737*/ uint16(xArgR32),
+	/*10738*/ uint16(xArgM16colon32),
+	/*10739*/ uint16(xMatch),
+	/*10740*/ uint16(xCondIs64), 10743, 0,
+	/*10743*/ uint16(xCondDataSize), 10747, 10753, 0,
+	/*10747*/ uint16(xSetOp), uint16(LDS),
+	/*10749*/ uint16(xReadSlashR),
+	/*10750*/ uint16(xArgR16),
+	/*10751*/ uint16(xArgM16colon16),
+	/*10752*/ uint16(xMatch),
+	/*10753*/ uint16(xSetOp), uint16(LDS),
+	/*10755*/ uint16(xReadSlashR),
+	/*10756*/ uint16(xArgR32),
+	/*10757*/ uint16(xArgM16colon32),
+	/*10758*/ uint16(xMatch),
+	/*10759*/ uint16(xCondByte), 1,
+	0xF8, 10778,
+	/*10763*/ uint16(xCondSlashR),
+	10772, // 0
+	0,     // 1
+	0,     // 2
+	0,     // 3
+	0,     // 4
+	0,     // 5
+	0,     // 6
+	0,     // 7
+	/*10772*/ uint16(xSetOp), uint16(MOV),
+	/*10774*/ uint16(xReadIb),
+	/*10775*/ uint16(xArgRM8),
+	/*10776*/ uint16(xArgImm8u),
+	/*10777*/ uint16(xMatch),
+	/*10778*/ uint16(xSetOp), uint16(XABORT),
+	/*10780*/ uint16(xReadIb),
+	/*10781*/ uint16(xArgImm8u),
+	/*10782*/ uint16(xMatch),
+	/*10783*/ uint16(xCondByte), 1,
+	0xF8, 10825,
+	/*10787*/ uint16(xCondSlashR),
+	10796, // 0
+	0,     // 1
+	0,     // 2
+	0,     // 3
+	0,     // 4
+	0,     // 5
+	0,     // 6
+	0,     // 7
+	/*10796*/ uint16(xCondIs64), 10799, 10815,
+	/*10799*/ uint16(xCondDataSize), 10803, 10809, 0,
+	/*10803*/ uint16(xSetOp), uint16(MOV),
+	/*10805*/ uint16(xReadIw),
+	/*10806*/ uint16(xArgRM16),
+	/*10807*/ uint16(xArgImm16),
+	/*10808*/ uint16(xMatch),
+	/*10809*/ uint16(xSetOp), uint16(MOV),
+	/*10811*/ uint16(xReadId),
+	/*10812*/ uint16(xArgRM32),
+	/*10813*/ uint16(xArgImm32),
+	/*10814*/ uint16(xMatch),
+	/*10815*/ uint16(xCondDataSize), 10803, 10809, 10819,
+	/*10819*/ uint16(xSetOp), uint16(MOV),
+	/*10821*/ uint16(xReadId),
+	/*10822*/ uint16(xArgRM64),
+	/*10823*/ uint16(xArgImm32),
+	/*10824*/ uint16(xMatch),
+	/*10825*/ uint16(xCondDataSize), 10829, 10834, 10839,
+	/*10829*/ uint16(xSetOp), uint16(XBEGIN),
+	/*10831*/ uint16(xReadCw),
+	/*10832*/ uint16(xArgRel16),
+	/*10833*/ uint16(xMatch),
+	/*10834*/ uint16(xSetOp), uint16(XBEGIN),
+	/*10836*/ uint16(xReadCd),
+	/*10837*/ uint16(xArgRel32),
+	/*10838*/ uint16(xMatch),
+	/*10839*/ uint16(xSetOp), uint16(XBEGIN),
+	/*10841*/ uint16(xReadCd),
+	/*10842*/ uint16(xArgRel32),
+	/*10843*/ uint16(xMatch),
+	/*10844*/ uint16(xSetOp), uint16(ENTER),
+	/*10846*/ uint16(xReadIw),
+	/*10847*/ uint16(xReadIb),
+	/*10848*/ uint16(xArgImm16u),
+	/*10849*/ uint16(xArgImm8u),
+	/*10850*/ uint16(xMatch),
+	/*10851*/ uint16(xCondIs64), 10854, 10864,
+	/*10854*/ uint16(xCondDataSize), 10858, 10861, 0,
+	/*10858*/ uint16(xSetOp), uint16(LEAVE),
+	/*10860*/ uint16(xMatch),
+	/*10861*/ uint16(xSetOp), uint16(LEAVE),
+	/*10863*/ uint16(xMatch),
+	/*10864*/ uint16(xCondDataSize), 10858, 10868, 10871,
+	/*10868*/ uint16(xSetOp), uint16(LEAVE),
+	/*10870*/ uint16(xMatch),
+	/*10871*/ uint16(xSetOp), uint16(LEAVE),
+	/*10873*/ uint16(xMatch),
+	/*10874*/ uint16(xSetOp), uint16(LRET),
+	/*10876*/ uint16(xReadIw),
+	/*10877*/ uint16(xArgImm16u),
+	/*10878*/ uint16(xMatch),
+	/*10879*/ uint16(xSetOp), uint16(LRET),
+	/*10881*/ uint16(xMatch),
+	/*10882*/ uint16(xSetOp), uint16(INT),
+	/*10884*/ uint16(xArg3),
+	/*10885*/ uint16(xMatch),
+	/*10886*/ uint16(xSetOp), uint16(INT),
+	/*10888*/ uint16(xReadIb),
+	/*10889*/ uint16(xArgImm8u),
+	/*10890*/ uint16(xMatch),
+	/*10891*/ uint16(xCondIs64), 10894, 0,
+	/*10894*/ uint16(xSetOp), uint16(INTO),
+	/*10896*/ uint16(xMatch),
+	/*10897*/ uint16(xCondIs64), 10900, 10910,
+	/*10900*/ uint16(xCondDataSize), 10904, 10907, 0,
+	/*10904*/ uint16(xSetOp), uint16(IRET),
+	/*10906*/ uint16(xMatch),
+	/*10907*/ uint16(xSetOp), uint16(IRETD),
+	/*10909*/ uint16(xMatch),
+	/*10910*/ uint16(xCondDataSize), 10904, 10907, 10914,
+	/*10914*/ uint16(xSetOp), uint16(IRETQ),
+	/*10916*/ uint16(xMatch),
+	/*10917*/ uint16(xCondSlashR),
+	10926, // 0
+	10931, // 1
+	10936, // 2
+	10941, // 3
+	10946, // 4
+	10951, // 5
+	0,     // 6
+	10956, // 7
+	/*10926*/ uint16(xSetOp), uint16(ROL),
+	/*10928*/ uint16(xArgRM8),
+	/*10929*/ uint16(xArg1),
+	/*10930*/ uint16(xMatch),
+	/*10931*/ uint16(xSetOp), uint16(ROR),
+	/*10933*/ uint16(xArgRM8),
+	/*10934*/ uint16(xArg1),
+	/*10935*/ uint16(xMatch),
+	/*10936*/ uint16(xSetOp), uint16(RCL),
+	/*10938*/ uint16(xArgRM8),
+	/*10939*/ uint16(xArg1),
+	/*10940*/ uint16(xMatch),
+	/*10941*/ uint16(xSetOp), uint16(RCR),
+	/*10943*/ uint16(xArgRM8),
+	/*10944*/ uint16(xArg1),
+	/*10945*/ uint16(xMatch),
+	/*10946*/ uint16(xSetOp), uint16(SHL),
+	/*10948*/ uint16(xArgRM8),
+	/*10949*/ uint16(xArg1),
+	/*10950*/ uint16(xMatch),
+	/*10951*/ uint16(xSetOp), uint16(SHR),
+	/*10953*/ uint16(xArgRM8),
+	/*10954*/ uint16(xArg1),
+	/*10955*/ uint16(xMatch),
+	/*10956*/ uint16(xSetOp), uint16(SAR),
+	/*10958*/ uint16(xArgRM8),
+	/*10959*/ uint16(xArg1),
+	/*10960*/ uint16(xMatch),
+	/*10961*/ uint16(xCondSlashR),
+	10970, // 0
+	10996, // 1
+	11022, // 2
+	11048, // 3
+	11074, // 4
+	11100, // 5
+	0,     // 6
+	11126, // 7
+	/*10970*/ uint16(xCondIs64), 10973, 10987,
+	/*10973*/ uint16(xCondDataSize), 10977, 10982, 0,
+	/*10977*/ uint16(xSetOp), uint16(ROL),
+	/*10979*/ uint16(xArgRM16),
+	/*10980*/ uint16(xArg1),
+	/*10981*/ uint16(xMatch),
+	/*10982*/ uint16(xSetOp), uint16(ROL),
+	/*10984*/ uint16(xArgRM32),
+	/*10985*/ uint16(xArg1),
+	/*10986*/ uint16(xMatch),
+	/*10987*/ uint16(xCondDataSize), 10977, 10982, 10991,
+	/*10991*/ uint16(xSetOp), uint16(ROL),
+	/*10993*/ uint16(xArgRM64),
+	/*10994*/ uint16(xArg1),
+	/*10995*/ uint16(xMatch),
+	/*10996*/ uint16(xCondIs64), 10999, 11013,
+	/*10999*/ uint16(xCondDataSize), 11003, 11008, 0,
+	/*11003*/ uint16(xSetOp), uint16(ROR),
+	/*11005*/ uint16(xArgRM16),
+	/*11006*/ uint16(xArg1),
+	/*11007*/ uint16(xMatch),
+	/*11008*/ uint16(xSetOp), uint16(ROR),
+	/*11010*/ uint16(xArgRM32),
+	/*11011*/ uint16(xArg1),
+	/*11012*/ uint16(xMatch),
+	/*11013*/ uint16(xCondDataSize), 11003, 11008, 11017,
+	/*11017*/ uint16(xSetOp), uint16(ROR),
+	/*11019*/ uint16(xArgRM64),
+	/*11020*/ uint16(xArg1),
+	/*11021*/ uint16(xMatch),
+	/*11022*/ uint16(xCondIs64), 11025, 11039,
+	/*11025*/ uint16(xCondDataSize), 11029, 11034, 0,
+	/*11029*/ uint16(xSetOp), uint16(RCL),
+	/*11031*/ uint16(xArgRM16),
+	/*11032*/ uint16(xArg1),
+	/*11033*/ uint16(xMatch),
+	/*11034*/ uint16(xSetOp), uint16(RCL),
+	/*11036*/ uint16(xArgRM32),
+	/*11037*/ uint16(xArg1),
+	/*11038*/ uint16(xMatch),
+	/*11039*/ uint16(xCondDataSize), 11029, 11034, 11043,
+	/*11043*/ uint16(xSetOp), uint16(RCL),
+	/*11045*/ uint16(xArgRM64),
+	/*11046*/ uint16(xArg1),
+	/*11047*/ uint16(xMatch),
+	/*11048*/ uint16(xCondIs64), 11051, 11065,
+	/*11051*/ uint16(xCondDataSize), 11055, 11060, 0,
+	/*11055*/ uint16(xSetOp), uint16(RCR),
+	/*11057*/ uint16(xArgRM16),
+	/*11058*/ uint16(xArg1),
+	/*11059*/ uint16(xMatch),
+	/*11060*/ uint16(xSetOp), uint16(RCR),
+	/*11062*/ uint16(xArgRM32),
+	/*11063*/ uint16(xArg1),
+	/*11064*/ uint16(xMatch),
+	/*11065*/ uint16(xCondDataSize), 11055, 11060, 11069,
+	/*11069*/ uint16(xSetOp), uint16(RCR),
+	/*11071*/ uint16(xArgRM64),
+	/*11072*/ uint16(xArg1),
+	/*11073*/ uint16(xMatch),
+	/*11074*/ uint16(xCondIs64), 11077, 11091,
+	/*11077*/ uint16(xCondDataSize), 11081, 11086, 0,
+	/*11081*/ uint16(xSetOp), uint16(SHL),
+	/*11083*/ uint16(xArgRM16),
+	/*11084*/ uint16(xArg1),
+	/*11085*/ uint16(xMatch),
+	/*11086*/ uint16(xSetOp), uint16(SHL),
+	/*11088*/ uint16(xArgRM32),
+	/*11089*/ uint16(xArg1),
+	/*11090*/ uint16(xMatch),
+	/*11091*/ uint16(xCondDataSize), 11081, 11086, 11095,
+	/*11095*/ uint16(xSetOp), uint16(SHL),
+	/*11097*/ uint16(xArgRM64),
+	/*11098*/ uint16(xArg1),
+	/*11099*/ uint16(xMatch),
+	/*11100*/ uint16(xCondIs64), 11103, 11117,
+	/*11103*/ uint16(xCondDataSize), 11107, 11112, 0,
+	/*11107*/ uint16(xSetOp), uint16(SHR),
+	/*11109*/ uint16(xArgRM16),
+	/*11110*/ uint16(xArg1),
+	/*11111*/ uint16(xMatch),
+	/*11112*/ uint16(xSetOp), uint16(SHR),
+	/*11114*/ uint16(xArgRM32),
+	/*11115*/ uint16(xArg1),
+	/*11116*/ uint16(xMatch),
+	/*11117*/ uint16(xCondDataSize), 11107, 11112, 11121,
+	/*11121*/ uint16(xSetOp), uint16(SHR),
+	/*11123*/ uint16(xArgRM64),
+	/*11124*/ uint16(xArg1),
+	/*11125*/ uint16(xMatch),
+	/*11126*/ uint16(xCondIs64), 11129, 11143,
+	/*11129*/ uint16(xCondDataSize), 11133, 11138, 0,
+	/*11133*/ uint16(xSetOp), uint16(SAR),
+	/*11135*/ uint16(xArgRM16),
+	/*11136*/ uint16(xArg1),
+	/*11137*/ uint16(xMatch),
+	/*11138*/ uint16(xSetOp), uint16(SAR),
+	/*11140*/ uint16(xArgRM32),
+	/*11141*/ uint16(xArg1),
+	/*11142*/ uint16(xMatch),
+	/*11143*/ uint16(xCondDataSize), 11133, 11138, 11147,
+	/*11147*/ uint16(xSetOp), uint16(SAR),
+	/*11149*/ uint16(xArgRM64),
+	/*11150*/ uint16(xArg1),
+	/*11151*/ uint16(xMatch),
+	/*11152*/ uint16(xCondSlashR),
+	11161, // 0
+	11166, // 1
+	11171, // 2
+	11176, // 3
+	11181, // 4
+	11186, // 5
+	0,     // 6
+	11191, // 7
+	/*11161*/ uint16(xSetOp), uint16(ROL),
+	/*11163*/ uint16(xArgRM8),
+	/*11164*/ uint16(xArgCL),
+	/*11165*/ uint16(xMatch),
+	/*11166*/ uint16(xSetOp), uint16(ROR),
+	/*11168*/ uint16(xArgRM8),
+	/*11169*/ uint16(xArgCL),
+	/*11170*/ uint16(xMatch),
+	/*11171*/ uint16(xSetOp), uint16(RCL),
+	/*11173*/ uint16(xArgRM8),
+	/*11174*/ uint16(xArgCL),
+	/*11175*/ uint16(xMatch),
+	/*11176*/ uint16(xSetOp), uint16(RCR),
+	/*11178*/ uint16(xArgRM8),
+	/*11179*/ uint16(xArgCL),
+	/*11180*/ uint16(xMatch),
+	/*11181*/ uint16(xSetOp), uint16(SHL),
+	/*11183*/ uint16(xArgRM8),
+	/*11184*/ uint16(xArgCL),
+	/*11185*/ uint16(xMatch),
+	/*11186*/ uint16(xSetOp), uint16(SHR),
+	/*11188*/ uint16(xArgRM8),
+	/*11189*/ uint16(xArgCL),
+	/*11190*/ uint16(xMatch),
+	/*11191*/ uint16(xSetOp), uint16(SAR),
+	/*11193*/ uint16(xArgRM8),
+	/*11194*/ uint16(xArgCL),
+	/*11195*/ uint16(xMatch),
+	/*11196*/ uint16(xCondSlashR),
+	11205, // 0
+	11231, // 1
+	11257, // 2
+	11283, // 3
+	11309, // 4
+	11335, // 5
+	0,     // 6
+	11361, // 7
+	/*11205*/ uint16(xCondIs64), 11208, 11222,
+	/*11208*/ uint16(xCondDataSize), 11212, 11217, 0,
+	/*11212*/ uint16(xSetOp), uint16(ROL),
+	/*11214*/ uint16(xArgRM16),
+	/*11215*/ uint16(xArgCL),
+	/*11216*/ uint16(xMatch),
+	/*11217*/ uint16(xSetOp), uint16(ROL),
+	/*11219*/ uint16(xArgRM32),
+	/*11220*/ uint16(xArgCL),
+	/*11221*/ uint16(xMatch),
+	/*11222*/ uint16(xCondDataSize), 11212, 11217, 11226,
+	/*11226*/ uint16(xSetOp), uint16(ROL),
+	/*11228*/ uint16(xArgRM64),
+	/*11229*/ uint16(xArgCL),
+	/*11230*/ uint16(xMatch),
+	/*11231*/ uint16(xCondIs64), 11234, 11248,
+	/*11234*/ uint16(xCondDataSize), 11238, 11243, 0,
+	/*11238*/ uint16(xSetOp), uint16(ROR),
+	/*11240*/ uint16(xArgRM16),
+	/*11241*/ uint16(xArgCL),
+	/*11242*/ uint16(xMatch),
+	/*11243*/ uint16(xSetOp), uint16(ROR),
+	/*11245*/ uint16(xArgRM32),
+	/*11246*/ uint16(xArgCL),
+	/*11247*/ uint16(xMatch),
+	/*11248*/ uint16(xCondDataSize), 11238, 11243, 11252,
+	/*11252*/ uint16(xSetOp), uint16(ROR),
+	/*11254*/ uint16(xArgRM64),
+	/*11255*/ uint16(xArgCL),
+	/*11256*/ uint16(xMatch),
+	/*11257*/ uint16(xCondIs64), 11260, 11274,
+	/*11260*/ uint16(xCondDataSize), 11264, 11269, 0,
+	/*11264*/ uint16(xSetOp), uint16(RCL),
+	/*11266*/ uint16(xArgRM16),
+	/*11267*/ uint16(xArgCL),
+	/*11268*/ uint16(xMatch),
+	/*11269*/ uint16(xSetOp), uint16(RCL),
+	/*11271*/ uint16(xArgRM32),
+	/*11272*/ uint16(xArgCL),
+	/*11273*/ uint16(xMatch),
+	/*11274*/ uint16(xCondDataSize), 11264, 11269, 11278,
+	/*11278*/ uint16(xSetOp), uint16(RCL),
+	/*11280*/ uint16(xArgRM64),
+	/*11281*/ uint16(xArgCL),
+	/*11282*/ uint16(xMatch),
+	/*11283*/ uint16(xCondIs64), 11286, 11300,
+	/*11286*/ uint16(xCondDataSize), 11290, 11295, 0,
+	/*11290*/ uint16(xSetOp), uint16(RCR),
+	/*11292*/ uint16(xArgRM16),
+	/*11293*/ uint16(xArgCL),
+	/*11294*/ uint16(xMatch),
+	/*11295*/ uint16(xSetOp), uint16(RCR),
+	/*11297*/ uint16(xArgRM32),
+	/*11298*/ uint16(xArgCL),
+	/*11299*/ uint16(xMatch),
+	/*11300*/ uint16(xCondDataSize), 11290, 11295, 11304,
+	/*11304*/ uint16(xSetOp), uint16(RCR),
+	/*11306*/ uint16(xArgRM64),
+	/*11307*/ uint16(xArgCL),
+	/*11308*/ uint16(xMatch),
+	/*11309*/ uint16(xCondIs64), 11312, 11326,
+	/*11312*/ uint16(xCondDataSize), 11316, 11321, 0,
+	/*11316*/ uint16(xSetOp), uint16(SHL),
+	/*11318*/ uint16(xArgRM16),
+	/*11319*/ uint16(xArgCL),
+	/*11320*/ uint16(xMatch),
+	/*11321*/ uint16(xSetOp), uint16(SHL),
+	/*11323*/ uint16(xArgRM32),
+	/*11324*/ uint16(xArgCL),
+	/*11325*/ uint16(xMatch),
+	/*11326*/ uint16(xCondDataSize), 11316, 11321, 11330,
+	/*11330*/ uint16(xSetOp), uint16(SHL),
+	/*11332*/ uint16(xArgRM64),
+	/*11333*/ uint16(xArgCL),
+	/*11334*/ uint16(xMatch),
+	/*11335*/ uint16(xCondIs64), 11338, 11352,
+	/*11338*/ uint16(xCondDataSize), 11342, 11347, 0,
+	/*11342*/ uint16(xSetOp), uint16(SHR),
+	/*11344*/ uint16(xArgRM16),
+	/*11345*/ uint16(xArgCL),
+	/*11346*/ uint16(xMatch),
+	/*11347*/ uint16(xSetOp), uint16(SHR),
+	/*11349*/ uint16(xArgRM32),
+	/*11350*/ uint16(xArgCL),
+	/*11351*/ uint16(xMatch),
+	/*11352*/ uint16(xCondDataSize), 11342, 11347, 11356,
+	/*11356*/ uint16(xSetOp), uint16(SHR),
+	/*11358*/ uint16(xArgRM64),
+	/*11359*/ uint16(xArgCL),
+	/*11360*/ uint16(xMatch),
+	/*11361*/ uint16(xCondIs64), 11364, 11378,
+	/*11364*/ uint16(xCondDataSize), 11368, 11373, 0,
+	/*11368*/ uint16(xSetOp), uint16(SAR),
+	/*11370*/ uint16(xArgRM16),
+	/*11371*/ uint16(xArgCL),
+	/*11372*/ uint16(xMatch),
+	/*11373*/ uint16(xSetOp), uint16(SAR),
+	/*11375*/ uint16(xArgRM32),
+	/*11376*/ uint16(xArgCL),
+	/*11377*/ uint16(xMatch),
+	/*11378*/ uint16(xCondDataSize), 11368, 11373, 11382,
+	/*11382*/ uint16(xSetOp), uint16(SAR),
+	/*11384*/ uint16(xArgRM64),
+	/*11385*/ uint16(xArgCL),
+	/*11386*/ uint16(xMatch),
+	/*11387*/ uint16(xCondIs64), 11390, 0,
+	/*11390*/ uint16(xSetOp), uint16(AAM),
+	/*11392*/ uint16(xReadIb),
+	/*11393*/ uint16(xArgImm8u),
+	/*11394*/ uint16(xMatch),
+	/*11395*/ uint16(xCondIs64), 11398, 0,
+	/*11398*/ uint16(xSetOp), uint16(AAD),
+	/*11400*/ uint16(xReadIb),
+	/*11401*/ uint16(xArgImm8u),
+	/*11402*/ uint16(xMatch),
+	/*11403*/ uint16(xCondIs64), 11406, 11409,
+	/*11406*/ uint16(xSetOp), uint16(XLATB),
+	/*11408*/ uint16(xMatch),
+	/*11409*/ uint16(xCondDataSize), 11406, 11406, 11413,
+	/*11413*/ uint16(xSetOp), uint16(XLATB),
+	/*11415*/ uint16(xMatch),
+	/*11416*/ uint16(xCondByte), 64,
+	0xc0, 11587,
+	0xc1, 11587,
+	0xc2, 11587,
+	0xc3, 11587,
+	0xc4, 11587,
+	0xc5, 11587,
+	0xc6, 11587,
+	0xc7, 11587,
+	0xc8, 11592,
+	0xc9, 11592,
+	0xca, 11592,
+	0xcb, 11592,
+	0xcc, 11592,
+	0xcd, 11592,
+	0xce, 11592,
+	0xcf, 11592,
+	0xd0, 11597,
+	0xd1, 11597,
+	0xd2, 11597,
+	0xd3, 11597,
+	0xd4, 11597,
+	0xd5, 11597,
+	0xd6, 11597,
+	0xd7, 11597,
+	0xd8, 11601,
+	0xd9, 11601,
+	0xda, 11601,
+	0xdb, 11601,
+	0xdc, 11601,
+	0xdd, 11601,
+	0xde, 11601,
+	0xdf, 11601,
+	0xe0, 11605,
+	0xe1, 11605,
+	0xe2, 11605,
+	0xe3, 11605,
+	0xe4, 11605,
+	0xe5, 11605,
+	0xe6, 11605,
+	0xe7, 11605,
+	0xe8, 11610,
+	0xe9, 11610,
+	0xea, 11610,
+	0xeb, 11610,
+	0xec, 11610,
+	0xed, 11610,
+	0xee, 11610,
+	0xef, 11610,
+	0xf0, 11615,
+	0xf1, 11615,
+	0xf2, 11615,
+	0xf3, 11615,
+	0xf4, 11615,
+	0xf5, 11615,
+	0xf6, 11615,
+	0xf7, 11615,
+	0xf8, 11620,
+	0xf9, 11620,
+	0xfa, 11620,
+	0xfb, 11620,
+	0xfc, 11620,
+	0xfd, 11620,
+	0xfe, 11620,
+	0xff, 11620,
+	/*11546*/ uint16(xCondSlashR),
+	11555, // 0
+	11559, // 1
+	11563, // 2
+	11567, // 3
+	11571, // 4
+	11575, // 5
+	11579, // 6
+	11583, // 7
+	/*11555*/ uint16(xSetOp), uint16(FADD),
+	/*11557*/ uint16(xArgM32fp),
+	/*11558*/ uint16(xMatch),
+	/*11559*/ uint16(xSetOp), uint16(FMUL),
+	/*11561*/ uint16(xArgM32fp),
+	/*11562*/ uint16(xMatch),
+	/*11563*/ uint16(xSetOp), uint16(FCOM),
+	/*11565*/ uint16(xArgM32fp),
+	/*11566*/ uint16(xMatch),
+	/*11567*/ uint16(xSetOp), uint16(FCOMP),
+	/*11569*/ uint16(xArgM32fp),
+	/*11570*/ uint16(xMatch),
+	/*11571*/ uint16(xSetOp), uint16(FSUB),
+	/*11573*/ uint16(xArgM32fp),
+	/*11574*/ uint16(xMatch),
+	/*11575*/ uint16(xSetOp), uint16(FSUBR),
+	/*11577*/ uint16(xArgM32fp),
+	/*11578*/ uint16(xMatch),
+	/*11579*/ uint16(xSetOp), uint16(FDIV),
+	/*11581*/ uint16(xArgM32fp),
+	/*11582*/ uint16(xMatch),
+	/*11583*/ uint16(xSetOp), uint16(FDIVR),
+	/*11585*/ uint16(xArgM32fp),
+	/*11586*/ uint16(xMatch),
+	/*11587*/ uint16(xSetOp), uint16(FADD),
+	/*11589*/ uint16(xArgST),
+	/*11590*/ uint16(xArgSTi),
+	/*11591*/ uint16(xMatch),
+	/*11592*/ uint16(xSetOp), uint16(FMUL),
+	/*11594*/ uint16(xArgST),
+	/*11595*/ uint16(xArgSTi),
+	/*11596*/ uint16(xMatch),
+	/*11597*/ uint16(xSetOp), uint16(FCOM),
+	/*11599*/ uint16(xArgSTi),
+	/*11600*/ uint16(xMatch),
+	/*11601*/ uint16(xSetOp), uint16(FCOMP),
+	/*11603*/ uint16(xArgSTi),
+	/*11604*/ uint16(xMatch),
+	/*11605*/ uint16(xSetOp), uint16(FSUB),
+	/*11607*/ uint16(xArgST),
+	/*11608*/ uint16(xArgSTi),
+	/*11609*/ uint16(xMatch),
+	/*11610*/ uint16(xSetOp), uint16(FSUBR),
+	/*11612*/ uint16(xArgST),
+	/*11613*/ uint16(xArgSTi),
+	/*11614*/ uint16(xMatch),
+	/*11615*/ uint16(xSetOp), uint16(FDIV),
+	/*11617*/ uint16(xArgST),
+	/*11618*/ uint16(xArgSTi),
+	/*11619*/ uint16(xMatch),
+	/*11620*/ uint16(xSetOp), uint16(FDIVR),
+	/*11622*/ uint16(xArgST),
+	/*11623*/ uint16(xArgSTi),
+	/*11624*/ uint16(xMatch),
+	/*11625*/ uint16(xCondByte), 44,
+	0xc0, 11752,
+	0xc1, 11752,
+	0xc2, 11752,
+	0xc3, 11752,
+	0xc4, 11752,
+	0xc5, 11752,
+	0xc6, 11752,
+	0xc7, 11752,
+	0xc8, 11756,
+	0xc9, 11756,
+	0xca, 11756,
+	0xcb, 11756,
+	0xcc, 11756,
+	0xcd, 11756,
+	0xce, 11756,
+	0xcf, 11756,
+	0xD0, 11760,
+	0xE0, 11763,
+	0xE1, 11766,
+	0xE4, 11769,
+	0xE5, 11772,
+	0xE8, 11775,
+	0xE9, 11778,
+	0xEA, 11781,
+	0xEB, 11784,
+	0xEC, 11787,
+	0xED, 11790,
+	0xEE, 11793,
+	0xF0, 11796,
+	0xF1, 11799,
+	0xF2, 11802,
+	0xF3, 11805,
+	0xF4, 11808,
+	0xF5, 11811,
+	0xF6, 11814,
+	0xF7, 11817,
+	0xF8, 11820,
+	0xF9, 11823,
+	0xFA, 11826,
+	0xFB, 11829,
+	0xFC, 11832,
+	0xFD, 11835,
+	0xFE, 11838,
+	0xFF, 11841,
+	/*11715*/ uint16(xCondSlashR),
+	11724, // 0
+	0,     // 1
+	11728, // 2
+	11732, // 3
+	11736, // 4
+	11740, // 5
+	11744, // 6
+	11748, // 7
+	/*11724*/ uint16(xSetOp), uint16(FLD),
+	/*11726*/ uint16(xArgM32fp),
+	/*11727*/ uint16(xMatch),
+	/*11728*/ uint16(xSetOp), uint16(FST),
+	/*11730*/ uint16(xArgM32fp),
+	/*11731*/ uint16(xMatch),
+	/*11732*/ uint16(xSetOp), uint16(FSTP),
+	/*11734*/ uint16(xArgM32fp),
+	/*11735*/ uint16(xMatch),
+	/*11736*/ uint16(xSetOp), uint16(FLDENV),
+	/*11738*/ uint16(xArgM1428byte),
+	/*11739*/ uint16(xMatch),
+	/*11740*/ uint16(xSetOp), uint16(FLDCW),
+	/*11742*/ uint16(xArgM2byte),
+	/*11743*/ uint16(xMatch),
+	/*11744*/ uint16(xSetOp), uint16(FNSTENV),
+	/*11746*/ uint16(xArgM1428byte),
+	/*11747*/ uint16(xMatch),
+	/*11748*/ uint16(xSetOp), uint16(FNSTCW),
+	/*11750*/ uint16(xArgM2byte),
+	/*11751*/ uint16(xMatch),
+	/*11752*/ uint16(xSetOp), uint16(FLD),
+	/*11754*/ uint16(xArgSTi),
+	/*11755*/ uint16(xMatch),
+	/*11756*/ uint16(xSetOp), uint16(FXCH),
+	/*11758*/ uint16(xArgSTi),
+	/*11759*/ uint16(xMatch),
+	/*11760*/ uint16(xSetOp), uint16(FNOP),
+	/*11762*/ uint16(xMatch),
+	/*11763*/ uint16(xSetOp), uint16(FCHS),
+	/*11765*/ uint16(xMatch),
+	/*11766*/ uint16(xSetOp), uint16(FABS),
+	/*11768*/ uint16(xMatch),
+	/*11769*/ uint16(xSetOp), uint16(FTST),
+	/*11771*/ uint16(xMatch),
+	/*11772*/ uint16(xSetOp), uint16(FXAM),
+	/*11774*/ uint16(xMatch),
+	/*11775*/ uint16(xSetOp), uint16(FLD1),
+	/*11777*/ uint16(xMatch),
+	/*11778*/ uint16(xSetOp), uint16(FLDL2T),
+	/*11780*/ uint16(xMatch),
+	/*11781*/ uint16(xSetOp), uint16(FLDL2E),
+	/*11783*/ uint16(xMatch),
+	/*11784*/ uint16(xSetOp), uint16(FLDPI),
+	/*11786*/ uint16(xMatch),
+	/*11787*/ uint16(xSetOp), uint16(FLDLG2),
+	/*11789*/ uint16(xMatch),
+	/*11790*/ uint16(xSetOp), uint16(FLDLN2),
+	/*11792*/ uint16(xMatch),
+	/*11793*/ uint16(xSetOp), uint16(FLDZ),
+	/*11795*/ uint16(xMatch),
+	/*11796*/ uint16(xSetOp), uint16(F2XM1),
+	/*11798*/ uint16(xMatch),
+	/*11799*/ uint16(xSetOp), uint16(FYL2X),
+	/*11801*/ uint16(xMatch),
+	/*11802*/ uint16(xSetOp), uint16(FPTAN),
+	/*11804*/ uint16(xMatch),
+	/*11805*/ uint16(xSetOp), uint16(FPATAN),
+	/*11807*/ uint16(xMatch),
+	/*11808*/ uint16(xSetOp), uint16(FXTRACT),
+	/*11810*/ uint16(xMatch),
+	/*11811*/ uint16(xSetOp), uint16(FPREM1),
+	/*11813*/ uint16(xMatch),
+	/*11814*/ uint16(xSetOp), uint16(FDECSTP),
+	/*11816*/ uint16(xMatch),
+	/*11817*/ uint16(xSetOp), uint16(FINCSTP),
+	/*11819*/ uint16(xMatch),
+	/*11820*/ uint16(xSetOp), uint16(FPREM),
+	/*11822*/ uint16(xMatch),
+	/*11823*/ uint16(xSetOp), uint16(FYL2XP1),
+	/*11825*/ uint16(xMatch),
+	/*11826*/ uint16(xSetOp), uint16(FSQRT),
+	/*11828*/ uint16(xMatch),
+	/*11829*/ uint16(xSetOp), uint16(FSINCOS),
+	/*11831*/ uint16(xMatch),
+	/*11832*/ uint16(xSetOp), uint16(FRNDINT),
+	/*11834*/ uint16(xMatch),
+	/*11835*/ uint16(xSetOp), uint16(FSCALE),
+	/*11837*/ uint16(xMatch),
+	/*11838*/ uint16(xSetOp), uint16(FSIN),
+	/*11840*/ uint16(xMatch),
+	/*11841*/ uint16(xSetOp), uint16(FCOS),
+	/*11843*/ uint16(xMatch),
+	/*11844*/ uint16(xCondByte), 33,
+	0xc0, 11953,
+	0xc1, 11953,
+	0xc2, 11953,
+	0xc3, 11953,
+	0xc4, 11953,
+	0xc5, 11953,
+	0xc6, 11953,
+	0xc7, 11953,
+	0xc8, 11958,
+	0xc9, 11958,
+	0xca, 11958,
+	0xcb, 11958,
+	0xcc, 11958,
+	0xcd, 11958,
+	0xce, 11958,
+	0xcf, 11958,
+	0xd0, 11963,
+	0xd1, 11963,
+	0xd2, 11963,
+	0xd3, 11963,
+	0xd4, 11963,
+	0xd5, 11963,
+	0xd6, 11963,
+	0xd7, 11963,
+	0xd8, 11968,
+	0xd9, 11968,
+	0xda, 11968,
+	0xdb, 11968,
+	0xdc, 11968,
+	0xdd, 11968,
+	0xde, 11968,
+	0xdf, 11968,
+	0xE9, 11973,
+	/*11912*/ uint16(xCondSlashR),
+	11921, // 0
+	11925, // 1
+	11929, // 2
+	11933, // 3
+	11937, // 4
+	11941, // 5
+	11945, // 6
+	11949, // 7
+	/*11921*/ uint16(xSetOp), uint16(FIADD),
+	/*11923*/ uint16(xArgM32int),
+	/*11924*/ uint16(xMatch),
+	/*11925*/ uint16(xSetOp), uint16(FIMUL),
+	/*11927*/ uint16(xArgM32int),
+	/*11928*/ uint16(xMatch),
+	/*11929*/ uint16(xSetOp), uint16(FICOM),
+	/*11931*/ uint16(xArgM32int),
+	/*11932*/ uint16(xMatch),
+	/*11933*/ uint16(xSetOp), uint16(FICOMP),
+	/*11935*/ uint16(xArgM32int),
+	/*11936*/ uint16(xMatch),
+	/*11937*/ uint16(xSetOp), uint16(FISUB),
+	/*11939*/ uint16(xArgM32int),
+	/*11940*/ uint16(xMatch),
+	/*11941*/ uint16(xSetOp), uint16(FISUBR),
+	/*11943*/ uint16(xArgM32int),
+	/*11944*/ uint16(xMatch),
+	/*11945*/ uint16(xSetOp), uint16(FIDIV),
+	/*11947*/ uint16(xArgM32int),
+	/*11948*/ uint16(xMatch),
+	/*11949*/ uint16(xSetOp), uint16(FIDIVR),
+	/*11951*/ uint16(xArgM32int),
+	/*11952*/ uint16(xMatch),
+	/*11953*/ uint16(xSetOp), uint16(FCMOVB),
+	/*11955*/ uint16(xArgST),
+	/*11956*/ uint16(xArgSTi),
+	/*11957*/ uint16(xMatch),
+	/*11958*/ uint16(xSetOp), uint16(FCMOVE),
+	/*11960*/ uint16(xArgST),
+	/*11961*/ uint16(xArgSTi),
+	/*11962*/ uint16(xMatch),
+	/*11963*/ uint16(xSetOp), uint16(FCMOVBE),
+	/*11965*/ uint16(xArgST),
+	/*11966*/ uint16(xArgSTi),
+	/*11967*/ uint16(xMatch),
+	/*11968*/ uint16(xSetOp), uint16(FCMOVU),
+	/*11970*/ uint16(xArgST),
+	/*11971*/ uint16(xArgSTi),
+	/*11972*/ uint16(xMatch),
+	/*11973*/ uint16(xSetOp), uint16(FUCOMPP),
+	/*11975*/ uint16(xMatch),
+	/*11976*/ uint16(xCondByte), 50,
+	0xc0, 12111,
+	0xc1, 12111,
+	0xc2, 12111,
+	0xc3, 12111,
+	0xc4, 12111,
+	0xc5, 12111,
+	0xc6, 12111,
+	0xc7, 12111,
+	0xc8, 12116,
+	0xc9, 12116,
+	0xca, 12116,
+	0xcb, 12116,
+	0xcc, 12116,
+	0xcd, 12116,
+	0xce, 12116,
+	0xcf, 12116,
+	0xd0, 12121,
+	0xd1, 12121,
+	0xd2, 12121,
+	0xd3, 12121,
+	0xd4, 12121,
+	0xd5, 12121,
+	0xd6, 12121,
+	0xd7, 12121,
+	0xd8, 12126,
+	0xd9, 12126,
+	0xda, 12126,
+	0xdb, 12126,
+	0xdc, 12126,
+	0xdd, 12126,
+	0xde, 12126,
+	0xdf, 12126,
+	0xE2, 12131,
+	0xE3, 12134,
+	0xe8, 12137,
+	0xe9, 12137,
+	0xea, 12137,
+	0xeb, 12137,
+	0xec, 12137,
+	0xed, 12137,
+	0xee, 12137,
+	0xef, 12137,
+	0xf0, 12142,
+	0xf1, 12142,
+	0xf2, 12142,
+	0xf3, 12142,
+	0xf4, 12142,
+	0xf5, 12142,
+	0xf6, 12142,
+	0xf7, 12142,
+	/*12078*/ uint16(xCondSlashR),
+	12087, // 0
+	12091, // 1
+	12095, // 2
+	12099, // 3
+	0,     // 4
+	12103, // 5
+	0,     // 6
+	12107, // 7
+	/*12087*/ uint16(xSetOp), uint16(FILD),
+	/*12089*/ uint16(xArgM32int),
+	/*12090*/ uint16(xMatch),
+	/*12091*/ uint16(xSetOp), uint16(FISTTP),
+	/*12093*/ uint16(xArgM32int),
+	/*12094*/ uint16(xMatch),
+	/*12095*/ uint16(xSetOp), uint16(FIST),
+	/*12097*/ uint16(xArgM32int),
+	/*12098*/ uint16(xMatch),
+	/*12099*/ uint16(xSetOp), uint16(FISTP),
+	/*12101*/ uint16(xArgM32int),
+	/*12102*/ uint16(xMatch),
+	/*12103*/ uint16(xSetOp), uint16(FLD),
+	/*12105*/ uint16(xArgM80fp),
+	/*12106*/ uint16(xMatch),
+	/*12107*/ uint16(xSetOp), uint16(FSTP),
+	/*12109*/ uint16(xArgM80fp),
+	/*12110*/ uint16(xMatch),
+	/*12111*/ uint16(xSetOp), uint16(FCMOVNB),
+	/*12113*/ uint16(xArgST),
+	/*12114*/ uint16(xArgSTi),
+	/*12115*/ uint16(xMatch),
+	/*12116*/ uint16(xSetOp), uint16(FCMOVNE),
+	/*12118*/ uint16(xArgST),
+	/*12119*/ uint16(xArgSTi),
+	/*12120*/ uint16(xMatch),
+	/*12121*/ uint16(xSetOp), uint16(FCMOVNBE),
+	/*12123*/ uint16(xArgST),
+	/*12124*/ uint16(xArgSTi),
+	/*12125*/ uint16(xMatch),
+	/*12126*/ uint16(xSetOp), uint16(FCMOVNU),
+	/*12128*/ uint16(xArgST),
+	/*12129*/ uint16(xArgSTi),
+	/*12130*/ uint16(xMatch),
+	/*12131*/ uint16(xSetOp), uint16(FNCLEX),
+	/*12133*/ uint16(xMatch),
+	/*12134*/ uint16(xSetOp), uint16(FNINIT),
+	/*12136*/ uint16(xMatch),
+	/*12137*/ uint16(xSetOp), uint16(FUCOMI),
+	/*12139*/ uint16(xArgST),
+	/*12140*/ uint16(xArgSTi),
+	/*12141*/ uint16(xMatch),
+	/*12142*/ uint16(xSetOp), uint16(FCOMI),
+	/*12144*/ uint16(xArgST),
+	/*12145*/ uint16(xArgSTi),
+	/*12146*/ uint16(xMatch),
+	/*12147*/ uint16(xCondByte), 48,
+	0xc0, 12286,
+	0xc1, 12286,
+	0xc2, 12286,
+	0xc3, 12286,
+	0xc4, 12286,
+	0xc5, 12286,
+	0xc6, 12286,
+	0xc7, 12286,
+	0xc8, 12291,
+	0xc9, 12291,
+	0xca, 12291,
+	0xcb, 12291,
+	0xcc, 12291,
+	0xcd, 12291,
+	0xce, 12291,
+	0xcf, 12291,
+	0xe0, 12296,
+	0xe1, 12296,
+	0xe2, 12296,
+	0xe3, 12296,
+	0xe4, 12296,
+	0xe5, 12296,
+	0xe6, 12296,
+	0xe7, 12296,
+	0xe8, 12301,
+	0xe9, 12301,
+	0xea, 12301,
+	0xeb, 12301,
+	0xec, 12301,
+	0xed, 12301,
+	0xee, 12301,
+	0xef, 12301,
+	0xf0, 12306,
+	0xf1, 12306,
+	0xf2, 12306,
+	0xf3, 12306,
+	0xf4, 12306,
+	0xf5, 12306,
+	0xf6, 12306,
+	0xf7, 12306,
+	0xf8, 12311,
+	0xf9, 12311,
+	0xfa, 12311,
+	0xfb, 12311,
+	0xfc, 12311,
+	0xfd, 12311,
+	0xfe, 12311,
+	0xff, 12311,
+	/*12245*/ uint16(xCondSlashR),
+	12254, // 0
+	12258, // 1
+	12262, // 2
+	12266, // 3
+	12270, // 4
+	12274, // 5
+	12278, // 6
+	12282, // 7
+	/*12254*/ uint16(xSetOp), uint16(FADD),
+	/*12256*/ uint16(xArgM64fp),
+	/*12257*/ uint16(xMatch),
+	/*12258*/ uint16(xSetOp), uint16(FMUL),
+	/*12260*/ uint16(xArgM64fp),
+	/*12261*/ uint16(xMatch),
+	/*12262*/ uint16(xSetOp), uint16(FCOM),
+	/*12264*/ uint16(xArgM64fp),
+	/*12265*/ uint16(xMatch),
+	/*12266*/ uint16(xSetOp), uint16(FCOMP),
+	/*12268*/ uint16(xArgM64fp),
+	/*12269*/ uint16(xMatch),
+	/*12270*/ uint16(xSetOp), uint16(FSUB),
+	/*12272*/ uint16(xArgM64fp),
+	/*12273*/ uint16(xMatch),
+	/*12274*/ uint16(xSetOp), uint16(FSUBR),
+	/*12276*/ uint16(xArgM64fp),
+	/*12277*/ uint16(xMatch),
+	/*12278*/ uint16(xSetOp), uint16(FDIV),
+	/*12280*/ uint16(xArgM64fp),
+	/*12281*/ uint16(xMatch),
+	/*12282*/ uint16(xSetOp), uint16(FDIVR),
+	/*12284*/ uint16(xArgM64fp),
+	/*12285*/ uint16(xMatch),
+	/*12286*/ uint16(xSetOp), uint16(FADD),
+	/*12288*/ uint16(xArgSTi),
+	/*12289*/ uint16(xArgST),
+	/*12290*/ uint16(xMatch),
+	/*12291*/ uint16(xSetOp), uint16(FMUL),
+	/*12293*/ uint16(xArgSTi),
+	/*12294*/ uint16(xArgST),
+	/*12295*/ uint16(xMatch),
+	/*12296*/ uint16(xSetOp), uint16(FSUBR),
+	/*12298*/ uint16(xArgSTi),
+	/*12299*/ uint16(xArgST),
+	/*12300*/ uint16(xMatch),
+	/*12301*/ uint16(xSetOp), uint16(FSUB),
+	/*12303*/ uint16(xArgSTi),
+	/*12304*/ uint16(xArgST),
+	/*12305*/ uint16(xMatch),
+	/*12306*/ uint16(xSetOp), uint16(FDIVR),
+	/*12308*/ uint16(xArgSTi),
+	/*12309*/ uint16(xArgST),
+	/*12310*/ uint16(xMatch),
+	/*12311*/ uint16(xSetOp), uint16(FDIV),
+	/*12313*/ uint16(xArgSTi),
+	/*12314*/ uint16(xArgST),
+	/*12315*/ uint16(xMatch),
+	/*12316*/ uint16(xCondByte), 40,
+	0xc0, 12435,
+	0xc1, 12435,
+	0xc2, 12435,
+	0xc3, 12435,
+	0xc4, 12435,
+	0xc5, 12435,
+	0xc6, 12435,
+	0xc7, 12435,
+	0xd0, 12439,
+	0xd1, 12439,
+	0xd2, 12439,
+	0xd3, 12439,
+	0xd4, 12439,
+	0xd5, 12439,
+	0xd6, 12439,
+	0xd7, 12439,
+	0xd8, 12443,
+	0xd9, 12443,
+	0xda, 12443,
+	0xdb, 12443,
+	0xdc, 12443,
+	0xdd, 12443,
+	0xde, 12443,
+	0xdf, 12443,
+	0xe0, 12447,
+	0xe1, 12447,
+	0xe2, 12447,
+	0xe3, 12447,
+	0xe4, 12447,
+	0xe5, 12447,
+	0xe6, 12447,
+	0xe7, 12447,
+	0xe8, 12451,
+	0xe9, 12451,
+	0xea, 12451,
+	0xeb, 12451,
+	0xec, 12451,
+	0xed, 12451,
+	0xee, 12451,
+	0xef, 12451,
+	/*12398*/ uint16(xCondSlashR),
+	12407, // 0
+	12411, // 1
+	12415, // 2
+	12419, // 3
+	12423, // 4
+	0,     // 5
+	12427, // 6
+	12431, // 7
+	/*12407*/ uint16(xSetOp), uint16(FLD),
+	/*12409*/ uint16(xArgM64fp),
+	/*12410*/ uint16(xMatch),
+	/*12411*/ uint16(xSetOp), uint16(FISTTP),
+	/*12413*/ uint16(xArgM64int),
+	/*12414*/ uint16(xMatch),
+	/*12415*/ uint16(xSetOp), uint16(FST),
+	/*12417*/ uint16(xArgM64fp),
+	/*12418*/ uint16(xMatch),
+	/*12419*/ uint16(xSetOp), uint16(FSTP),
+	/*12421*/ uint16(xArgM64fp),
+	/*12422*/ uint16(xMatch),
+	/*12423*/ uint16(xSetOp), uint16(FRSTOR),
+	/*12425*/ uint16(xArgM94108byte),
+	/*12426*/ uint16(xMatch),
+	/*12427*/ uint16(xSetOp), uint16(FNSAVE),
+	/*12429*/ uint16(xArgM94108byte),
+	/*12430*/ uint16(xMatch),
+	/*12431*/ uint16(xSetOp), uint16(FNSTSW),
+	/*12433*/ uint16(xArgM2byte),
+	/*12434*/ uint16(xMatch),
+	/*12435*/ uint16(xSetOp), uint16(FFREE),
+	/*12437*/ uint16(xArgSTi),
+	/*12438*/ uint16(xMatch),
+	/*12439*/ uint16(xSetOp), uint16(FST),
+	/*12441*/ uint16(xArgSTi),
+	/*12442*/ uint16(xMatch),
+	/*12443*/ uint16(xSetOp), uint16(FSTP),
+	/*12445*/ uint16(xArgSTi),
+	/*12446*/ uint16(xMatch),
+	/*12447*/ uint16(xSetOp), uint16(FUCOM),
+	/*12449*/ uint16(xArgSTi),
+	/*12450*/ uint16(xMatch),
+	/*12451*/ uint16(xSetOp), uint16(FUCOMP),
+	/*12453*/ uint16(xArgSTi),
+	/*12454*/ uint16(xMatch),
+	/*12455*/ uint16(xCondByte), 49,
+	0xc0, 12596,
+	0xc1, 12596,
+	0xc2, 12596,
+	0xc3, 12596,
+	0xc4, 12596,
+	0xc5, 12596,
+	0xc6, 12596,
+	0xc7, 12596,
+	0xc8, 12601,
+	0xc9, 12601,
+	0xca, 12601,
+	0xcb, 12601,
+	0xcc, 12601,
+	0xcd, 12601,
+	0xce, 12601,
+	0xcf, 12601,
+	0xD9, 12606,
+	0xe0, 12609,
+	0xe1, 12609,
+	0xe2, 12609,
+	0xe3, 12609,
+	0xe4, 12609,
+	0xe5, 12609,
+	0xe6, 12609,
+	0xe7, 12609,
+	0xe8, 12614,
+	0xe9, 12614,
+	0xea, 12614,
+	0xeb, 12614,
+	0xec, 12614,
+	0xed, 12614,
+	0xee, 12614,
+	0xef, 12614,
+	0xf0, 12619,
+	0xf1, 12619,
+	0xf2, 12619,
+	0xf3, 12619,
+	0xf4, 12619,
+	0xf5, 12619,
+	0xf6, 12619,
+	0xf7, 12619,
+	0xf8, 12624,
+	0xf9, 12624,
+	0xfa, 12624,
+	0xfb, 12624,
+	0xfc, 12624,
+	0xfd, 12624,
+	0xfe, 12624,
+	0xff, 12624,
+	/*12555*/ uint16(xCondSlashR),
+	12564, // 0
+	12568, // 1
+	12572, // 2
+	12576, // 3
+	12580, // 4
+	12584, // 5
+	12588, // 6
+	12592, // 7
+	/*12564*/ uint16(xSetOp), uint16(FIADD),
+	/*12566*/ uint16(xArgM16int),
+	/*12567*/ uint16(xMatch),
+	/*12568*/ uint16(xSetOp), uint16(FIMUL),
+	/*12570*/ uint16(xArgM16int),
+	/*12571*/ uint16(xMatch),
+	/*12572*/ uint16(xSetOp), uint16(FICOM),
+	/*12574*/ uint16(xArgM16int),
+	/*12575*/ uint16(xMatch),
+	/*12576*/ uint16(xSetOp), uint16(FICOMP),
+	/*12578*/ uint16(xArgM16int),
+	/*12579*/ uint16(xMatch),
+	/*12580*/ uint16(xSetOp), uint16(FISUB),
+	/*12582*/ uint16(xArgM16int),
+	/*12583*/ uint16(xMatch),
+	/*12584*/ uint16(xSetOp), uint16(FISUBR),
+	/*12586*/ uint16(xArgM16int),
+	/*12587*/ uint16(xMatch),
+	/*12588*/ uint16(xSetOp), uint16(FIDIV),
+	/*12590*/ uint16(xArgM16int),
+	/*12591*/ uint16(xMatch),
+	/*12592*/ uint16(xSetOp), uint16(FIDIVR),
+	/*12594*/ uint16(xArgM16int),
+	/*12595*/ uint16(xMatch),
+	/*12596*/ uint16(xSetOp), uint16(FADDP),
+	/*12598*/ uint16(xArgSTi),
+	/*12599*/ uint16(xArgST),
+	/*12600*/ uint16(xMatch),
+	/*12601*/ uint16(xSetOp), uint16(FMULP),
+	/*12603*/ uint16(xArgSTi),
+	/*12604*/ uint16(xArgST),
+	/*12605*/ uint16(xMatch),
+	/*12606*/ uint16(xSetOp), uint16(FCOMPP),
+	/*12608*/ uint16(xMatch),
+	/*12609*/ uint16(xSetOp), uint16(FSUBRP),
+	/*12611*/ uint16(xArgSTi),
+	/*12612*/ uint16(xArgST),
+	/*12613*/ uint16(xMatch),
+	/*12614*/ uint16(xSetOp), uint16(FSUBP),
+	/*12616*/ uint16(xArgSTi),
+	/*12617*/ uint16(xArgST),
+	/*12618*/ uint16(xMatch),
+	/*12619*/ uint16(xSetOp), uint16(FDIVRP),
+	/*12621*/ uint16(xArgSTi),
+	/*12622*/ uint16(xArgST),
+	/*12623*/ uint16(xMatch),
+	/*12624*/ uint16(xSetOp), uint16(FDIVP),
+	/*12626*/ uint16(xArgSTi),
+	/*12627*/ uint16(xArgST),
+	/*12628*/ uint16(xMatch),
+	/*12629*/ uint16(xCondByte), 25,
+	0xc0, 12722,
+	0xc1, 12722,
+	0xc2, 12722,
+	0xc3, 12722,
+	0xc4, 12722,
+	0xc5, 12722,
+	0xc6, 12722,
+	0xc7, 12722,
+	0xE0, 12726,
+	0xe8, 12730,
+	0xe9, 12730,
+	0xea, 12730,
+	0xeb, 12730,
+	0xec, 12730,
+	0xed, 12730,
+	0xee, 12730,
+	0xef, 12730,
+	0xf0, 12735,
+	0xf1, 12735,
+	0xf2, 12735,
+	0xf3, 12735,
+	0xf4, 12735,
+	0xf5, 12735,
+	0xf6, 12735,
+	0xf7, 12735,
+	/*12681*/ uint16(xCondSlashR),
+	12690, // 0
+	12694, // 1
+	12698, // 2
+	12702, // 3
+	12706, // 4
+	12710, // 5
+	12714, // 6
+	12718, // 7
+	/*12690*/ uint16(xSetOp), uint16(FILD),
+	/*12692*/ uint16(xArgM16int),
+	/*12693*/ uint16(xMatch),
+	/*12694*/ uint16(xSetOp), uint16(FISTTP),
+	/*12696*/ uint16(xArgM16int),
+	/*12697*/ uint16(xMatch),
+	/*12698*/ uint16(xSetOp), uint16(FIST),
+	/*12700*/ uint16(xArgM16int),
+	/*12701*/ uint16(xMatch),
+	/*12702*/ uint16(xSetOp), uint16(FISTP),
+	/*12704*/ uint16(xArgM16int),
+	/*12705*/ uint16(xMatch),
+	/*12706*/ uint16(xSetOp), uint16(FBLD),
+	/*12708*/ uint16(xArgM80dec),
+	/*12709*/ uint16(xMatch),
+	/*12710*/ uint16(xSetOp), uint16(FILD),
+	/*12712*/ uint16(xArgM64int),
+	/*12713*/ uint16(xMatch),
+	/*12714*/ uint16(xSetOp), uint16(FBSTP),
+	/*12716*/ uint16(xArgM80bcd),
+	/*12717*/ uint16(xMatch),
+	/*12718*/ uint16(xSetOp), uint16(FISTP),
+	/*12720*/ uint16(xArgM64int),
+	/*12721*/ uint16(xMatch),
+	/*12722*/ uint16(xSetOp), uint16(FFREEP),
+	/*12724*/ uint16(xArgSTi),
+	/*12725*/ uint16(xMatch),
+	/*12726*/ uint16(xSetOp), uint16(FNSTSW),
+	/*12728*/ uint16(xArgAX),
+	/*12729*/ uint16(xMatch),
+	/*12730*/ uint16(xSetOp), uint16(FUCOMIP),
+	/*12732*/ uint16(xArgST),
+	/*12733*/ uint16(xArgSTi),
+	/*12734*/ uint16(xMatch),
+	/*12735*/ uint16(xSetOp), uint16(FCOMIP),
+	/*12737*/ uint16(xArgST),
+	/*12738*/ uint16(xArgSTi),
+	/*12739*/ uint16(xMatch),
+	/*12740*/ uint16(xSetOp), uint16(LOOPNE),
+	/*12742*/ uint16(xReadCb),
+	/*12743*/ uint16(xArgRel8),
+	/*12744*/ uint16(xMatch),
+	/*12745*/ uint16(xSetOp), uint16(LOOPE),
+	/*12747*/ uint16(xReadCb),
+	/*12748*/ uint16(xArgRel8),
+	/*12749*/ uint16(xMatch),
+	/*12750*/ uint16(xSetOp), uint16(LOOP),
+	/*12752*/ uint16(xReadCb),
+	/*12753*/ uint16(xArgRel8),
+	/*12754*/ uint16(xMatch),
+	/*12755*/ uint16(xCondIs64), 12758, 12772,
+	/*12758*/ uint16(xCondAddrSize), 12762, 12767, 0,
+	/*12762*/ uint16(xSetOp), uint16(JCXZ),
+	/*12764*/ uint16(xReadCb),
+	/*12765*/ uint16(xArgRel8),
+	/*12766*/ uint16(xMatch),
+	/*12767*/ uint16(xSetOp), uint16(JECXZ),
+	/*12769*/ uint16(xReadCb),
+	/*12770*/ uint16(xArgRel8),
+	/*12771*/ uint16(xMatch),
+	/*12772*/ uint16(xCondAddrSize), 0, 12767, 12776,
+	/*12776*/ uint16(xSetOp), uint16(JRCXZ),
+	/*12778*/ uint16(xReadCb),
+	/*12779*/ uint16(xArgRel8),
+	/*12780*/ uint16(xMatch),
+	/*12781*/ uint16(xSetOp), uint16(IN),
+	/*12783*/ uint16(xReadIb),
+	/*12784*/ uint16(xArgAL),
+	/*12785*/ uint16(xArgImm8u),
+	/*12786*/ uint16(xMatch),
+	/*12787*/ uint16(xCondDataSize), 12791, 12797, 12803,
+	/*12791*/ uint16(xSetOp), uint16(IN),
+	/*12793*/ uint16(xReadIb),
+	/*12794*/ uint16(xArgAX),
+	/*12795*/ uint16(xArgImm8u),
+	/*12796*/ uint16(xMatch),
+	/*12797*/ uint16(xSetOp), uint16(IN),
+	/*12799*/ uint16(xReadIb),
+	/*12800*/ uint16(xArgEAX),
+	/*12801*/ uint16(xArgImm8u),
+	/*12802*/ uint16(xMatch),
+	/*12803*/ uint16(xSetOp), uint16(IN),
+	/*12805*/ uint16(xReadIb),
+	/*12806*/ uint16(xArgEAX),
+	/*12807*/ uint16(xArgImm8u),
+	/*12808*/ uint16(xMatch),
+	/*12809*/ uint16(xSetOp), uint16(OUT),
+	/*12811*/ uint16(xReadIb),
+	/*12812*/ uint16(xArgImm8u),
+	/*12813*/ uint16(xArgAL),
+	/*12814*/ uint16(xMatch),
+	/*12815*/ uint16(xCondPrefix), 3,
+	0xC5, 12859,
+	0xC4, 12845,
+	0x0, 12823,
+	/*12823*/ uint16(xCondDataSize), 12827, 12833, 12839,
+	/*12827*/ uint16(xSetOp), uint16(OUT),
+	/*12829*/ uint16(xReadIb),
+	/*12830*/ uint16(xArgImm8u),
+	/*12831*/ uint16(xArgAX),
+	/*12832*/ uint16(xMatch),
+	/*12833*/ uint16(xSetOp), uint16(OUT),
+	/*12835*/ uint16(xReadIb),
+	/*12836*/ uint16(xArgImm8u),
+	/*12837*/ uint16(xArgEAX),
+	/*12838*/ uint16(xMatch),
+	/*12839*/ uint16(xSetOp), uint16(OUT),
+	/*12841*/ uint16(xReadIb),
+	/*12842*/ uint16(xArgImm8u),
+	/*12843*/ uint16(xArgEAX),
+	/*12844*/ uint16(xMatch),
+	/*12845*/ uint16(xCondPrefix), 1,
+	0x66, 12849,
+	/*12849*/ uint16(xCondPrefix), 1,
+	0x0F, 12853,
+	/*12853*/ uint16(xSetOp), uint16(VMOVNTDQ),
+	/*12855*/ uint16(xReadSlashR),
+	/*12856*/ uint16(xArgM256),
+	/*12857*/ uint16(xArgYmm1),
+	/*12858*/ uint16(xMatch),
+	/*12859*/ uint16(xCondPrefix), 1,
+	0x66, 12863,
+	/*12863*/ uint16(xCondPrefix), 1,
+	0x0F, 12867,
+	/*12867*/ uint16(xSetOp), uint16(VMOVNTDQ),
+	/*12869*/ uint16(xReadSlashR),
+	/*12870*/ uint16(xArgM256),
+	/*12871*/ uint16(xArgYmm1),
+	/*12872*/ uint16(xMatch),
+	/*12873*/ uint16(xCondIs64), 12876, 12890,
+	/*12876*/ uint16(xCondDataSize), 12880, 12885, 0,
+	/*12880*/ uint16(xSetOp), uint16(CALL),
+	/*12882*/ uint16(xReadCw),
+	/*12883*/ uint16(xArgRel16),
+	/*12884*/ uint16(xMatch),
+	/*12885*/ uint16(xSetOp), uint16(CALL),
+	/*12887*/ uint16(xReadCd),
+	/*12888*/ uint16(xArgRel32),
+	/*12889*/ uint16(xMatch),
+	/*12890*/ uint16(xCondDataSize), 12894, 12885, 12899,
+	/*12894*/ uint16(xSetOp), uint16(CALL),
+	/*12896*/ uint16(xReadCd),
+	/*12897*/ uint16(xArgRel32),
+	/*12898*/ uint16(xMatch),
+	/*12899*/ uint16(xSetOp), uint16(CALL),
+	/*12901*/ uint16(xReadCd),
+	/*12902*/ uint16(xArgRel32),
+	/*12903*/ uint16(xMatch),
+	/*12904*/ uint16(xCondIs64), 12907, 12921,
+	/*12907*/ uint16(xCondDataSize), 12911, 12916, 0,
+	/*12911*/ uint16(xSetOp), uint16(JMP),
+	/*12913*/ uint16(xReadCw),
+	/*12914*/ uint16(xArgRel16),
+	/*12915*/ uint16(xMatch),
+	/*12916*/ uint16(xSetOp), uint16(JMP),
+	/*12918*/ uint16(xReadCd),
+	/*12919*/ uint16(xArgRel32),
+	/*12920*/ uint16(xMatch),
+	/*12921*/ uint16(xCondDataSize), 12925, 12916, 12930,
+	/*12925*/ uint16(xSetOp), uint16(JMP),
+	/*12927*/ uint16(xReadCd),
+	/*12928*/ uint16(xArgRel32),
+	/*12929*/ uint16(xMatch),
+	/*12930*/ uint16(xSetOp), uint16(JMP),
+	/*12932*/ uint16(xReadCd),
+	/*12933*/ uint16(xArgRel32),
+	/*12934*/ uint16(xMatch),
+	/*12935*/ uint16(xCondIs64), 12938, 0,
+	/*12938*/ uint16(xCondDataSize), 12942, 12947, 0,
+	/*12942*/ uint16(xSetOp), uint16(LJMP),
+	/*12944*/ uint16(xReadCd),
+	/*12945*/ uint16(xArgPtr16colon16),
+	/*12946*/ uint16(xMatch),
+	/*12947*/ uint16(xSetOp), uint16(LJMP),
+	/*12949*/ uint16(xReadCp),
+	/*12950*/ uint16(xArgPtr16colon32),
+	/*12951*/ uint16(xMatch),
+	/*12952*/ uint16(xSetOp), uint16(JMP),
+	/*12954*/ uint16(xReadCb),
+	/*12955*/ uint16(xArgRel8),
+	/*12956*/ uint16(xMatch),
+	/*12957*/ uint16(xSetOp), uint16(IN),
+	/*12959*/ uint16(xArgAL),
+	/*12960*/ uint16(xArgDX),
+	/*12961*/ uint16(xMatch),
+	/*12962*/ uint16(xCondDataSize), 12966, 12971, 12976,
+	/*12966*/ uint16(xSetOp), uint16(IN),
+	/*12968*/ uint16(xArgAX),
+	/*12969*/ uint16(xArgDX),
+	/*12970*/ uint16(xMatch),
+	/*12971*/ uint16(xSetOp), uint16(IN),
+	/*12973*/ uint16(xArgEAX),
+	/*12974*/ uint16(xArgDX),
+	/*12975*/ uint16(xMatch),
+	/*12976*/ uint16(xSetOp), uint16(IN),
+	/*12978*/ uint16(xArgEAX),
+	/*12979*/ uint16(xArgDX),
+	/*12980*/ uint16(xMatch),
+	/*12981*/ uint16(xSetOp), uint16(OUT),
+	/*12983*/ uint16(xArgDX),
+	/*12984*/ uint16(xArgAL),
+	/*12985*/ uint16(xMatch),
+	/*12986*/ uint16(xCondDataSize), 12990, 12995, 13000,
+	/*12990*/ uint16(xSetOp), uint16(OUT),
+	/*12992*/ uint16(xArgDX),
+	/*12993*/ uint16(xArgAX),
+	/*12994*/ uint16(xMatch),
+	/*12995*/ uint16(xSetOp), uint16(OUT),
+	/*12997*/ uint16(xArgDX),
+	/*12998*/ uint16(xArgEAX),
+	/*12999*/ uint16(xMatch),
+	/*13000*/ uint16(xSetOp), uint16(OUT),
+	/*13002*/ uint16(xArgDX),
+	/*13003*/ uint16(xArgEAX),
+	/*13004*/ uint16(xMatch),
+	/*13005*/ uint16(xSetOp), uint16(ICEBP),
+	/*13007*/ uint16(xMatch),
+	/*13008*/ uint16(xSetOp), uint16(HLT),
+	/*13010*/ uint16(xMatch),
+	/*13011*/ uint16(xSetOp), uint16(CMC),
+	/*13013*/ uint16(xMatch),
+	/*13014*/ uint16(xCondSlashR),
+	13023, // 0
+	0,     // 1
+	13029, // 2
+	13033, // 3
+	13037, // 4
+	13041, // 5
+	13045, // 6
+	13049, // 7
+	/*13023*/ uint16(xSetOp), uint16(TEST),
+	/*13025*/ uint16(xReadIb),
+	/*13026*/ uint16(xArgRM8),
+	/*13027*/ uint16(xArgImm8u),
+	/*13028*/ uint16(xMatch),
+	/*13029*/ uint16(xSetOp), uint16(NOT),
+	/*13031*/ uint16(xArgRM8),
+	/*13032*/ uint16(xMatch),
+	/*13033*/ uint16(xSetOp), uint16(NEG),
+	/*13035*/ uint16(xArgRM8),
+	/*13036*/ uint16(xMatch),
+	/*13037*/ uint16(xSetOp), uint16(MUL),
+	/*13039*/ uint16(xArgRM8),
+	/*13040*/ uint16(xMatch),
+	/*13041*/ uint16(xSetOp), uint16(IMUL),
+	/*13043*/ uint16(xArgRM8),
+	/*13044*/ uint16(xMatch),
+	/*13045*/ uint16(xSetOp), uint16(DIV),
+	/*13047*/ uint16(xArgRM8),
+	/*13048*/ uint16(xMatch),
+	/*13049*/ uint16(xSetOp), uint16(IDIV),
+	/*13051*/ uint16(xArgRM8),
+	/*13052*/ uint16(xMatch),
+	/*13053*/ uint16(xCondSlashR),
+	13062, // 0
+	0,     // 1
+	13091, // 2
+	13114, // 3
+	13137, // 4
+	13160, // 5
+	13183, // 6
+	13206, // 7
+	/*13062*/ uint16(xCondIs64), 13065, 13081,
+	/*13065*/ uint16(xCondDataSize), 13069, 13075, 0,
+	/*13069*/ uint16(xSetOp), uint16(TEST),
+	/*13071*/ uint16(xReadIw),
+	/*13072*/ uint16(xArgRM16),
+	/*13073*/ uint16(xArgImm16),
+	/*13074*/ uint16(xMatch),
+	/*13075*/ uint16(xSetOp), uint16(TEST),
+	/*13077*/ uint16(xReadId),
+	/*13078*/ uint16(xArgRM32),
+	/*13079*/ uint16(xArgImm32),
+	/*13080*/ uint16(xMatch),
+	/*13081*/ uint16(xCondDataSize), 13069, 13075, 13085,
+	/*13085*/ uint16(xSetOp), uint16(TEST),
+	/*13087*/ uint16(xReadId),
+	/*13088*/ uint16(xArgRM64),
+	/*13089*/ uint16(xArgImm32),
+	/*13090*/ uint16(xMatch),
+	/*13091*/ uint16(xCondIs64), 13094, 13106,
+	/*13094*/ uint16(xCondDataSize), 13098, 13102, 0,
+	/*13098*/ uint16(xSetOp), uint16(NOT),
+	/*13100*/ uint16(xArgRM16),
+	/*13101*/ uint16(xMatch),
+	/*13102*/ uint16(xSetOp), uint16(NOT),
+	/*13104*/ uint16(xArgRM32),
+	/*13105*/ uint16(xMatch),
+	/*13106*/ uint16(xCondDataSize), 13098, 13102, 13110,
+	/*13110*/ uint16(xSetOp), uint16(NOT),
+	/*13112*/ uint16(xArgRM64),
+	/*13113*/ uint16(xMatch),
+	/*13114*/ uint16(xCondIs64), 13117, 13129,
+	/*13117*/ uint16(xCondDataSize), 13121, 13125, 0,
+	/*13121*/ uint16(xSetOp), uint16(NEG),
+	/*13123*/ uint16(xArgRM16),
+	/*13124*/ uint16(xMatch),
+	/*13125*/ uint16(xSetOp), uint16(NEG),
+	/*13127*/ uint16(xArgRM32),
+	/*13128*/ uint16(xMatch),
+	/*13129*/ uint16(xCondDataSize), 13121, 13125, 13133,
+	/*13133*/ uint16(xSetOp), uint16(NEG),
+	/*13135*/ uint16(xArgRM64),
+	/*13136*/ uint16(xMatch),
+	/*13137*/ uint16(xCondIs64), 13140, 13152,
+	/*13140*/ uint16(xCondDataSize), 13144, 13148, 0,
+	/*13144*/ uint16(xSetOp), uint16(MUL),
+	/*13146*/ uint16(xArgRM16),
+	/*13147*/ uint16(xMatch),
+	/*13148*/ uint16(xSetOp), uint16(MUL),
+	/*13150*/ uint16(xArgRM32),
+	/*13151*/ uint16(xMatch),
+	/*13152*/ uint16(xCondDataSize), 13144, 13148, 13156,
+	/*13156*/ uint16(xSetOp), uint16(MUL),
+	/*13158*/ uint16(xArgRM64),
+	/*13159*/ uint16(xMatch),
+	/*13160*/ uint16(xCondIs64), 13163, 13175,
+	/*13163*/ uint16(xCondDataSize), 13167, 13171, 0,
+	/*13167*/ uint16(xSetOp), uint16(IMUL),
+	/*13169*/ uint16(xArgRM16),
+	/*13170*/ uint16(xMatch),
+	/*13171*/ uint16(xSetOp), uint16(IMUL),
+	/*13173*/ uint16(xArgRM32),
+	/*13174*/ uint16(xMatch),
+	/*13175*/ uint16(xCondDataSize), 13167, 13171, 13179,
+	/*13179*/ uint16(xSetOp), uint16(IMUL),
+	/*13181*/ uint16(xArgRM64),
+	/*13182*/ uint16(xMatch),
+	/*13183*/ uint16(xCondIs64), 13186, 13198,
+	/*13186*/ uint16(xCondDataSize), 13190, 13194, 0,
+	/*13190*/ uint16(xSetOp), uint16(DIV),
+	/*13192*/ uint16(xArgRM16),
+	/*13193*/ uint16(xMatch),
+	/*13194*/ uint16(xSetOp), uint16(DIV),
+	/*13196*/ uint16(xArgRM32),
+	/*13197*/ uint16(xMatch),
+	/*13198*/ uint16(xCondDataSize), 13190, 13194, 13202,
+	/*13202*/ uint16(xSetOp), uint16(DIV),
+	/*13204*/ uint16(xArgRM64),
+	/*13205*/ uint16(xMatch),
+	/*13206*/ uint16(xCondIs64), 13209, 13221,
+	/*13209*/ uint16(xCondDataSize), 13213, 13217, 0,
+	/*13213*/ uint16(xSetOp), uint16(IDIV),
+	/*13215*/ uint16(xArgRM16),
+	/*13216*/ uint16(xMatch),
+	/*13217*/ uint16(xSetOp), uint16(IDIV),
+	/*13219*/ uint16(xArgRM32),
+	/*13220*/ uint16(xMatch),
+	/*13221*/ uint16(xCondDataSize), 13213, 13217, 13225,
+	/*13225*/ uint16(xSetOp), uint16(IDIV),
+	/*13227*/ uint16(xArgRM64),
+	/*13228*/ uint16(xMatch),
+	/*13229*/ uint16(xSetOp), uint16(CLC),
+	/*13231*/ uint16(xMatch),
+	/*13232*/ uint16(xSetOp), uint16(STC),
+	/*13234*/ uint16(xMatch),
+	/*13235*/ uint16(xSetOp), uint16(CLI),
+	/*13237*/ uint16(xMatch),
+	/*13238*/ uint16(xSetOp), uint16(STI),
+	/*13240*/ uint16(xMatch),
+	/*13241*/ uint16(xSetOp), uint16(CLD),
+	/*13243*/ uint16(xMatch),
+	/*13244*/ uint16(xSetOp), uint16(STD),
+	/*13246*/ uint16(xMatch),
+	/*13247*/ uint16(xCondSlashR),
+	13256, // 0
+	13260, // 1
+	0,     // 2
+	0,     // 3
+	0,     // 4
+	0,     // 5
+	0,     // 6
+	0,     // 7
+	/*13256*/ uint16(xSetOp), uint16(INC),
+	/*13258*/ uint16(xArgRM8),
+	/*13259*/ uint16(xMatch),
+	/*13260*/ uint16(xSetOp), uint16(DEC),
+	/*13262*/ uint16(xArgRM8),
+	/*13263*/ uint16(xMatch),
+	/*13264*/ uint16(xCondSlashR),
+	13273, // 0
+	13296, // 1
+	13319, // 2
+	13338, // 3
+	13361, // 4
+	13380, // 5
+	13403, // 6
+	0,     // 7
+	/*13273*/ uint16(xCondIs64), 13276, 13288,
+	/*13276*/ uint16(xCondDataSize), 13280, 13284, 0,
+	/*13280*/ uint16(xSetOp), uint16(INC),
+	/*13282*/ uint16(xArgRM16),
+	/*13283*/ uint16(xMatch),
+	/*13284*/ uint16(xSetOp), uint16(INC),
+	/*13286*/ uint16(xArgRM32),
+	/*13287*/ uint16(xMatch),
+	/*13288*/ uint16(xCondDataSize), 13280, 13284, 13292,
+	/*13292*/ uint16(xSetOp), uint16(INC),
+	/*13294*/ uint16(xArgRM64),
+	/*13295*/ uint16(xMatch),
+	/*13296*/ uint16(xCondIs64), 13299, 13311,
+	/*13299*/ uint16(xCondDataSize), 13303, 13307, 0,
+	/*13303*/ uint16(xSetOp), uint16(DEC),
+	/*13305*/ uint16(xArgRM16),
+	/*13306*/ uint16(xMatch),
+	/*13307*/ uint16(xSetOp), uint16(DEC),
+	/*13309*/ uint16(xArgRM32),
+	/*13310*/ uint16(xMatch),
+	/*13311*/ uint16(xCondDataSize), 13303, 13307, 13315,
+	/*13315*/ uint16(xSetOp), uint16(DEC),
+	/*13317*/ uint16(xArgRM64),
+	/*13318*/ uint16(xMatch),
+	/*13319*/ uint16(xCondIs64), 13322, 13334,
+	/*13322*/ uint16(xCondDataSize), 13326, 13330, 0,
+	/*13326*/ uint16(xSetOp), uint16(CALL),
+	/*13328*/ uint16(xArgRM16),
+	/*13329*/ uint16(xMatch),
+	/*13330*/ uint16(xSetOp), uint16(CALL),
+	/*13332*/ uint16(xArgRM32),
+	/*13333*/ uint16(xMatch),
+	/*13334*/ uint16(xSetOp), uint16(CALL),
+	/*13336*/ uint16(xArgRM64),
+	/*13337*/ uint16(xMatch),
+	/*13338*/ uint16(xCondIs64), 13341, 13353,
+	/*13341*/ uint16(xCondDataSize), 13345, 13349, 0,
+	/*13345*/ uint16(xSetOp), uint16(LCALL),
+	/*13347*/ uint16(xArgM16colon16),
+	/*13348*/ uint16(xMatch),
+	/*13349*/ uint16(xSetOp), uint16(LCALL),
+	/*13351*/ uint16(xArgM16colon32),
+	/*13352*/ uint16(xMatch),
+	/*13353*/ uint16(xCondDataSize), 13345, 13349, 13357,
+	/*13357*/ uint16(xSetOp), uint16(LCALL),
+	/*13359*/ uint16(xArgM16colon64),
+	/*13360*/ uint16(xMatch),
+	/*13361*/ uint16(xCondIs64), 13364, 13376,
+	/*13364*/ uint16(xCondDataSize), 13368, 13372, 0,
+	/*13368*/ uint16(xSetOp), uint16(JMP),
+	/*13370*/ uint16(xArgRM16),
+	/*13371*/ uint16(xMatch),
+	/*13372*/ uint16(xSetOp), uint16(JMP),
+	/*13374*/ uint16(xArgRM32),
+	/*13375*/ uint16(xMatch),
+	/*13376*/ uint16(xSetOp), uint16(JMP),
+	/*13378*/ uint16(xArgRM64),
+	/*13379*/ uint16(xMatch),
+	/*13380*/ uint16(xCondIs64), 13383, 13395,
+	/*13383*/ uint16(xCondDataSize), 13387, 13391, 0,
+	/*13387*/ uint16(xSetOp), uint16(LJMP),
+	/*13389*/ uint16(xArgM16colon16),
+	/*13390*/ uint16(xMatch),
+	/*13391*/ uint16(xSetOp), uint16(LJMP),
+	/*13393*/ uint16(xArgM16colon32),
+	/*13394*/ uint16(xMatch),
+	/*13395*/ uint16(xCondDataSize), 13387, 13391, 13399,
+	/*13399*/ uint16(xSetOp), uint16(LJMP),
+	/*13401*/ uint16(xArgM16colon64),
+	/*13402*/ uint16(xMatch),
+	/*13403*/ uint16(xCondIs64), 13406, 13418,
+	/*13406*/ uint16(xCondDataSize), 13410, 13414, 0,
+	/*13410*/ uint16(xSetOp), uint16(PUSH),
+	/*13412*/ uint16(xArgRM16),
+	/*13413*/ uint16(xMatch),
+	/*13414*/ uint16(xSetOp), uint16(PUSH),
+	/*13416*/ uint16(xArgRM32),
+	/*13417*/ uint16(xMatch),
+	/*13418*/ uint16(xCondDataSize), 13410, 13422, 13426,
+	/*13422*/ uint16(xSetOp), uint16(PUSH),
+	/*13424*/ uint16(xArgRM64),
+	/*13425*/ uint16(xMatch),
+	/*13426*/ uint16(xSetOp), uint16(PUSH),
+	/*13428*/ uint16(xArgRM64),
+	/*13429*/ uint16(xMatch),
+}
+
+const (
+	_ Op = iota
+
+	AAA
+	AAD
+	AAM
+	AAS
+	ADC
+	ADD
+	ADDPD
+	ADDPS
+	ADDSD
+	ADDSS
+	ADDSUBPD
+	ADDSUBPS
+	AESDEC
+	AESDECLAST
+	AESENC
+	AESENCLAST
+	AESIMC
+	AESKEYGENASSIST
+	AND
+	ANDNPD
+	ANDNPS
+	ANDPD
+	ANDPS
+	ARPL
+	BLENDPD
+	BLENDPS
+	BLENDVPD
+	BLENDVPS
+	BOUND
+	BSF
+	BSR
+	BSWAP
+	BT
+	BTC
+	BTR
+	BTS
+	CALL
+	CBW
+	CDQ
+	CDQE
+	CLC
+	CLD
+	CLFLUSH
+	CLI
+	CLTS
+	CMC
+	CMOVA
+	CMOVAE
+	CMOVB
+	CMOVBE
+	CMOVE
+	CMOVG
+	CMOVGE
+	CMOVL
+	CMOVLE
+	CMOVNE
+	CMOVNO
+	CMOVNP
+	CMOVNS
+	CMOVO
+	CMOVP
+	CMOVS
+	CMP
+	CMPPD
+	CMPPS
+	CMPSB
+	CMPSD
+	CMPSD_XMM
+	CMPSQ
+	CMPSS
+	CMPSW
+	CMPXCHG
+	CMPXCHG16B
+	CMPXCHG8B
+	COMISD
+	COMISS
+	CPUID
+	CQO
+	CRC32
+	CVTDQ2PD
+	CVTDQ2PS
+	CVTPD2DQ
+	CVTPD2PI
+	CVTPD2PS
+	CVTPI2PD
+	CVTPI2PS
+	CVTPS2DQ
+	CVTPS2PD
+	CVTPS2PI
+	CVTSD2SI
+	CVTSD2SS
+	CVTSI2SD
+	CVTSI2SS
+	CVTSS2SD
+	CVTSS2SI
+	CVTTPD2DQ
+	CVTTPD2PI
+	CVTTPS2DQ
+	CVTTPS2PI
+	CVTTSD2SI
+	CVTTSS2SI
+	CWD
+	CWDE
+	DAA
+	DAS
+	DEC
+	DIV
+	DIVPD
+	DIVPS
+	DIVSD
+	DIVSS
+	DPPD
+	DPPS
+	EMMS
+	ENTER
+	EXTRACTPS
+	F2XM1
+	FABS
+	FADD
+	FADDP
+	FBLD
+	FBSTP
+	FCHS
+	FCMOVB
+	FCMOVBE
+	FCMOVE
+	FCMOVNB
+	FCMOVNBE
+	FCMOVNE
+	FCMOVNU
+	FCMOVU
+	FCOM
+	FCOMI
+	FCOMIP
+	FCOMP
+	FCOMPP
+	FCOS
+	FDECSTP
+	FDIV
+	FDIVP
+	FDIVR
+	FDIVRP
+	FFREE
+	FFREEP
+	FIADD
+	FICOM
+	FICOMP
+	FIDIV
+	FIDIVR
+	FILD
+	FIMUL
+	FINCSTP
+	FIST
+	FISTP
+	FISTTP
+	FISUB
+	FISUBR
+	FLD
+	FLD1
+	FLDCW
+	FLDENV
+	FLDL2E
+	FLDL2T
+	FLDLG2
+	FLDLN2
+	FLDPI
+	FLDZ
+	FMUL
+	FMULP
+	FNCLEX
+	FNINIT
+	FNOP
+	FNSAVE
+	FNSTCW
+	FNSTENV
+	FNSTSW
+	FPATAN
+	FPREM
+	FPREM1
+	FPTAN
+	FRNDINT
+	FRSTOR
+	FSCALE
+	FSIN
+	FSINCOS
+	FSQRT
+	FST
+	FSTP
+	FSUB
+	FSUBP
+	FSUBR
+	FSUBRP
+	FTST
+	FUCOM
+	FUCOMI
+	FUCOMIP
+	FUCOMP
+	FUCOMPP
+	FWAIT
+	FXAM
+	FXCH
+	FXRSTOR
+	FXRSTOR64
+	FXSAVE
+	FXSAVE64
+	FXTRACT
+	FYL2X
+	FYL2XP1
+	HADDPD
+	HADDPS
+	HLT
+	HSUBPD
+	HSUBPS
+	ICEBP
+	IDIV
+	IMUL
+	IN
+	INC
+	INSB
+	INSD
+	INSERTPS
+	INSW
+	INT
+	INTO
+	INVD
+	INVLPG
+	INVPCID
+	IRET
+	IRETD
+	IRETQ
+	JA
+	JAE
+	JB
+	JBE
+	JCXZ
+	JE
+	JECXZ
+	JG
+	JGE
+	JL
+	JLE
+	JMP
+	JNE
+	JNO
+	JNP
+	JNS
+	JO
+	JP
+	JRCXZ
+	JS
+	LAHF
+	LAR
+	LCALL
+	LDDQU
+	LDMXCSR
+	LDS
+	LEA
+	LEAVE
+	LES
+	LFENCE
+	LFS
+	LGDT
+	LGS
+	LIDT
+	LJMP
+	LLDT
+	LMSW
+	LODSB
+	LODSD
+	LODSQ
+	LODSW
+	LOOP
+	LOOPE
+	LOOPNE
+	LRET
+	LSL
+	LSS
+	LTR
+	LZCNT
+	MASKMOVDQU
+	MASKMOVQ
+	MAXPD
+	MAXPS
+	MAXSD
+	MAXSS
+	MFENCE
+	MINPD
+	MINPS
+	MINSD
+	MINSS
+	MONITOR
+	MOV
+	MOVAPD
+	MOVAPS
+	MOVBE
+	MOVD
+	MOVDDUP
+	MOVDQ2Q
+	MOVDQA
+	MOVDQU
+	MOVHLPS
+	MOVHPD
+	MOVHPS
+	MOVLHPS
+	MOVLPD
+	MOVLPS
+	MOVMSKPD
+	MOVMSKPS
+	MOVNTDQ
+	MOVNTDQA
+	MOVNTI
+	MOVNTPD
+	MOVNTPS
+	MOVNTQ
+	MOVNTSD
+	MOVNTSS
+	MOVQ
+	MOVQ2DQ
+	MOVSB
+	MOVSD
+	MOVSD_XMM
+	MOVSHDUP
+	MOVSLDUP
+	MOVSQ
+	MOVSS
+	MOVSW
+	MOVSX
+	MOVSXD
+	MOVUPD
+	MOVUPS
+	MOVZX
+	MPSADBW
+	MUL
+	MULPD
+	MULPS
+	MULSD
+	MULSS
+	MWAIT
+	NEG
+	NOP
+	NOT
+	OR
+	ORPD
+	ORPS
+	OUT
+	OUTSB
+	OUTSD
+	OUTSW
+	PABSB
+	PABSD
+	PABSW
+	PACKSSDW
+	PACKSSWB
+	PACKUSDW
+	PACKUSWB
+	PADDB
+	PADDD
+	PADDQ
+	PADDSB
+	PADDSW
+	PADDUSB
+	PADDUSW
+	PADDW
+	PALIGNR
+	PAND
+	PANDN
+	PAUSE
+	PAVGB
+	PAVGW
+	PBLENDVB
+	PBLENDW
+	PCLMULQDQ
+	PCMPEQB
+	PCMPEQD
+	PCMPEQQ
+	PCMPEQW
+	PCMPESTRI
+	PCMPESTRM
+	PCMPGTB
+	PCMPGTD
+	PCMPGTQ
+	PCMPGTW
+	PCMPISTRI
+	PCMPISTRM
+	PEXTRB
+	PEXTRD
+	PEXTRQ
+	PEXTRW
+	PHADDD
+	PHADDSW
+	PHADDW
+	PHMINPOSUW
+	PHSUBD
+	PHSUBSW
+	PHSUBW
+	PINSRB
+	PINSRD
+	PINSRQ
+	PINSRW
+	PMADDUBSW
+	PMADDWD
+	PMAXSB
+	PMAXSD
+	PMAXSW
+	PMAXUB
+	PMAXUD
+	PMAXUW
+	PMINSB
+	PMINSD
+	PMINSW
+	PMINUB
+	PMINUD
+	PMINUW
+	PMOVMSKB
+	PMOVSXBD
+	PMOVSXBQ
+	PMOVSXBW
+	PMOVSXDQ
+	PMOVSXWD
+	PMOVSXWQ
+	PMOVZXBD
+	PMOVZXBQ
+	PMOVZXBW
+	PMOVZXDQ
+	PMOVZXWD
+	PMOVZXWQ
+	PMULDQ
+	PMULHRSW
+	PMULHUW
+	PMULHW
+	PMULLD
+	PMULLW
+	PMULUDQ
+	POP
+	POPA
+	POPAD
+	POPCNT
+	POPF
+	POPFD
+	POPFQ
+	POR
+	PREFETCHNTA
+	PREFETCHT0
+	PREFETCHT1
+	PREFETCHT2
+	PREFETCHW
+	PSADBW
+	PSHUFB
+	PSHUFD
+	PSHUFHW
+	PSHUFLW
+	PSHUFW
+	PSIGNB
+	PSIGND
+	PSIGNW
+	PSLLD
+	PSLLDQ
+	PSLLQ
+	PSLLW
+	PSRAD
+	PSRAW
+	PSRLD
+	PSRLDQ
+	PSRLQ
+	PSRLW
+	PSUBB
+	PSUBD
+	PSUBQ
+	PSUBSB
+	PSUBSW
+	PSUBUSB
+	PSUBUSW
+	PSUBW
+	PTEST
+	PUNPCKHBW
+	PUNPCKHDQ
+	PUNPCKHQDQ
+	PUNPCKHWD
+	PUNPCKLBW
+	PUNPCKLDQ
+	PUNPCKLQDQ
+	PUNPCKLWD
+	PUSH
+	PUSHA
+	PUSHAD
+	PUSHF
+	PUSHFD
+	PUSHFQ
+	PXOR
+	RCL
+	RCPPS
+	RCPSS
+	RCR
+	RDFSBASE
+	RDGSBASE
+	RDMSR
+	RDPMC
+	RDRAND
+	RDTSC
+	RDTSCP
+	RET
+	ROL
+	ROR
+	ROUNDPD
+	ROUNDPS
+	ROUNDSD
+	ROUNDSS
+	RSM
+	RSQRTPS
+	RSQRTSS
+	SAHF
+	SAR
+	SBB
+	SCASB
+	SCASD
+	SCASQ
+	SCASW
+	SETA
+	SETAE
+	SETB
+	SETBE
+	SETE
+	SETG
+	SETGE
+	SETL
+	SETLE
+	SETNE
+	SETNO
+	SETNP
+	SETNS
+	SETO
+	SETP
+	SETS
+	SFENCE
+	SGDT
+	SHL
+	SHLD
+	SHR
+	SHRD
+	SHUFPD
+	SHUFPS
+	SIDT
+	SLDT
+	SMSW
+	SQRTPD
+	SQRTPS
+	SQRTSD
+	SQRTSS
+	STC
+	STD
+	STI
+	STMXCSR
+	STOSB
+	STOSD
+	STOSQ
+	STOSW
+	STR
+	SUB
+	SUBPD
+	SUBPS
+	SUBSD
+	SUBSS
+	SWAPGS
+	SYSCALL
+	SYSENTER
+	SYSEXIT
+	SYSRET
+	TEST
+	TZCNT
+	UCOMISD
+	UCOMISS
+	UD0
+	UD1
+	UD2
+	UNPCKHPD
+	UNPCKHPS
+	UNPCKLPD
+	UNPCKLPS
+	VERR
+	VERW
+	VMOVDQA
+	VMOVDQU
+	VMOVNTDQ
+	VMOVNTDQA
+	VZEROUPPER
+	WBINVD
+	WRFSBASE
+	WRGSBASE
+	WRMSR
+	XABORT
+	XADD
+	XBEGIN
+	XCHG
+	XEND
+	XGETBV
+	XLATB
+	XOR
+	XORPD
+	XORPS
+	XRSTOR
+	XRSTOR64
+	XRSTORS
+	XRSTORS64
+	XSAVE
+	XSAVE64
+	XSAVEC
+	XSAVEC64
+	XSAVEOPT
+	XSAVEOPT64
+	XSAVES
+	XSAVES64
+	XSETBV
+	XTEST
+)
+
+const maxOp = XTEST
+
+var opNames = [...]string{
+	AAA:             "AAA",
+	AAD:             "AAD",
+	AAM:             "AAM",
+	AAS:             "AAS",
+	ADC:             "ADC",
+	ADD:             "ADD",
+	ADDPD:           "ADDPD",
+	ADDPS:           "ADDPS",
+	ADDSD:           "ADDSD",
+	ADDSS:           "ADDSS",
+	ADDSUBPD:        "ADDSUBPD",
+	ADDSUBPS:        "ADDSUBPS",
+	AESDEC:          "AESDEC",
+	AESDECLAST:      "AESDECLAST",
+	AESENC:          "AESENC",
+	AESENCLAST:      "AESENCLAST",
+	AESIMC:          "AESIMC",
+	AESKEYGENASSIST: "AESKEYGENASSIST",
+	AND:             "AND",
+	ANDNPD:          "ANDNPD",
+	ANDNPS:          "ANDNPS",
+	ANDPD:           "ANDPD",
+	ANDPS:           "ANDPS",
+	ARPL:            "ARPL",
+	BLENDPD:         "BLENDPD",
+	BLENDPS:         "BLENDPS",
+	BLENDVPD:        "BLENDVPD",
+	BLENDVPS:        "BLENDVPS",
+	BOUND:           "BOUND",
+	BSF:             "BSF",
+	BSR:             "BSR",
+	BSWAP:           "BSWAP",
+	BT:              "BT",
+	BTC:             "BTC",
+	BTR:             "BTR",
+	BTS:             "BTS",
+	CALL:            "CALL",
+	CBW:             "CBW",
+	CDQ:             "CDQ",
+	CDQE:            "CDQE",
+	CLC:             "CLC",
+	CLD:             "CLD",
+	CLFLUSH:         "CLFLUSH",
+	CLI:             "CLI",
+	CLTS:            "CLTS",
+	CMC:             "CMC",
+	CMOVA:           "CMOVA",
+	CMOVAE:          "CMOVAE",
+	CMOVB:           "CMOVB",
+	CMOVBE:          "CMOVBE",
+	CMOVE:           "CMOVE",
+	CMOVG:           "CMOVG",
+	CMOVGE:          "CMOVGE",
+	CMOVL:           "CMOVL",
+	CMOVLE:          "CMOVLE",
+	CMOVNE:          "CMOVNE",
+	CMOVNO:          "CMOVNO",
+	CMOVNP:          "CMOVNP",
+	CMOVNS:          "CMOVNS",
+	CMOVO:           "CMOVO",
+	CMOVP:           "CMOVP",
+	CMOVS:           "CMOVS",
+	CMP:             "CMP",
+	CMPPD:           "CMPPD",
+	CMPPS:           "CMPPS",
+	CMPSB:           "CMPSB",
+	CMPSD:           "CMPSD",
+	CMPSD_XMM:       "CMPSD_XMM",
+	CMPSQ:           "CMPSQ",
+	CMPSS:           "CMPSS",
+	CMPSW:           "CMPSW",
+	CMPXCHG:         "CMPXCHG",
+	CMPXCHG16B:      "CMPXCHG16B",
+	CMPXCHG8B:       "CMPXCHG8B",
+	COMISD:          "COMISD",
+	COMISS:          "COMISS",
+	CPUID:           "CPUID",
+	CQO:             "CQO",
+	CRC32:           "CRC32",
+	CVTDQ2PD:        "CVTDQ2PD",
+	CVTDQ2PS:        "CVTDQ2PS",
+	CVTPD2DQ:        "CVTPD2DQ",
+	CVTPD2PI:        "CVTPD2PI",
+	CVTPD2PS:        "CVTPD2PS",
+	CVTPI2PD:        "CVTPI2PD",
+	CVTPI2PS:        "CVTPI2PS",
+	CVTPS2DQ:        "CVTPS2DQ",
+	CVTPS2PD:        "CVTPS2PD",
+	CVTPS2PI:        "CVTPS2PI",
+	CVTSD2SI:        "CVTSD2SI",
+	CVTSD2SS:        "CVTSD2SS",
+	CVTSI2SD:        "CVTSI2SD",
+	CVTSI2SS:        "CVTSI2SS",
+	CVTSS2SD:        "CVTSS2SD",
+	CVTSS2SI:        "CVTSS2SI",
+	CVTTPD2DQ:       "CVTTPD2DQ",
+	CVTTPD2PI:       "CVTTPD2PI",
+	CVTTPS2DQ:       "CVTTPS2DQ",
+	CVTTPS2PI:       "CVTTPS2PI",
+	CVTTSD2SI:       "CVTTSD2SI",
+	CVTTSS2SI:       "CVTTSS2SI",
+	CWD:             "CWD",
+	CWDE:            "CWDE",
+	DAA:             "DAA",
+	DAS:             "DAS",
+	DEC:             "DEC",
+	DIV:             "DIV",
+	DIVPD:           "DIVPD",
+	DIVPS:           "DIVPS",
+	DIVSD:           "DIVSD",
+	DIVSS:           "DIVSS",
+	DPPD:            "DPPD",
+	DPPS:            "DPPS",
+	EMMS:            "EMMS",
+	ENTER:           "ENTER",
+	EXTRACTPS:       "EXTRACTPS",
+	F2XM1:           "F2XM1",
+	FABS:            "FABS",
+	FADD:            "FADD",
+	FADDP:           "FADDP",
+	FBLD:            "FBLD",
+	FBSTP:           "FBSTP",
+	FCHS:            "FCHS",
+	FCMOVB:          "FCMOVB",
+	FCMOVBE:         "FCMOVBE",
+	FCMOVE:          "FCMOVE",
+	FCMOVNB:         "FCMOVNB",
+	FCMOVNBE:        "FCMOVNBE",
+	FCMOVNE:         "FCMOVNE",
+	FCMOVNU:         "FCMOVNU",
+	FCMOVU:          "FCMOVU",
+	FCOM:            "FCOM",
+	FCOMI:           "FCOMI",
+	FCOMIP:          "FCOMIP",
+	FCOMP:           "FCOMP",
+	FCOMPP:          "FCOMPP",
+	FCOS:            "FCOS",
+	FDECSTP:         "FDECSTP",
+	FDIV:            "FDIV",
+	FDIVP:           "FDIVP",
+	FDIVR:           "FDIVR",
+	FDIVRP:          "FDIVRP",
+	FFREE:           "FFREE",
+	FFREEP:          "FFREEP",
+	FIADD:           "FIADD",
+	FICOM:           "FICOM",
+	FICOMP:          "FICOMP",
+	FIDIV:           "FIDIV",
+	FIDIVR:          "FIDIVR",
+	FILD:            "FILD",
+	FIMUL:           "FIMUL",
+	FINCSTP:         "FINCSTP",
+	FIST:            "FIST",
+	FISTP:           "FISTP",
+	FISTTP:          "FISTTP",
+	FISUB:           "FISUB",
+	FISUBR:          "FISUBR",
+	FLD:             "FLD",
+	FLD1:            "FLD1",
+	FLDCW:           "FLDCW",
+	FLDENV:          "FLDENV",
+	FLDL2E:          "FLDL2E",
+	FLDL2T:          "FLDL2T",
+	FLDLG2:          "FLDLG2",
+	FLDLN2:          "FLDLN2",
+	FLDPI:           "FLDPI",
+	FLDZ:            "FLDZ",
+	FMUL:            "FMUL",
+	FMULP:           "FMULP",
+	FNCLEX:          "FNCLEX",
+	FNINIT:          "FNINIT",
+	FNOP:            "FNOP",
+	FNSAVE:          "FNSAVE",
+	FNSTCW:          "FNSTCW",
+	FNSTENV:         "FNSTENV",
+	FNSTSW:          "FNSTSW",
+	FPATAN:          "FPATAN",
+	FPREM:           "FPREM",
+	FPREM1:          "FPREM1",
+	FPTAN:           "FPTAN",
+	FRNDINT:         "FRNDINT",
+	FRSTOR:          "FRSTOR",
+	FSCALE:          "FSCALE",
+	FSIN:            "FSIN",
+	FSINCOS:         "FSINCOS",
+	FSQRT:           "FSQRT",
+	FST:             "FST",
+	FSTP:            "FSTP",
+	FSUB:            "FSUB",
+	FSUBP:           "FSUBP",
+	FSUBR:           "FSUBR",
+	FSUBRP:          "FSUBRP",
+	FTST:            "FTST",
+	FUCOM:           "FUCOM",
+	FUCOMI:          "FUCOMI",
+	FUCOMIP:         "FUCOMIP",
+	FUCOMP:          "FUCOMP",
+	FUCOMPP:         "FUCOMPP",
+	FWAIT:           "FWAIT",
+	FXAM:            "FXAM",
+	FXCH:            "FXCH",
+	FXRSTOR:         "FXRSTOR",
+	FXRSTOR64:       "FXRSTOR64",
+	FXSAVE:          "FXSAVE",
+	FXSAVE64:        "FXSAVE64",
+	FXTRACT:         "FXTRACT",
+	FYL2X:           "FYL2X",
+	FYL2XP1:         "FYL2XP1",
+	HADDPD:          "HADDPD",
+	HADDPS:          "HADDPS",
+	HLT:             "HLT",
+	HSUBPD:          "HSUBPD",
+	HSUBPS:          "HSUBPS",
+	ICEBP:           "ICEBP",
+	IDIV:            "IDIV",
+	IMUL:            "IMUL",
+	IN:              "IN",
+	INC:             "INC",
+	INSB:            "INSB",
+	INSD:            "INSD",
+	INSERTPS:        "INSERTPS",
+	INSW:            "INSW",
+	INT:             "INT",
+	INTO:            "INTO",
+	INVD:            "INVD",
+	INVLPG:          "INVLPG",
+	INVPCID:         "INVPCID",
+	IRET:            "IRET",
+	IRETD:           "IRETD",
+	IRETQ:           "IRETQ",
+	JA:              "JA",
+	JAE:             "JAE",
+	JB:              "JB",
+	JBE:             "JBE",
+	JCXZ:            "JCXZ",
+	JE:              "JE",
+	JECXZ:           "JECXZ",
+	JG:              "JG",
+	JGE:             "JGE",
+	JL:              "JL",
+	JLE:             "JLE",
+	JMP:             "JMP",
+	JNE:             "JNE",
+	JNO:             "JNO",
+	JNP:             "JNP",
+	JNS:             "JNS",
+	JO:              "JO",
+	JP:              "JP",
+	JRCXZ:           "JRCXZ",
+	JS:              "JS",
+	LAHF:            "LAHF",
+	LAR:             "LAR",
+	LCALL:           "LCALL",
+	LDDQU:           "LDDQU",
+	LDMXCSR:         "LDMXCSR",
+	LDS:             "LDS",
+	LEA:             "LEA",
+	LEAVE:           "LEAVE",
+	LES:             "LES",
+	LFENCE:          "LFENCE",
+	LFS:             "LFS",
+	LGDT:            "LGDT",
+	LGS:             "LGS",
+	LIDT:            "LIDT",
+	LJMP:            "LJMP",
+	LLDT:            "LLDT",
+	LMSW:            "LMSW",
+	LODSB:           "LODSB",
+	LODSD:           "LODSD",
+	LODSQ:           "LODSQ",
+	LODSW:           "LODSW",
+	LOOP:            "LOOP",
+	LOOPE:           "LOOPE",
+	LOOPNE:          "LOOPNE",
+	LRET:            "LRET",
+	LSL:             "LSL",
+	LSS:             "LSS",
+	LTR:             "LTR",
+	LZCNT:           "LZCNT",
+	MASKMOVDQU:      "MASKMOVDQU",
+	MASKMOVQ:        "MASKMOVQ",
+	MAXPD:           "MAXPD",
+	MAXPS:           "MAXPS",
+	MAXSD:           "MAXSD",
+	MAXSS:           "MAXSS",
+	MFENCE:          "MFENCE",
+	MINPD:           "MINPD",
+	MINPS:           "MINPS",
+	MINSD:           "MINSD",
+	MINSS:           "MINSS",
+	MONITOR:         "MONITOR",
+	MOV:             "MOV",
+	MOVAPD:          "MOVAPD",
+	MOVAPS:          "MOVAPS",
+	MOVBE:           "MOVBE",
+	MOVD:            "MOVD",
+	MOVDDUP:         "MOVDDUP",
+	MOVDQ2Q:         "MOVDQ2Q",
+	MOVDQA:          "MOVDQA",
+	MOVDQU:          "MOVDQU",
+	MOVHLPS:         "MOVHLPS",
+	MOVHPD:          "MOVHPD",
+	MOVHPS:          "MOVHPS",
+	MOVLHPS:         "MOVLHPS",
+	MOVLPD:          "MOVLPD",
+	MOVLPS:          "MOVLPS",
+	MOVMSKPD:        "MOVMSKPD",
+	MOVMSKPS:        "MOVMSKPS",
+	MOVNTDQ:         "MOVNTDQ",
+	MOVNTDQA:        "MOVNTDQA",
+	MOVNTI:          "MOVNTI",
+	MOVNTPD:         "MOVNTPD",
+	MOVNTPS:         "MOVNTPS",
+	MOVNTQ:          "MOVNTQ",
+	MOVNTSD:         "MOVNTSD",
+	MOVNTSS:         "MOVNTSS",
+	MOVQ:            "MOVQ",
+	MOVQ2DQ:         "MOVQ2DQ",
+	MOVSB:           "MOVSB",
+	MOVSD:           "MOVSD",
+	MOVSD_XMM:       "MOVSD_XMM",
+	MOVSHDUP:        "MOVSHDUP",
+	MOVSLDUP:        "MOVSLDUP",
+	MOVSQ:           "MOVSQ",
+	MOVSS:           "MOVSS",
+	MOVSW:           "MOVSW",
+	MOVSX:           "MOVSX",
+	MOVSXD:          "MOVSXD",
+	MOVUPD:          "MOVUPD",
+	MOVUPS:          "MOVUPS",
+	MOVZX:           "MOVZX",
+	MPSADBW:         "MPSADBW",
+	MUL:             "MUL",
+	MULPD:           "MULPD",
+	MULPS:           "MULPS",
+	MULSD:           "MULSD",
+	MULSS:           "MULSS",
+	MWAIT:           "MWAIT",
+	NEG:             "NEG",
+	NOP:             "NOP",
+	NOT:             "NOT",
+	OR:              "OR",
+	ORPD:            "ORPD",
+	ORPS:            "ORPS",
+	OUT:             "OUT",
+	OUTSB:           "OUTSB",
+	OUTSD:           "OUTSD",
+	OUTSW:           "OUTSW",
+	PABSB:           "PABSB",
+	PABSD:           "PABSD",
+	PABSW:           "PABSW",
+	PACKSSDW:        "PACKSSDW",
+	PACKSSWB:        "PACKSSWB",
+	PACKUSDW:        "PACKUSDW",
+	PACKUSWB:        "PACKUSWB",
+	PADDB:           "PADDB",
+	PADDD:           "PADDD",
+	PADDQ:           "PADDQ",
+	PADDSB:          "PADDSB",
+	PADDSW:          "PADDSW",
+	PADDUSB:         "PADDUSB",
+	PADDUSW:         "PADDUSW",
+	PADDW:           "PADDW",
+	PALIGNR:         "PALIGNR",
+	PAND:            "PAND",
+	PANDN:           "PANDN",
+	PAUSE:           "PAUSE",
+	PAVGB:           "PAVGB",
+	PAVGW:           "PAVGW",
+	PBLENDVB:        "PBLENDVB",
+	PBLENDW:         "PBLENDW",
+	PCLMULQDQ:       "PCLMULQDQ",
+	PCMPEQB:         "PCMPEQB",
+	PCMPEQD:         "PCMPEQD",
+	PCMPEQQ:         "PCMPEQQ",
+	PCMPEQW:         "PCMPEQW",
+	PCMPESTRI:       "PCMPESTRI",
+	PCMPESTRM:       "PCMPESTRM",
+	PCMPGTB:         "PCMPGTB",
+	PCMPGTD:         "PCMPGTD",
+	PCMPGTQ:         "PCMPGTQ",
+	PCMPGTW:         "PCMPGTW",
+	PCMPISTRI:       "PCMPISTRI",
+	PCMPISTRM:       "PCMPISTRM",
+	PEXTRB:          "PEXTRB",
+	PEXTRD:          "PEXTRD",
+	PEXTRQ:          "PEXTRQ",
+	PEXTRW:          "PEXTRW",
+	PHADDD:          "PHADDD",
+	PHADDSW:         "PHADDSW",
+	PHADDW:          "PHADDW",
+	PHMINPOSUW:      "PHMINPOSUW",
+	PHSUBD:          "PHSUBD",
+	PHSUBSW:         "PHSUBSW",
+	PHSUBW:          "PHSUBW",
+	PINSRB:          "PINSRB",
+	PINSRD:          "PINSRD",
+	PINSRQ:          "PINSRQ",
+	PINSRW:          "PINSRW",
+	PMADDUBSW:       "PMADDUBSW",
+	PMADDWD:         "PMADDWD",
+	PMAXSB:          "PMAXSB",
+	PMAXSD:          "PMAXSD",
+	PMAXSW:          "PMAXSW",
+	PMAXUB:          "PMAXUB",
+	PMAXUD:          "PMAXUD",
+	PMAXUW:          "PMAXUW",
+	PMINSB:          "PMINSB",
+	PMINSD:          "PMINSD",
+	PMINSW:          "PMINSW",
+	PMINUB:          "PMINUB",
+	PMINUD:          "PMINUD",
+	PMINUW:          "PMINUW",
+	PMOVMSKB:        "PMOVMSKB",
+	PMOVSXBD:        "PMOVSXBD",
+	PMOVSXBQ:        "PMOVSXBQ",
+	PMOVSXBW:        "PMOVSXBW",
+	PMOVSXDQ:        "PMOVSXDQ",
+	PMOVSXWD:        "PMOVSXWD",
+	PMOVSXWQ:        "PMOVSXWQ",
+	PMOVZXBD:        "PMOVZXBD",
+	PMOVZXBQ:        "PMOVZXBQ",
+	PMOVZXBW:        "PMOVZXBW",
+	PMOVZXDQ:        "PMOVZXDQ",
+	PMOVZXWD:        "PMOVZXWD",
+	PMOVZXWQ:        "PMOVZXWQ",
+	PMULDQ:          "PMULDQ",
+	PMULHRSW:        "PMULHRSW",
+	PMULHUW:         "PMULHUW",
+	PMULHW:          "PMULHW",
+	PMULLD:          "PMULLD",
+	PMULLW:          "PMULLW",
+	PMULUDQ:         "PMULUDQ",
+	POP:             "POP",
+	POPA:            "POPA",
+	POPAD:           "POPAD",
+	POPCNT:          "POPCNT",
+	POPF:            "POPF",
+	POPFD:           "POPFD",
+	POPFQ:           "POPFQ",
+	POR:             "POR",
+	PREFETCHNTA:     "PREFETCHNTA",
+	PREFETCHT0:      "PREFETCHT0",
+	PREFETCHT1:      "PREFETCHT1",
+	PREFETCHT2:      "PREFETCHT2",
+	PREFETCHW:       "PREFETCHW",
+	PSADBW:          "PSADBW",
+	PSHUFB:          "PSHUFB",
+	PSHUFD:          "PSHUFD",
+	PSHUFHW:         "PSHUFHW",
+	PSHUFLW:         "PSHUFLW",
+	PSHUFW:          "PSHUFW",
+	PSIGNB:          "PSIGNB",
+	PSIGND:          "PSIGND",
+	PSIGNW:          "PSIGNW",
+	PSLLD:           "PSLLD",
+	PSLLDQ:          "PSLLDQ",
+	PSLLQ:           "PSLLQ",
+	PSLLW:           "PSLLW",
+	PSRAD:           "PSRAD",
+	PSRAW:           "PSRAW",
+	PSRLD:           "PSRLD",
+	PSRLDQ:          "PSRLDQ",
+	PSRLQ:           "PSRLQ",
+	PSRLW:           "PSRLW",
+	PSUBB:           "PSUBB",
+	PSUBD:           "PSUBD",
+	PSUBQ:           "PSUBQ",
+	PSUBSB:          "PSUBSB",
+	PSUBSW:          "PSUBSW",
+	PSUBUSB:         "PSUBUSB",
+	PSUBUSW:         "PSUBUSW",
+	PSUBW:           "PSUBW",
+	PTEST:           "PTEST",
+	PUNPCKHBW:       "PUNPCKHBW",
+	PUNPCKHDQ:       "PUNPCKHDQ",
+	PUNPCKHQDQ:      "PUNPCKHQDQ",
+	PUNPCKHWD:       "PUNPCKHWD",
+	PUNPCKLBW:       "PUNPCKLBW",
+	PUNPCKLDQ:       "PUNPCKLDQ",
+	PUNPCKLQDQ:      "PUNPCKLQDQ",
+	PUNPCKLWD:       "PUNPCKLWD",
+	PUSH:            "PUSH",
+	PUSHA:           "PUSHA",
+	PUSHAD:          "PUSHAD",
+	PUSHF:           "PUSHF",
+	PUSHFD:          "PUSHFD",
+	PUSHFQ:          "PUSHFQ",
+	PXOR:            "PXOR",
+	RCL:             "RCL",
+	RCPPS:           "RCPPS",
+	RCPSS:           "RCPSS",
+	RCR:             "RCR",
+	RDFSBASE:        "RDFSBASE",
+	RDGSBASE:        "RDGSBASE",
+	RDMSR:           "RDMSR",
+	RDPMC:           "RDPMC",
+	RDRAND:          "RDRAND",
+	RDTSC:           "RDTSC",
+	RDTSCP:          "RDTSCP",
+	RET:             "RET",
+	ROL:             "ROL",
+	ROR:             "ROR",
+	ROUNDPD:         "ROUNDPD",
+	ROUNDPS:         "ROUNDPS",
+	ROUNDSD:         "ROUNDSD",
+	ROUNDSS:         "ROUNDSS",
+	RSM:             "RSM",
+	RSQRTPS:         "RSQRTPS",
+	RSQRTSS:         "RSQRTSS",
+	SAHF:            "SAHF",
+	SAR:             "SAR",
+	SBB:             "SBB",
+	SCASB:           "SCASB",
+	SCASD:           "SCASD",
+	SCASQ:           "SCASQ",
+	SCASW:           "SCASW",
+	SETA:            "SETA",
+	SETAE:           "SETAE",
+	SETB:            "SETB",
+	SETBE:           "SETBE",
+	SETE:            "SETE",
+	SETG:            "SETG",
+	SETGE:           "SETGE",
+	SETL:            "SETL",
+	SETLE:           "SETLE",
+	SETNE:           "SETNE",
+	SETNO:           "SETNO",
+	SETNP:           "SETNP",
+	SETNS:           "SETNS",
+	SETO:            "SETO",
+	SETP:            "SETP",
+	SETS:            "SETS",
+	SFENCE:          "SFENCE",
+	SGDT:            "SGDT",
+	SHL:             "SHL",
+	SHLD:            "SHLD",
+	SHR:             "SHR",
+	SHRD:            "SHRD",
+	SHUFPD:          "SHUFPD",
+	SHUFPS:          "SHUFPS",
+	SIDT:            "SIDT",
+	SLDT:            "SLDT",
+	SMSW:            "SMSW",
+	SQRTPD:          "SQRTPD",
+	SQRTPS:          "SQRTPS",
+	SQRTSD:          "SQRTSD",
+	SQRTSS:          "SQRTSS",
+	STC:             "STC",
+	STD:             "STD",
+	STI:             "STI",
+	STMXCSR:         "STMXCSR",
+	STOSB:           "STOSB",
+	STOSD:           "STOSD",
+	STOSQ:           "STOSQ",
+	STOSW:           "STOSW",
+	STR:             "STR",
+	SUB:             "SUB",
+	SUBPD:           "SUBPD",
+	SUBPS:           "SUBPS",
+	SUBSD:           "SUBSD",
+	SUBSS:           "SUBSS",
+	SWAPGS:          "SWAPGS",
+	SYSCALL:         "SYSCALL",
+	SYSENTER:        "SYSENTER",
+	SYSEXIT:         "SYSEXIT",
+	SYSRET:          "SYSRET",
+	TEST:            "TEST",
+	TZCNT:           "TZCNT",
+	UCOMISD:         "UCOMISD",
+	UCOMISS:         "UCOMISS",
+	UD0:             "UD0",
+	UD1:             "UD1",
+	UD2:             "UD2",
+	UNPCKHPD:        "UNPCKHPD",
+	UNPCKHPS:        "UNPCKHPS",
+	UNPCKLPD:        "UNPCKLPD",
+	UNPCKLPS:        "UNPCKLPS",
+	VERR:            "VERR",
+	VERW:            "VERW",
+	VMOVDQA:         "VMOVDQA",
+	VMOVDQU:         "VMOVDQU",
+	VMOVNTDQ:        "VMOVNTDQ",
+	VMOVNTDQA:       "VMOVNTDQA",
+	VZEROUPPER:      "VZEROUPPER",
+	WBINVD:          "WBINVD",
+	WRFSBASE:        "WRFSBASE",
+	WRGSBASE:        "WRGSBASE",
+	WRMSR:           "WRMSR",
+	XABORT:          "XABORT",
+	XADD:            "XADD",
+	XBEGIN:          "XBEGIN",
+	XCHG:            "XCHG",
+	XEND:            "XEND",
+	XGETBV:          "XGETBV",
+	XLATB:           "XLATB",
+	XOR:             "XOR",
+	XORPD:           "XORPD",
+	XORPS:           "XORPS",
+	XRSTOR:          "XRSTOR",
+	XRSTOR64:        "XRSTOR64",
+	XRSTORS:         "XRSTORS",
+	XRSTORS64:       "XRSTORS64",
+	XSAVE:           "XSAVE",
+	XSAVE64:         "XSAVE64",
+	XSAVEC:          "XSAVEC",
+	XSAVEC64:        "XSAVEC64",
+	XSAVEOPT:        "XSAVEOPT",
+	XSAVEOPT64:      "XSAVEOPT64",
+	XSAVES:          "XSAVES",
+	XSAVES64:        "XSAVES64",
+	XSETBV:          "XSETBV",
+	XTEST:           "XTEST",
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index bdf90d040..f06d16caf 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -86,6 +86,30 @@ 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
+## explicit; go 1.15
+github.com/bytedance/sonic
+github.com/bytedance/sonic/ast
+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/jit
+github.com/bytedance/sonic/internal/loader
+github.com/bytedance/sonic/internal/native
+github.com/bytedance/sonic/internal/native/avx
+github.com/bytedance/sonic/internal/native/avx2
+github.com/bytedance/sonic/internal/native/sse
+github.com/bytedance/sonic/internal/native/types
+github.com/bytedance/sonic/internal/resolver
+github.com/bytedance/sonic/internal/rt
+github.com/bytedance/sonic/loader
+github.com/bytedance/sonic/option
+github.com/bytedance/sonic/unquote
+github.com/bytedance/sonic/utf8
+# github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311
+## explicit; go 1.15
+github.com/chenzhuoyu/base64x
 # github.com/cilium/ebpf v0.4.0
 ## explicit; go 1.15
 github.com/cilium/ebpf
@@ -158,7 +182,7 @@ 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.8.2
+# github.com/gin-gonic/gin v1.9.0
 ## explicit; go 1.18
 github.com/gin-gonic/gin
 github.com/gin-gonic/gin/binding
@@ -189,7 +213,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.9.11
+# github.com/goccy/go-json v0.10.0
 ## explicit; go 1.12
 github.com/goccy/go-json
 github.com/goccy/go-json/internal/decoder
@@ -633,7 +657,26 @@ github.com/tdewolff/parse/v2/strconv
 # github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc
 ## explicit
 github.com/tmthrgd/go-hex
-# github.com/ugorji/go/codec v1.2.7
+# github.com/twitchyliquid64/golang-asm v0.15.1
+## explicit; go 1.13
+github.com/twitchyliquid64/golang-asm/asm/arch
+github.com/twitchyliquid64/golang-asm/bio
+github.com/twitchyliquid64/golang-asm/dwarf
+github.com/twitchyliquid64/golang-asm/goobj
+github.com/twitchyliquid64/golang-asm/obj
+github.com/twitchyliquid64/golang-asm/obj/arm
+github.com/twitchyliquid64/golang-asm/obj/arm64
+github.com/twitchyliquid64/golang-asm/obj/mips
+github.com/twitchyliquid64/golang-asm/obj/ppc64
+github.com/twitchyliquid64/golang-asm/obj/riscv
+github.com/twitchyliquid64/golang-asm/obj/s390x
+github.com/twitchyliquid64/golang-asm/obj/wasm
+github.com/twitchyliquid64/golang-asm/obj/x86
+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
 ## explicit; go 1.11
 github.com/ugorji/go/codec
 # github.com/ulule/limiter/v3 v3.11.0
@@ -689,6 +732,9 @@ github.com/yuin/goldmark/util
 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
+## explicit; go 1.17
+golang.org/x/arch/x86/x86asm
 # golang.org/x/crypto v0.6.0
 ## explicit; go 1.17
 golang.org/x/crypto/acme